binutils/dwarf.c

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