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
2010         default:
2011           if (uvalue >= DW_ATE_lo_user
2012               && uvalue <= DW_ATE_hi_user)
2013             printf (_("(user defined type)"));
2014           else
2015             printf (_("(unknown type)"));
2016           break;
2017         }
2018       break;
2019
2020     case DW_AT_accessibility:
2021       printf ("\t");
2022       switch (uvalue)
2023         {
2024         case DW_ACCESS_public:          printf ("(public)"); break;
2025         case DW_ACCESS_protected:       printf ("(protected)"); break;
2026         case DW_ACCESS_private:         printf ("(private)"); break;
2027         default:
2028           printf (_("(unknown accessibility)"));
2029           break;
2030         }
2031       break;
2032
2033     case DW_AT_visibility:
2034       printf ("\t");
2035       switch (uvalue)
2036         {
2037         case DW_VIS_local:              printf ("(local)"); break;
2038         case DW_VIS_exported:           printf ("(exported)"); break;
2039         case DW_VIS_qualified:          printf ("(qualified)"); break;
2040         default:                        printf (_("(unknown visibility)")); break;
2041         }
2042       break;
2043
2044     case DW_AT_virtuality:
2045       printf ("\t");
2046       switch (uvalue)
2047         {
2048         case DW_VIRTUALITY_none:        printf ("(none)"); break;
2049         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
2050         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2051         default:                        printf (_("(unknown virtuality)")); break;
2052         }
2053       break;
2054
2055     case DW_AT_identifier_case:
2056       printf ("\t");
2057       switch (uvalue)
2058         {
2059         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
2060         case DW_ID_up_case:             printf ("(up_case)"); break;
2061         case DW_ID_down_case:           printf ("(down_case)"); break;
2062         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
2063         default:                        printf (_("(unknown case)")); break;
2064         }
2065       break;
2066
2067     case DW_AT_calling_convention:
2068       printf ("\t");
2069       switch (uvalue)
2070         {
2071         case DW_CC_normal:      printf ("(normal)"); break;
2072         case DW_CC_program:     printf ("(program)"); break;
2073         case DW_CC_nocall:      printf ("(nocall)"); break;
2074         default:
2075           if (uvalue >= DW_CC_lo_user
2076               && uvalue <= DW_CC_hi_user)
2077             printf (_("(user defined)"));
2078           else
2079             printf (_("(unknown convention)"));
2080         }
2081       break;
2082
2083     case DW_AT_ordering:
2084       printf ("\t");
2085       switch (uvalue)
2086         {
2087         case -1: printf (_("(undefined)")); break;
2088         case 0:  printf ("(row major)"); break;
2089         case 1:  printf ("(column major)"); break;
2090         }
2091       break;
2092
2093     case DW_AT_frame_base:
2094       have_frame_base = 1;
2095     case DW_AT_location:
2096     case DW_AT_string_length:
2097     case DW_AT_return_addr:
2098     case DW_AT_data_member_location:
2099     case DW_AT_vtable_elem_location:
2100     case DW_AT_segment:
2101     case DW_AT_static_link:
2102     case DW_AT_use_location:
2103     case DW_AT_GNU_call_site_value:
2104     case DW_AT_GNU_call_site_data_value:
2105     case DW_AT_GNU_call_site_target:
2106     case DW_AT_GNU_call_site_target_clobbered:
2107       if ((dwarf_version < 4
2108            && (form == DW_FORM_data4 || form == DW_FORM_data8))
2109           || form == DW_FORM_sec_offset)
2110         printf (_(" (location list)"));
2111       /* Fall through.  */
2112     case DW_AT_allocated:
2113     case DW_AT_associated:
2114     case DW_AT_data_location:
2115     case DW_AT_stride:
2116     case DW_AT_upper_bound:
2117     case DW_AT_lower_bound:
2118       if (block_start)
2119         {
2120           int need_frame_base;
2121
2122           printf ("\t(");
2123           need_frame_base = decode_location_expression (block_start,
2124                                                         pointer_size,
2125                                                         offset_size,
2126                                                         dwarf_version,
2127                                                         uvalue,
2128                                                         cu_offset, section);
2129           printf (")");
2130           if (need_frame_base && !have_frame_base)
2131             printf (_(" [without DW_AT_frame_base]"));
2132         }
2133       break;
2134
2135     case DW_AT_import:
2136       {
2137         if (form == DW_FORM_ref_sig8
2138             || form == DW_FORM_GNU_ref_alt)
2139           break;
2140
2141         if (form == DW_FORM_ref1
2142             || form == DW_FORM_ref2
2143             || form == DW_FORM_ref4
2144             || form == DW_FORM_ref_udata)
2145           uvalue += cu_offset;
2146
2147         if (uvalue >= section->size)
2148           warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2149                 dwarf_vmatoa ("x", uvalue),
2150                 (unsigned long) (orig_data - section->start));
2151         else
2152           {
2153             unsigned long abbrev_number;
2154             abbrev_entry * entry;
2155
2156             abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2157
2158             printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2159             /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2160                use different abbrev table, and we don't track .debug_info chunks
2161                yet.  */
2162             if (form != DW_FORM_ref_addr)
2163               {
2164                 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2165                   if (entry->entry == abbrev_number)
2166                     break;
2167                 if (entry != NULL)
2168                   printf (" (%s)", get_TAG_name (entry->tag));
2169               }
2170             printf ("]");
2171           }
2172       }
2173       break;
2174
2175     default:
2176       break;
2177     }
2178
2179   return data;
2180 }
2181
2182 static const char *
2183 get_AT_name (unsigned long attribute)
2184 {
2185   const char *name;
2186
2187   if (attribute == 0)
2188     return "DW_AT value: 0";
2189
2190   /* One value is shared by the MIPS and HP extensions:  */
2191   if (attribute == DW_AT_MIPS_fde)
2192     return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2193
2194   name = get_DW_AT_name (attribute);
2195
2196   if (name == NULL)
2197     {
2198       static char buffer[100];
2199
2200       snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2201                 attribute);
2202       return buffer;
2203     }
2204
2205   return name;
2206 }
2207
2208 static unsigned char *
2209 read_and_display_attr (unsigned long attribute,
2210                        unsigned long form,
2211                        unsigned char * data,
2212                        unsigned char * end,
2213                        dwarf_vma cu_offset,
2214                        dwarf_vma pointer_size,
2215                        dwarf_vma offset_size,
2216                        int dwarf_version,
2217                        debug_info * debug_info_p,
2218                        int do_loc,
2219                        struct dwarf_section * section,
2220                        struct cu_tu_set * this_set)
2221 {
2222   if (!do_loc)
2223     printf ("   %-18s:", get_AT_name (attribute));
2224   data = read_and_display_attr_value (attribute, form, data, end,
2225                                       cu_offset, pointer_size, offset_size,
2226                                       dwarf_version, debug_info_p,
2227                                       do_loc, section, this_set);
2228   if (!do_loc)
2229     printf ("\n");
2230   return data;
2231 }
2232
2233 /* Process the contents of a .debug_info section.  If do_loc is non-zero
2234    then we are scanning for location lists and we do not want to display
2235    anything to the user.  If do_types is non-zero, we are processing
2236    a .debug_types section instead of a .debug_info section.  */
2237
2238 static int
2239 process_debug_info (struct dwarf_section *section,
2240                     void *file,
2241                     enum dwarf_section_display_enum abbrev_sec,
2242                     int do_loc,
2243                     int do_types)
2244 {
2245   unsigned char *start = section->start;
2246   unsigned char *end = start + section->size;
2247   unsigned char *section_begin;
2248   unsigned int unit;
2249   unsigned int num_units = 0;
2250
2251   if ((do_loc || do_debug_loc || do_debug_ranges)
2252       && num_debug_info_entries == 0
2253       && ! do_types)
2254     {
2255       dwarf_vma length;
2256
2257       /* First scan the section to get the number of comp units.  */
2258       for (section_begin = start, num_units = 0; section_begin < end;
2259            num_units ++)
2260         {
2261           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2262              will be the length.  For a 64-bit DWARF section, it'll be
2263              the escape code 0xffffffff followed by an 8 byte length.  */
2264           SAFE_BYTE_GET (length, section_begin, 4, end);
2265
2266           if (length == 0xffffffff)
2267             {
2268               SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2269               section_begin += length + 12;
2270             }
2271           else if (length >= 0xfffffff0 && length < 0xffffffff)
2272             {
2273               warn (_("Reserved length value (0x%s) found in section %s\n"),
2274                     dwarf_vmatoa ("x", length), section->name);
2275               return 0;
2276             }
2277           else
2278             section_begin += length + 4;
2279
2280           /* Negative values are illegal, they may even cause infinite
2281              looping.  This can happen if we can't accurately apply
2282              relocations to an object file, or if the file is corrupt.  */
2283           if ((signed long) length <= 0 || section_begin < start)
2284             {
2285               warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2286                     dwarf_vmatoa ("x", length), section->name);
2287               return 0;
2288             }
2289         }
2290
2291       if (num_units == 0)
2292         {
2293           error (_("No comp units in %s section ?\n"), section->name);
2294           return 0;
2295         }
2296
2297       /* Then allocate an array to hold the information.  */
2298       debug_information = (debug_info *) cmalloc (num_units,
2299                                                   sizeof (* debug_information));
2300       if (debug_information == NULL)
2301         {
2302           error (_("Not enough memory for a debug info array of %u entries\n"),
2303                  num_units);
2304           alloc_num_debug_info_entries = num_debug_info_entries = 0;
2305           return 0;
2306         }
2307       /* PR 17531: file: 92ca3797.
2308          We cannot rely upon the debug_information array being initialised
2309          before it is used.  A corrupt file could easily contain references
2310          to a unit for which information has not been made available.  So
2311          we ensure that the array is zeroed here.  */
2312       memset (debug_information, 0, num_units * sizeof (*debug_information));
2313
2314       alloc_num_debug_info_entries = num_units;
2315     }
2316
2317   if (!do_loc)
2318     {
2319       if (dwarf_start_die == 0)
2320         printf (_("Contents of the %s section:\n\n"), section->name);
2321
2322       load_debug_section (str, file);
2323       load_debug_section (str_dwo, file);
2324       load_debug_section (str_index, file);
2325       load_debug_section (str_index_dwo, file);
2326       load_debug_section (debug_addr, file);
2327     }
2328
2329   load_debug_section (abbrev_sec, file);
2330   if (debug_displays [abbrev_sec].section.start == NULL)
2331     {
2332       warn (_("Unable to locate %s section!\n"),
2333             debug_displays [abbrev_sec].section.name);
2334       return 0;
2335     }
2336
2337   for (section_begin = start, unit = 0; start < end; unit++)
2338     {
2339       DWARF2_Internal_CompUnit compunit;
2340       unsigned char *hdrptr;
2341       unsigned char *tags;
2342       int level, last_level, saved_level;
2343       dwarf_vma cu_offset;
2344       unsigned int offset_size;
2345       int initial_length_size;
2346       dwarf_vma signature_high = 0;
2347       dwarf_vma signature_low = 0;
2348       dwarf_vma type_offset = 0;
2349       struct cu_tu_set *this_set;
2350       dwarf_vma abbrev_base;
2351       size_t abbrev_size;
2352
2353       hdrptr = start;
2354
2355       SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2356
2357       if (compunit.cu_length == 0xffffffff)
2358         {
2359           SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2360           offset_size = 8;
2361           initial_length_size = 12;
2362         }
2363       else
2364         {
2365           offset_size = 4;
2366           initial_length_size = 4;
2367         }
2368
2369       SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2370
2371       cu_offset = start - section_begin;
2372
2373       this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2374
2375       SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2376
2377       if (this_set == NULL)
2378         {
2379           abbrev_base = 0;
2380           abbrev_size = debug_displays [abbrev_sec].section.size;
2381         }
2382       else
2383         {
2384           abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2385           abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2386         }
2387
2388       SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2389       /* PR 17512: file: 001-108546-0.001:0.1.  */
2390       if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2391         {
2392           warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2393                 compunit.cu_pointer_size, offset_size);
2394           compunit.cu_pointer_size = offset_size;
2395         }
2396
2397       if (do_types)
2398         {
2399           SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2400           hdrptr += 8;
2401           SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2402         }
2403
2404       if ((do_loc || do_debug_loc || do_debug_ranges)
2405           && num_debug_info_entries == 0
2406           && ! do_types)
2407         {
2408           debug_information [unit].cu_offset = cu_offset;
2409           debug_information [unit].pointer_size
2410             = compunit.cu_pointer_size;
2411           debug_information [unit].offset_size = offset_size;
2412           debug_information [unit].dwarf_version = compunit.cu_version;
2413           debug_information [unit].base_address = 0;
2414           debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2415           debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2416           debug_information [unit].loc_offsets = NULL;
2417           debug_information [unit].have_frame_base = NULL;
2418           debug_information [unit].max_loc_offsets = 0;
2419           debug_information [unit].num_loc_offsets = 0;
2420           debug_information [unit].range_lists = NULL;
2421           debug_information [unit].max_range_lists= 0;
2422           debug_information [unit].num_range_lists = 0;
2423         }
2424
2425       if (!do_loc && dwarf_start_die == 0)
2426         {
2427           printf (_("  Compilation Unit @ offset 0x%s:\n"),
2428                   dwarf_vmatoa ("x", cu_offset));
2429           printf (_("   Length:        0x%s (%s)\n"),
2430                   dwarf_vmatoa ("x", compunit.cu_length),
2431                   offset_size == 8 ? "64-bit" : "32-bit");
2432           printf (_("   Version:       %d\n"), compunit.cu_version);
2433           printf (_("   Abbrev Offset: 0x%s\n"),
2434                   dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2435           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2436           if (do_types)
2437             {
2438               char buf[64];
2439
2440               printf (_("   Signature:     0x%s\n"),
2441                       dwarf_vmatoa64 (signature_high, signature_low,
2442                                       buf, sizeof (buf)));
2443               printf (_("   Type Offset:   0x%s\n"),
2444                       dwarf_vmatoa ("x", type_offset));
2445             }
2446           if (this_set != NULL)
2447             {
2448               dwarf_vma *offsets = this_set->section_offsets;
2449               size_t *sizes = this_set->section_sizes;
2450
2451               printf (_("   Section contributions:\n"));
2452               printf (_("    .debug_abbrev.dwo:       0x%s  0x%s\n"),
2453                       dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2454                       dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2455               printf (_("    .debug_line.dwo:         0x%s  0x%s\n"),
2456                       dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2457                       dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2458               printf (_("    .debug_loc.dwo:          0x%s  0x%s\n"),
2459                       dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2460                       dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2461               printf (_("    .debug_str_offsets.dwo:  0x%s  0x%s\n"),
2462                       dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2463                       dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2464             }
2465         }
2466
2467       if (cu_offset + compunit.cu_length + initial_length_size
2468           > section->size)
2469         {
2470           warn (_("Debug info is corrupted, length of CU at %s"
2471                   " extends beyond end of section (length = %s)\n"),
2472                 dwarf_vmatoa ("x", cu_offset),
2473                 dwarf_vmatoa ("x", compunit.cu_length));
2474           num_units = unit;
2475           break;
2476         }
2477       tags = hdrptr;
2478       start += compunit.cu_length + initial_length_size;
2479
2480       if (start > end)
2481         {
2482           warn (_("Debug info is corrupt.  CU at %s extends beyond end of section"),
2483                 dwarf_vmatoa ("x", cu_offset));
2484           start = end;
2485         }
2486
2487       if (compunit.cu_version != 2
2488           && compunit.cu_version != 3
2489           && compunit.cu_version != 4)
2490         {
2491           warn (_("CU at offset %s contains corrupt or "
2492                   "unsupported version number: %d.\n"),
2493                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2494           continue;
2495         }
2496
2497       free_abbrevs ();
2498
2499       /* Process the abbrevs used by this compilation unit.  */
2500       if (compunit.cu_abbrev_offset >= abbrev_size)
2501         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2502               (unsigned long) compunit.cu_abbrev_offset,
2503               (unsigned long) abbrev_size);
2504       /* PR 17531: file:4bcd9ce9.  */
2505       else if ((abbrev_base + abbrev_size)
2506                > debug_displays [abbrev_sec].section.size)
2507         warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2508               (unsigned long) abbrev_base + abbrev_size,
2509               (unsigned long) debug_displays [abbrev_sec].section.size);
2510       else
2511         process_abbrev_section
2512           (((unsigned char *) debug_displays [abbrev_sec].section.start
2513             + abbrev_base + compunit.cu_abbrev_offset),
2514            ((unsigned char *) debug_displays [abbrev_sec].section.start
2515             + abbrev_base + abbrev_size));
2516
2517       level = 0;
2518       last_level = level;
2519       saved_level = -1;
2520       while (tags < start)
2521         {
2522           unsigned int bytes_read;
2523           unsigned long abbrev_number;
2524           unsigned long die_offset;
2525           abbrev_entry *entry;
2526           abbrev_attr *attr;
2527           int do_printing = 1;
2528
2529           die_offset = tags - section_begin;
2530
2531           abbrev_number = read_uleb128 (tags, & bytes_read, start);
2532           tags += bytes_read;
2533
2534           /* A null DIE marks the end of a list of siblings or it may also be
2535              a section padding.  */
2536           if (abbrev_number == 0)
2537             {
2538               /* Check if it can be a section padding for the last CU.  */
2539               if (level == 0 && start == end)
2540                 {
2541                   unsigned char *chk;
2542
2543                   for (chk = tags; chk < start; chk++)
2544                     if (*chk != 0)
2545                       break;
2546                   if (chk == start)
2547                     break;
2548                 }
2549
2550               if (!do_loc && die_offset >= dwarf_start_die
2551                   && (dwarf_cutoff_level == -1
2552                       || level < dwarf_cutoff_level))
2553                 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2554                         level, die_offset);
2555
2556               --level;
2557               if (level < 0)
2558                 {
2559                   static unsigned num_bogus_warns = 0;
2560
2561                   if (num_bogus_warns < 3)
2562                     {
2563                       warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2564                             die_offset, section->name);
2565                       num_bogus_warns ++;
2566                       if (num_bogus_warns == 3)
2567                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2568                     }
2569                 }
2570               if (dwarf_start_die != 0 && level < saved_level)
2571                 return 1;
2572               continue;
2573             }
2574
2575           if (!do_loc)
2576             {
2577               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2578                 do_printing = 0;
2579               else
2580                 {
2581                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2582                     saved_level = level;
2583                   do_printing = (dwarf_cutoff_level == -1
2584                                  || level < dwarf_cutoff_level);
2585                   if (do_printing)
2586                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2587                             level, die_offset, abbrev_number);
2588                   else if (dwarf_cutoff_level == -1
2589                            || last_level < dwarf_cutoff_level)
2590                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2591                   last_level = level;
2592                 }
2593             }
2594
2595           /* Scan through the abbreviation list until we reach the
2596              correct entry.  */
2597           for (entry = first_abbrev;
2598                entry && entry->entry != abbrev_number;
2599                entry = entry->next)
2600             continue;
2601
2602           if (entry == NULL)
2603             {
2604               if (!do_loc && do_printing)
2605                 {
2606                   printf ("\n");
2607                   fflush (stdout);
2608                 }
2609               warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2610                     die_offset, abbrev_number);
2611               return 0;
2612             }
2613
2614           if (!do_loc && do_printing)
2615             printf (" (%s)\n", get_TAG_name (entry->tag));
2616
2617           switch (entry->tag)
2618             {
2619             default:
2620               need_base_address = 0;
2621               break;
2622             case DW_TAG_compile_unit:
2623               need_base_address = 1;
2624               break;
2625             case DW_TAG_entry_point:
2626             case DW_TAG_subprogram:
2627               need_base_address = 0;
2628               /* Assuming that there is no DW_AT_frame_base.  */
2629               have_frame_base = 0;
2630               break;
2631             }
2632
2633           for (attr = entry->first_attr;
2634                attr && attr->attribute;
2635                attr = attr->next)
2636             {
2637               debug_info *arg;
2638
2639               if (! do_loc && do_printing)
2640                 /* Show the offset from where the tag was extracted.  */
2641                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2642
2643               if (debug_information && unit < alloc_num_debug_info_entries)
2644                 arg = debug_information + unit;
2645               else
2646                 arg = NULL;
2647
2648               tags = read_and_display_attr (attr->attribute,
2649                                             attr->form,
2650                                             tags,
2651                                             end,
2652                                             cu_offset,
2653                                             compunit.cu_pointer_size,
2654                                             offset_size,
2655                                             compunit.cu_version,
2656                                             arg,
2657                                             do_loc || ! do_printing,
2658                                             section,
2659                                             this_set);
2660             }
2661
2662           if (entry->children)
2663             ++level;
2664         }
2665     }
2666
2667   /* Set num_debug_info_entries here so that it can be used to check if
2668      we need to process .debug_loc and .debug_ranges sections.  */
2669   if ((do_loc || do_debug_loc || do_debug_ranges)
2670       && num_debug_info_entries == 0
2671       && ! do_types)
2672     {
2673       if (num_units > alloc_num_debug_info_entries)
2674         num_debug_info_entries = alloc_num_debug_info_entries;
2675       else
2676         num_debug_info_entries = num_units;
2677     }
2678
2679   if (!do_loc)
2680     printf ("\n");
2681
2682   return 1;
2683 }
2684
2685 /* Locate and scan the .debug_info section in the file and record the pointer
2686    sizes and offsets for the compilation units in it.  Usually an executable
2687    will have just one pointer size, but this is not guaranteed, and so we try
2688    not to make any assumptions.  Returns zero upon failure, or the number of
2689    compilation units upon success.  */
2690
2691 static unsigned int
2692 load_debug_info (void * file)
2693 {
2694   /* Reset the last pointer size so that we can issue correct error
2695      messages if we are displaying the contents of more than one section.  */
2696   last_pointer_size = 0;
2697   warned_about_missing_comp_units = FALSE;
2698
2699   /* If we have already tried and failed to load the .debug_info
2700      section then do not bother to repeat the task.  */
2701   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2702     return 0;
2703
2704   /* If we already have the information there is nothing else to do.  */
2705   if (num_debug_info_entries > 0)
2706     return num_debug_info_entries;
2707
2708   /* If this is a DWARF package file, load the CU and TU indexes.  */
2709   load_cu_tu_indexes (file);
2710
2711   if (load_debug_section (info, file)
2712       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2713     return num_debug_info_entries;
2714
2715   if (load_debug_section (info_dwo, file)
2716       && process_debug_info (&debug_displays [info_dwo].section, file,
2717                              abbrev_dwo, 1, 0))
2718     return num_debug_info_entries;
2719
2720   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2721   return 0;
2722 }
2723
2724 /* Read a DWARF .debug_line section header starting at DATA.
2725    Upon success returns an updated DATA pointer and the LINFO
2726    structure and the END_OF_SEQUENCE pointer will be filled in.
2727    Otherwise returns NULL.  */
2728
2729 static unsigned char *
2730 read_debug_line_header (struct dwarf_section * section,
2731                         unsigned char * data,
2732                         unsigned char * end,
2733                         DWARF2_Internal_LineInfo * linfo,
2734                         unsigned char ** end_of_sequence)
2735 {
2736   unsigned char *hdrptr;
2737   unsigned int offset_size;
2738   unsigned int initial_length_size;
2739
2740   /* Extract information from the Line Number Program Header.
2741      (section 6.2.4 in the Dwarf3 doc).  */
2742   hdrptr = data;
2743
2744   /* Get and check the length of the block.  */
2745   SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2746
2747   if (linfo->li_length == 0xffffffff)
2748     {
2749       /* This section is 64-bit DWARF 3.  */
2750       SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2751       offset_size = 8;
2752       initial_length_size = 12;
2753     }
2754   else
2755     {
2756       offset_size = 4;
2757       initial_length_size = 4;
2758     }
2759
2760   if (linfo->li_length + initial_length_size > section->size)
2761     {
2762       /* If the length is just a bias against the initial_length_size then
2763          this means that the field has a relocation against it which has not
2764          been applied.  (Ie we are dealing with an object file, not a linked
2765          binary).  Do not complain but instead assume that the rest of the
2766          section applies to this particular header.  */
2767       if (linfo->li_length == - initial_length_size)
2768         {
2769           linfo->li_length = section->size - initial_length_size;
2770         }
2771       else
2772         {
2773           warn (_("The line info appears to be corrupt - the section is too small\n"));
2774           return NULL;
2775         }
2776     }
2777
2778   /* Get and check the version number.  */
2779   SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2780
2781   if (linfo->li_version != 2
2782       && linfo->li_version != 3
2783       && linfo->li_version != 4)
2784     {
2785       warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2786       return NULL;
2787     }
2788
2789   SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2790   SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2791
2792   if (linfo->li_version >= 4)
2793     {
2794       SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2795
2796       if (linfo->li_max_ops_per_insn == 0)
2797         {
2798           warn (_("Invalid maximum operations per insn.\n"));
2799           return NULL;
2800         }
2801     }
2802   else
2803     linfo->li_max_ops_per_insn = 1;
2804
2805   SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2806   SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2807   SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2808   SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2809
2810   * end_of_sequence = data + linfo->li_length + initial_length_size;
2811   /* PR 17512: file:002-117414-0.004.  */
2812   if (* end_of_sequence > end)
2813     {
2814       warn (_("Line length %s extends beyond end of section\n"),
2815             dwarf_vmatoa ("u", linfo->li_length));
2816       * end_of_sequence = end;
2817       return NULL;
2818     }
2819
2820   return hdrptr;
2821 }
2822
2823 static int
2824 display_debug_lines_raw (struct dwarf_section *section,
2825                          unsigned char *data,
2826                          unsigned char *end)
2827 {
2828   unsigned char *start = section->start;
2829
2830   printf (_("Raw dump of debug contents of section %s:\n\n"),
2831           section->name);
2832
2833   while (data < end)
2834     {
2835       static DWARF2_Internal_LineInfo saved_linfo;
2836       DWARF2_Internal_LineInfo linfo;
2837       unsigned char *standard_opcodes;
2838       unsigned char *end_of_sequence;
2839       unsigned int last_dir_entry = 0;
2840       int i;
2841
2842       if (const_strneq (section->name, ".debug_line.")
2843           /* Note: the following does not apply to .debug_line.dwo sections.
2844              These are full debug_line sections.  */
2845           && strcmp (section->name, ".debug_line.dwo") != 0)
2846         {
2847           /* Sections named .debug_line.<foo> are fragments of a .debug_line
2848              section containing just the Line Number Statements.  They are
2849              created by the assembler and intended to be used alongside gcc's
2850              -ffunction-sections command line option.  When the linker's
2851              garbage collection decides to discard a .text.<foo> section it
2852              can then also discard the line number information in .debug_line.<foo>.
2853
2854              Since the section is a fragment it does not have the details
2855              needed to fill out a LineInfo structure, so instead we use the
2856              details from the last full debug_line section that we processed.  */
2857           end_of_sequence = end;
2858           standard_opcodes = NULL;
2859           linfo = saved_linfo;
2860           /* PR 17531: file: 0522b371.  */
2861           if (linfo.li_line_range == 0)
2862             {
2863               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2864               return 0;
2865             }
2866           reset_state_machine (linfo.li_default_is_stmt);
2867         }
2868       else
2869         {
2870           unsigned char * hdrptr;
2871
2872           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2873                                                 & end_of_sequence)) == NULL)
2874             return 0;
2875
2876           printf (_("  Offset:                      0x%lx\n"), (long)(data - start));
2877           printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2878           printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2879           printf (_("  Prologue Length:             %d\n"), (int) linfo.li_prologue_length);
2880           printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2881           if (linfo.li_version >= 4)
2882             printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2883           printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2884           printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2885           printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2886           printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2887
2888           /* PR 17512: file: 1665-6428-0.004.  */
2889           if (linfo.li_line_range == 0)
2890             {
2891               warn (_("Line range of 0 is invalid, using 1 instead\n"));
2892               linfo.li_line_range = 1;
2893             }
2894
2895           reset_state_machine (linfo.li_default_is_stmt);
2896
2897           /* Display the contents of the Opcodes table.  */
2898           standard_opcodes = hdrptr;
2899
2900           /* PR 17512: file: 002-417945-0.004.  */
2901           if (standard_opcodes + linfo.li_opcode_base >= end)
2902             {
2903               warn (_("Line Base extends beyond end of section\n"));
2904               return 0;
2905             }
2906
2907           printf (_("\n Opcodes:\n"));
2908
2909           for (i = 1; i < linfo.li_opcode_base; i++)
2910             printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2911
2912           /* Display the contents of the Directory table.  */
2913           data = standard_opcodes + linfo.li_opcode_base - 1;
2914
2915           if (*data == 0)
2916             printf (_("\n The Directory Table is empty.\n"));
2917           else
2918             {
2919               printf (_("\n The Directory Table (offset 0x%lx):\n"),
2920                       (long)(data - start));
2921
2922               while (data < end && *data != 0)
2923                 {
2924                   printf ("  %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2925
2926                   data += strnlen ((char *) data, end - data) + 1;
2927                 }
2928
2929               /* PR 17512: file: 002-132094-0.004.  */
2930               if (data >= end - 1)
2931                 break;
2932             }
2933
2934           /* Skip the NUL at the end of the table.  */
2935           data++;
2936
2937           /* Display the contents of the File Name table.  */
2938           if (*data == 0)
2939             printf (_("\n The File Name Table is empty.\n"));
2940           else
2941             {
2942               printf (_("\n The File Name Table (offset 0x%lx):\n"),
2943                       (long)(data - start));
2944               printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2945
2946               while (data < end && *data != 0)
2947                 {
2948                   unsigned char *name;
2949                   unsigned int bytes_read;
2950
2951                   printf ("  %d\t", ++state_machine_regs.last_file_entry);
2952                   name = data;
2953                   data += strnlen ((char *) data, end - data) + 1;
2954
2955                   printf ("%s\t",
2956                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2957                   data += bytes_read;
2958                   printf ("%s\t",
2959                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2960                   data += bytes_read;
2961                   printf ("%s\t",
2962                           dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2963                   data += bytes_read;
2964                   printf ("%.*s\n", (int)(end - name), name);
2965
2966                   if (data == end)
2967                     {
2968                       warn (_("Corrupt file name table entry\n"));
2969                       break;
2970                     }
2971                 }
2972             }
2973
2974           /* Skip the NUL at the end of the table.  */
2975           data++;
2976           putchar ('\n');
2977           saved_linfo = linfo;
2978         }
2979
2980       /* Now display the statements.  */
2981       if (data >= end_of_sequence)
2982         printf (_(" No Line Number Statements.\n"));
2983       else
2984         {
2985           printf (_(" Line Number Statements:\n"));
2986
2987           while (data < end_of_sequence)
2988             {
2989               unsigned char op_code;
2990               dwarf_signed_vma adv;
2991               dwarf_vma uladv;
2992               unsigned int bytes_read;
2993
2994               printf ("  [0x%08lx]", (long)(data - start));
2995
2996               op_code = *data++;
2997
2998               if (op_code >= linfo.li_opcode_base)
2999                 {
3000                   op_code -= linfo.li_opcode_base;
3001                   uladv = (op_code / linfo.li_line_range);
3002                   if (linfo.li_max_ops_per_insn == 1)
3003                     {
3004                       uladv *= linfo.li_min_insn_length;
3005                       state_machine_regs.address += uladv;
3006                       printf (_("  Special opcode %d: "
3007                                 "advance Address by %s to 0x%s"),
3008                               op_code, dwarf_vmatoa ("u", uladv),
3009                               dwarf_vmatoa ("x", state_machine_regs.address));
3010                     }
3011                   else
3012                     {
3013                       state_machine_regs.address
3014                         += ((state_machine_regs.op_index + uladv)
3015                             / linfo.li_max_ops_per_insn)
3016                         * linfo.li_min_insn_length;
3017                       state_machine_regs.op_index
3018                         = (state_machine_regs.op_index + uladv)
3019                         % linfo.li_max_ops_per_insn;
3020                       printf (_("  Special opcode %d: "
3021                                 "advance Address by %s to 0x%s[%d]"),
3022                               op_code, dwarf_vmatoa ("u", uladv),
3023                               dwarf_vmatoa ("x", state_machine_regs.address),
3024                               state_machine_regs.op_index);
3025                     }
3026                   adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3027                   state_machine_regs.line += adv;
3028                   printf (_(" and Line by %s to %d\n"),
3029                           dwarf_vmatoa ("d", adv), state_machine_regs.line);
3030                 }
3031               else switch (op_code)
3032                      {
3033                      case DW_LNS_extended_op:
3034                        data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3035                        break;
3036
3037                      case DW_LNS_copy:
3038                        printf (_("  Copy\n"));
3039                        break;
3040
3041                      case DW_LNS_advance_pc:
3042                        uladv = read_uleb128 (data, & bytes_read, end);
3043                        data += bytes_read;
3044                        if (linfo.li_max_ops_per_insn == 1)
3045                          {
3046                            uladv *= linfo.li_min_insn_length;
3047                            state_machine_regs.address += uladv;
3048                            printf (_("  Advance PC by %s to 0x%s\n"),
3049                                    dwarf_vmatoa ("u", uladv),
3050                                    dwarf_vmatoa ("x", state_machine_regs.address));
3051                          }
3052                        else
3053                          {
3054                            state_machine_regs.address
3055                              += ((state_machine_regs.op_index + uladv)
3056                                  / linfo.li_max_ops_per_insn)
3057                              * linfo.li_min_insn_length;
3058                            state_machine_regs.op_index
3059                              = (state_machine_regs.op_index + uladv)
3060                              % linfo.li_max_ops_per_insn;
3061                            printf (_("  Advance PC by %s to 0x%s[%d]\n"),
3062                                    dwarf_vmatoa ("u", uladv),
3063                                    dwarf_vmatoa ("x", state_machine_regs.address),
3064                                    state_machine_regs.op_index);
3065                          }
3066                        break;
3067
3068                      case DW_LNS_advance_line:
3069                        adv = read_sleb128 (data, & bytes_read, end);
3070                        data += bytes_read;
3071                        state_machine_regs.line += adv;
3072                        printf (_("  Advance Line by %s to %d\n"),
3073                                dwarf_vmatoa ("d", adv),
3074                                state_machine_regs.line);
3075                        break;
3076
3077                      case DW_LNS_set_file:
3078                        adv = read_uleb128 (data, & bytes_read, end);
3079                        data += bytes_read;
3080                        printf (_("  Set File Name to entry %s in the File Name Table\n"),
3081                                dwarf_vmatoa ("d", adv));
3082                        state_machine_regs.file = adv;
3083                        break;
3084
3085                      case DW_LNS_set_column:
3086                        uladv = read_uleb128 (data, & bytes_read, end);
3087                        data += bytes_read;
3088                        printf (_("  Set column to %s\n"),
3089                                dwarf_vmatoa ("u", uladv));
3090                        state_machine_regs.column = uladv;
3091                        break;
3092
3093                      case DW_LNS_negate_stmt:
3094                        adv = state_machine_regs.is_stmt;
3095                        adv = ! adv;
3096                        printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3097                        state_machine_regs.is_stmt = adv;
3098                        break;
3099
3100                      case DW_LNS_set_basic_block:
3101                        printf (_("  Set basic block\n"));
3102                        state_machine_regs.basic_block = 1;
3103                        break;
3104
3105                      case DW_LNS_const_add_pc:
3106                        uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3107                        if (linfo.li_max_ops_per_insn)
3108                          {
3109                            uladv *= linfo.li_min_insn_length;
3110                            state_machine_regs.address += uladv;
3111                            printf (_("  Advance PC by constant %s to 0x%s\n"),
3112                                    dwarf_vmatoa ("u", uladv),
3113                                    dwarf_vmatoa ("x", state_machine_regs.address));
3114                          }
3115                        else
3116                          {
3117                            state_machine_regs.address
3118                              += ((state_machine_regs.op_index + uladv)
3119                                  / linfo.li_max_ops_per_insn)
3120                              * linfo.li_min_insn_length;
3121                            state_machine_regs.op_index
3122                              = (state_machine_regs.op_index + uladv)
3123                              % linfo.li_max_ops_per_insn;
3124                            printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
3125                                    dwarf_vmatoa ("u", uladv),
3126                                    dwarf_vmatoa ("x", state_machine_regs.address),
3127                                    state_machine_regs.op_index);
3128                          }
3129                        break;
3130
3131                      case DW_LNS_fixed_advance_pc:
3132                        SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3133                        state_machine_regs.address += uladv;
3134                        state_machine_regs.op_index = 0;
3135                        printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
3136                                dwarf_vmatoa ("u", uladv),
3137                                dwarf_vmatoa ("x", state_machine_regs.address));
3138                        break;
3139
3140                      case DW_LNS_set_prologue_end:
3141                        printf (_("  Set prologue_end to true\n"));
3142                        break;
3143
3144                      case DW_LNS_set_epilogue_begin:
3145                        printf (_("  Set epilogue_begin to true\n"));
3146                        break;
3147
3148                      case DW_LNS_set_isa:
3149                        uladv = read_uleb128 (data, & bytes_read, end);
3150                        data += bytes_read;
3151                        printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3152                        break;
3153
3154                      default:
3155                        printf (_("  Unknown opcode %d with operands: "), op_code);
3156
3157                        if (standard_opcodes != NULL)
3158                          for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3159                            {
3160                              printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3161                                                                                 &bytes_read, end)),
3162                                      i == 1 ? "" : ", ");
3163                              data += bytes_read;
3164                            }
3165                        putchar ('\n');
3166                        break;
3167                      }
3168             }
3169           putchar ('\n');
3170         }
3171     }
3172
3173   return 1;
3174 }
3175
3176 typedef struct
3177 {
3178   unsigned char *name;
3179   unsigned int directory_index;
3180   unsigned int modification_date;
3181   unsigned int length;
3182 } File_Entry;
3183
3184 /* Output a decoded representation of the .debug_line section.  */
3185
3186 static int
3187 display_debug_lines_decoded (struct dwarf_section *section,
3188                              unsigned char *data,
3189                              unsigned char *end)
3190 {
3191   static DWARF2_Internal_LineInfo saved_linfo;
3192
3193   printf (_("Decoded dump of debug contents of section %s:\n\n"),
3194           section->name);
3195
3196   while (data < end)
3197     {
3198       /* This loop amounts to one iteration per compilation unit.  */
3199       DWARF2_Internal_LineInfo linfo;
3200       unsigned char *standard_opcodes;
3201       unsigned char *end_of_sequence;
3202       int i;
3203       File_Entry *file_table = NULL;
3204       unsigned int n_files = 0;
3205       unsigned char **directory_table = NULL;
3206       unsigned int n_directories = 0;
3207
3208       if (const_strneq (section->name, ".debug_line.")
3209           /* Note: the following does not apply to .debug_line.dwo sections.
3210              These are full debug_line sections.  */
3211           && strcmp (section->name, ".debug_line.dwo") != 0)
3212         {
3213           /* See comment in display_debug_lines_raw().  */
3214           end_of_sequence = end;
3215           standard_opcodes = NULL;
3216           linfo = saved_linfo;
3217           /* PR 17531: file: 0522b371.  */
3218           if (linfo.li_line_range == 0)
3219             {
3220               warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3221               return 0;
3222             }
3223           reset_state_machine (linfo.li_default_is_stmt);
3224         }
3225       else
3226         {
3227           unsigned char *hdrptr;
3228
3229           if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3230                                                 & end_of_sequence)) == NULL)
3231               return 0;
3232
3233           /* PR 17531: file: 0522b371.  */
3234           if (linfo.li_line_range == 0)
3235             {
3236               warn (_("Line range of 0 is invalid, using 1 instead\n"));
3237               linfo.li_line_range = 1;
3238             }
3239           reset_state_machine (linfo.li_default_is_stmt);
3240
3241           /* Save a pointer to the contents of the Opcodes table.  */
3242           standard_opcodes = hdrptr;
3243
3244           /* Traverse the Directory table just to count entries.  */
3245           data = standard_opcodes + linfo.li_opcode_base - 1;
3246           if (*data != 0)
3247             {
3248               unsigned char *ptr_directory_table = data;
3249
3250               while (*data != 0)
3251                 {
3252                   data += strnlen ((char *) data, end - data) + 1;
3253                   n_directories++;
3254                 }
3255
3256               /* Go through the directory table again to save the directories.  */
3257               directory_table = (unsigned char **)
3258                 xmalloc (n_directories * sizeof (unsigned char *));
3259
3260               i = 0;
3261               while (*ptr_directory_table != 0)
3262                 {
3263                   directory_table[i] = ptr_directory_table;
3264                   ptr_directory_table += strnlen ((char *) ptr_directory_table,
3265                                                   ptr_directory_table - end) + 1;
3266                   i++;
3267                 }
3268             }
3269           /* Skip the NUL at the end of the table.  */
3270           data++;
3271
3272           /* Traverse the File Name table just to count the entries.  */
3273           if (*data != 0)
3274             {
3275               unsigned char *ptr_file_name_table = data;
3276
3277               while (*data != 0)
3278                 {
3279                   unsigned int bytes_read;
3280
3281                   /* Skip Name, directory index, last modification time and length
3282                      of file.  */
3283                   data += strnlen ((char *) data, end - data) + 1;
3284                   read_uleb128 (data, & bytes_read, end);
3285                   data += bytes_read;
3286                   read_uleb128 (data, & bytes_read, end);
3287                   data += bytes_read;
3288                   read_uleb128 (data, & bytes_read, end);
3289                   data += bytes_read;
3290
3291                   n_files++;
3292                 }
3293
3294               /* Go through the file table again to save the strings.  */
3295               file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3296
3297               i = 0;
3298               while (*ptr_file_name_table != 0)
3299                 {
3300                   unsigned int bytes_read;
3301
3302                   file_table[i].name = ptr_file_name_table;
3303                   ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3304                                                   end - ptr_file_name_table) + 1;
3305
3306                   /* We are not interested in directory, time or size.  */
3307                   file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3308                                                                 & bytes_read, end);
3309                   ptr_file_name_table += bytes_read;
3310                   file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3311                                                                   & bytes_read, end);
3312                   ptr_file_name_table += bytes_read;
3313                   file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3314                   ptr_file_name_table += bytes_read;
3315                   i++;
3316                 }
3317               i = 0;
3318
3319               /* Print the Compilation Unit's name and a header.  */
3320               if (directory_table == NULL)
3321                 {
3322                   printf (_("CU: %s:\n"), file_table[0].name);
3323                   printf (_("File name                            Line number    Starting address\n"));
3324                 }
3325               else
3326                 {
3327                   unsigned int ix = file_table[0].directory_index;
3328                   const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3329
3330                   if (do_wide || strlen (directory) < 76)
3331                     printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3332                   else
3333                     printf ("%s:\n", file_table[0].name);
3334
3335                   printf (_("File name                            Line number    Starting address\n"));
3336                 }
3337             }
3338
3339           /* Skip the NUL at the end of the table.  */
3340           data++;
3341
3342           saved_linfo = linfo;
3343         }
3344
3345       /* This loop iterates through the Dwarf Line Number Program.  */
3346       while (data < end_of_sequence)
3347         {
3348           unsigned char op_code;
3349           int adv;
3350           unsigned long int uladv;
3351           unsigned int bytes_read;
3352           int is_special_opcode = 0;
3353
3354           op_code = *data++;
3355
3356           if (op_code >= linfo.li_opcode_base)
3357             {
3358               op_code -= linfo.li_opcode_base;
3359               uladv = (op_code / linfo.li_line_range);
3360               if (linfo.li_max_ops_per_insn == 1)
3361                 {
3362                   uladv *= linfo.li_min_insn_length;
3363                   state_machine_regs.address += uladv;
3364                 }
3365               else
3366                 {
3367                   state_machine_regs.address
3368                     += ((state_machine_regs.op_index + uladv)
3369                         / linfo.li_max_ops_per_insn)
3370                     * linfo.li_min_insn_length;
3371                   state_machine_regs.op_index
3372                     = (state_machine_regs.op_index + uladv)
3373                     % linfo.li_max_ops_per_insn;
3374                 }
3375
3376               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3377               state_machine_regs.line += adv;
3378               is_special_opcode = 1;
3379             }
3380           else switch (op_code)
3381                  {
3382                  case DW_LNS_extended_op:
3383                    {
3384                      unsigned int ext_op_code_len;
3385                      unsigned char ext_op_code;
3386                      unsigned char *op_code_data = data;
3387
3388                      ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3389                                                      end_of_sequence);
3390                      op_code_data += bytes_read;
3391
3392                      if (ext_op_code_len == 0)
3393                        {
3394                          warn (_("Badly formed extended line op encountered!\n"));
3395                          break;
3396                        }
3397                      ext_op_code_len += bytes_read;
3398                      ext_op_code = *op_code_data++;
3399
3400                      switch (ext_op_code)
3401                        {
3402                        case DW_LNE_end_sequence:
3403                          reset_state_machine (linfo.li_default_is_stmt);
3404                          break;
3405                        case DW_LNE_set_address:
3406                          SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3407                                                 op_code_data,
3408                                                 ext_op_code_len - bytes_read - 1,
3409                                                 end);
3410                          state_machine_regs.op_index = 0;
3411                          break;
3412                        case DW_LNE_define_file:
3413                          {
3414                            file_table = (File_Entry *) xrealloc
3415                              (file_table, (n_files + 1) * sizeof (File_Entry));
3416
3417                            ++state_machine_regs.last_file_entry;
3418                            /* Source file name.  */
3419                            file_table[n_files].name = op_code_data;
3420                            op_code_data += strlen ((char *) op_code_data) + 1;
3421                            /* Directory index.  */
3422                            file_table[n_files].directory_index =
3423                              read_uleb128 (op_code_data, & bytes_read,
3424                                            end_of_sequence);
3425                            op_code_data += bytes_read;
3426                            /* Last modification time.  */
3427                            file_table[n_files].modification_date =
3428                              read_uleb128 (op_code_data, & bytes_read,
3429                                            end_of_sequence);
3430                            op_code_data += bytes_read;
3431                            /* File length.  */
3432                            file_table[n_files].length =
3433                              read_uleb128 (op_code_data, & bytes_read,
3434                                            end_of_sequence);
3435
3436                            n_files++;
3437                            break;
3438                          }
3439                        case DW_LNE_set_discriminator:
3440                        case DW_LNE_HP_set_sequence:
3441                          /* Simply ignored.  */
3442                          break;
3443
3444                        default:
3445                          printf (_("UNKNOWN (%u): length %d\n"),
3446                                  ext_op_code, ext_op_code_len - bytes_read);
3447                          break;
3448                        }
3449                      data += ext_op_code_len;
3450                      break;
3451                    }
3452                  case DW_LNS_copy:
3453                    break;
3454
3455                  case DW_LNS_advance_pc:
3456                    uladv = read_uleb128 (data, & bytes_read, end);
3457                    data += bytes_read;
3458                    if (linfo.li_max_ops_per_insn == 1)
3459                      {
3460                        uladv *= linfo.li_min_insn_length;
3461                        state_machine_regs.address += uladv;
3462                      }
3463                    else
3464                      {
3465                        state_machine_regs.address
3466                          += ((state_machine_regs.op_index + uladv)
3467                              / linfo.li_max_ops_per_insn)
3468                          * linfo.li_min_insn_length;
3469                        state_machine_regs.op_index
3470                          = (state_machine_regs.op_index + uladv)
3471                          % linfo.li_max_ops_per_insn;
3472                      }
3473                    break;
3474
3475                  case DW_LNS_advance_line:
3476                    adv = read_sleb128 (data, & bytes_read, end);
3477                    data += bytes_read;
3478                    state_machine_regs.line += adv;
3479                    break;
3480
3481                  case DW_LNS_set_file:
3482                    adv = read_uleb128 (data, & bytes_read, end);
3483                    data += bytes_read;
3484                    state_machine_regs.file = adv;
3485
3486                    if (file_table == NULL)
3487                      printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3488                    else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3489                      /* If directory index is 0, that means current directory.  */
3490                      printf ("\n./%s:[++]\n",
3491                              file_table[state_machine_regs.file - 1].name);
3492                    else if (directory_table == NULL)
3493                      printf (_("\n [Use directory table entry %d]\n"),
3494                              file_table[state_machine_regs.file - 1].directory_index - 1);
3495                    else
3496                      /* The directory index starts counting at 1.  */
3497                      printf ("\n%s/%s:\n",
3498                              directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3499                              file_table[state_machine_regs.file - 1].name);
3500                    break;
3501
3502                  case DW_LNS_set_column:
3503                    uladv = read_uleb128 (data, & bytes_read, end);
3504                    data += bytes_read;
3505                    state_machine_regs.column = uladv;
3506                    break;
3507
3508                  case DW_LNS_negate_stmt:
3509                    adv = state_machine_regs.is_stmt;
3510                    adv = ! adv;
3511                    state_machine_regs.is_stmt = adv;
3512                    break;
3513
3514                  case DW_LNS_set_basic_block:
3515                    state_machine_regs.basic_block = 1;
3516                    break;
3517
3518                  case DW_LNS_const_add_pc:
3519                    uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3520                    if (linfo.li_max_ops_per_insn == 1)
3521                      {
3522                        uladv *= linfo.li_min_insn_length;
3523                        state_machine_regs.address += uladv;
3524                      }
3525                    else
3526                      {
3527                        state_machine_regs.address
3528                          += ((state_machine_regs.op_index + uladv)
3529                              / linfo.li_max_ops_per_insn)
3530                          * linfo.li_min_insn_length;
3531                        state_machine_regs.op_index
3532                          = (state_machine_regs.op_index + uladv)
3533                          % linfo.li_max_ops_per_insn;
3534                      }
3535                    break;
3536
3537                  case DW_LNS_fixed_advance_pc:
3538                    SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3539                    state_machine_regs.address += uladv;
3540                    state_machine_regs.op_index = 0;
3541                    break;
3542
3543                  case DW_LNS_set_prologue_end:
3544                    break;
3545
3546                  case DW_LNS_set_epilogue_begin:
3547                    break;
3548
3549                  case DW_LNS_set_isa:
3550                    uladv = read_uleb128 (data, & bytes_read, end);
3551                    data += bytes_read;
3552                    printf (_("  Set ISA to %lu\n"), uladv);
3553                    break;
3554
3555                  default:
3556                    printf (_("  Unknown opcode %d with operands: "), op_code);
3557
3558                    if (standard_opcodes != NULL)
3559                      for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3560                        {
3561                          printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3562                                                                             &bytes_read, end)),
3563                                  i == 1 ? "" : ", ");
3564                          data += bytes_read;
3565                        }
3566                    putchar ('\n');
3567                    break;
3568                  }
3569
3570           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3571              to the DWARF address/line matrix.  */
3572           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3573               || (op_code == DW_LNS_copy))
3574             {
3575               const unsigned int MAX_FILENAME_LENGTH = 35;
3576               char *fileName;
3577               char *newFileName = NULL;
3578               size_t fileNameLength;
3579
3580               if (file_table)
3581                 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3582               else
3583                 fileName = "<unknown>";
3584
3585               fileNameLength = strlen (fileName);
3586
3587               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3588                 {
3589                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3590                   /* Truncate file name */
3591                   strncpy (newFileName,
3592                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3593                            MAX_FILENAME_LENGTH + 1);
3594                 }
3595               else
3596                 {
3597                   newFileName = (char *) xmalloc (fileNameLength + 1);
3598                   strncpy (newFileName, fileName, fileNameLength + 1);
3599                 }
3600
3601               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3602                 {
3603                   if (linfo.li_max_ops_per_insn == 1)
3604                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3605                             newFileName, state_machine_regs.line,
3606                             state_machine_regs.address);
3607                   else
3608                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3609                             newFileName, state_machine_regs.line,
3610                             state_machine_regs.address,
3611                             state_machine_regs.op_index);
3612                 }
3613               else
3614                 {
3615                   if (linfo.li_max_ops_per_insn == 1)
3616                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3617                             newFileName, state_machine_regs.line,
3618                             state_machine_regs.address);
3619                   else
3620                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3621                             newFileName, state_machine_regs.line,
3622                             state_machine_regs.address,
3623                             state_machine_regs.op_index);
3624                 }
3625
3626               if (op_code == DW_LNE_end_sequence)
3627                 printf ("\n");
3628
3629               free (newFileName);
3630             }
3631         }
3632
3633       if (file_table)
3634         {
3635           free (file_table);
3636           file_table = NULL;
3637           n_files = 0;
3638         }
3639
3640       if (directory_table)
3641         {
3642           free (directory_table);
3643           directory_table = NULL;
3644           n_directories = 0;
3645         }
3646
3647       putchar ('\n');
3648     }
3649
3650   return 1;
3651 }
3652
3653 static int
3654 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3655 {
3656   unsigned char *data = section->start;
3657   unsigned char *end = data + section->size;
3658   int retValRaw = 1;
3659   int retValDecoded = 1;
3660
3661   if (do_debug_lines == 0)
3662     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3663
3664   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3665     retValRaw = display_debug_lines_raw (section, data, end);
3666
3667   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3668     retValDecoded = display_debug_lines_decoded (section, data, end);
3669
3670   if (!retValRaw || !retValDecoded)
3671     return 0;
3672
3673   return 1;
3674 }
3675
3676 static debug_info *
3677 find_debug_info_for_offset (unsigned long offset)
3678 {
3679   unsigned int i;
3680
3681   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3682     return NULL;
3683
3684   for (i = 0; i < num_debug_info_entries; i++)
3685     if (debug_information[i].cu_offset == offset)
3686       return debug_information + i;
3687
3688   return NULL;
3689 }
3690
3691 static const char *
3692 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3693 {
3694   /* See gdb/gdb-index.h.  */
3695   static const char * const kinds[] =
3696   {
3697     N_ ("no info"),
3698     N_ ("type"),
3699     N_ ("variable"),
3700     N_ ("function"),
3701     N_ ("other"),
3702     N_ ("unused5"),
3703     N_ ("unused6"),
3704     N_ ("unused7")
3705   };
3706
3707   return _ (kinds[kind]);
3708 }
3709
3710 static int
3711 display_debug_pubnames_worker (struct dwarf_section *section,
3712                                void *file ATTRIBUTE_UNUSED,
3713                                int is_gnu)
3714 {
3715   DWARF2_Internal_PubNames names;
3716   unsigned char *start = section->start;
3717   unsigned char *end = start + section->size;
3718
3719   /* It does not matter if this load fails,
3720      we test for that later on.  */
3721   load_debug_info (file);
3722
3723   printf (_("Contents of the %s section:\n\n"), section->name);
3724
3725   while (start < end)
3726     {
3727       unsigned char *data;
3728       unsigned char *adr;
3729       dwarf_vma offset;
3730       unsigned int offset_size, initial_length_size;
3731
3732       data = start;
3733
3734       SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
3735       if (names.pn_length == 0xffffffff)
3736         {
3737           SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
3738           offset_size = 8;
3739           initial_length_size = 12;
3740         }
3741       else
3742         {
3743           offset_size = 4;
3744           initial_length_size = 4;
3745         }
3746
3747       SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3748       SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
3749
3750       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3751           && num_debug_info_entries > 0
3752           && find_debug_info_for_offset (names.pn_offset) == NULL)
3753         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3754               (unsigned long) names.pn_offset, section->name);
3755
3756       SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
3757
3758       adr = start + names.pn_length + initial_length_size;
3759       /* PR 17531: file: 7615b6b2.  */
3760       if ((dwarf_signed_vma) names.pn_length < 0
3761           /* PR 17531: file: a5dbeaa7. */
3762           || adr < start)
3763         {
3764           warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3765           start = end;
3766         }
3767       else
3768         start = adr;
3769
3770       printf (_("  Length:                              %ld\n"),
3771               (long) names.pn_length);
3772       printf (_("  Version:                             %d\n"),
3773               names.pn_version);
3774       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3775               (unsigned long) names.pn_offset);
3776       printf (_("  Size of area in .debug_info section: %ld\n"),
3777               (long) names.pn_size);
3778
3779       if (names.pn_version != 2 && names.pn_version != 3)
3780         {
3781           static int warned = 0;
3782
3783           if (! warned)
3784             {
3785               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3786               warned = 1;
3787             }
3788
3789           continue;
3790         }
3791
3792       if (is_gnu)
3793         printf (_("\n    Offset  Kind          Name\n"));
3794       else
3795         printf (_("\n    Offset\tName\n"));
3796
3797       do
3798         {
3799           bfd_size_type maxprint;
3800
3801           SAFE_BYTE_GET (offset, data, offset_size, end);
3802
3803           if (offset != 0)
3804             {
3805               data += offset_size;
3806               if (data >= end)
3807                 break;
3808               maxprint = (end - data) - 1;
3809
3810               if (is_gnu)
3811                 {
3812                   unsigned int kind_data;
3813                   gdb_index_symbol_kind kind;
3814                   const char *kind_name;
3815                   int is_static;
3816
3817                   SAFE_BYTE_GET (kind_data, data, 1, end);
3818                   data++;
3819                   maxprint --;
3820                   /* GCC computes the kind as the upper byte in the CU index
3821                      word, and then right shifts it by the CU index size.
3822                      Left shift KIND to where the gdb-index.h accessor macros
3823                      can use it.  */
3824                   kind_data <<= GDB_INDEX_CU_BITSIZE;
3825                   kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3826                   kind_name = get_gdb_index_symbol_kind_name (kind);
3827                   is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
3828                   printf ("    %-6lx  %s,%-10s  %.*s\n",
3829                           (unsigned long) offset, is_static ? _("s") : _("g"),
3830                           kind_name, (int) maxprint, data);
3831                 }
3832               else
3833                 printf ("    %-6lx\t%.*s\n",
3834                         (unsigned long) offset, (int) maxprint, data);
3835
3836               data += strnlen ((char *) data, maxprint) + 1;
3837               if (data >= end)
3838                 break;
3839             }
3840         }
3841       while (offset != 0);
3842     }
3843
3844   printf ("\n");
3845   return 1;
3846 }
3847
3848 static int
3849 display_debug_pubnames (struct dwarf_section *section, void *file)
3850 {
3851   return display_debug_pubnames_worker (section, file, 0);
3852 }
3853
3854 static int
3855 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3856 {
3857   return display_debug_pubnames_worker (section, file, 1);
3858 }
3859
3860 static int
3861 display_debug_macinfo (struct dwarf_section *section,
3862                        void *file ATTRIBUTE_UNUSED)
3863 {
3864   unsigned char *start = section->start;
3865   unsigned char *end = start + section->size;
3866   unsigned char *curr = start;
3867   unsigned int bytes_read;
3868   enum dwarf_macinfo_record_type op;
3869
3870   printf (_("Contents of the %s section:\n\n"), section->name);
3871
3872   while (curr < end)
3873     {
3874       unsigned int lineno;
3875       const unsigned char *string;
3876
3877       op = (enum dwarf_macinfo_record_type) *curr;
3878       curr++;
3879
3880       switch (op)
3881         {
3882         case DW_MACINFO_start_file:
3883           {
3884             unsigned int filenum;
3885
3886             lineno = read_uleb128 (curr, & bytes_read, end);
3887             curr += bytes_read;
3888             filenum = read_uleb128 (curr, & bytes_read, end);
3889             curr += bytes_read;
3890
3891             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3892                     lineno, filenum);
3893           }
3894           break;
3895
3896         case DW_MACINFO_end_file:
3897           printf (_(" DW_MACINFO_end_file\n"));
3898           break;
3899
3900         case DW_MACINFO_define:
3901           lineno = read_uleb128 (curr, & bytes_read, end);
3902           curr += bytes_read;
3903           string = curr;
3904           curr += strnlen ((char *) string, end - string) + 1;
3905           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3906                   lineno, string);
3907           break;
3908
3909         case DW_MACINFO_undef:
3910           lineno = read_uleb128 (curr, & bytes_read, end);
3911           curr += bytes_read;
3912           string = curr;
3913           curr += strnlen ((char *) string, end - string) + 1;
3914           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3915                   lineno, string);
3916           break;
3917
3918         case DW_MACINFO_vendor_ext:
3919           {
3920             unsigned int constant;
3921
3922             constant = read_uleb128 (curr, & bytes_read, end);
3923             curr += bytes_read;
3924             string = curr;
3925             curr += strnlen ((char *) string, end - string) + 1;
3926             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3927                     constant, string);
3928           }
3929           break;
3930         }
3931     }
3932
3933   return 1;
3934 }
3935
3936 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3937    filename and dirname corresponding to file name table entry with index
3938    FILEIDX.  Return NULL on failure.  */
3939
3940 static unsigned char *
3941 get_line_filename_and_dirname (dwarf_vma line_offset,
3942                                dwarf_vma fileidx,
3943                                unsigned char **dir_name)
3944 {
3945   struct dwarf_section *section = &debug_displays [line].section;
3946   unsigned char *hdrptr, *dirtable, *file_name;
3947   unsigned int offset_size, initial_length_size;
3948   unsigned int version, opcode_base, bytes_read;
3949   dwarf_vma length, diridx;
3950   const unsigned char * end;
3951
3952   *dir_name = NULL;
3953   if (section->start == NULL
3954       || line_offset >= section->size
3955       || fileidx == 0)
3956     return NULL;
3957
3958   hdrptr = section->start + line_offset;
3959   end = section->start + section->size;
3960
3961   SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
3962   if (length == 0xffffffff)
3963     {
3964       /* This section is 64-bit DWARF 3.  */
3965       SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
3966       offset_size = 8;
3967       initial_length_size = 12;
3968     }
3969   else
3970     {
3971       offset_size = 4;
3972       initial_length_size = 4;
3973     }
3974   if (length + initial_length_size > section->size)
3975     return NULL;
3976
3977   SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
3978   if (version != 2 && version != 3 && version != 4)
3979     return NULL;
3980   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
3981   if (version >= 4)
3982     hdrptr++;               /* Skip max_ops_per_insn.  */
3983   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
3984
3985   SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
3986   if (opcode_base == 0)
3987     return NULL;
3988
3989   hdrptr += opcode_base - 1;
3990   dirtable = hdrptr;
3991   /* Skip over dirname table.  */
3992   while (*hdrptr != '\0')
3993     hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3994   hdrptr++;                 /* Skip the NUL at the end of the table.  */
3995   /* Now skip over preceding filename table entries.  */
3996   for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3997     {
3998       hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
3999       read_uleb128 (hdrptr, &bytes_read, end);
4000       hdrptr += bytes_read;
4001       read_uleb128 (hdrptr, &bytes_read, end);
4002       hdrptr += bytes_read;
4003       read_uleb128 (hdrptr, &bytes_read, end);
4004       hdrptr += bytes_read;
4005     }
4006   if (hdrptr == end || *hdrptr == '\0')
4007     return NULL;
4008   file_name = hdrptr;
4009   hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4010   diridx = read_uleb128 (hdrptr, &bytes_read, end);
4011   if (diridx == 0)
4012     return file_name;
4013   for (; *dirtable != '\0' && diridx > 1; diridx--)
4014     dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4015   if (*dirtable == '\0')
4016     return NULL;
4017   *dir_name = dirtable;
4018   return file_name;
4019 }
4020
4021 static int
4022 display_debug_macro (struct dwarf_section *section,
4023                      void *file)
4024 {
4025   unsigned char *start = section->start;
4026   unsigned char *end = start + section->size;
4027   unsigned char *curr = start;
4028   unsigned char *extended_op_buf[256];
4029   unsigned int bytes_read;
4030
4031   load_debug_section (str, file);
4032   load_debug_section (line, file);
4033
4034   printf (_("Contents of the %s section:\n\n"), section->name);
4035
4036   while (curr < end)
4037     {
4038       unsigned int lineno, version, flags;
4039       unsigned int offset_size = 4;
4040       const unsigned char *string;
4041       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4042       unsigned char **extended_ops = NULL;
4043
4044       SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4045       if (version != 4)
4046         {
4047           error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4048                  section->name);
4049           return 0;
4050         }
4051
4052       SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4053       if (flags & 1)
4054         offset_size = 8;
4055       printf (_("  Offset:                      0x%lx\n"),
4056               (unsigned long) sec_offset);
4057       printf (_("  Version:                     %d\n"), version);
4058       printf (_("  Offset size:                 %d\n"), offset_size);
4059       if (flags & 2)
4060         {
4061           SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4062           printf (_("  Offset into .debug_line:     0x%lx\n"),
4063                   (unsigned long) line_offset);
4064         }
4065       if (flags & 4)
4066         {
4067           unsigned int i, count, op;
4068           dwarf_vma nargs, n;
4069
4070           SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4071
4072           memset (extended_op_buf, 0, sizeof (extended_op_buf));
4073           extended_ops = extended_op_buf;
4074           if (count)
4075             {
4076               printf (_("  Extension opcode arguments:\n"));
4077               for (i = 0; i < count; i++)
4078                 {
4079                   SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4080                   extended_ops[op] = curr;
4081                   nargs = read_uleb128 (curr, &bytes_read, end);
4082                   curr += bytes_read;
4083                   if (nargs == 0)
4084                     printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
4085                   else
4086                     {
4087                       printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
4088                       for (n = 0; n < nargs; n++)
4089                         {
4090                           unsigned int form;
4091
4092                           SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4093                           printf ("%s%s", get_FORM_name (form),
4094                                   n == nargs - 1 ? "\n" : ", ");
4095                           switch (form)
4096                             {
4097                             case DW_FORM_data1:
4098                             case DW_FORM_data2:
4099                             case DW_FORM_data4:
4100                             case DW_FORM_data8:
4101                             case DW_FORM_sdata:
4102                             case DW_FORM_udata:
4103                             case DW_FORM_block:
4104                             case DW_FORM_block1:
4105                             case DW_FORM_block2:
4106                             case DW_FORM_block4:
4107                             case DW_FORM_flag:
4108                             case DW_FORM_string:
4109                             case DW_FORM_strp:
4110                             case DW_FORM_sec_offset:
4111                               break;
4112                             default:
4113                               error (_("Invalid extension opcode form %s\n"),
4114                                      get_FORM_name (form));
4115                               return 0;
4116                             }
4117                         }
4118                     }
4119                 }
4120             }
4121         }
4122       printf ("\n");
4123
4124       while (1)
4125         {
4126           unsigned int op;
4127
4128           if (curr >= end)
4129             {
4130               error (_(".debug_macro section not zero terminated\n"));
4131               return 0;
4132             }
4133
4134           SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4135           if (op == 0)
4136             break;
4137
4138           switch (op)
4139             {
4140             case DW_MACRO_GNU_start_file:
4141               {
4142                 unsigned int filenum;
4143                 unsigned char *file_name = NULL, *dir_name = NULL;
4144
4145                 lineno = read_uleb128 (curr, &bytes_read, end);
4146                 curr += bytes_read;
4147                 filenum = read_uleb128 (curr, &bytes_read, end);
4148                 curr += bytes_read;
4149
4150                 if ((flags & 2) == 0)
4151                   error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4152                 else
4153                   file_name
4154                     = get_line_filename_and_dirname (line_offset, filenum,
4155                                                      &dir_name);
4156                 if (file_name == NULL)
4157                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4158                           lineno, filenum);
4159                 else
4160                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4161                           lineno, filenum,
4162                           dir_name != NULL ? (const char *) dir_name : "",
4163                           dir_name != NULL ? "/" : "", file_name);
4164               }
4165               break;
4166
4167             case DW_MACRO_GNU_end_file:
4168               printf (_(" DW_MACRO_GNU_end_file\n"));
4169               break;
4170
4171             case DW_MACRO_GNU_define:
4172               lineno = read_uleb128 (curr, &bytes_read, end);
4173               curr += bytes_read;
4174               string = curr;
4175               curr += strnlen ((char *) string, end - string) + 1;
4176               printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4177                       lineno, string);
4178               break;
4179
4180             case DW_MACRO_GNU_undef:
4181               lineno = read_uleb128 (curr, &bytes_read, end);
4182               curr += bytes_read;
4183               string = curr;
4184               curr += strnlen ((char *) string, end - string) + 1;
4185               printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4186                       lineno, string);
4187               break;
4188
4189             case DW_MACRO_GNU_define_indirect:
4190               lineno = read_uleb128 (curr, &bytes_read, end);
4191               curr += bytes_read;
4192               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4193               string = fetch_indirect_string (offset);
4194               printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4195                       lineno, string);
4196               break;
4197
4198             case DW_MACRO_GNU_undef_indirect:
4199               lineno = read_uleb128 (curr, &bytes_read, end);
4200               curr += bytes_read;
4201               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4202               string = fetch_indirect_string (offset);
4203               printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4204                       lineno, string);
4205               break;
4206
4207             case DW_MACRO_GNU_transparent_include:
4208               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4209               printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4210                       (unsigned long) offset);
4211               break;
4212
4213             case DW_MACRO_GNU_define_indirect_alt:
4214               lineno = read_uleb128 (curr, &bytes_read, end);
4215               curr += bytes_read;
4216               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4217               printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4218                       lineno, (unsigned long) offset);
4219               break;
4220
4221             case DW_MACRO_GNU_undef_indirect_alt:
4222               lineno = read_uleb128 (curr, &bytes_read, end);
4223               curr += bytes_read;
4224               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4225               printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4226                       lineno, (unsigned long) offset);
4227               break;
4228
4229             case DW_MACRO_GNU_transparent_include_alt:
4230               SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4231               printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4232                       (unsigned long) offset);
4233               break;
4234
4235             default:
4236               if (extended_ops == NULL || extended_ops[op] == NULL)
4237                 {
4238                   error (_(" Unknown macro opcode %02x seen\n"), op);
4239                   return 0;
4240                 }
4241               else
4242                 {
4243                   /* Skip over unhandled opcodes.  */
4244                   dwarf_vma nargs, n;
4245                   unsigned char *desc = extended_ops[op];
4246                   nargs = read_uleb128 (desc, &bytes_read, end);
4247                   desc += bytes_read;
4248                   if (nargs == 0)
4249                     {
4250                       printf (_(" DW_MACRO_GNU_%02x\n"), op);
4251                       break;
4252                     }
4253                   printf (_(" DW_MACRO_GNU_%02x -"), op);
4254                   for (n = 0; n < nargs; n++)
4255                     {
4256                       int val;
4257
4258                       SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4259                       curr
4260                         = read_and_display_attr_value (0, val,
4261                                                        curr, end, 0, 0, offset_size,
4262                                                        version, NULL, 0, NULL,
4263                                                        NULL);
4264                       if (n != nargs - 1)
4265                         printf (",");
4266                     }
4267                   printf ("\n");
4268                 }
4269               break;
4270             }
4271         }
4272
4273       printf ("\n");
4274     }
4275
4276   return 1;
4277 }
4278
4279 static int
4280 display_debug_abbrev (struct dwarf_section *section,
4281                       void *file ATTRIBUTE_UNUSED)
4282 {
4283   abbrev_entry *entry;
4284   unsigned char *start = section->start;
4285   unsigned char *end = start + section->size;
4286
4287   printf (_("Contents of the %s section:\n\n"), section->name);
4288
4289   do
4290     {
4291       unsigned char *last;
4292
4293       free_abbrevs ();
4294
4295       last = start;
4296       start = process_abbrev_section (start, end);
4297
4298       if (first_abbrev == NULL)
4299         continue;
4300
4301       printf (_("  Number TAG (0x%lx)\n"), (long) (last - section->start));
4302
4303       for (entry = first_abbrev; entry; entry = entry->next)
4304         {
4305           abbrev_attr *attr;
4306
4307           printf ("   %ld      %s    [%s]\n",
4308                   entry->entry,
4309                   get_TAG_name (entry->tag),
4310                   entry->children ? _("has children") : _("no children"));
4311
4312           for (attr = entry->first_attr; attr; attr = attr->next)
4313             printf ("    %-18s %s\n",
4314                     get_AT_name (attr->attribute),
4315                     get_FORM_name (attr->form));
4316         }
4317     }
4318   while (start);
4319
4320   printf ("\n");
4321
4322   return 1;
4323 }
4324
4325 /* Display a location list from a normal (ie, non-dwo) .debug_loc section.  */
4326
4327 static void
4328 display_loc_list (struct dwarf_section *section,
4329                   unsigned char **start_ptr,
4330                   unsigned int debug_info_entry,
4331                   unsigned long offset,
4332                   unsigned long base_address,
4333                   int has_frame_base)
4334 {
4335   unsigned char *start = *start_ptr;
4336   unsigned char *section_end = section->start + section->size;
4337   unsigned long cu_offset;
4338   unsigned int pointer_size;
4339   unsigned int offset_size;
4340   int dwarf_version;
4341
4342   dwarf_vma begin;
4343   dwarf_vma end;
4344   unsigned short length;
4345   int need_frame_base;
4346
4347   if (debug_info_entry >= num_debug_info_entries)
4348     {
4349       warn (_("No debug information available for loc lists of entry: %u\n"),
4350             debug_info_entry);
4351       return;
4352     }
4353
4354   cu_offset = debug_information [debug_info_entry].cu_offset;
4355   pointer_size = debug_information [debug_info_entry].pointer_size;
4356   offset_size = debug_information [debug_info_entry].offset_size;
4357   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4358
4359   if (pointer_size < 2 || pointer_size > 8)
4360     {
4361       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4362             pointer_size, debug_info_entry);
4363       return;
4364     }
4365
4366   while (1)
4367     {
4368       if (start + 2 * pointer_size > section_end)
4369         {
4370           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4371                 offset);
4372           break;
4373         }
4374
4375       printf ("    %8.8lx ", offset + (start - *start_ptr));
4376
4377       /* Note: we use sign extension here in order to be sure that we can detect
4378          the -1 escape value.  Sign extension into the top 32 bits of a 32-bit
4379          address will not affect the values that we display since we always show
4380          hex values, and always the bottom 32-bits.  */
4381       SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4382       SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4383
4384       if (begin == 0 && end == 0)
4385         {
4386           printf (_("<End of list>\n"));
4387           break;
4388         }
4389
4390       /* Check base address specifiers.  */
4391       if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4392         {
4393           base_address = end;
4394           print_dwarf_vma (begin, pointer_size);
4395           print_dwarf_vma (end, pointer_size);
4396           printf (_("(base address)\n"));
4397           continue;
4398         }
4399
4400       if (start + 2 > section_end)
4401         {
4402           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4403                 offset);
4404           break;
4405         }
4406
4407       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4408
4409       if (start + length > section_end)
4410         {
4411           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4412                 offset);
4413           break;
4414         }
4415
4416       print_dwarf_vma (begin + base_address, pointer_size);
4417       print_dwarf_vma (end + base_address, pointer_size);
4418
4419       putchar ('(');
4420       need_frame_base = decode_location_expression (start,
4421                                                     pointer_size,
4422                                                     offset_size,
4423                                                     dwarf_version,
4424                                                     length,
4425                                                     cu_offset, section);
4426       putchar (')');
4427
4428       if (need_frame_base && !has_frame_base)
4429         printf (_(" [without DW_AT_frame_base]"));
4430
4431       if (begin == end)
4432         fputs (_(" (start == end)"), stdout);
4433       else if (begin > end)
4434         fputs (_(" (start > end)"), stdout);
4435
4436       putchar ('\n');
4437
4438       start += length;
4439     }
4440
4441   *start_ptr = start;
4442 }
4443
4444 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4445    right-adjusted in a field of length LEN, and followed by a space.  */
4446
4447 static void
4448 print_addr_index (unsigned int idx, unsigned int len)
4449 {
4450   static char buf[15];
4451   snprintf (buf, sizeof (buf), "[%d]", idx);
4452   printf ("%*s ", len, buf);
4453 }
4454
4455 /* Display a location list from a .dwo section. It uses address indexes rather
4456    than embedded addresses.  This code closely follows display_loc_list, but the
4457    two are sufficiently different that combining things is very ugly.  */
4458
4459 static void
4460 display_loc_list_dwo (struct dwarf_section *section,
4461                       unsigned char **start_ptr,
4462                       unsigned int debug_info_entry,
4463                       unsigned long offset,
4464                       int has_frame_base)
4465 {
4466   unsigned char *start = *start_ptr;
4467   unsigned char *section_end = section->start + section->size;
4468   unsigned long cu_offset;
4469   unsigned int pointer_size;
4470   unsigned int offset_size;
4471   int dwarf_version;
4472   int entry_type;
4473   unsigned short length;
4474   int need_frame_base;
4475   unsigned int idx;
4476   unsigned int bytes_read;
4477
4478   if (debug_info_entry >= num_debug_info_entries)
4479     {
4480       warn (_("No debug information for loc lists of entry: %u\n"),
4481             debug_info_entry);
4482       return;
4483     }
4484
4485   cu_offset = debug_information [debug_info_entry].cu_offset;
4486   pointer_size = debug_information [debug_info_entry].pointer_size;
4487   offset_size = debug_information [debug_info_entry].offset_size;
4488   dwarf_version = debug_information [debug_info_entry].dwarf_version;
4489
4490   if (pointer_size < 2 || pointer_size > 8)
4491     {
4492       warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4493             pointer_size, debug_info_entry);
4494       return;
4495     }
4496
4497   while (1)
4498     {
4499       printf ("    %8.8lx ", offset + (start - *start_ptr));
4500
4501       if (start >= section_end)
4502         {
4503           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4504                 offset);
4505           break;
4506         }
4507
4508       SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4509       switch (entry_type)
4510         {
4511         case 0: /* A terminating entry.  */
4512           *start_ptr = start;
4513           printf (_("<End of list>\n"));
4514           return;
4515         case 1: /* A base-address entry.  */
4516           idx = read_uleb128 (start, &bytes_read, section_end);
4517           start += bytes_read;
4518           print_addr_index (idx, 8);
4519           printf ("         ");
4520           printf (_("(base address selection entry)\n"));
4521           continue;
4522         case 2: /* A start/end entry.  */
4523           idx = read_uleb128 (start, &bytes_read, section_end);
4524           start += bytes_read;
4525           print_addr_index (idx, 8);
4526           idx = read_uleb128 (start, &bytes_read, section_end);
4527           start += bytes_read;
4528           print_addr_index (idx, 8);
4529           break;
4530         case 3: /* A start/length entry.  */
4531           idx = read_uleb128 (start, &bytes_read, section_end);
4532           start += bytes_read;
4533           print_addr_index (idx, 8);
4534           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4535           printf ("%08x ", idx);
4536           break;
4537         case 4: /* An offset pair entry.  */
4538           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4539           printf ("%08x ", idx);
4540           SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4541           printf ("%08x ", idx);
4542           break;
4543         default:
4544           warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4545           *start_ptr = start;
4546           return;
4547         }
4548
4549       if (start + 2 > section_end)
4550         {
4551           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4552                 offset);
4553           break;
4554         }
4555
4556       SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4557       if (start + length > section_end)
4558         {
4559           warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4560                 offset);
4561           break;
4562         }
4563
4564       putchar ('(');
4565       need_frame_base = decode_location_expression (start,
4566                                                     pointer_size,
4567                                                     offset_size,
4568                                                     dwarf_version,
4569                                                     length,
4570                                                     cu_offset, section);
4571       putchar (')');
4572
4573       if (need_frame_base && !has_frame_base)
4574         printf (_(" [without DW_AT_frame_base]"));
4575
4576       putchar ('\n');
4577
4578       start += length;
4579     }
4580
4581   *start_ptr = start;
4582 }
4583
4584 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
4585
4586 static dwarf_vma *loc_offsets;
4587
4588 static int
4589 loc_offsets_compar (const void *ap, const void *bp)
4590 {
4591   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4592   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4593
4594   return (a > b) - (b > a);
4595 }
4596
4597 static int
4598 display_debug_loc (struct dwarf_section *section, void *file)
4599 {
4600   unsigned char *start = section->start;
4601   unsigned long bytes;
4602   unsigned char *section_begin = start;
4603   unsigned int num_loc_list = 0;
4604   unsigned long last_offset = 0;
4605   unsigned int first = 0;
4606   unsigned int i;
4607   unsigned int j;
4608   unsigned int k;
4609   int seen_first_offset = 0;
4610   int locs_sorted = 1;
4611   unsigned char *next;
4612   unsigned int *array = NULL;
4613   const char *suffix = strrchr (section->name, '.');
4614   int is_dwo = 0;
4615
4616   if (suffix && strcmp (suffix, ".dwo") == 0)
4617     is_dwo = 1;
4618
4619   bytes = section->size;
4620
4621   if (bytes == 0)
4622     {
4623       printf (_("\nThe %s section is empty.\n"), section->name);
4624       return 0;
4625     }
4626
4627   if (load_debug_info (file) == 0)
4628     {
4629       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4630             section->name);
4631       return 0;
4632     }
4633
4634   /* Check the order of location list in .debug_info section. If
4635      offsets of location lists are in the ascending order, we can
4636      use `debug_information' directly.  */
4637   for (i = 0; i < num_debug_info_entries; i++)
4638     {
4639       unsigned int num;
4640
4641       num = debug_information [i].num_loc_offsets;
4642       if (num > num_loc_list)
4643         num_loc_list = num;
4644
4645       /* Check if we can use `debug_information' directly.  */
4646       if (locs_sorted && num != 0)
4647         {
4648           if (!seen_first_offset)
4649             {
4650               /* This is the first location list.  */
4651               last_offset = debug_information [i].loc_offsets [0];
4652               first = i;
4653               seen_first_offset = 1;
4654               j = 1;
4655             }
4656           else
4657             j = 0;
4658
4659           for (; j < num; j++)
4660             {
4661               if (last_offset >
4662                   debug_information [i].loc_offsets [j])
4663                 {
4664                   locs_sorted = 0;
4665                   break;
4666                 }
4667               last_offset = debug_information [i].loc_offsets [j];
4668             }
4669         }
4670     }
4671
4672   if (!seen_first_offset)
4673     error (_("No location lists in .debug_info section!\n"));
4674
4675   if (debug_information [first].num_loc_offsets > 0
4676       && debug_information [first].loc_offsets [0] != 0)
4677     warn (_("Location lists in %s section start at 0x%s\n"),
4678           section->name,
4679           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4680
4681   if (!locs_sorted)
4682     array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4683   printf (_("Contents of the %s section:\n\n"), section->name);
4684   printf (_("    Offset   Begin    End      Expression\n"));
4685
4686   seen_first_offset = 0;
4687   for (i = first; i < num_debug_info_entries; i++)
4688     {
4689       unsigned long offset;
4690       unsigned long base_address;
4691       int has_frame_base;
4692
4693       if (!locs_sorted)
4694         {
4695           for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4696             array[k] = k;
4697           loc_offsets = debug_information [i].loc_offsets;
4698           qsort (array, debug_information [i].num_loc_offsets,
4699                  sizeof (*array), loc_offsets_compar);
4700         }
4701
4702       for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4703         {
4704           j = locs_sorted ? k : array[k];
4705           if (k
4706               && debug_information [i].loc_offsets [locs_sorted
4707                                                     ? k - 1 : array [k - 1]]
4708                  == debug_information [i].loc_offsets [j])
4709             continue;
4710           has_frame_base = debug_information [i].have_frame_base [j];
4711           offset = debug_information [i].loc_offsets [j];
4712           next = section_begin + offset;
4713           base_address = debug_information [i].base_address;
4714
4715           if (!seen_first_offset)
4716             seen_first_offset = 1;
4717           else
4718             {
4719               if (start < next)
4720                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4721                       (unsigned long) (start - section_begin),
4722                       (unsigned long) offset);
4723               else if (start > next)
4724                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4725                       (unsigned long) (start - section_begin),
4726                       (unsigned long) offset);
4727             }
4728           start = next;
4729
4730           if (offset >= bytes)
4731             {
4732               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4733                     offset);
4734               continue;
4735             }
4736
4737           if (is_dwo)
4738             display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4739           else
4740             display_loc_list (section, &start, i, offset, base_address,
4741                               has_frame_base);
4742         }
4743     }
4744
4745   if (start < section->start + section->size)
4746     warn (_("There are %ld unused bytes at the end of section %s\n"),
4747           (long) (section->start + section->size - start), section->name);
4748   putchar ('\n');
4749   free (array);
4750   return 1;
4751 }
4752
4753 static int
4754 display_debug_str (struct dwarf_section *section,
4755                    void *file ATTRIBUTE_UNUSED)
4756 {
4757   unsigned char *start = section->start;
4758   unsigned long bytes = section->size;
4759   dwarf_vma addr = section->address;
4760
4761   if (bytes == 0)
4762     {
4763       printf (_("\nThe %s section is empty.\n"), section->name);
4764       return 0;
4765     }
4766
4767   printf (_("Contents of the %s section:\n\n"), section->name);
4768
4769   while (bytes)
4770     {
4771       int j;
4772       int k;
4773       int lbytes;
4774
4775       lbytes = (bytes > 16 ? 16 : bytes);
4776
4777       printf ("  0x%8.8lx ", (unsigned long) addr);
4778
4779       for (j = 0; j < 16; j++)
4780         {
4781           if (j < lbytes)
4782             printf ("%2.2x", start[j]);
4783           else
4784             printf ("  ");
4785
4786           if ((j & 3) == 3)
4787             printf (" ");
4788         }
4789
4790       for (j = 0; j < lbytes; j++)
4791         {
4792           k = start[j];
4793           if (k >= ' ' && k < 0x80)
4794             printf ("%c", k);
4795           else
4796             printf (".");
4797         }
4798
4799       putchar ('\n');
4800
4801       start += lbytes;
4802       addr  += lbytes;
4803       bytes -= lbytes;
4804     }
4805
4806   putchar ('\n');
4807
4808   return 1;
4809 }
4810
4811 static int
4812 display_debug_info (struct dwarf_section *section, void *file)
4813 {
4814   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4815 }
4816
4817 static int
4818 display_debug_types (struct dwarf_section *section, void *file)
4819 {
4820   return process_debug_info (section, file, section->abbrev_sec, 0, 1);
4821 }
4822
4823 static int
4824 display_trace_info (struct dwarf_section *section, void *file)
4825 {
4826   return process_debug_info (section, file, section->abbrev_sec, 0, 0);
4827 }
4828
4829 static int
4830 display_debug_aranges (struct dwarf_section *section,
4831                        void *file ATTRIBUTE_UNUSED)
4832 {
4833   unsigned char *start = section->start;
4834   unsigned char *end = start + section->size;
4835
4836   printf (_("Contents of the %s section:\n\n"), section->name);
4837
4838   /* It does not matter if this load fails,
4839      we test for that later on.  */
4840   load_debug_info (file);
4841
4842   while (start < end)
4843     {
4844       unsigned char *hdrptr;
4845       DWARF2_Internal_ARange arange;
4846       unsigned char *addr_ranges;
4847       dwarf_vma length;
4848       dwarf_vma address;
4849       unsigned char address_size;
4850       int excess;
4851       unsigned int offset_size;
4852       unsigned int initial_length_size;
4853
4854       hdrptr = start;
4855
4856       SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
4857       if (arange.ar_length == 0xffffffff)
4858         {
4859           SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
4860           offset_size = 8;
4861           initial_length_size = 12;
4862         }
4863       else
4864         {
4865           offset_size = 4;
4866           initial_length_size = 4;
4867         }
4868
4869       SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4870       SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
4871
4872       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4873           && num_debug_info_entries > 0
4874           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4875         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4876               (unsigned long) arange.ar_info_offset, section->name);
4877
4878       SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4879       SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
4880
4881       if (arange.ar_version != 2 && arange.ar_version != 3)
4882         {
4883           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4884           break;
4885         }
4886
4887       printf (_("  Length:                   %ld\n"),
4888               (long) arange.ar_length);
4889       printf (_("  Version:                  %d\n"), arange.ar_version);
4890       printf (_("  Offset into .debug_info:  0x%lx\n"),
4891               (unsigned long) arange.ar_info_offset);
4892       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
4893       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
4894
4895       address_size = arange.ar_pointer_size + arange.ar_segment_size;
4896
4897       /* PR 17512: file: 001-108546-0.001:0.1.  */
4898       if (address_size == 0 || address_size > 8)
4899         {
4900           error (_("Invalid address size in %s section!\n"),
4901                  section->name);
4902           break;
4903         }
4904
4905       /* The DWARF spec does not require that the address size be a power
4906          of two, but we do.  This will have to change if we ever encounter
4907          an uneven architecture.  */
4908       if ((address_size & (address_size - 1)) != 0)
4909         {
4910           warn (_("Pointer size + Segment size is not a power of two.\n"));
4911           break;
4912         }
4913
4914       if (address_size > 4)
4915         printf (_("\n    Address            Length\n"));
4916       else
4917         printf (_("\n    Address    Length\n"));
4918
4919       addr_ranges = hdrptr;
4920
4921       /* Must pad to an alignment boundary that is twice the address size.  */
4922       excess = (hdrptr - start) % (2 * address_size);
4923       if (excess)
4924         addr_ranges += (2 * address_size) - excess;
4925
4926       hdrptr = start + arange.ar_length + initial_length_size;
4927       if (hdrptr < start || hdrptr > end)
4928         {
4929           error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
4930           break;
4931         }
4932       start = hdrptr;
4933
4934       while (addr_ranges + 2 * address_size <= start)
4935         {
4936           SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4937           SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
4938
4939           printf ("    ");
4940           print_dwarf_vma (address, address_size);
4941           print_dwarf_vma (length, address_size);
4942           putchar ('\n');
4943         }
4944     }
4945
4946   printf ("\n");
4947
4948   return 1;
4949 }
4950
4951 /* Comparison function for qsort.  */
4952 static int
4953 comp_addr_base (const void * v0, const void * v1)
4954 {
4955   debug_info * info0 = (debug_info *) v0;
4956   debug_info * info1 = (debug_info *) v1;
4957   return info0->addr_base - info1->addr_base;
4958 }
4959
4960 /* Display the debug_addr section.  */
4961 static int
4962 display_debug_addr (struct dwarf_section *section,
4963                     void *file)
4964 {
4965   debug_info **debug_addr_info;
4966   unsigned char *entry;
4967   unsigned char *end;
4968   unsigned int i;
4969   unsigned int count;
4970
4971   if (section->size == 0)
4972     {
4973       printf (_("\nThe %s section is empty.\n"), section->name);
4974       return 0;
4975     }
4976
4977   if (load_debug_info (file) == 0)
4978     {
4979       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4980             section->name);
4981       return 0;
4982     }
4983
4984   printf (_("Contents of the %s section:\n\n"), section->name);
4985
4986   /* PR  17531: file: cf38d01b.
4987      We use xcalloc because a corrupt file may not have initialised all of the
4988      fields in the debug_info structure, which means that the sort below might
4989      try to move uninitialised data.  */
4990   debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4991                                              sizeof (debug_info *));
4992
4993   count = 0;
4994   for (i = 0; i < num_debug_info_entries; i++)
4995     if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
4996       {
4997         /* PR 17531: file: cf38d01b.  */
4998         if (debug_information[i].addr_base >= section->size)
4999           warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5000                 (unsigned long) debug_information[i].addr_base, i);
5001         else
5002           debug_addr_info [count++] = debug_information + i;
5003       }
5004
5005   /* Add a sentinel to make iteration convenient.  */
5006   debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5007   debug_addr_info [count]->addr_base = section->size;
5008   qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5009
5010   for (i = 0; i < count; i++)
5011     {
5012       unsigned int idx;
5013       unsigned int address_size = debug_addr_info [i]->pointer_size;
5014
5015       printf (_("  For compilation unit at offset 0x%s:\n"),
5016               dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5017
5018       printf (_("\tIndex\tAddress\n"));
5019       entry = section->start + debug_addr_info [i]->addr_base;
5020       end = section->start + debug_addr_info [i + 1]->addr_base;
5021       idx = 0;
5022       while (entry < end)
5023         {
5024           dwarf_vma base = byte_get (entry, address_size);
5025           printf (_("\t%d:\t"), idx);
5026           print_dwarf_vma (base, address_size);
5027           printf ("\n");
5028           entry += address_size;
5029           idx++;
5030         }
5031     }
5032   printf ("\n");
5033
5034   free (debug_addr_info);
5035   return 1;
5036 }
5037
5038 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections.  */
5039 static int
5040 display_debug_str_offsets (struct dwarf_section *section,
5041                            void *file ATTRIBUTE_UNUSED)
5042 {
5043   if (section->size == 0)
5044     {
5045       printf (_("\nThe %s section is empty.\n"), section->name);
5046       return 0;
5047     }
5048   /* TODO: Dump the contents.  This is made somewhat difficult by not knowing
5049      what the offset size is for this section.  */
5050   return 1;
5051 }
5052
5053 /* Each debug_information[x].range_lists[y] gets this representation for
5054    sorting purposes.  */
5055
5056 struct range_entry
5057 {
5058   /* The debug_information[x].range_lists[y] value.  */
5059   unsigned long ranges_offset;
5060
5061   /* Original debug_information to find parameters of the data.  */
5062   debug_info *debug_info_p;
5063 };
5064
5065 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
5066
5067 static int
5068 range_entry_compar (const void *ap, const void *bp)
5069 {
5070   const struct range_entry *a_re = (const struct range_entry *) ap;
5071   const struct range_entry *b_re = (const struct range_entry *) bp;
5072   const unsigned long a = a_re->ranges_offset;
5073   const unsigned long b = b_re->ranges_offset;
5074
5075   return (a > b) - (b > a);
5076 }
5077
5078 static int
5079 display_debug_ranges (struct dwarf_section *section,
5080                       void *file ATTRIBUTE_UNUSED)
5081 {
5082   unsigned char *start = section->start;
5083   unsigned char *last_start = start;
5084   unsigned long bytes = section->size;
5085   unsigned char *section_begin = start;
5086   unsigned char *finish = start + bytes;
5087   unsigned int num_range_list, i;
5088   struct range_entry *range_entries, *range_entry_fill;
5089
5090   if (bytes == 0)
5091     {
5092       printf (_("\nThe %s section is empty.\n"), section->name);
5093       return 0;
5094     }
5095
5096   if (load_debug_info (file) == 0)
5097     {
5098       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5099             section->name);
5100       return 0;
5101     }
5102
5103   num_range_list = 0;
5104   for (i = 0; i < num_debug_info_entries; i++)
5105     num_range_list += debug_information [i].num_range_lists;
5106
5107   if (num_range_list == 0)
5108     {
5109       /* This can happen when the file was compiled with -gsplit-debug
5110          which removes references to range lists from the primary .o file.  */
5111       printf (_("No range lists in .debug_info section.\n"));
5112       return 1;
5113     }
5114
5115   range_entries = (struct range_entry *)
5116       xmalloc (sizeof (*range_entries) * num_range_list);
5117   range_entry_fill = range_entries;
5118
5119   for (i = 0; i < num_debug_info_entries; i++)
5120     {
5121       debug_info *debug_info_p = &debug_information[i];
5122       unsigned int j;
5123
5124       for (j = 0; j < debug_info_p->num_range_lists; j++)
5125         {
5126           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5127           range_entry_fill->debug_info_p = debug_info_p;
5128           range_entry_fill++;
5129         }
5130     }
5131
5132   qsort (range_entries, num_range_list, sizeof (*range_entries),
5133          range_entry_compar);
5134
5135   if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5136     warn (_("Range lists in %s section start at 0x%lx\n"),
5137           section->name, range_entries[0].ranges_offset);
5138
5139   printf (_("Contents of the %s section:\n\n"), section->name);
5140   printf (_("    Offset   Begin    End\n"));
5141
5142   for (i = 0; i < num_range_list; i++)
5143     {
5144       struct range_entry *range_entry = &range_entries[i];
5145       debug_info *debug_info_p = range_entry->debug_info_p;
5146       unsigned int pointer_size;
5147       unsigned long offset;
5148       unsigned char *next;
5149       unsigned long base_address;
5150
5151       pointer_size = debug_info_p->pointer_size;
5152       offset = range_entry->ranges_offset;
5153       next = section_begin + offset;
5154       base_address = debug_info_p->base_address;
5155
5156       /* PR 17512: file: 001-101485-0.001:0.1.  */
5157       if (pointer_size < 2 || pointer_size > 8)
5158         {
5159           warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5160                 pointer_size, offset);
5161           continue;
5162         }
5163
5164       if (dwarf_check != 0 && i > 0)
5165         {
5166           if (start < next)
5167             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5168                   (unsigned long) (start - section_begin),
5169                   (unsigned long) (next - section_begin), section->name);
5170           else if (start > next)
5171             {
5172               if (next == last_start)
5173                 continue;
5174               warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5175                     (unsigned long) (start - section_begin),
5176                     (unsigned long) (next - section_begin), section->name);
5177             }
5178         }
5179       start = next;
5180       last_start = next;
5181
5182       while (start < finish)
5183         {
5184           dwarf_vma begin;
5185           dwarf_vma end;
5186
5187           /* Note: we use sign extension here in order to be sure that
5188              we can detect the -1 escape value.  Sign extension into the
5189              top 32 bits of a 32-bit address will not affect the values
5190              that we display since we always show hex values, and always
5191              the bottom 32-bits.  */
5192           SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5193           if (start >= finish)
5194             break;
5195           SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5196
5197           printf ("    %8.8lx ", offset);
5198
5199           if (begin == 0 && end == 0)
5200             {
5201               printf (_("<End of list>\n"));
5202               break;
5203             }
5204
5205           /* Check base address specifiers.  */
5206           if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5207             {
5208               base_address = end;
5209               print_dwarf_vma (begin, pointer_size);
5210               print_dwarf_vma (end, pointer_size);
5211               printf ("(base address)\n");
5212               continue;
5213             }
5214
5215           print_dwarf_vma (begin + base_address, pointer_size);
5216           print_dwarf_vma (end + base_address, pointer_size);
5217
5218           if (begin == end)
5219             fputs (_("(start == end)"), stdout);
5220           else if (begin > end)
5221             fputs (_("(start > end)"), stdout);
5222
5223           putchar ('\n');
5224         }
5225     }
5226   putchar ('\n');
5227
5228   free (range_entries);
5229
5230   return 1;
5231 }
5232
5233 typedef struct Frame_Chunk
5234 {
5235   struct Frame_Chunk *next;
5236   unsigned char *chunk_start;
5237   unsigned int ncols;
5238   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
5239   short int *col_type;
5240   int *col_offset;
5241   char *augmentation;
5242   unsigned int code_factor;
5243   int data_factor;
5244   dwarf_vma pc_begin;
5245   dwarf_vma pc_range;
5246   int cfa_reg;
5247   dwarf_vma cfa_offset;
5248   unsigned int ra;
5249   unsigned char fde_encoding;
5250   unsigned char cfa_exp;
5251   unsigned char ptr_size;
5252   unsigned char segment_size;
5253 }
5254 Frame_Chunk;
5255
5256 static const char *const *dwarf_regnames;
5257 static unsigned int dwarf_regnames_count;
5258
5259 /* A marker for a col_type that means this column was never referenced
5260    in the frame info.  */
5261 #define DW_CFA_unreferenced (-1)
5262
5263 /* Return 0 if no more space is needed, 1 if more space is needed,
5264    -1 for invalid reg.  */
5265
5266 static int
5267 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5268 {
5269   unsigned int prev = fc->ncols;
5270
5271   if (reg < (unsigned int) fc->ncols)
5272     return 0;
5273
5274   if (dwarf_regnames_count
5275       && reg > dwarf_regnames_count)
5276     return -1;
5277
5278   fc->ncols = reg + 1;
5279   /* PR 17512: file: 10450-2643-0.004.
5280      If reg == -1 then this can happen...  */
5281   if (fc->ncols == 0)
5282     return -1;
5283
5284   /* PR 17512: file: 2844a11d.  */
5285   if (fc->ncols > 1024)
5286     {
5287       error (_("Unfeasibly large register number: %u\n"), reg);
5288       fc->ncols = 0;
5289       /* FIXME: 1024 is an arbitrary limit.  Increase it if
5290          we ever encounter a valid binary that exceeds it.  */
5291       return -1;
5292     }
5293
5294   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5295                                           sizeof (short int));
5296   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5297   /* PR 17512: file:002-10025-0.005.  */
5298   if (fc->col_type == NULL || fc->col_offset == NULL)
5299     {
5300       error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5301              fc->ncols);
5302       fc->ncols = 0;
5303       return -1;
5304     }
5305
5306   while (prev < fc->ncols)
5307     {
5308       fc->col_type[prev] = DW_CFA_unreferenced;
5309       fc->col_offset[prev] = 0;
5310       prev++;
5311     }
5312   return 1;
5313 }
5314
5315 static const char *const dwarf_regnames_i386[] =
5316 {
5317   "eax", "ecx", "edx", "ebx",                     /* 0 - 3  */
5318   "esp", "ebp", "esi", "edi",                     /* 4 - 7  */
5319   "eip", "eflags", NULL,                          /* 8 - 10  */
5320   "st0", "st1", "st2", "st3",                     /* 11 - 14  */
5321   "st4", "st5", "st6", "st7",                     /* 15 - 18  */
5322   NULL, NULL,                                     /* 19 - 20  */
5323   "xmm0", "xmm1", "xmm2", "xmm3",                 /* 21 - 24  */
5324   "xmm4", "xmm5", "xmm6", "xmm7",                 /* 25 - 28  */
5325   "mm0", "mm1", "mm2", "mm3",                     /* 29 - 32  */
5326   "mm4", "mm5", "mm6", "mm7",                     /* 33 - 36  */
5327   "fcw", "fsw", "mxcsr",                          /* 37 - 39  */
5328   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47  */
5329   "tr", "ldtr",                                   /* 48 - 49  */
5330   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57  */
5331   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65  */
5332   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73  */
5333   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81  */
5334   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89  */
5335   NULL, NULL, NULL,                               /* 90 - 92  */
5336   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"  /* 93 - 100  */
5337 };
5338
5339 void
5340 init_dwarf_regnames_i386 (void)
5341 {
5342   dwarf_regnames = dwarf_regnames_i386;
5343   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5344 }
5345
5346 static const char *const dwarf_regnames_x86_64[] =
5347 {
5348   "rax", "rdx", "rcx", "rbx",
5349   "rsi", "rdi", "rbp", "rsp",
5350   "r8",  "r9",  "r10", "r11",
5351   "r12", "r13", "r14", "r15",
5352   "rip",
5353   "xmm0",  "xmm1",  "xmm2",  "xmm3",
5354   "xmm4",  "xmm5",  "xmm6",  "xmm7",
5355   "xmm8",  "xmm9",  "xmm10", "xmm11",
5356   "xmm12", "xmm13", "xmm14", "xmm15",
5357   "st0", "st1", "st2", "st3",
5358   "st4", "st5", "st6", "st7",
5359   "mm0", "mm1", "mm2", "mm3",
5360   "mm4", "mm5", "mm6", "mm7",
5361   "rflags",
5362   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5363   "fs.base", "gs.base", NULL, NULL,
5364   "tr", "ldtr",
5365   "mxcsr", "fcw", "fsw",
5366   "xmm16",  "xmm17",  "xmm18",  "xmm19",
5367   "xmm20",  "xmm21",  "xmm22",  "xmm23",
5368   "xmm24",  "xmm25",  "xmm26",  "xmm27",
5369   "xmm28",  "xmm29",  "xmm30",  "xmm31",
5370   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90  */
5371   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98  */
5372   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106  */
5373   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114  */
5374   NULL, NULL, NULL,                               /* 115 - 117  */
5375   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5376 };
5377
5378 void
5379 init_dwarf_regnames_x86_64 (void)
5380 {
5381   dwarf_regnames = dwarf_regnames_x86_64;
5382   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5383 }
5384
5385 static const char *const dwarf_regnames_aarch64[] =
5386 {
5387    "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
5388    "x8",  "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5389   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5390   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5391    NULL, "elr",  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5392    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5393    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5394    NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,  NULL,
5395    "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",
5396    "v8",  "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5397   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5398   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5399 };
5400
5401 void
5402 init_dwarf_regnames_aarch64 (void)
5403 {
5404   dwarf_regnames = dwarf_regnames_aarch64;
5405   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5406 }
5407
5408 void
5409 init_dwarf_regnames (unsigned int e_machine)
5410 {
5411   switch (e_machine)
5412     {
5413     case EM_386:
5414     case EM_486:
5415       init_dwarf_regnames_i386 ();
5416       break;
5417
5418     case EM_X86_64:
5419     case EM_L1OM:
5420     case EM_K1OM:
5421       init_dwarf_regnames_x86_64 ();
5422       break;
5423
5424     case EM_AARCH64:
5425       init_dwarf_regnames_aarch64 ();
5426       break;
5427
5428     default:
5429       break;
5430     }
5431 }
5432
5433 static const char *
5434 regname (unsigned int regno, int row)
5435 {
5436   static char reg[64];
5437   if (dwarf_regnames
5438       && regno < dwarf_regnames_count
5439       && dwarf_regnames [regno] != NULL)
5440     {
5441       if (row)
5442         return dwarf_regnames [regno];
5443       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5444                 dwarf_regnames [regno]);
5445     }
5446   else
5447     snprintf (reg, sizeof (reg), "r%d", regno);
5448   return reg;
5449 }
5450
5451 static void
5452 frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
5453 {
5454   unsigned int r;
5455   char tmp[100];
5456
5457   if (*max_regs < fc->ncols)
5458     *max_regs = fc->ncols;
5459
5460   if (*need_col_headers)
5461     {
5462       static const char *sloc = "   LOC";
5463
5464       *need_col_headers = 0;
5465
5466       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
5467
5468       for (r = 0; r < *max_regs; r++)
5469         if (fc->col_type[r] != DW_CFA_unreferenced)
5470           {
5471             if (r == fc->ra)
5472               printf ("ra      ");
5473             else
5474               printf ("%-5s ", regname (r, 1));
5475           }
5476
5477       printf ("\n");
5478     }
5479
5480   print_dwarf_vma (fc->pc_begin, eh_addr_size);
5481   if (fc->cfa_exp)
5482     strcpy (tmp, "exp");
5483   else
5484     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
5485   printf ("%-8s ", tmp);
5486
5487   for (r = 0; r < fc->ncols; r++)
5488     {
5489       if (fc->col_type[r] != DW_CFA_unreferenced)
5490         {
5491           switch (fc->col_type[r])
5492             {
5493             case DW_CFA_undefined:
5494               strcpy (tmp, "u");
5495               break;
5496             case DW_CFA_same_value:
5497               strcpy (tmp, "s");
5498               break;
5499             case DW_CFA_offset:
5500               sprintf (tmp, "c%+d", fc->col_offset[r]);
5501               break;
5502             case DW_CFA_val_offset:
5503               sprintf (tmp, "v%+d", fc->col_offset[r]);
5504               break;
5505             case DW_CFA_register:
5506               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5507               break;
5508             case DW_CFA_expression:
5509               strcpy (tmp, "exp");
5510               break;
5511             case DW_CFA_val_expression:
5512               strcpy (tmp, "vexp");
5513               break;
5514             default:
5515               strcpy (tmp, "n/a");
5516               break;
5517             }
5518           printf ("%-5s ", tmp);
5519         }
5520     }
5521   printf ("\n");
5522 }
5523
5524 #define GET(VAR, N)     SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5525 #define LEB()   read_uleb128 (start, & length_return, end); start += length_return
5526 #define SLEB()  read_sleb128 (start, & length_return, end); start += length_return
5527
5528 static unsigned char *
5529 read_cie (unsigned char *start, unsigned char *end,
5530           Frame_Chunk **p_cie, int *p_version,
5531           unsigned long *p_aug_len, unsigned char **p_aug)
5532 {
5533   int version;
5534   Frame_Chunk *fc;
5535   unsigned int length_return;
5536   unsigned char *augmentation_data = NULL;
5537   unsigned long augmentation_data_len = 0;
5538
5539   * p_cie = NULL;
5540   /* PR 17512: file: 001-228113-0.004.  */
5541   if (start >= end)
5542     return end;
5543
5544   fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5545   memset (fc, 0, sizeof (Frame_Chunk));
5546
5547   fc->col_type = (short int *) xmalloc (sizeof (short int));
5548   fc->col_offset = (int *) xmalloc (sizeof (int));
5549
5550   version = *start++;
5551
5552   fc->augmentation = (char *) start;
5553   /* PR 17512: file: 001-228113-0.004.
5554      Skip past augmentation name, but avoid running off the end of the data.  */
5555   while (start < end)
5556     if (* start ++ == '\0')
5557       break;
5558   if (start == end)
5559     {
5560       warn (_("No terminator for augmentation name\n"));
5561       return start;
5562     }
5563
5564   if (strcmp (fc->augmentation, "eh") == 0)
5565     start += eh_addr_size;
5566
5567   if (version >= 4)
5568     {
5569       GET (fc->ptr_size, 1);
5570       if (fc->ptr_size < 1 || fc->ptr_size > 8)
5571         {
5572           warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5573           return end;
5574         }
5575
5576       GET (fc->segment_size, 1);
5577       /* PR 17512: file: e99d2804.  */
5578       if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5579         {
5580           warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5581           return end;
5582         }
5583
5584       eh_addr_size = fc->ptr_size;
5585     }
5586   else
5587     {
5588       fc->ptr_size = eh_addr_size;
5589       fc->segment_size = 0;
5590     }
5591   fc->code_factor = LEB ();
5592   fc->data_factor = SLEB ();
5593   if (version == 1)
5594     {
5595       GET (fc->ra, 1);
5596     }
5597   else
5598     {
5599       fc->ra = LEB ();
5600     }
5601
5602   if (fc->augmentation[0] == 'z')
5603     {
5604       augmentation_data_len = LEB ();
5605       augmentation_data = start;
5606       start += augmentation_data_len;
5607       /* PR 17512: file: 11042-2589-0.004.  */
5608       if (start > end)
5609         {
5610           warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
5611           return end;
5612         }
5613     }
5614
5615   if (augmentation_data_len)
5616     {
5617       unsigned char *p;
5618       unsigned char *q;
5619       unsigned char *qend;
5620
5621       p = (unsigned char *) fc->augmentation + 1;
5622       q = augmentation_data;
5623       qend = q + augmentation_data_len;
5624
5625       /* PR 17531: file: 015adfaa.  */
5626       if (qend < q)
5627         {
5628           warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5629           augmentation_data_len = 0;
5630         }
5631
5632       while (p < end && q < augmentation_data + augmentation_data_len)
5633         {
5634           if (*p == 'L')
5635             q++;
5636           else if (*p == 'P')
5637             q += 1 + size_of_encoded_value (*q);
5638           else if (*p == 'R')
5639             fc->fde_encoding = *q++;
5640           else if (*p == 'S')
5641             ;
5642           else
5643             break;
5644           p++;
5645         }
5646       /* Note - it is OK if this loop terminates with q < qend.
5647          Padding may have been inserted to align the end of the CIE.  */
5648     }
5649
5650   *p_cie = fc;
5651   if (p_version)
5652     *p_version = version;
5653   if (p_aug_len)
5654     {
5655       *p_aug_len = augmentation_data_len;
5656       *p_aug = augmentation_data;
5657     }
5658   return start;
5659 }
5660
5661 static int
5662 display_debug_frames (struct dwarf_section *section,
5663                       void *file ATTRIBUTE_UNUSED)
5664 {
5665   unsigned char *start = section->start;
5666   unsigned char *end = start + section->size;
5667   unsigned char *section_start = start;
5668   Frame_Chunk *chunks = 0, *forward_refs = 0;
5669   Frame_Chunk *remembered_state = 0;
5670   Frame_Chunk *rs;
5671   int is_eh = strcmp (section->name, ".eh_frame") == 0;
5672   unsigned int length_return;
5673   unsigned int max_regs = 0;
5674   const char *bad_reg = _("bad register: ");
5675   unsigned int saved_eh_addr_size = eh_addr_size;
5676
5677   printf (_("Contents of the %s section:\n"), section->name);
5678
5679   while (start < end)
5680     {
5681       unsigned char *saved_start;
5682       unsigned char *block_end;
5683       dwarf_vma length;
5684       dwarf_vma cie_id;
5685       Frame_Chunk *fc;
5686       Frame_Chunk *cie;
5687       int need_col_headers = 1;
5688       unsigned char *augmentation_data = NULL;
5689       unsigned long augmentation_data_len = 0;
5690       unsigned int encoded_ptr_size = saved_eh_addr_size;
5691       unsigned int offset_size;
5692       unsigned int initial_length_size;
5693
5694       saved_start = start;
5695
5696       SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5697
5698       if (length == 0)
5699         {
5700           printf ("\n%08lx ZERO terminator\n\n",
5701                     (unsigned long)(saved_start - section_start));
5702           /* Skip any zero terminators that directly follow.
5703              A corrupt section size could have loaded a whole
5704              slew of zero filled memory bytes.  eg
5705              PR 17512: file: 070-19381-0.004.  */
5706           while (start < end && * start == 0)
5707             ++ start;
5708           continue;
5709         }
5710
5711       if (length == 0xffffffff)
5712         {
5713           SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5714           offset_size = 8;
5715           initial_length_size = 12;
5716         }
5717       else
5718         {
5719           offset_size = 4;
5720           initial_length_size = 4;
5721         }
5722
5723       block_end = saved_start + length + initial_length_size;
5724       if (block_end > end || block_end < start)
5725         {
5726           warn ("Invalid length 0x%s in FDE at %#08lx\n",
5727                 dwarf_vmatoa_1 (NULL, length, offset_size),
5728                 (unsigned long) (saved_start - section_start));
5729           block_end = end;
5730         }
5731
5732       SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5733
5734       if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5735                                    || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5736         {
5737           int version;
5738           unsigned int mreg;
5739
5740           start = read_cie (start, end, &cie, &version,
5741                             &augmentation_data_len, &augmentation_data);
5742           /* PR 17512: file: 027-135133-0.005.  */
5743           if (cie == NULL)
5744             break;
5745
5746           fc = cie;
5747           fc->next = chunks;
5748           chunks = fc;
5749           fc->chunk_start = saved_start;
5750           mreg = max_regs > 0 ? max_regs - 1 : 0;
5751           if (mreg < fc->ra)
5752             mreg = fc->ra;
5753           if (frame_need_space (fc, mreg) < 0)
5754             break;
5755           if (fc->fde_encoding)
5756             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5757
5758           printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5759           print_dwarf_vma (length, fc->ptr_size);
5760           print_dwarf_vma (cie_id, offset_size);
5761
5762           if (do_debug_frames_interp)
5763             {
5764               printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5765                       fc->code_factor, fc->data_factor, fc->ra);
5766             }
5767           else
5768             {
5769               printf ("CIE\n");
5770               printf ("  Version:               %d\n", version);
5771               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
5772               if (version >= 4)
5773                 {
5774                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
5775                   printf ("  Segment Size:          %u\n", fc->segment_size);
5776                 }
5777               printf ("  Code alignment factor: %u\n", fc->code_factor);
5778               printf ("  Data alignment factor: %d\n", fc->data_factor);
5779               printf ("  Return address column: %d\n", fc->ra);
5780
5781               if (augmentation_data_len)
5782                 {
5783                   unsigned long i;
5784
5785                   printf ("  Augmentation data:    ");
5786                   for (i = 0; i < augmentation_data_len; ++i)
5787                     /* FIXME: If do_wide is FALSE, then we should
5788                        add carriage returns at 80 columns...  */
5789                     printf (" %02x", augmentation_data[i]);
5790                   putchar ('\n');
5791                 }
5792               putchar ('\n');
5793             }
5794         }
5795       else
5796         {
5797           unsigned char *look_for;
5798           static Frame_Chunk fde_fc;
5799           unsigned long segment_selector;
5800
5801           if (is_eh)
5802             {
5803               dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5804               look_for = start - 4 - ((cie_id ^ sign) - sign);
5805             }
5806           else
5807             look_for = section_start + cie_id;
5808
5809           if (look_for <= saved_start)
5810             {
5811               for (cie = chunks; cie ; cie = cie->next)
5812                 if (cie->chunk_start == look_for)
5813                   break;
5814             }
5815           else
5816             {
5817               for (cie = forward_refs; cie ; cie = cie->next)
5818                 if (cie->chunk_start == look_for)
5819                   break;
5820               if (!cie)
5821                 {
5822                   unsigned int off_size;
5823                   unsigned char *cie_scan;
5824
5825                   cie_scan = look_for;
5826                   off_size = 4;
5827                   SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5828                   if (length == 0xffffffff)
5829                     {
5830                       SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5831                       off_size = 8;
5832                     }
5833                   if (length != 0)
5834                     {
5835                       dwarf_vma c_id;
5836
5837                       SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5838                       if (is_eh
5839                           ? c_id == 0
5840                           : ((off_size == 4 && c_id == DW_CIE_ID)
5841                              || (off_size == 8 && c_id == DW64_CIE_ID)))
5842                         {
5843                           int version;
5844                           unsigned int mreg;
5845
5846                           read_cie (cie_scan, end, &cie, &version,
5847                                     &augmentation_data_len, &augmentation_data);
5848                           /* PR 17512: file: 3450-2098-0.004.  */
5849                           if (cie == NULL)
5850                             {
5851                               warn (_("Failed to read CIE information\n"));
5852                               break;
5853                             }
5854                           cie->next = forward_refs;
5855                           forward_refs = cie;
5856                           cie->chunk_start = look_for;
5857                           mreg = max_regs > 0 ? max_regs - 1 : 0;
5858                           if (mreg < cie->ra)
5859                             mreg = cie->ra;
5860                           if (frame_need_space (cie, mreg) < 0)
5861                             {
5862                               warn (_("Invalid max register\n"));
5863                               break;
5864                             }
5865                           if (cie->fde_encoding)
5866                             encoded_ptr_size
5867                               = size_of_encoded_value (cie->fde_encoding);
5868                         }
5869                     }
5870                 }
5871             }
5872
5873           fc = &fde_fc;
5874           memset (fc, 0, sizeof (Frame_Chunk));
5875
5876           if (!cie)
5877             {
5878               warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5879                     dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5880                     (unsigned long) (saved_start - section_start));
5881               fc->ncols = 0;
5882               fc->col_type = (short int *) xmalloc (sizeof (short int));
5883               fc->col_offset = (int *) xmalloc (sizeof (int));
5884               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5885                 {
5886                   warn (_("Invalid max register\n"));
5887                   break;
5888                 }
5889               cie = fc;
5890               fc->augmentation = "";
5891               fc->fde_encoding = 0;
5892               fc->ptr_size = eh_addr_size;
5893               fc->segment_size = 0;
5894             }
5895           else
5896             {
5897               fc->ncols = cie->ncols;
5898               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5899               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
5900               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5901               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5902               fc->augmentation = cie->augmentation;
5903               fc->ptr_size = cie->ptr_size;
5904               eh_addr_size = cie->ptr_size;
5905               fc->segment_size = cie->segment_size;
5906               fc->code_factor = cie->code_factor;
5907               fc->data_factor = cie->data_factor;
5908               fc->cfa_reg = cie->cfa_reg;
5909               fc->cfa_offset = cie->cfa_offset;
5910               fc->ra = cie->ra;
5911               if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5912                 {
5913                   warn (_("Invalid max register\n"));
5914                   break;
5915                 }
5916               fc->fde_encoding = cie->fde_encoding;
5917             }
5918
5919           if (fc->fde_encoding)
5920             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5921
5922           segment_selector = 0;
5923           if (fc->segment_size)
5924             {
5925               if (fc->segment_size > sizeof (segment_selector))
5926                 {
5927                   /* PR 17512: file: 9e196b3e.  */
5928                   warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
5929                   fc->segment_size = 4;
5930                 }
5931               SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5932             }
5933
5934           fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
5935
5936           /* FIXME: It appears that sometimes the final pc_range value is
5937              encoded in less than encoded_ptr_size bytes.  See the x86_64
5938              run of the "objcopy on compressed debug sections" test for an
5939              example of this.  */
5940           SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5941
5942           if (cie->augmentation[0] == 'z')
5943             {
5944               augmentation_data_len = LEB ();
5945               augmentation_data = start;
5946               start += augmentation_data_len;
5947               /* PR 17512: file: 722-8446-0.004.  */
5948               if (start >= end || ((signed long) augmentation_data_len) < 0)
5949                 {
5950                   warn (_("Corrupt augmentation data length: %lx\n"),
5951                         augmentation_data_len);
5952                   start = end;
5953                   augmentation_data = NULL;
5954                   augmentation_data_len = 0;
5955                 }
5956             }
5957
5958           printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5959                   (unsigned long)(saved_start - section_start),
5960                   dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
5961                   dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5962                   (unsigned long)(cie->chunk_start - section_start));
5963
5964           if (fc->segment_size)
5965             printf ("%04lx:", segment_selector);
5966
5967           printf ("%s..%s\n",
5968                   dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5969                   dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5970
5971           if (! do_debug_frames_interp && augmentation_data_len)
5972             {
5973               unsigned long i;
5974
5975               printf ("  Augmentation data:    ");
5976               for (i = 0; i < augmentation_data_len; ++i)
5977                 printf (" %02x", augmentation_data[i]);
5978               putchar ('\n');
5979               putchar ('\n');
5980             }
5981         }
5982
5983       /* At this point, fc is the current chunk, cie (if any) is set, and
5984          we're about to interpret instructions for the chunk.  */
5985       /* ??? At present we need to do this always, since this sizes the
5986          fc->col_type and fc->col_offset arrays, which we write into always.
5987          We should probably split the interpreted and non-interpreted bits
5988          into two different routines, since there's so much that doesn't
5989          really overlap between them.  */
5990       if (1 || do_debug_frames_interp)
5991         {
5992           /* Start by making a pass over the chunk, allocating storage
5993              and taking note of what registers are used.  */
5994           unsigned char *tmp = start;
5995
5996           while (start < block_end)
5997             {
5998               unsigned int reg, op, opa;
5999               unsigned long temp;
6000               unsigned char * new_start;
6001
6002               op = *start++;
6003               opa = op & 0x3f;
6004               if (op & 0xc0)
6005                 op &= 0xc0;
6006
6007               /* Warning: if you add any more cases to this switch, be
6008                  sure to add them to the corresponding switch below.  */
6009               switch (op)
6010                 {
6011                 case DW_CFA_advance_loc:
6012                   break;
6013                 case DW_CFA_offset:
6014                   LEB ();
6015                   if (frame_need_space (fc, opa) >= 0)
6016                     fc->col_type[opa] = DW_CFA_undefined;
6017                   break;
6018                 case DW_CFA_restore:
6019                   if (frame_need_space (fc, opa) >= 0)
6020                     fc->col_type[opa] = DW_CFA_undefined;
6021                   break;
6022                 case DW_CFA_set_loc:
6023                   start += encoded_ptr_size;
6024                   break;
6025                 case DW_CFA_advance_loc1:
6026                   start += 1;
6027                   break;
6028                 case DW_CFA_advance_loc2:
6029                   start += 2;
6030                   break;
6031                 case DW_CFA_advance_loc4:
6032                   start += 4;
6033                   break;
6034                 case DW_CFA_offset_extended:
6035                 case DW_CFA_val_offset:
6036                   reg = LEB (); LEB ();
6037                   if (frame_need_space (fc, reg) >= 0)
6038                     fc->col_type[reg] = DW_CFA_undefined;
6039                   break;
6040                 case DW_CFA_restore_extended:
6041                   reg = LEB ();
6042                   if (frame_need_space (fc, reg) >= 0)
6043                     fc->col_type[reg] = DW_CFA_undefined;
6044                   break;
6045                 case DW_CFA_undefined:
6046                   reg = LEB ();
6047                   if (frame_need_space (fc, reg) >= 0)
6048                     fc->col_type[reg] = DW_CFA_undefined;
6049                   break;
6050                 case DW_CFA_same_value:
6051                   reg = LEB ();
6052                   if (frame_need_space (fc, reg) >= 0)
6053                     fc->col_type[reg] = DW_CFA_undefined;
6054                   break;
6055                 case DW_CFA_register:
6056                   reg = LEB (); LEB ();
6057                   if (frame_need_space (fc, reg) >= 0)
6058                     fc->col_type[reg] = DW_CFA_undefined;
6059                   break;
6060                 case DW_CFA_def_cfa:
6061                   LEB (); LEB ();
6062                   break;
6063                 case DW_CFA_def_cfa_register:
6064                   LEB ();
6065                   break;
6066                 case DW_CFA_def_cfa_offset:
6067                   LEB ();
6068                   break;
6069                 case DW_CFA_def_cfa_expression:
6070                   temp = LEB ();
6071                   new_start = start + temp;
6072                   if (new_start < start)
6073                     {
6074                       warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6075                       start = block_end;
6076                     }
6077                   else
6078                     start = new_start;
6079                   break;
6080                 case DW_CFA_expression:
6081                 case DW_CFA_val_expression:
6082                   reg = LEB ();
6083                   temp = LEB ();
6084                   new_start = start + temp;
6085                   if (new_start < start)
6086                     {
6087                       /* PR 17512: file:306-192417-0.005.  */
6088                       warn (_("Corrupt CFA expression value: %lu\n"), temp);
6089                       start = block_end;
6090                     }
6091                   else
6092                     start = new_start;
6093                   if (frame_need_space (fc, reg) >= 0)
6094                     fc->col_type[reg] = DW_CFA_undefined;
6095                   break;
6096                 case DW_CFA_offset_extended_sf:
6097                 case DW_CFA_val_offset_sf:
6098                   reg = LEB (); SLEB ();
6099                   if (frame_need_space (fc, reg) >= 0)
6100                     fc->col_type[reg] = DW_CFA_undefined;
6101                   break;
6102                 case DW_CFA_def_cfa_sf:
6103                   LEB (); SLEB ();
6104                   break;
6105                 case DW_CFA_def_cfa_offset_sf:
6106                   SLEB ();
6107                   break;
6108                 case DW_CFA_MIPS_advance_loc8:
6109                   start += 8;
6110                   break;
6111                 case DW_CFA_GNU_args_size:
6112                   LEB ();
6113                   break;
6114                 case DW_CFA_GNU_negative_offset_extended:
6115                   reg = LEB (); LEB ();
6116                   if (frame_need_space (fc, reg) >= 0)
6117                     fc->col_type[reg] = DW_CFA_undefined;
6118                   break;
6119                 default:
6120                   break;
6121                 }
6122             }
6123           start = tmp;
6124         }
6125
6126       /* Now we know what registers are used, make a second pass over
6127          the chunk, this time actually printing out the info.  */
6128
6129       while (start < block_end)
6130         {
6131           unsigned char * tmp;
6132           unsigned op, opa;
6133           unsigned long ul, reg, roffs;
6134           dwarf_vma l;
6135           dwarf_vma ofs;
6136           dwarf_vma vma;
6137           const char *reg_prefix = "";
6138
6139           op = *start++;
6140           opa = op & 0x3f;
6141           if (op & 0xc0)
6142             op &= 0xc0;
6143
6144           /* Warning: if you add any more cases to this switch, be
6145              sure to add them to the corresponding switch above.  */
6146           switch (op)
6147             {
6148             case DW_CFA_advance_loc:
6149               if (do_debug_frames_interp)
6150                 frame_display_row (fc, &need_col_headers, &max_regs);
6151               else
6152                 printf ("  DW_CFA_advance_loc: %d to %s\n",
6153                         opa * fc->code_factor,
6154                         dwarf_vmatoa_1 (NULL,
6155                                         fc->pc_begin + opa * fc->code_factor,
6156                                         fc->ptr_size));
6157               fc->pc_begin += opa * fc->code_factor;
6158               break;
6159
6160             case DW_CFA_offset:
6161               roffs = LEB ();
6162               if (opa >= (unsigned int) fc->ncols)
6163                 reg_prefix = bad_reg;
6164               if (! do_debug_frames_interp || *reg_prefix != '\0')
6165                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
6166                         reg_prefix, regname (opa, 0),
6167                         roffs * fc->data_factor);
6168               if (*reg_prefix == '\0')
6169                 {
6170                   fc->col_type[opa] = DW_CFA_offset;
6171                   fc->col_offset[opa] = roffs * fc->data_factor;
6172                 }
6173               break;
6174
6175             case DW_CFA_restore:
6176               if (opa >= (unsigned int) cie->ncols
6177                   || opa >= (unsigned int) fc->ncols)
6178                 reg_prefix = bad_reg;
6179               if (! do_debug_frames_interp || *reg_prefix != '\0')
6180                 printf ("  DW_CFA_restore: %s%s\n",
6181                         reg_prefix, regname (opa, 0));
6182               if (*reg_prefix == '\0')
6183                 {
6184                   fc->col_type[opa] = cie->col_type[opa];
6185                   fc->col_offset[opa] = cie->col_offset[opa];
6186                   if (do_debug_frames_interp
6187                       && fc->col_type[opa] == DW_CFA_unreferenced)
6188                     fc->col_type[opa] = DW_CFA_undefined;
6189                 }
6190               break;
6191
6192             case DW_CFA_set_loc:
6193               vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
6194               if (do_debug_frames_interp)
6195                 frame_display_row (fc, &need_col_headers, &max_regs);
6196               else
6197                 printf ("  DW_CFA_set_loc: %s\n",
6198                         dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6199               fc->pc_begin = vma;
6200               break;
6201
6202             case DW_CFA_advance_loc1:
6203               SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6204               if (do_debug_frames_interp)
6205                 frame_display_row (fc, &need_col_headers, &max_regs);
6206               else
6207                 printf ("  DW_CFA_advance_loc1: %ld to %s\n",
6208                         (unsigned long) (ofs * fc->code_factor),
6209                         dwarf_vmatoa_1 (NULL,
6210                                         fc->pc_begin + ofs * fc->code_factor,
6211                                         fc->ptr_size));
6212               fc->pc_begin += ofs * fc->code_factor;
6213               break;
6214
6215             case DW_CFA_advance_loc2:
6216               SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
6217               if (do_debug_frames_interp)
6218                 frame_display_row (fc, &need_col_headers, &max_regs);
6219               else
6220                 printf ("  DW_CFA_advance_loc2: %ld to %s\n",
6221                         (unsigned long) (ofs * fc->code_factor),
6222                         dwarf_vmatoa_1 (NULL,
6223                                         fc->pc_begin + ofs * fc->code_factor,
6224                                         fc->ptr_size));
6225               fc->pc_begin += ofs * fc->code_factor;
6226               break;
6227
6228             case DW_CFA_advance_loc4:
6229               SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
6230               if (do_debug_frames_interp)
6231                 frame_display_row (fc, &need_col_headers, &max_regs);
6232               else
6233                 printf ("  DW_CFA_advance_loc4: %ld to %s\n",
6234                         (unsigned long) (ofs * fc->code_factor),
6235                         dwarf_vmatoa_1 (NULL,
6236                                         fc->pc_begin + ofs * fc->code_factor,
6237                                         fc->ptr_size));
6238               fc->pc_begin += ofs * fc->code_factor;
6239               break;
6240
6241             case DW_CFA_offset_extended:
6242               reg = LEB ();
6243               roffs = LEB ();
6244               if (reg >= (unsigned int) fc->ncols)
6245                 reg_prefix = bad_reg;
6246               if (! do_debug_frames_interp || *reg_prefix != '\0')
6247                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6248                         reg_prefix, regname (reg, 0),
6249                         roffs * fc->data_factor);
6250               if (*reg_prefix == '\0')
6251                 {
6252                   fc->col_type[reg] = DW_CFA_offset;
6253                   fc->col_offset[reg] = roffs * fc->data_factor;
6254                 }
6255               break;
6256
6257             case DW_CFA_val_offset:
6258               reg = LEB ();
6259               roffs = LEB ();
6260               if (reg >= (unsigned int) fc->ncols)
6261                 reg_prefix = bad_reg;
6262               if (! do_debug_frames_interp || *reg_prefix != '\0')
6263                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
6264                         reg_prefix, regname (reg, 0),
6265                         roffs * fc->data_factor);
6266               if (*reg_prefix == '\0')
6267                 {
6268                   fc->col_type[reg] = DW_CFA_val_offset;
6269                   fc->col_offset[reg] = roffs * fc->data_factor;
6270                 }
6271               break;
6272
6273             case DW_CFA_restore_extended:
6274               reg = LEB ();
6275               if (reg >= (unsigned int) cie->ncols
6276                   || reg >= (unsigned int) fc->ncols)
6277                 reg_prefix = bad_reg;
6278               if (! do_debug_frames_interp || *reg_prefix != '\0')
6279                 printf ("  DW_CFA_restore_extended: %s%s\n",
6280                         reg_prefix, regname (reg, 0));
6281               if (*reg_prefix == '\0')
6282                 {
6283                   fc->col_type[reg] = cie->col_type[reg];
6284                   fc->col_offset[reg] = cie->col_offset[reg];
6285                 }
6286               break;
6287
6288             case DW_CFA_undefined:
6289               reg = LEB ();
6290               if (reg >= (unsigned int) fc->ncols)
6291                 reg_prefix = bad_reg;
6292               if (! do_debug_frames_interp || *reg_prefix != '\0')
6293                 printf ("  DW_CFA_undefined: %s%s\n",
6294                         reg_prefix, regname (reg, 0));
6295               if (*reg_prefix == '\0')
6296                 {
6297                   fc->col_type[reg] = DW_CFA_undefined;
6298                   fc->col_offset[reg] = 0;
6299                 }
6300               break;
6301
6302             case DW_CFA_same_value:
6303               reg = LEB ();
6304               if (reg >= (unsigned int) fc->ncols)
6305                 reg_prefix = bad_reg;
6306               if (! do_debug_frames_interp || *reg_prefix != '\0')
6307                 printf ("  DW_CFA_same_value: %s%s\n",
6308                         reg_prefix, regname (reg, 0));
6309               if (*reg_prefix == '\0')
6310                 {
6311                   fc->col_type[reg] = DW_CFA_same_value;
6312                   fc->col_offset[reg] = 0;
6313                 }
6314               break;
6315
6316             case DW_CFA_register:
6317               reg = LEB ();
6318               roffs = LEB ();
6319               if (reg >= (unsigned int) fc->ncols)
6320                 reg_prefix = bad_reg;
6321               if (! do_debug_frames_interp || *reg_prefix != '\0')
6322                 {
6323                   printf ("  DW_CFA_register: %s%s in ",
6324                           reg_prefix, regname (reg, 0));
6325                   puts (regname (roffs, 0));
6326                 }
6327               if (*reg_prefix == '\0')
6328                 {
6329                   fc->col_type[reg] = DW_CFA_register;
6330                   fc->col_offset[reg] = roffs;
6331                 }
6332               break;
6333
6334             case DW_CFA_remember_state:
6335               if (! do_debug_frames_interp)
6336                 printf ("  DW_CFA_remember_state\n");
6337               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6338               rs->cfa_offset = fc->cfa_offset;
6339               rs->cfa_reg = fc->cfa_reg;
6340               rs->ra = fc->ra;
6341               rs->cfa_exp = fc->cfa_exp;
6342               rs->ncols = fc->ncols;
6343               rs->col_type = (short int *) xcmalloc (rs->ncols,
6344                                                      sizeof (* rs->col_type));
6345               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6346               memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6347               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6348               rs->next = remembered_state;
6349               remembered_state = rs;
6350               break;
6351
6352             case DW_CFA_restore_state:
6353               if (! do_debug_frames_interp)
6354                 printf ("  DW_CFA_restore_state\n");
6355               rs = remembered_state;
6356               if (rs)
6357                 {
6358                   remembered_state = rs->next;
6359                   fc->cfa_offset = rs->cfa_offset;
6360                   fc->cfa_reg = rs->cfa_reg;
6361                   fc->ra = rs->ra;
6362                   fc->cfa_exp = rs->cfa_exp;
6363                   if (frame_need_space (fc, rs->ncols - 1) < 0)
6364                     {
6365                       warn (_("Invalid column number in saved frame state\n"));
6366                       fc->ncols = 0;
6367                       break;
6368                     }
6369                   memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6370                   memcpy (fc->col_offset, rs->col_offset,
6371                           rs->ncols * sizeof (* rs->col_offset));
6372                   free (rs->col_type);
6373                   free (rs->col_offset);
6374                   free (rs);
6375                 }
6376               else if (do_debug_frames_interp)
6377                 printf ("Mismatched DW_CFA_restore_state\n");
6378               break;
6379
6380             case DW_CFA_def_cfa:
6381               fc->cfa_reg = LEB ();
6382               fc->cfa_offset = LEB ();
6383               fc->cfa_exp = 0;
6384               if (! do_debug_frames_interp)
6385                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
6386                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6387               break;
6388
6389             case DW_CFA_def_cfa_register:
6390               fc->cfa_reg = LEB ();
6391               fc->cfa_exp = 0;
6392               if (! do_debug_frames_interp)
6393                 printf ("  DW_CFA_def_cfa_register: %s\n",
6394                         regname (fc->cfa_reg, 0));
6395               break;
6396
6397             case DW_CFA_def_cfa_offset:
6398               fc->cfa_offset = LEB ();
6399               if (! do_debug_frames_interp)
6400                 printf ("  DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
6401               break;
6402
6403             case DW_CFA_nop:
6404               if (! do_debug_frames_interp)
6405                 printf ("  DW_CFA_nop\n");
6406               break;
6407
6408             case DW_CFA_def_cfa_expression:
6409               ul = LEB ();
6410               if (start >= block_end || start + ul > block_end || start + ul < start)
6411                 {
6412                   printf (_("  DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6413                   break;
6414                 }
6415               if (! do_debug_frames_interp)
6416                 {
6417                   printf ("  DW_CFA_def_cfa_expression (");
6418                   decode_location_expression (start, eh_addr_size, 0, -1,
6419                                               ul, 0, section);
6420                   printf (")\n");
6421                 }
6422               fc->cfa_exp = 1;
6423               start += ul;
6424               break;
6425
6426             case DW_CFA_expression:
6427               reg = LEB ();
6428               ul = LEB ();
6429               if (reg >= (unsigned int) fc->ncols)
6430                 reg_prefix = bad_reg;
6431               /* PR 17512: file: 069-133014-0.006.  */
6432               /* PR 17512: file: 98c02eb4.  */
6433               tmp = start + ul;
6434               if (start >= block_end || tmp > block_end || tmp < start)
6435                 {
6436                   printf (_("  DW_CFA_expression: <corrupt len %lu>\n"), ul);
6437                   break;
6438                 }
6439               if (! do_debug_frames_interp || *reg_prefix != '\0')
6440                 {
6441                   printf ("  DW_CFA_expression: %s%s (",
6442                           reg_prefix, regname (reg, 0));
6443                   decode_location_expression (start, eh_addr_size, 0, -1,
6444                                               ul, 0, section);
6445                   printf (")\n");
6446                 }
6447               if (*reg_prefix == '\0')
6448                 fc->col_type[reg] = DW_CFA_expression;
6449               start = tmp;
6450               break;
6451
6452             case DW_CFA_val_expression:
6453               reg = LEB ();
6454               ul = LEB ();
6455               if (reg >= (unsigned int) fc->ncols)
6456                 reg_prefix = bad_reg;
6457               tmp = start + ul;
6458               if (start >= block_end || tmp > block_end || tmp < start)
6459                 {
6460                   printf ("  DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6461                   break;
6462                 }
6463               if (! do_debug_frames_interp || *reg_prefix != '\0')
6464                 {
6465                   printf ("  DW_CFA_val_expression: %s%s (",
6466                           reg_prefix, regname (reg, 0));
6467                   decode_location_expression (start, eh_addr_size, 0, -1,
6468                                               ul, 0, section);
6469                   printf (")\n");
6470                 }
6471               if (*reg_prefix == '\0')
6472                 fc->col_type[reg] = DW_CFA_val_expression;
6473               start = tmp;
6474               break;
6475
6476             case DW_CFA_offset_extended_sf:
6477               reg = LEB ();
6478               l = SLEB ();
6479               if (frame_need_space (fc, reg) < 0)
6480                 reg_prefix = bad_reg;
6481               if (! do_debug_frames_interp || *reg_prefix != '\0')
6482                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6483                         reg_prefix, regname (reg, 0),
6484                         (long)(l * fc->data_factor));
6485               if (*reg_prefix == '\0')
6486                 {
6487                   fc->col_type[reg] = DW_CFA_offset;
6488                   fc->col_offset[reg] = l * fc->data_factor;
6489                 }
6490               break;
6491
6492             case DW_CFA_val_offset_sf:
6493               reg = LEB ();
6494               l = SLEB ();
6495               if (frame_need_space (fc, reg) < 0)
6496                 reg_prefix = bad_reg;
6497               if (! do_debug_frames_interp || *reg_prefix != '\0')
6498                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6499                         reg_prefix, regname (reg, 0),
6500                         (long)(l * fc->data_factor));
6501               if (*reg_prefix == '\0')
6502                 {
6503                   fc->col_type[reg] = DW_CFA_val_offset;
6504                   fc->col_offset[reg] = l * fc->data_factor;
6505                 }
6506               break;
6507
6508             case DW_CFA_def_cfa_sf:
6509               fc->cfa_reg = LEB ();
6510               fc->cfa_offset = SLEB ();
6511               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6512               fc->cfa_exp = 0;
6513               if (! do_debug_frames_interp)
6514                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
6515                         regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
6516               break;
6517
6518             case DW_CFA_def_cfa_offset_sf:
6519               fc->cfa_offset = SLEB ();
6520               fc->cfa_offset *= fc->data_factor;
6521               if (! do_debug_frames_interp)
6522                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
6523               break;
6524
6525             case DW_CFA_MIPS_advance_loc8:
6526               SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
6527               if (do_debug_frames_interp)
6528                 frame_display_row (fc, &need_col_headers, &max_regs);
6529               else
6530                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6531                         (unsigned long) (ofs * fc->code_factor),
6532                         dwarf_vmatoa_1 (NULL,
6533                                         fc->pc_begin + ofs * fc->code_factor,
6534                                         fc->ptr_size));
6535               fc->pc_begin += ofs * fc->code_factor;
6536               break;
6537
6538             case DW_CFA_GNU_window_save:
6539               if (! do_debug_frames_interp)
6540                 printf ("  DW_CFA_GNU_window_save\n");
6541               break;
6542
6543             case DW_CFA_GNU_args_size:
6544               ul = LEB ();
6545               if (! do_debug_frames_interp)
6546                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
6547               break;
6548
6549             case DW_CFA_GNU_negative_offset_extended:
6550               reg = LEB ();
6551               l = - LEB ();
6552               if (frame_need_space (fc, reg) < 0)
6553                 reg_prefix = bad_reg;
6554               if (! do_debug_frames_interp || *reg_prefix != '\0')
6555                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6556                         reg_prefix, regname (reg, 0),
6557                         (long)(l * fc->data_factor));
6558               if (*reg_prefix == '\0')
6559                 {
6560                   fc->col_type[reg] = DW_CFA_offset;
6561                   fc->col_offset[reg] = l * fc->data_factor;
6562                 }
6563               break;
6564
6565             default:
6566               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6567                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6568               else
6569                 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6570               start = block_end;
6571             }
6572         }
6573
6574       if (do_debug_frames_interp)
6575         frame_display_row (fc, &need_col_headers, &max_regs);
6576
6577       start = block_end;
6578       eh_addr_size = saved_eh_addr_size;
6579     }
6580
6581   printf ("\n");
6582
6583   return 1;
6584 }
6585
6586 #undef GET
6587 #undef LEB
6588 #undef SLEB
6589
6590 static int
6591 display_gdb_index (struct dwarf_section *section,
6592                    void *file ATTRIBUTE_UNUSED)
6593 {
6594   unsigned char *start = section->start;
6595   uint32_t version;
6596   uint32_t cu_list_offset, tu_list_offset;
6597   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6598   unsigned int cu_list_elements, tu_list_elements;
6599   unsigned int address_table_size, symbol_table_slots;
6600   unsigned char *cu_list, *tu_list;
6601   unsigned char *address_table, *symbol_table, *constant_pool;
6602   unsigned int i;
6603
6604   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
6605
6606   printf (_("Contents of the %s section:\n"), section->name);
6607
6608   if (section->size < 6 * sizeof (uint32_t))
6609     {
6610       warn (_("Truncated header in the %s section.\n"), section->name);
6611       return 0;
6612     }
6613
6614   version = byte_get_little_endian (start, 4);
6615   printf (_("Version %ld\n"), (long) version);
6616
6617   /* Prior versions are obsolete, and future versions may not be
6618      backwards compatible.  */
6619   if (version < 3 || version > 8)
6620     {
6621       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6622       return 0;
6623     }
6624   if (version < 4)
6625     warn (_("The address table data in version 3 may be wrong.\n"));
6626   if (version < 5)
6627     warn (_("Version 4 does not support case insensitive lookups.\n"));
6628   if (version < 6)
6629     warn (_("Version 5 does not include inlined functions.\n"));
6630   if (version < 7)
6631       warn (_("Version 6 does not include symbol attributes.\n"));
6632   /* Version 7 indices generated by Gold have bad type unit references,
6633      PR binutils/15021.  But we don't know if the index was generated by
6634      Gold or not, so to avoid worrying users with gdb-generated indices
6635      we say nothing for version 7 here.  */
6636
6637   cu_list_offset = byte_get_little_endian (start + 4, 4);
6638   tu_list_offset = byte_get_little_endian (start + 8, 4);
6639   address_table_offset = byte_get_little_endian (start + 12, 4);
6640   symbol_table_offset = byte_get_little_endian (start + 16, 4);
6641   constant_pool_offset = byte_get_little_endian (start + 20, 4);
6642
6643   if (cu_list_offset > section->size
6644       || tu_list_offset > section->size
6645       || address_table_offset > section->size
6646       || symbol_table_offset > section->size
6647       || constant_pool_offset > section->size)
6648     {
6649       warn (_("Corrupt header in the %s section.\n"), section->name);
6650       return 0;
6651     }
6652
6653   /* PR 17531: file: 418d0a8a.  */
6654   if (tu_list_offset < cu_list_offset)
6655     {
6656       warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6657             tu_list_offset, cu_list_offset);
6658       return 0;
6659     }
6660
6661   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6662
6663   if (address_table_offset < tu_list_offset)
6664     {
6665       warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6666             address_table_offset, tu_list_offset);
6667       return 0;
6668     }
6669
6670   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6671
6672   /* PR 17531: file: 18a47d3d.  */
6673   if (symbol_table_offset < address_table_offset)
6674     {
6675       warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6676             symbol_table_offset, address_table_offset);
6677       return 0;
6678     }
6679
6680   address_table_size = symbol_table_offset - address_table_offset;
6681
6682   if (constant_pool_offset < symbol_table_offset)
6683     {
6684       warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6685             constant_pool_offset, symbol_table_offset);
6686       return 0;
6687     }
6688
6689   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6690
6691   cu_list = start + cu_list_offset;
6692   tu_list = start + tu_list_offset;
6693   address_table = start + address_table_offset;
6694   symbol_table = start + symbol_table_offset;
6695   constant_pool = start + constant_pool_offset;
6696
6697   if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6698     {
6699       warn (_("Address table extends beyond end of section.\n"));
6700       return 0;
6701     }
6702
6703   printf (_("\nCU table:\n"));
6704   for (i = 0; i < cu_list_elements; i += 2)
6705     {
6706       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6707       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6708
6709       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6710               (unsigned long) cu_offset,
6711               (unsigned long) (cu_offset + cu_length - 1));
6712     }
6713
6714   printf (_("\nTU table:\n"));
6715   for (i = 0; i < tu_list_elements; i += 3)
6716     {
6717       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6718       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6719       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6720
6721       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6722               (unsigned long) tu_offset,
6723               (unsigned long) type_offset);
6724       print_dwarf_vma (signature, 8);
6725       printf ("\n");
6726     }
6727
6728   printf (_("\nAddress table:\n"));
6729   for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6730        i += 2 * 8 + 4)
6731     {
6732       uint64_t low = byte_get_little_endian (address_table + i, 8);
6733       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6734       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6735
6736       print_dwarf_vma (low, 8);
6737       print_dwarf_vma (high, 8);
6738       printf (_("%lu\n"), (unsigned long) cu_index);
6739     }
6740
6741   printf (_("\nSymbol table:\n"));
6742   for (i = 0; i < symbol_table_slots; ++i)
6743     {
6744       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6745       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6746       uint32_t num_cus, cu;
6747
6748       if (name_offset != 0
6749           || cu_vector_offset != 0)
6750         {
6751           unsigned int j;
6752           unsigned char * adr;
6753
6754           adr = constant_pool + name_offset;
6755           /* PR 17531: file: 5b7b07ad.  */
6756           if (adr < constant_pool || adr >= section->start + section->size)
6757             {
6758               printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6759               warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6760                     name_offset, i);
6761             }
6762           else
6763             printf ("[%3u] %.*s:", i,
6764                     (int) (section->size - (constant_pool_offset + name_offset)),
6765                     constant_pool + name_offset);
6766
6767           adr = constant_pool + cu_vector_offset;
6768           if (adr < constant_pool || adr >= section->start + section->size - 3)
6769             {
6770               printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6771               warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6772                     cu_vector_offset, i);
6773               continue;
6774             }
6775
6776           num_cus = byte_get_little_endian (adr, 4);
6777
6778           adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
6779           if (num_cus * 4 < num_cus
6780               || adr >= section->start + section->size
6781               || adr < constant_pool)
6782             {
6783               printf ("<invalid number of CUs: %d>\n", num_cus);
6784               warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6785                     num_cus, i);
6786               continue;
6787             }
6788
6789           if (num_cus > 1)
6790             printf ("\n");
6791
6792           for (j = 0; j < num_cus; ++j)
6793             {
6794               int is_static;
6795               gdb_index_symbol_kind kind;
6796
6797               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6798               is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6799               kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6800               cu = GDB_INDEX_CU_VALUE (cu);
6801               /* Convert to TU number if it's for a type unit.  */
6802               if (cu >= cu_list_elements / 2)
6803                 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6804                         (unsigned long) (cu - cu_list_elements / 2));
6805               else
6806                 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6807
6808               printf (" [%s, %s]",
6809                       is_static ? _("static") : _("global"),
6810                       get_gdb_index_symbol_kind_name (kind));
6811               if (num_cus > 1)
6812                 printf ("\n");
6813             }
6814           if (num_cus <= 1)
6815             printf ("\n");
6816         }
6817     }
6818
6819   return 1;
6820 }
6821
6822 /* Pre-allocate enough space for the CU/TU sets needed.  */
6823
6824 static void
6825 prealloc_cu_tu_list (unsigned int nshndx)
6826 {
6827   if (shndx_pool == NULL)
6828     {
6829       shndx_pool_size = nshndx;
6830       shndx_pool_used = 0;
6831       shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6832                                               sizeof (unsigned int));
6833     }
6834   else
6835     {
6836       shndx_pool_size = shndx_pool_used + nshndx;
6837       shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6838                                                sizeof (unsigned int));
6839     }
6840 }
6841
6842 static void
6843 add_shndx_to_cu_tu_entry (unsigned int shndx)
6844 {
6845   if (shndx_pool_used >= shndx_pool_size)
6846     {
6847       error (_("Internal error: out of space in the shndx pool.\n"));
6848       return;
6849     }
6850   shndx_pool [shndx_pool_used++] = shndx;
6851 }
6852
6853 static void
6854 end_cu_tu_entry (void)
6855 {
6856   if (shndx_pool_used >= shndx_pool_size)
6857     {
6858       error (_("Internal error: out of space in the shndx pool.\n"));
6859       return;
6860     }
6861   shndx_pool [shndx_pool_used++] = 0;
6862 }
6863
6864 /* Return the short name of a DWARF section given by a DW_SECT enumerator.  */
6865
6866 static const char *
6867 get_DW_SECT_short_name (unsigned int dw_sect)
6868 {
6869   static char buf[16];
6870
6871   switch (dw_sect)
6872     {
6873       case DW_SECT_INFO:
6874         return "info";
6875       case DW_SECT_TYPES:
6876         return "types";
6877       case DW_SECT_ABBREV:
6878         return "abbrev";
6879       case DW_SECT_LINE:
6880         return "line";
6881       case DW_SECT_LOC:
6882         return "loc";
6883       case DW_SECT_STR_OFFSETS:
6884         return "str_off";
6885       case DW_SECT_MACINFO:
6886         return "macinfo";
6887       case DW_SECT_MACRO:
6888         return "macro";
6889       default:
6890         break;
6891     }
6892
6893   snprintf (buf, sizeof (buf), "%d", dw_sect);
6894   return buf;
6895 }
6896
6897 /* Process a CU or TU index.  If DO_DISPLAY is true, print the contents.
6898    These sections are extensions for Fission.
6899    See http://gcc.gnu.org/wiki/DebugFissionDWP.  */
6900
6901 static int
6902 process_cu_tu_index (struct dwarf_section *section, int do_display)
6903 {
6904   unsigned char *phdr = section->start;
6905   unsigned char *limit = phdr + section->size;
6906   unsigned char *phash;
6907   unsigned char *pindex;
6908   unsigned char *ppool;
6909   unsigned int version;
6910   unsigned int ncols = 0;
6911   unsigned int nused;
6912   unsigned int nslots;
6913   unsigned int i;
6914   unsigned int j;
6915   dwarf_vma signature_high;
6916   dwarf_vma signature_low;
6917   char buf[64];
6918
6919   /* PR 17512: file: 002-168123-0.004.  */
6920   if (phdr == NULL)
6921     {
6922       warn (_("Section %s is empty\n"), section->name);
6923       return 0;
6924     }
6925   /* PR 17512: file: 002-376-0.004.  */
6926   if (section->size < 24)
6927     {
6928       warn (_("Section %s is too small to contain a CU/TU header\n"),
6929             section->name);
6930       return 0;
6931     }
6932
6933   SAFE_BYTE_GET (version, phdr, 4, limit);
6934   if (version >= 2)
6935     SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6936   SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6937   SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6938
6939   phash = phdr + 16;
6940   pindex = phash + nslots * 8;
6941   ppool = pindex + nslots * 4;
6942
6943   /* PR 17531: file: 45d69832.  */
6944   if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
6945     {
6946       warn (_("Section %s is too small for %d slots\n"),
6947             section->name, nslots);
6948       return 0;
6949     }
6950
6951   if (do_display)
6952     {
6953       printf (_("Contents of the %s section:\n\n"), section->name);
6954       printf (_("  Version:                 %d\n"), version);
6955       if (version >= 2)
6956         printf (_("  Number of columns:       %d\n"), ncols);
6957       printf (_("  Number of used entries:  %d\n"), nused);
6958       printf (_("  Number of slots:         %d\n\n"), nslots);
6959     }
6960
6961   if (ppool > limit || ppool < phdr)
6962     {
6963       warn (_("Section %s too small for %d hash table entries\n"),
6964             section->name, nslots);
6965       return 0;
6966     }
6967
6968   if (version == 1)
6969     {
6970       if (!do_display)
6971         prealloc_cu_tu_list ((limit - ppool) / 4);
6972       for (i = 0; i < nslots; i++)
6973         {
6974           unsigned char *shndx_list;
6975           unsigned int shndx;
6976
6977           SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
6978           if (signature_high != 0 || signature_low != 0)
6979             {
6980               SAFE_BYTE_GET (j, pindex, 4, limit);
6981               shndx_list = ppool + j * 4;
6982               /* PR 17531: file: 705e010d.  */
6983               if (shndx_list < ppool)
6984                 {
6985                   warn (_("Section index pool located before start of section\n"));
6986                   return 0;
6987                 }
6988
6989               if (do_display)
6990                 printf (_("  [%3d] Signature:  0x%s  Sections: "),
6991                         i, dwarf_vmatoa64 (signature_high, signature_low,
6992                                            buf, sizeof (buf)));
6993               for (;;)
6994                 {
6995                   if (shndx_list >= limit)
6996                     {
6997                       warn (_("Section %s too small for shndx pool\n"),
6998                             section->name);
6999                       return 0;
7000                     }
7001                   SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
7002                   if (shndx == 0)
7003                     break;
7004                   if (do_display)
7005                     printf (" %d", shndx);
7006                   else
7007                     add_shndx_to_cu_tu_entry (shndx);
7008                   shndx_list += 4;
7009                 }
7010               if (do_display)
7011                 printf ("\n");
7012               else
7013                 end_cu_tu_entry ();
7014             }
7015           phash += 8;
7016           pindex += 4;
7017         }
7018     }
7019   else if (version == 2)
7020     {
7021       unsigned int val;
7022       unsigned int dw_sect;
7023       unsigned char *ph = phash;
7024       unsigned char *pi = pindex;
7025       unsigned char *poffsets = ppool + ncols * 4;
7026       unsigned char *psizes = poffsets + nused * ncols * 4;
7027       unsigned char *pend = psizes + nused * ncols * 4;
7028       bfd_boolean is_tu_index;
7029       struct cu_tu_set *this_set = NULL;
7030       unsigned int row;
7031       unsigned char *prow;
7032
7033       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7034
7035       /* PR 17531: file: 0dd159bf.
7036          Check for wraparound with an overlarge ncols value.  */
7037       if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
7038         {
7039           warn (_("Overlarge number of columns: %x\n"), ncols);
7040           return 0;
7041         }
7042
7043       if (pend > limit)
7044         {
7045           warn (_("Section %s too small for offset and size tables\n"),
7046                 section->name);
7047           return 0;
7048         }
7049
7050       if (do_display)
7051         {
7052           printf (_("  Offset table\n"));
7053           printf ("  slot  %-16s  ",
7054                  is_tu_index ? _("signature") : _("dwo_id"));
7055         }
7056       else
7057         {
7058           if (is_tu_index)
7059             {
7060               tu_count = nused;
7061               tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7062               this_set = tu_sets;
7063             }
7064           else
7065             {
7066               cu_count = nused;
7067               cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
7068               this_set = cu_sets;
7069             }
7070         }
7071
7072       if (do_display)
7073         {
7074           for (j = 0; j < ncols; j++)
7075             {
7076               SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7077               printf (" %8s", get_DW_SECT_short_name (dw_sect));
7078             }
7079           printf ("\n");
7080         }
7081
7082       for (i = 0; i < nslots; i++)
7083         {
7084           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7085
7086           SAFE_BYTE_GET (row, pi, 4, limit);
7087           if (row != 0)
7088             {
7089               /* PR 17531: file: a05f6ab3.  */
7090               if (row > nused)
7091                 {
7092                   warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7093                         row, nused);
7094                   return 0;
7095                 }
7096
7097               if (!do_display)
7098                 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7099
7100               prow = poffsets + (row - 1) * ncols * 4;
7101               /* PR 17531: file: b8ce60a8.  */
7102               if (prow < poffsets || prow > limit)
7103                 {
7104                   warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7105                         row, ncols);
7106                   return 0;
7107                 }
7108
7109               if (do_display)
7110                 printf (_("  [%3d] 0x%s"),
7111                         i, dwarf_vmatoa64 (signature_high, signature_low,
7112                                            buf, sizeof (buf)));
7113               for (j = 0; j < ncols; j++)
7114                 {
7115                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7116                   if (do_display)
7117                     printf (" %8d", val);
7118                   else
7119                     {
7120                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7121
7122                       /* PR 17531: file: 10796eb3.  */
7123                       if (dw_sect >= DW_SECT_MAX)
7124                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7125                       else
7126                         this_set [row - 1].section_offsets [dw_sect] = val;
7127                     }
7128                 }
7129
7130               if (do_display)
7131                 printf ("\n");
7132             }
7133           ph += 8;
7134           pi += 4;
7135         }
7136
7137       ph = phash;
7138       pi = pindex;
7139       if (do_display)
7140         {
7141           printf ("\n");
7142           printf (_("  Size table\n"));
7143           printf ("  slot  %-16s  ",
7144                  is_tu_index ? _("signature") : _("dwo_id"));
7145         }
7146
7147       for (j = 0; j < ncols; j++)
7148         {
7149           SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
7150           if (do_display)
7151             printf (" %8s", get_DW_SECT_short_name (val));
7152         }
7153
7154       if (do_display)
7155         printf ("\n");
7156
7157       for (i = 0; i < nslots; i++)
7158         {
7159           SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7160
7161           SAFE_BYTE_GET (row, pi, 4, limit);
7162           if (row != 0)
7163             {
7164               prow = psizes + (row - 1) * ncols * 4;
7165
7166               if (do_display)
7167                 printf (_("  [%3d] 0x%s"),
7168                         i, dwarf_vmatoa64 (signature_high, signature_low,
7169                                            buf, sizeof (buf)));
7170
7171               for (j = 0; j < ncols; j++)
7172                 {
7173                   SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
7174                   if (do_display)
7175                     printf (" %8d", val);
7176                   else
7177                     {
7178                       SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
7179                       if (dw_sect >= DW_SECT_MAX)
7180                         warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7181                       else
7182                       this_set [row - 1].section_sizes [dw_sect] = val;
7183                     }
7184                 }
7185
7186               if (do_display)
7187                 printf ("\n");
7188             }
7189
7190           ph += 8;
7191           pi += 4;
7192         }
7193     }
7194   else if (do_display)
7195     printf (_("  Unsupported version (%d)\n"), version);
7196
7197   if (do_display)
7198       printf ("\n");
7199
7200   return 1;
7201 }
7202
7203 /* Load the CU and TU indexes if present.  This will build a list of
7204    section sets that we can use to associate a .debug_info.dwo section
7205    with its associated .debug_abbrev.dwo section in a .dwp file.  */
7206
7207 static void
7208 load_cu_tu_indexes (void *file)
7209 {
7210   /* If we have already loaded (or tried to load) the CU and TU indexes
7211      then do not bother to repeat the task.  */
7212   if (cu_tu_indexes_read)
7213     return;
7214
7215   if (load_debug_section (dwp_cu_index, file))
7216     process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7217
7218   if (load_debug_section (dwp_tu_index, file))
7219     process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7220
7221   cu_tu_indexes_read = 1;
7222 }
7223
7224 /* Find the set of sections that includes section SHNDX.  */
7225
7226 unsigned int *
7227 find_cu_tu_set (void *file, unsigned int shndx)
7228 {
7229   unsigned int i;
7230
7231   load_cu_tu_indexes (file);
7232
7233   /* Find SHNDX in the shndx pool.  */
7234   for (i = 0; i < shndx_pool_used; i++)
7235     if (shndx_pool [i] == shndx)
7236       break;
7237
7238   if (i >= shndx_pool_used)
7239     return NULL;
7240
7241   /* Now backup to find the first entry in the set.  */
7242   while (i > 0 && shndx_pool [i - 1] != 0)
7243     i--;
7244
7245   return shndx_pool + i;
7246 }
7247
7248 /* Display a .debug_cu_index or .debug_tu_index section.  */
7249
7250 static int
7251 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7252 {
7253   return process_cu_tu_index (section, 1);
7254 }
7255
7256 static int
7257 display_debug_not_supported (struct dwarf_section *section,
7258                              void *file ATTRIBUTE_UNUSED)
7259 {
7260   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7261             section->name);
7262
7263   return 1;
7264 }
7265
7266 /* Like malloc, but takes two parameters like calloc.
7267    Verifies that the first parameter is not too large.
7268    Note: does *not* initialise the allocated memory to zero.  */
7269 void *
7270 cmalloc (size_t nmemb, size_t size)
7271 {
7272   /* Check for overflow.  */
7273   if (nmemb >= ~(size_t) 0 / size)
7274     return NULL;
7275
7276   return xmalloc (nmemb * size);
7277 }
7278
7279 /* Like xmalloc, but takes two parameters like calloc.
7280    Verifies that the first parameter is not too large.
7281    Note: does *not* initialise the allocated memory to zero.  */
7282 void *
7283 xcmalloc (size_t nmemb, size_t size)
7284 {
7285   /* Check for overflow.  */
7286   if (nmemb >= ~(size_t) 0 / size)
7287     {
7288       fprintf (stderr,
7289                _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7290                (long) nmemb);
7291       xexit (1);
7292     }
7293
7294   return xmalloc (nmemb * size);
7295 }
7296
7297 /* Like xrealloc, but takes three parameters.
7298    Verifies that the second parameter is not too large.
7299    Note: does *not* initialise any new memory to zero.  */
7300 void *
7301 xcrealloc (void *ptr, size_t nmemb, size_t size)
7302 {
7303   /* Check for overflow.  */
7304   if (nmemb >= ~(size_t) 0 / size)
7305     {
7306       fprintf (stderr,
7307                _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7308                (long) nmemb);
7309       xexit (1);
7310     }
7311
7312   return xrealloc (ptr, nmemb * size);
7313 }
7314
7315 /* Like xcalloc, but verifies that the first parameter is not too large.  */
7316 void *
7317 xcalloc2 (size_t nmemb, size_t size)
7318 {
7319   /* Check for overflow.  */
7320   if (nmemb >= ~(size_t) 0 / size)
7321     {
7322       fprintf (stderr,
7323                _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7324                (long) nmemb);
7325       xexit (1);
7326     }
7327
7328   return xcalloc (nmemb, size);
7329 }
7330
7331 void
7332 free_debug_memory (void)
7333 {
7334   unsigned int i;
7335
7336   free_abbrevs ();
7337
7338   for (i = 0; i < max; i++)
7339     free_debug_section ((enum dwarf_section_display_enum) i);
7340
7341   if (debug_information != NULL)
7342     {
7343       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7344         {
7345           for (i = 0; i < num_debug_info_entries; i++)
7346             {
7347               if (!debug_information [i].max_loc_offsets)
7348                 {
7349                   free (debug_information [i].loc_offsets);
7350                   free (debug_information [i].have_frame_base);
7351                 }
7352               if (!debug_information [i].max_range_lists)
7353                 free (debug_information [i].range_lists);
7354             }
7355         }
7356       free (debug_information);
7357       debug_information = NULL;
7358       alloc_num_debug_info_entries = num_debug_info_entries = 0;
7359     }
7360 }
7361
7362 void
7363 dwarf_select_sections_by_names (const char *names)
7364 {
7365   typedef struct
7366   {
7367     const char * option;
7368     int *        variable;
7369     int          val;
7370   }
7371   debug_dump_long_opts;
7372
7373   static const debug_dump_long_opts opts_table [] =
7374     {
7375       /* Please keep this table alpha- sorted.  */
7376       { "Ranges", & do_debug_ranges, 1 },
7377       { "abbrev", & do_debug_abbrevs, 1 },
7378       { "addr", & do_debug_addr, 1 },
7379       { "aranges", & do_debug_aranges, 1 },
7380       { "cu_index", & do_debug_cu_index, 1 },
7381       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7382       { "frames", & do_debug_frames, 1 },
7383       { "frames-interp", & do_debug_frames_interp, 1 },
7384       /* The special .gdb_index section.  */
7385       { "gdb_index", & do_gdb_index, 1 },
7386       { "info", & do_debug_info, 1 },
7387       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
7388       { "loc",  & do_debug_loc, 1 },
7389       { "macro", & do_debug_macinfo, 1 },
7390       { "pubnames", & do_debug_pubnames, 1 },
7391       { "pubtypes", & do_debug_pubtypes, 1 },
7392       /* This entry is for compatability
7393          with earlier versions of readelf.  */
7394       { "ranges", & do_debug_aranges, 1 },
7395       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7396       { "str", & do_debug_str, 1 },
7397       /* These trace_* sections are used by Itanium VMS.  */
7398       { "trace_abbrev", & do_trace_abbrevs, 1 },
7399       { "trace_aranges", & do_trace_aranges, 1 },
7400       { "trace_info", & do_trace_info, 1 },
7401       { NULL, NULL, 0 }
7402     };
7403
7404   const char *p;
7405
7406   p = names;
7407   while (*p)
7408     {
7409       const debug_dump_long_opts * entry;
7410
7411       for (entry = opts_table; entry->option; entry++)
7412         {
7413           size_t len = strlen (entry->option);
7414
7415           if (strncmp (p, entry->option, len) == 0
7416               && (p[len] == ',' || p[len] == '\0'))
7417             {
7418               * entry->variable |= entry->val;
7419
7420               /* The --debug-dump=frames-interp option also
7421                  enables the --debug-dump=frames option.  */
7422               if (do_debug_frames_interp)
7423                 do_debug_frames = 1;
7424
7425               p += len;
7426               break;
7427             }
7428         }
7429
7430       if (entry->option == NULL)
7431         {
7432           warn (_("Unrecognized debug option '%s'\n"), p);
7433           p = strchr (p, ',');
7434           if (p == NULL)
7435             break;
7436         }
7437
7438       if (*p == ',')
7439         p++;
7440     }
7441 }
7442
7443 void
7444 dwarf_select_sections_by_letters (const char *letters)
7445 {
7446   unsigned int lindex = 0;
7447
7448   while (letters[lindex])
7449     switch (letters[lindex++])
7450       {
7451       case 'i':
7452         do_debug_info = 1;
7453         break;
7454
7455       case 'a':
7456         do_debug_abbrevs = 1;
7457         break;
7458
7459       case 'l':
7460         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7461         break;
7462
7463       case 'L':
7464         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7465         break;
7466
7467       case 'p':
7468         do_debug_pubnames = 1;
7469         break;
7470
7471       case 't':
7472         do_debug_pubtypes = 1;
7473         break;
7474
7475       case 'r':
7476         do_debug_aranges = 1;
7477         break;
7478
7479       case 'R':
7480         do_debug_ranges = 1;
7481         break;
7482
7483       case 'F':
7484         do_debug_frames_interp = 1;
7485       case 'f':
7486         do_debug_frames = 1;
7487         break;
7488
7489       case 'm':
7490         do_debug_macinfo = 1;
7491         break;
7492
7493       case 's':
7494         do_debug_str = 1;
7495         break;
7496
7497       case 'o':
7498         do_debug_loc = 1;
7499         break;
7500
7501       default:
7502         warn (_("Unrecognized debug option '%s'\n"), letters);
7503         break;
7504       }
7505 }
7506
7507 void
7508 dwarf_select_sections_all (void)
7509 {
7510   do_debug_info = 1;
7511   do_debug_abbrevs = 1;
7512   do_debug_lines = FLAG_DEBUG_LINES_RAW;
7513   do_debug_pubnames = 1;
7514   do_debug_pubtypes = 1;
7515   do_debug_aranges = 1;
7516   do_debug_ranges = 1;
7517   do_debug_frames = 1;
7518   do_debug_macinfo = 1;
7519   do_debug_str = 1;
7520   do_debug_loc = 1;
7521   do_gdb_index = 1;
7522   do_trace_info = 1;
7523   do_trace_abbrevs = 1;
7524   do_trace_aranges = 1;
7525   do_debug_addr = 1;
7526   do_debug_cu_index = 1;
7527 }
7528
7529 struct dwarf_section_display debug_displays[] =
7530 {
7531   { { ".debug_abbrev",      ".zdebug_abbrev",   NULL, NULL, 0, 0, 0, NULL },
7532     display_debug_abbrev,   &do_debug_abbrevs,  0 },
7533   { { ".debug_aranges",     ".zdebug_aranges",  NULL, NULL, 0, 0, 0, NULL },
7534     display_debug_aranges,  &do_debug_aranges,  1 },
7535   { { ".debug_frame",       ".zdebug_frame",    NULL, NULL, 0, 0, 0, NULL },
7536     display_debug_frames,   &do_debug_frames,   1 },
7537   { { ".debug_info",        ".zdebug_info",     NULL, NULL, 0, 0, abbrev, NULL },
7538     display_debug_info,     &do_debug_info,     1 },
7539   { { ".debug_line",        ".zdebug_line",     NULL, NULL, 0, 0, 0, NULL },
7540     display_debug_lines,    &do_debug_lines,    1 },
7541   { { ".debug_pubnames",    ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
7542     display_debug_pubnames, &do_debug_pubnames, 0 },
7543   { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
7544     display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7545   { { ".eh_frame",          "",                 NULL, NULL, 0, 0, 0, NULL },
7546     display_debug_frames,   &do_debug_frames,   1 },
7547   { { ".debug_macinfo",     ".zdebug_macinfo",  NULL, NULL, 0, 0, 0, NULL },
7548     display_debug_macinfo,  &do_debug_macinfo,  0 },
7549   { { ".debug_macro",       ".zdebug_macro",    NULL, NULL, 0, 0, 0, NULL },
7550     display_debug_macro,    &do_debug_macinfo,  1 },
7551   { { ".debug_str",         ".zdebug_str",      NULL, NULL, 0, 0, 0, NULL },
7552     display_debug_str,      &do_debug_str,      0 },
7553   { { ".debug_loc",         ".zdebug_loc",      NULL, NULL, 0, 0, 0, NULL },
7554     display_debug_loc,      &do_debug_loc,      1 },
7555   { { ".debug_pubtypes",    ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7556     display_debug_pubnames, &do_debug_pubtypes, 0 },
7557   { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
7558     display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7559   { { ".debug_ranges",      ".zdebug_ranges",   NULL, NULL, 0, 0, 0, NULL },
7560     display_debug_ranges,   &do_debug_ranges,   1 },
7561   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
7562     display_debug_not_supported, NULL,          0 },
7563   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
7564     display_debug_not_supported, NULL,          0 },
7565   { { ".debug_types",       ".zdebug_types",    NULL, NULL, 0, 0, abbrev, NULL },
7566     display_debug_types,    &do_debug_info,     1 },
7567   { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
7568     display_debug_not_supported, NULL,          0 },
7569   { { ".gdb_index",         "",                 NULL, NULL, 0, 0, 0, NULL },
7570     display_gdb_index,      &do_gdb_index,      0 },
7571   { { ".trace_info",        "",                 NULL, NULL, 0, 0, trace_abbrev, NULL },
7572     display_trace_info,     &do_trace_info,     1 },
7573   { { ".trace_abbrev",      "",                 NULL, NULL, 0, 0, 0, NULL },
7574     display_debug_abbrev,   &do_trace_abbrevs,  0 },
7575   { { ".trace_aranges",     "",                 NULL, NULL, 0, 0, 0, NULL },
7576     display_debug_aranges,  &do_trace_aranges,  0 },
7577   { { ".debug_info.dwo",    ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7578     display_debug_info,     &do_debug_info,     1 },
7579   { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
7580     display_debug_abbrev,   &do_debug_abbrevs,  0 },
7581   { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
7582     display_debug_types,    &do_debug_info,     1 },
7583   { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
7584     display_debug_lines,    &do_debug_lines,    1 },
7585   { { ".debug_loc.dwo",     ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0, NULL },
7586     display_debug_loc,      &do_debug_loc,      1 },
7587   { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
7588     display_debug_macro,    &do_debug_macinfo,  1 },
7589   { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
7590     display_debug_macinfo,  &do_debug_macinfo,  0 },
7591   { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0, NULL },
7592     display_debug_str,      &do_debug_str,      1 },
7593   { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
7594     display_debug_str_offsets, NULL,            0 },
7595   { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
7596     display_debug_str_offsets, NULL,            0 },
7597   { { ".debug_addr",        ".zdebug_addr",     NULL, NULL, 0, 0, 0, NULL },
7598     display_debug_addr,     &do_debug_addr,     1 },
7599   { { ".debug_cu_index",    "",                 NULL, NULL, 0, 0, 0, NULL },
7600     display_cu_index,       &do_debug_cu_index, 0 },
7601   { { ".debug_tu_index",    "",                 NULL, NULL, 0, 0, 0, NULL },
7602     display_cu_index,       &do_debug_cu_index, 0 },
7603 };