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",
4943   "esp", "ebp", "esi", "edi",
4944   "eip", "eflags", NULL,
4945   "st0", "st1", "st2", "st3",
4946   "st4", "st5", "st6", "st7",
4947   NULL, NULL,
4948   "xmm0", "xmm1", "xmm2", "xmm3",
4949   "xmm4", "xmm5", "xmm6", "xmm7",
4950   "mm0", "mm1", "mm2", "mm3",
4951   "mm4", "mm5", "mm6", "mm7",
4952   "fcw", "fsw", "mxcsr",
4953   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4954   "tr", "ldtr"
4955 };
4956
4957 void
4958 init_dwarf_regnames_i386 (void)
4959 {
4960   dwarf_regnames = dwarf_regnames_i386;
4961   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4962 }
4963
4964 static const char *const dwarf_regnames_x86_64[] =
4965 {
4966   "rax", "rdx", "rcx", "rbx",
4967   "rsi", "rdi", "rbp", "rsp",
4968   "r8",  "r9",  "r10", "r11",
4969   "r12", "r13", "r14", "r15",
4970   "rip",
4971   "xmm0",  "xmm1",  "xmm2",  "xmm3",
4972   "xmm4",  "xmm5",  "xmm6",  "xmm7",
4973   "xmm8",  "xmm9",  "xmm10", "xmm11",
4974   "xmm12", "xmm13", "xmm14", "xmm15",
4975   "st0", "st1", "st2", "st3",
4976   "st4", "st5", "st6", "st7",
4977   "mm0", "mm1", "mm2", "mm3",
4978   "mm4", "mm5", "mm6", "mm7",
4979   "rflags",
4980   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4981   "fs.base", "gs.base", NULL, NULL,
4982   "tr", "ldtr",
4983   "mxcsr", "fcw", "fsw"
4984 };
4985
4986 void
4987 init_dwarf_regnames_x86_64 (void)
4988 {
4989   dwarf_regnames = dwarf_regnames_x86_64;
4990   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4991 }
4992
4993 void
4994 init_dwarf_regnames (unsigned int e_machine)
4995 {
4996   switch (e_machine)
4997     {
4998     case EM_386:
4999     case EM_486:
5000       init_dwarf_regnames_i386 ();
5001       break;
5002
5003     case EM_X86_64:
5004     case EM_L1OM:
5005     case EM_K1OM:
5006       init_dwarf_regnames_x86_64 ();
5007       break;
5008
5009     default:
5010       break;
5011     }
5012 }
5013
5014 static const char *
5015 regname (unsigned int regno, int row)
5016 {
5017   static char reg[64];
5018   if (dwarf_regnames
5019       && regno < dwarf_regnames_count
5020       && dwarf_regnames [regno] != NULL)
5021     {
5022       if (row)
5023         return dwarf_regnames [regno];
5024       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5025                 dwarf_regnames [regno]);
5026     }
5027   else
5028     snprintf (reg, sizeof (reg), "r%d", regno);
5029   return reg;
5030 }
5031
5032 static void
5033 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
5034 {
5035   int r;
5036   char tmp[100];
5037
5038   if (*max_regs < fc->ncols)
5039     *max_regs = fc->ncols;
5040
5041   if (*need_col_headers)
5042     {
5043       static const char *sloc = "   LOC";
5044
5045       *need_col_headers = 0;
5046
5047       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
5048
5049       for (r = 0; r < *max_regs; r++)
5050         if (fc->col_type[r] != DW_CFA_unreferenced)
5051           {
5052             if (r == fc->ra)
5053               printf ("ra      ");
5054             else
5055               printf ("%-5s ", regname (r, 1));
5056           }
5057
5058       printf ("\n");
5059     }
5060
5061   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
5062   if (fc->cfa_exp)
5063     strcpy (tmp, "exp");
5064   else
5065     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5066   printf ("%-8s ", tmp);
5067
5068   for (r = 0; r < fc->ncols; r++)
5069     {
5070       if (fc->col_type[r] != DW_CFA_unreferenced)
5071         {
5072           switch (fc->col_type[r])
5073             {
5074             case DW_CFA_undefined:
5075               strcpy (tmp, "u");
5076               break;
5077             case DW_CFA_same_value:
5078               strcpy (tmp, "s");
5079               break;
5080             case DW_CFA_offset:
5081               sprintf (tmp, "c%+d", fc->col_offset[r]);
5082               break;
5083             case DW_CFA_val_offset:
5084               sprintf (tmp, "v%+d", fc->col_offset[r]);
5085               break;
5086             case DW_CFA_register:
5087               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5088               break;
5089             case DW_CFA_expression:
5090               strcpy (tmp, "exp");
5091               break;
5092             case DW_CFA_val_expression:
5093               strcpy (tmp, "vexp");
5094               break;
5095             default:
5096               strcpy (tmp, "n/a");
5097               break;
5098             }
5099           printf ("%-5s ", tmp);
5100         }
5101     }
5102   printf ("\n");
5103 }
5104
5105 #define GET(VAR, N)     SAFE_BYTE_GET_AND_INC (VAR, start, N, end);
5106 #define LEB()   read_uleb128 (start, & length_return, end); start += length_return
5107 #define SLEB()  read_sleb128 (start, & length_return, end); start += length_return
5108
5109 static int
5110 display_debug_frames (struct dwarf_section *section,
5111                       void *file ATTRIBUTE_UNUSED)
5112 {
5113   unsigned char *start = section->start;
5114   unsigned char *end = start + section->size;
5115   unsigned char *section_start = start;
5116   Frame_Chunk *chunks = 0;
5117   Frame_Chunk *remembered_state = 0;
5118   Frame_Chunk *rs;
5119   int is_eh = strcmp (section->name, ".eh_frame") == 0;
5120   unsigned int length_return;
5121   int max_regs = 0;
5122   const char *bad_reg = _("bad register: ");
5123   int saved_eh_addr_size = eh_addr_size;
5124
5125   printf (_("Contents of the %s section:\n"), section->name);
5126
5127   while (start < end)
5128     {
5129       unsigned char *saved_start;
5130       unsigned char *block_end;
5131       unsigned long length;
5132       unsigned long cie_id;
5133       Frame_Chunk *fc;
5134       Frame_Chunk *cie;
5135       int need_col_headers = 1;
5136       unsigned char *augmentation_data = NULL;
5137       unsigned long augmentation_data_len = 0;
5138       int encoded_ptr_size = saved_eh_addr_size;
5139       int offset_size;
5140       int initial_length_size;
5141
5142       saved_start = start;
5143
5144       SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5145       if (length == 0)
5146         {
5147           printf ("\n%08lx ZERO terminator\n\n",
5148                     (unsigned long)(saved_start - section_start));
5149           continue;
5150         }
5151
5152       if (length == 0xffffffff)
5153         {
5154           SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5155           offset_size = 8;
5156           initial_length_size = 12;
5157         }
5158       else
5159         {
5160           offset_size = 4;
5161           initial_length_size = 4;
5162         }
5163
5164       block_end = saved_start + length + initial_length_size;
5165       if (block_end > end)
5166         {
5167           warn ("Invalid length %#08lx in FDE at %#08lx\n",
5168                 length, (unsigned long)(saved_start - section_start));
5169           block_end = end;
5170         }
5171
5172       SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5173
5174       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
5175         {
5176           int version;
5177
5178           fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5179           memset (fc, 0, sizeof (Frame_Chunk));
5180
5181           fc->next = chunks;
5182           chunks = fc;
5183           fc->chunk_start = saved_start;
5184           fc->ncols = 0;
5185           fc->col_type = (short int *) xmalloc (sizeof (short int));
5186           fc->col_offset = (int *) xmalloc (sizeof (int));
5187           frame_need_space (fc, max_regs - 1);
5188
5189           version = *start++;
5190
5191           fc->augmentation = (char *) start;
5192           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
5193
5194           if (strcmp (fc->augmentation, "eh") == 0)
5195             start += eh_addr_size;
5196
5197           if (version >= 4)
5198             {
5199               GET (fc->ptr_size, 1);
5200               GET (fc->segment_size, 1);
5201               eh_addr_size = fc->ptr_size;
5202             }
5203           else
5204             {
5205               fc->ptr_size = eh_addr_size;
5206               fc->segment_size = 0;
5207             }
5208           fc->code_factor = LEB ();
5209           fc->data_factor = SLEB ();
5210           if (version == 1)
5211             {
5212               GET (fc->ra, 1);
5213             }
5214           else
5215             {
5216               fc->ra = LEB ();
5217             }
5218
5219           if (fc->augmentation[0] == 'z')
5220             {
5221               augmentation_data_len = LEB ();
5222               augmentation_data = start;
5223               start += augmentation_data_len;
5224             }
5225           cie = fc;
5226
5227           if (do_debug_frames_interp)
5228             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
5229                     (unsigned long)(saved_start - section_start), length, cie_id,
5230                     fc->augmentation, fc->code_factor, fc->data_factor,
5231                     fc->ra);
5232           else
5233             {
5234               printf ("\n%08lx %08lx %08lx CIE\n",
5235                       (unsigned long)(saved_start - section_start), length, cie_id);
5236               printf ("  Version:               %d\n", version);
5237               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
5238               if (version >= 4)
5239                 {
5240                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
5241                   printf ("  Segment Size:          %u\n", fc->segment_size);
5242                 }
5243               printf ("  Code alignment factor: %u\n", fc->code_factor);
5244               printf ("  Data alignment factor: %d\n", fc->data_factor);
5245               printf ("  Return address column: %d\n", fc->ra);
5246
5247               if (augmentation_data_len)
5248                 {
5249                   unsigned long i;
5250                   printf ("  Augmentation data:    ");
5251                   for (i = 0; i < augmentation_data_len; ++i)
5252                     printf (" %02x", augmentation_data[i]);
5253                   putchar ('\n');
5254                 }
5255               putchar ('\n');
5256             }
5257
5258           if (augmentation_data_len)
5259             {
5260               unsigned char *p, *q;
5261               p = (unsigned char *) fc->augmentation + 1;
5262               q = augmentation_data;
5263
5264               while (1)
5265                 {
5266                   if (*p == 'L')
5267                     q++;
5268                   else if (*p == 'P')
5269                     q += 1 + size_of_encoded_value (*q);
5270                   else if (*p == 'R')
5271                     fc->fde_encoding = *q++;
5272                   else if (*p == 'S')
5273                     ;
5274                   else
5275                     break;
5276                   p++;
5277                 }
5278
5279               if (fc->fde_encoding)
5280                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5281             }
5282
5283           frame_need_space (fc, fc->ra);
5284         }
5285       else
5286         {
5287           unsigned char *look_for;
5288           static Frame_Chunk fde_fc;
5289           unsigned long segment_selector;
5290
5291           fc = & fde_fc;
5292           memset (fc, 0, sizeof (Frame_Chunk));
5293
5294           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
5295
5296           for (cie = chunks; cie ; cie = cie->next)
5297             if (cie->chunk_start == look_for)
5298               break;
5299
5300           if (!cie)
5301             {
5302               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
5303                     cie_id, (unsigned long)(saved_start - section_start));
5304               fc->ncols = 0;
5305               fc->col_type = (short int *) xmalloc (sizeof (short int));
5306               fc->col_offset = (int *) xmalloc (sizeof (int));
5307               frame_need_space (fc, max_regs - 1);
5308               cie = fc;
5309               fc->augmentation = "";
5310               fc->fde_encoding = 0;
5311               fc->ptr_size = eh_addr_size;
5312               fc->segment_size = 0;
5313             }
5314           else
5315             {
5316               fc->ncols = cie->ncols;
5317               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5318               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
5319               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5320               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5321               fc->augmentation = cie->augmentation;
5322               fc->ptr_size = cie->ptr_size;
5323               eh_addr_size = cie->ptr_size;
5324               fc->segment_size = cie->segment_size;
5325               fc->code_factor = cie->code_factor;
5326               fc->data_factor = cie->data_factor;
5327               fc->cfa_reg = cie->cfa_reg;
5328               fc->cfa_offset = cie->cfa_offset;
5329               fc->ra = cie->ra;
5330               frame_need_space (fc, max_regs - 1);
5331               fc->fde_encoding = cie->fde_encoding;
5332             }
5333
5334           if (fc->fde_encoding)
5335             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5336
5337           segment_selector = 0;
5338           if (fc->segment_size)
5339             {
5340               SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5341             }
5342           fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
5343           start += encoded_ptr_size;
5344
5345           /* FIXME: It appears that sometimes the final pc_range value is
5346              encoded in less than encoded_ptr_size bytes.  See the x86_64
5347              run of the "objcopy on compressed debug sections" test for an
5348              example of this.  */
5349           SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
5350
5351           if (cie->augmentation[0] == 'z')
5352             {
5353               augmentation_data_len = LEB ();
5354               augmentation_data = start;
5355               start += augmentation_data_len;
5356             }
5357
5358           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
5359                   (unsigned long)(saved_start - section_start), length, cie_id,
5360                   (unsigned long)(cie->chunk_start - section_start));
5361           if (fc->segment_size)
5362             printf ("%04lx:", segment_selector);
5363           printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
5364           if (! do_debug_frames_interp && augmentation_data_len)
5365             {
5366               unsigned long i;
5367
5368               printf ("  Augmentation data:    ");
5369               for (i = 0; i < augmentation_data_len; ++i)
5370                 printf (" %02x", augmentation_data[i]);
5371               putchar ('\n');
5372               putchar ('\n');
5373             }
5374         }
5375
5376       /* At this point, fc is the current chunk, cie (if any) is set, and
5377          we're about to interpret instructions for the chunk.  */
5378       /* ??? At present we need to do this always, since this sizes the
5379          fc->col_type and fc->col_offset arrays, which we write into always.
5380          We should probably split the interpreted and non-interpreted bits
5381          into two different routines, since there's so much that doesn't
5382          really overlap between them.  */
5383       if (1 || do_debug_frames_interp)
5384         {
5385           /* Start by making a pass over the chunk, allocating storage
5386              and taking note of what registers are used.  */
5387           unsigned char *tmp = start;
5388
5389           while (start < block_end)
5390             {
5391               unsigned op, opa;
5392               unsigned long reg, temp;
5393
5394               op = *start++;
5395               opa = op & 0x3f;
5396               if (op & 0xc0)
5397                 op &= 0xc0;
5398
5399               /* Warning: if you add any more cases to this switch, be
5400                  sure to add them to the corresponding switch below.  */
5401               switch (op)
5402                 {
5403                 case DW_CFA_advance_loc:
5404                   break;
5405                 case DW_CFA_offset:
5406                   LEB ();
5407                   if (frame_need_space (fc, opa) >= 0)
5408                     fc->col_type[opa] = DW_CFA_undefined;
5409                   break;
5410                 case DW_CFA_restore:
5411                   if (frame_need_space (fc, opa) >= 0)
5412                     fc->col_type[opa] = DW_CFA_undefined;
5413                   break;
5414                 case DW_CFA_set_loc:
5415                   start += encoded_ptr_size;
5416                   break;
5417                 case DW_CFA_advance_loc1:
5418                   start += 1;
5419                   break;
5420                 case DW_CFA_advance_loc2:
5421                   start += 2;
5422                   break;
5423                 case DW_CFA_advance_loc4:
5424                   start += 4;
5425                   break;
5426                 case DW_CFA_offset_extended:
5427                 case DW_CFA_val_offset:
5428                   reg = LEB (); LEB ();
5429                   if (frame_need_space (fc, reg) >= 0)
5430                     fc->col_type[reg] = DW_CFA_undefined;
5431                   break;
5432                 case DW_CFA_restore_extended:
5433                   reg = LEB ();
5434                   frame_need_space (fc, reg);
5435                   if (frame_need_space (fc, reg) >= 0)
5436                     fc->col_type[reg] = DW_CFA_undefined;
5437                   break;
5438                 case DW_CFA_undefined:
5439                   reg = LEB ();
5440                   if (frame_need_space (fc, reg) >= 0)
5441                     fc->col_type[reg] = DW_CFA_undefined;
5442                   break;
5443                 case DW_CFA_same_value:
5444                   reg = LEB ();
5445                   if (frame_need_space (fc, reg) >= 0)
5446                     fc->col_type[reg] = DW_CFA_undefined;
5447                   break;
5448                 case DW_CFA_register:
5449                   reg = LEB (); LEB ();
5450                   if (frame_need_space (fc, reg) >= 0)
5451                     fc->col_type[reg] = DW_CFA_undefined;
5452                   break;
5453                 case DW_CFA_def_cfa:
5454                   LEB (); LEB ();
5455                   break;
5456                 case DW_CFA_def_cfa_register:
5457                   LEB ();
5458                   break;
5459                 case DW_CFA_def_cfa_offset:
5460                   LEB ();
5461                   break;
5462                 case DW_CFA_def_cfa_expression:
5463                   temp = LEB ();
5464                   start += temp;
5465                   break;
5466                 case DW_CFA_expression:
5467                 case DW_CFA_val_expression:
5468                   reg = LEB ();
5469                   temp = LEB ();
5470                   start += temp;
5471                   if (frame_need_space (fc, reg) >= 0)
5472                     fc->col_type[reg] = DW_CFA_undefined;
5473                   break;
5474                 case DW_CFA_offset_extended_sf:
5475                 case DW_CFA_val_offset_sf:
5476                   reg = LEB (); SLEB ();
5477                   if (frame_need_space (fc, reg) >= 0)
5478                     fc->col_type[reg] = DW_CFA_undefined;
5479                   break;
5480                 case DW_CFA_def_cfa_sf:
5481                   LEB (); SLEB ();
5482                   break;
5483                 case DW_CFA_def_cfa_offset_sf:
5484                   SLEB ();
5485                   break;
5486                 case DW_CFA_MIPS_advance_loc8:
5487                   start += 8;
5488                   break;
5489                 case DW_CFA_GNU_args_size:
5490                   LEB ();
5491                   break;
5492                 case DW_CFA_GNU_negative_offset_extended:
5493                   reg = LEB (); LEB ();
5494                   if (frame_need_space (fc, reg) >= 0)
5495                     fc->col_type[reg] = DW_CFA_undefined;
5496                   break;
5497                 default:
5498                   break;
5499                 }
5500             }
5501           start = tmp;
5502         }
5503
5504       /* Now we know what registers are used, make a second pass over
5505          the chunk, this time actually printing out the info.  */
5506
5507       while (start < block_end)
5508         {
5509           unsigned op, opa;
5510           unsigned long ul, reg, roffs;
5511           long l, ofs;
5512           dwarf_vma vma;
5513           const char *reg_prefix = "";
5514
5515           op = *start++;
5516           opa = op & 0x3f;
5517           if (op & 0xc0)
5518             op &= 0xc0;
5519
5520           /* Warning: if you add any more cases to this switch, be
5521              sure to add them to the corresponding switch above.  */
5522           switch (op)
5523             {
5524             case DW_CFA_advance_loc:
5525               if (do_debug_frames_interp)
5526                 frame_display_row (fc, &need_col_headers, &max_regs);
5527               else
5528                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
5529                         opa * fc->code_factor,
5530                         fc->pc_begin + opa * fc->code_factor);
5531               fc->pc_begin += opa * fc->code_factor;
5532               break;
5533
5534             case DW_CFA_offset:
5535               roffs = LEB ();
5536               if (opa >= (unsigned int) fc->ncols)
5537                 reg_prefix = bad_reg;
5538               if (! do_debug_frames_interp || *reg_prefix != '\0')
5539                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
5540                         reg_prefix, regname (opa, 0),
5541                         roffs * fc->data_factor);
5542               if (*reg_prefix == '\0')
5543                 {
5544                   fc->col_type[opa] = DW_CFA_offset;
5545                   fc->col_offset[opa] = roffs * fc->data_factor;
5546                 }
5547               break;
5548
5549             case DW_CFA_restore:
5550               if (opa >= (unsigned int) cie->ncols
5551                   || opa >= (unsigned int) fc->ncols)
5552                 reg_prefix = bad_reg;
5553               if (! do_debug_frames_interp || *reg_prefix != '\0')
5554                 printf ("  DW_CFA_restore: %s%s\n",
5555                         reg_prefix, regname (opa, 0));
5556               if (*reg_prefix == '\0')
5557                 {
5558                   fc->col_type[opa] = cie->col_type[opa];
5559                   fc->col_offset[opa] = cie->col_offset[opa];
5560                   if (do_debug_frames_interp
5561                       && fc->col_type[opa] == DW_CFA_unreferenced)
5562                     fc->col_type[opa] = DW_CFA_undefined;
5563                 }
5564               break;
5565
5566             case DW_CFA_set_loc:
5567               vma = get_encoded_value (start, fc->fde_encoding, section);
5568               start += encoded_ptr_size;
5569               if (do_debug_frames_interp)
5570                 frame_display_row (fc, &need_col_headers, &max_regs);
5571               else
5572                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
5573               fc->pc_begin = vma;
5574               break;
5575
5576             case DW_CFA_advance_loc1:
5577               SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
5578               if (do_debug_frames_interp)
5579                 frame_display_row (fc, &need_col_headers, &max_regs);
5580               else
5581                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
5582                         ofs * fc->code_factor,
5583                         fc->pc_begin + ofs * fc->code_factor);
5584               fc->pc_begin += ofs * fc->code_factor;
5585               break;
5586
5587             case DW_CFA_advance_loc2:
5588               SAFE_BYTE_GET_AND_INC (ofs, start, 2, end);
5589               if (do_debug_frames_interp)
5590                 frame_display_row (fc, &need_col_headers, &max_regs);
5591               else
5592                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
5593                         ofs * fc->code_factor,
5594                         fc->pc_begin + ofs * fc->code_factor);
5595               fc->pc_begin += ofs * fc->code_factor;
5596               break;
5597
5598             case DW_CFA_advance_loc4:
5599               SAFE_BYTE_GET_AND_INC (ofs, start, 4, end);
5600               if (do_debug_frames_interp)
5601                 frame_display_row (fc, &need_col_headers, &max_regs);
5602               else
5603                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
5604                         ofs * fc->code_factor,
5605                         fc->pc_begin + ofs * fc->code_factor);
5606               fc->pc_begin += ofs * fc->code_factor;
5607               break;
5608
5609             case DW_CFA_offset_extended:
5610               reg = LEB ();
5611               roffs = LEB ();
5612               if (reg >= (unsigned int) fc->ncols)
5613                 reg_prefix = bad_reg;
5614               if (! do_debug_frames_interp || *reg_prefix != '\0')
5615                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5616                         reg_prefix, regname (reg, 0),
5617                         roffs * fc->data_factor);
5618               if (*reg_prefix == '\0')
5619                 {
5620                   fc->col_type[reg] = DW_CFA_offset;
5621                   fc->col_offset[reg] = roffs * fc->data_factor;
5622                 }
5623               break;
5624
5625             case DW_CFA_val_offset:
5626               reg = LEB ();
5627               roffs = LEB ();
5628               if (reg >= (unsigned int) fc->ncols)
5629                 reg_prefix = bad_reg;
5630               if (! do_debug_frames_interp || *reg_prefix != '\0')
5631                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
5632                         reg_prefix, regname (reg, 0),
5633                         roffs * fc->data_factor);
5634               if (*reg_prefix == '\0')
5635                 {
5636                   fc->col_type[reg] = DW_CFA_val_offset;
5637                   fc->col_offset[reg] = roffs * fc->data_factor;
5638                 }
5639               break;
5640
5641             case DW_CFA_restore_extended:
5642               reg = LEB ();
5643               if (reg >= (unsigned int) cie->ncols
5644                   || reg >= (unsigned int) fc->ncols)
5645                 reg_prefix = bad_reg;
5646               if (! do_debug_frames_interp || *reg_prefix != '\0')
5647                 printf ("  DW_CFA_restore_extended: %s%s\n",
5648                         reg_prefix, regname (reg, 0));
5649               if (*reg_prefix == '\0')
5650                 {
5651                   fc->col_type[reg] = cie->col_type[reg];
5652                   fc->col_offset[reg] = cie->col_offset[reg];
5653                 }
5654               break;
5655
5656             case DW_CFA_undefined:
5657               reg = LEB ();
5658               if (reg >= (unsigned int) fc->ncols)
5659                 reg_prefix = bad_reg;
5660               if (! do_debug_frames_interp || *reg_prefix != '\0')
5661                 printf ("  DW_CFA_undefined: %s%s\n",
5662                         reg_prefix, regname (reg, 0));
5663               if (*reg_prefix == '\0')
5664                 {
5665                   fc->col_type[reg] = DW_CFA_undefined;
5666                   fc->col_offset[reg] = 0;
5667                 }
5668               break;
5669
5670             case DW_CFA_same_value:
5671               reg = LEB ();
5672               if (reg >= (unsigned int) fc->ncols)
5673                 reg_prefix = bad_reg;
5674               if (! do_debug_frames_interp || *reg_prefix != '\0')
5675                 printf ("  DW_CFA_same_value: %s%s\n",
5676                         reg_prefix, regname (reg, 0));
5677               if (*reg_prefix == '\0')
5678                 {
5679                   fc->col_type[reg] = DW_CFA_same_value;
5680                   fc->col_offset[reg] = 0;
5681                 }
5682               break;
5683
5684             case DW_CFA_register:
5685               reg = LEB ();
5686               roffs = LEB ();
5687               if (reg >= (unsigned int) fc->ncols)
5688                 reg_prefix = bad_reg;
5689               if (! do_debug_frames_interp || *reg_prefix != '\0')
5690                 {
5691                   printf ("  DW_CFA_register: %s%s in ",
5692                           reg_prefix, regname (reg, 0));
5693                   puts (regname (roffs, 0));
5694                 }
5695               if (*reg_prefix == '\0')
5696                 {
5697                   fc->col_type[reg] = DW_CFA_register;
5698                   fc->col_offset[reg] = roffs;
5699                 }
5700               break;
5701
5702             case DW_CFA_remember_state:
5703               if (! do_debug_frames_interp)
5704                 printf ("  DW_CFA_remember_state\n");
5705               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5706               rs->ncols = fc->ncols;
5707               rs->col_type = (short int *) xcmalloc (rs->ncols,
5708                                                      sizeof (short int));
5709               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
5710               memcpy (rs->col_type, fc->col_type, rs->ncols);
5711               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5712               rs->next = remembered_state;
5713               remembered_state = rs;
5714               break;
5715
5716             case DW_CFA_restore_state:
5717               if (! do_debug_frames_interp)
5718                 printf ("  DW_CFA_restore_state\n");
5719               rs = remembered_state;
5720               if (rs)
5721                 {
5722                   remembered_state = rs->next;
5723                   frame_need_space (fc, rs->ncols - 1);
5724                   memcpy (fc->col_type, rs->col_type, rs->ncols);
5725                   memcpy (fc->col_offset, rs->col_offset,
5726                           rs->ncols * sizeof (int));
5727                   free (rs->col_type);
5728                   free (rs->col_offset);
5729                   free (rs);
5730                 }
5731               else if (do_debug_frames_interp)
5732                 printf ("Mismatched DW_CFA_restore_state\n");
5733               break;
5734
5735             case DW_CFA_def_cfa:
5736               fc->cfa_reg = LEB ();
5737               fc->cfa_offset = LEB ();
5738               fc->cfa_exp = 0;
5739               if (! do_debug_frames_interp)
5740                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
5741                         regname (fc->cfa_reg, 0), fc->cfa_offset);
5742               break;
5743
5744             case DW_CFA_def_cfa_register:
5745               fc->cfa_reg = LEB ();
5746               fc->cfa_exp = 0;
5747               if (! do_debug_frames_interp)
5748                 printf ("  DW_CFA_def_cfa_register: %s\n",
5749                         regname (fc->cfa_reg, 0));
5750               break;
5751
5752             case DW_CFA_def_cfa_offset:
5753               fc->cfa_offset = LEB ();
5754               if (! do_debug_frames_interp)
5755                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5756               break;
5757
5758             case DW_CFA_nop:
5759               if (! do_debug_frames_interp)
5760                 printf ("  DW_CFA_nop\n");
5761               break;
5762
5763             case DW_CFA_def_cfa_expression:
5764               ul = LEB ();
5765               if (! do_debug_frames_interp)
5766                 {
5767                   printf ("  DW_CFA_def_cfa_expression (");
5768                   decode_location_expression (start, eh_addr_size, 0, -1,
5769                                               ul, 0, section);
5770                   printf (")\n");
5771                 }
5772               fc->cfa_exp = 1;
5773               start += ul;
5774               break;
5775
5776             case DW_CFA_expression:
5777               reg = LEB ();
5778               ul = LEB ();
5779               if (reg >= (unsigned int) fc->ncols)
5780                 reg_prefix = bad_reg;
5781               if (! do_debug_frames_interp || *reg_prefix != '\0')
5782                 {
5783                   printf ("  DW_CFA_expression: %s%s (",
5784                           reg_prefix, regname (reg, 0));
5785                   decode_location_expression (start, eh_addr_size, 0, -1,
5786                                               ul, 0, section);
5787                   printf (")\n");
5788                 }
5789               if (*reg_prefix == '\0')
5790                 fc->col_type[reg] = DW_CFA_expression;
5791               start += ul;
5792               break;
5793
5794             case DW_CFA_val_expression:
5795               reg = LEB ();
5796               ul = LEB ();
5797               if (reg >= (unsigned int) fc->ncols)
5798                 reg_prefix = bad_reg;
5799               if (! do_debug_frames_interp || *reg_prefix != '\0')
5800                 {
5801                   printf ("  DW_CFA_val_expression: %s%s (",
5802                           reg_prefix, regname (reg, 0));
5803                   decode_location_expression (start, eh_addr_size, 0, -1,
5804                                               ul, 0, section);
5805                   printf (")\n");
5806                 }
5807               if (*reg_prefix == '\0')
5808                 fc->col_type[reg] = DW_CFA_val_expression;
5809               start += ul;
5810               break;
5811
5812             case DW_CFA_offset_extended_sf:
5813               reg = LEB ();
5814               l = SLEB ();
5815               if (frame_need_space (fc, reg) < 0)
5816                 reg_prefix = bad_reg;
5817               if (! do_debug_frames_interp || *reg_prefix != '\0')
5818                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5819                         reg_prefix, regname (reg, 0),
5820                         l * fc->data_factor);
5821               if (*reg_prefix == '\0')
5822                 {
5823                   fc->col_type[reg] = DW_CFA_offset;
5824                   fc->col_offset[reg] = l * fc->data_factor;
5825                 }
5826               break;
5827
5828             case DW_CFA_val_offset_sf:
5829               reg = LEB ();
5830               l = SLEB ();
5831               if (frame_need_space (fc, reg) < 0)
5832                 reg_prefix = bad_reg;
5833               if (! do_debug_frames_interp || *reg_prefix != '\0')
5834                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5835                         reg_prefix, regname (reg, 0),
5836                         l * fc->data_factor);
5837               if (*reg_prefix == '\0')
5838                 {
5839                   fc->col_type[reg] = DW_CFA_val_offset;
5840                   fc->col_offset[reg] = l * fc->data_factor;
5841                 }
5842               break;
5843
5844             case DW_CFA_def_cfa_sf:
5845               fc->cfa_reg = LEB ();
5846               fc->cfa_offset = SLEB ();
5847               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5848               fc->cfa_exp = 0;
5849               if (! do_debug_frames_interp)
5850                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
5851                         regname (fc->cfa_reg, 0), fc->cfa_offset);
5852               break;
5853
5854             case DW_CFA_def_cfa_offset_sf:
5855               fc->cfa_offset = SLEB ();
5856               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5857               if (! do_debug_frames_interp)
5858                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5859               break;
5860
5861             case DW_CFA_MIPS_advance_loc8:
5862               SAFE_BYTE_GET_AND_INC (ofs, start, 8, end);
5863               if (do_debug_frames_interp)
5864                 frame_display_row (fc, &need_col_headers, &max_regs);
5865               else
5866                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5867                         ofs * fc->code_factor,
5868                         fc->pc_begin + ofs * fc->code_factor);
5869               fc->pc_begin += ofs * fc->code_factor;
5870               break;
5871
5872             case DW_CFA_GNU_window_save:
5873               if (! do_debug_frames_interp)
5874                 printf ("  DW_CFA_GNU_window_save\n");
5875               break;
5876
5877             case DW_CFA_GNU_args_size:
5878               ul = LEB ();
5879               if (! do_debug_frames_interp)
5880                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
5881               break;
5882
5883             case DW_CFA_GNU_negative_offset_extended:
5884               reg = LEB ();
5885               l = - LEB ();
5886               if (frame_need_space (fc, reg) < 0)
5887                 reg_prefix = bad_reg;
5888               if (! do_debug_frames_interp || *reg_prefix != '\0')
5889                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5890                         reg_prefix, regname (reg, 0),
5891                         l * fc->data_factor);
5892               if (*reg_prefix == '\0')
5893                 {
5894                   fc->col_type[reg] = DW_CFA_offset;
5895                   fc->col_offset[reg] = l * fc->data_factor;
5896                 }
5897               break;
5898
5899             default:
5900               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5901                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5902               else
5903                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5904               start = block_end;
5905             }
5906         }
5907
5908       if (do_debug_frames_interp)
5909         frame_display_row (fc, &need_col_headers, &max_regs);
5910
5911       start = block_end;
5912       eh_addr_size = saved_eh_addr_size;
5913     }
5914
5915   printf ("\n");
5916
5917   return 1;
5918 }
5919
5920 #undef GET
5921 #undef LEB
5922 #undef SLEB
5923
5924 static int
5925 display_gdb_index (struct dwarf_section *section,
5926                    void *file ATTRIBUTE_UNUSED)
5927 {
5928   unsigned char *start = section->start;
5929   uint32_t version;
5930   uint32_t cu_list_offset, tu_list_offset;
5931   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5932   unsigned int cu_list_elements, tu_list_elements;
5933   unsigned int address_table_size, symbol_table_slots;
5934   unsigned char *cu_list, *tu_list;
5935   unsigned char *address_table, *symbol_table, *constant_pool;
5936   unsigned int i;
5937
5938   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
5939
5940   printf (_("Contents of the %s section:\n"), section->name);
5941
5942   if (section->size < 6 * sizeof (uint32_t))
5943     {
5944       warn (_("Truncated header in the %s section.\n"), section->name);
5945       return 0;
5946     }
5947
5948   version = byte_get_little_endian (start, 4);
5949   printf (_("Version %ld\n"), (long) version);
5950
5951   /* Prior versions are obsolete, and future versions may not be
5952      backwards compatible.  */
5953   if (version < 3 || version > 8)
5954     {
5955       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5956       return 0;
5957     }
5958   if (version < 4)
5959     warn (_("The address table data in version 3 may be wrong.\n"));
5960   if (version < 5)
5961     warn (_("Version 4 does not support case insensitive lookups.\n"));
5962   if (version < 6)
5963     warn (_("Version 5 does not include inlined functions.\n"));
5964   if (version < 7)
5965       warn (_("Version 6 does not include symbol attributes.\n"));
5966   /* Version 7 indices generated by Gold have bad type unit references,
5967      PR binutils/15021.  But we don't know if the index was generated by
5968      Gold or not, so to avoid worrying users with gdb-generated indices
5969      we say nothing for version 7 here.  */
5970
5971   cu_list_offset = byte_get_little_endian (start + 4, 4);
5972   tu_list_offset = byte_get_little_endian (start + 8, 4);
5973   address_table_offset = byte_get_little_endian (start + 12, 4);
5974   symbol_table_offset = byte_get_little_endian (start + 16, 4);
5975   constant_pool_offset = byte_get_little_endian (start + 20, 4);
5976
5977   if (cu_list_offset > section->size
5978       || tu_list_offset > section->size
5979       || address_table_offset > section->size
5980       || symbol_table_offset > section->size
5981       || constant_pool_offset > section->size)
5982     {
5983       warn (_("Corrupt header in the %s section.\n"), section->name);
5984       return 0;
5985     }
5986
5987   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5988   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5989   address_table_size = symbol_table_offset - address_table_offset;
5990   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5991
5992   cu_list = start + cu_list_offset;
5993   tu_list = start + tu_list_offset;
5994   address_table = start + address_table_offset;
5995   symbol_table = start + symbol_table_offset;
5996   constant_pool = start + constant_pool_offset;
5997
5998   printf (_("\nCU table:\n"));
5999   for (i = 0; i < cu_list_elements; i += 2)
6000     {
6001       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6002       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6003
6004       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6005               (unsigned long) cu_offset,
6006               (unsigned long) (cu_offset + cu_length - 1));
6007     }
6008
6009   printf (_("\nTU table:\n"));
6010   for (i = 0; i < tu_list_elements; i += 3)
6011     {
6012       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6013       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6014       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6015
6016       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6017               (unsigned long) tu_offset,
6018               (unsigned long) type_offset);
6019       print_dwarf_vma (signature, 8);
6020       printf ("\n");
6021     }
6022
6023   printf (_("\nAddress table:\n"));
6024   for (i = 0; i < address_table_size; i += 2 * 8 + 4)
6025     {
6026       uint64_t low = byte_get_little_endian (address_table + i, 8);
6027       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6028       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6029
6030       print_dwarf_vma (low, 8);
6031       print_dwarf_vma (high, 8);
6032       printf (_("%lu\n"), (unsigned long) cu_index);
6033     }
6034
6035   printf (_("\nSymbol table:\n"));
6036   for (i = 0; i < symbol_table_slots; ++i)
6037     {
6038       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6039       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6040       uint32_t num_cus, cu;
6041
6042       if (name_offset != 0
6043           || cu_vector_offset != 0)
6044         {
6045           unsigned int j;
6046
6047           printf ("[%3u] %s:", i, constant_pool + name_offset);
6048           num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6049           if (num_cus > 1)
6050             printf ("\n");
6051           for (j = 0; j < num_cus; ++j)
6052             {
6053               int is_static;
6054               gdb_index_symbol_kind kind;
6055
6056               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6057               is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6058               kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6059               cu = GDB_INDEX_CU_VALUE (cu);
6060               /* Convert to TU number if it's for a type unit.  */
6061               if (cu >= cu_list_elements / 2)
6062                 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6063                         (unsigned long) (cu - cu_list_elements / 2));
6064               else
6065                 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6066
6067               switch (kind)
6068                 {
6069                 case GDB_INDEX_SYMBOL_KIND_NONE:
6070                   printf (_(" [no symbol information]"));
6071                   break;
6072                 case GDB_INDEX_SYMBOL_KIND_TYPE:
6073                   printf (is_static
6074                           ? _(" [static type]")
6075                           : _(" [global type]"));
6076                   break;
6077                 case GDB_INDEX_SYMBOL_KIND_VARIABLE:
6078                   printf (is_static
6079                           ? _(" [static variable]")
6080                           : _(" [global variable]"));
6081                   break;
6082                 case GDB_INDEX_SYMBOL_KIND_FUNCTION:
6083                   printf (is_static
6084                           ? _(" [static function]")
6085                           : _(" [global function]"));
6086                   break;
6087                 case GDB_INDEX_SYMBOL_KIND_OTHER:
6088                   printf (is_static
6089                           ? _(" [static other]")
6090                           : _(" [global other]"));
6091                   break;
6092                 default:
6093                   printf (is_static
6094                           ? _(" [static unknown: %d]")
6095                           : _(" [global unknown: %d]"),
6096                           kind);
6097                   break;
6098                 }
6099               if (num_cus > 1)
6100                 printf ("\n");
6101             }
6102           if (num_cus <= 1)
6103             printf ("\n");
6104         }
6105     }
6106
6107   return 1;
6108 }
6109
6110 /* Pre-allocate enough space for the CU/TU sets needed.  */
6111
6112 static void
6113 prealloc_cu_tu_list (unsigned int nshndx)
6114 {
6115   if (shndx_pool == NULL)
6116     {
6117       shndx_pool_size = nshndx;
6118       shndx_pool_used = 0;
6119       shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6120                                               sizeof (unsigned int));
6121     }
6122   else
6123     {
6124       shndx_pool_size = shndx_pool_used + nshndx;
6125       shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6126                                                sizeof (unsigned int));
6127     }
6128 }
6129
6130 static void
6131 add_shndx_to_cu_tu_entry (unsigned int shndx)
6132 {
6133   if (shndx_pool_used >= shndx_pool_size)
6134     {
6135       error (_("Internal error: out of space in the shndx pool.\n"));
6136       return;
6137     }
6138   shndx_pool [shndx_pool_used++] = shndx;
6139 }
6140
6141 static void
6142 end_cu_tu_entry (void)
6143 {
6144   if (shndx_pool_used >= shndx_pool_size)
6145     {
6146       error (_("Internal error: out of space in the shndx pool.\n"));
6147       return;
6148     }
6149   shndx_pool [shndx_pool_used++] = 0;
6150 }
6151
6152 /* Return the short name of a DWARF section given by a DW_SECT enumerator.  */
6153
6154 static const char *
6155 get_DW_SECT_short_name (unsigned int dw_sect)
6156 {
6157   static char buf[16];
6158
6159   switch (dw_sect)
6160     {
6161       case DW_SECT_INFO:
6162         return "info";
6163       case DW_SECT_TYPES:
6164         return "types";
6165       case DW_SECT_ABBREV:
6166         return "abbrev";
6167       case DW_SECT_LINE:
6168         return "line";
6169       case DW_SECT_LOC:
6170         return "loc";
6171       case DW_SECT_STR_OFFSETS:
6172         return "str_off";
6173       case DW_SECT_MACINFO:
6174         return "macinfo";
6175       case DW_SECT_MACRO:
6176         return "macro";
6177       default:
6178         break;
6179     }
6180
6181   snprintf (buf, sizeof (buf), "%d", dw_sect);
6182   return buf;
6183 }
6184
6185 /* Process a CU or TU index.  If DO_DISPLAY is true, print the contents.
6186    These sections are extensions for Fission.
6187    See http://gcc.gnu.org/wiki/DebugFissionDWP.  */
6188
6189 static int
6190 process_cu_tu_index (struct dwarf_section *section, int do_display)
6191 {
6192   unsigned char *phdr = section->start;
6193   unsigned char *limit = phdr + section->size;
6194   unsigned char *phash;
6195   unsigned char *pindex;
6196   unsigned char *ppool;
6197   unsigned int version;
6198   unsigned int ncols = 0;
6199   unsigned int nused;
6200   unsigned int nslots;
6201   unsigned int i;
6202   unsigned int j;
6203   dwarf_vma signature_high;
6204   dwarf_vma signature_low;
6205   char buf[64];
6206
6207   version = byte_get (phdr, 4);
6208   if (version >= 2)
6209     ncols = byte_get (phdr + 4, 4);
6210   nused = byte_get (phdr + 8, 4);
6211   nslots = byte_get (phdr + 12, 4);
6212   phash = phdr + 16;
6213   pindex = phash + nslots * 8;
6214   ppool = pindex + nslots * 4;
6215
6216   if (do_display)
6217     {
6218       printf (_("Contents of the %s section:\n\n"), section->name);
6219       printf (_("  Version:                 %d\n"), version);
6220       if (version >= 2)
6221         printf (_("  Number of columns:       %d\n"), ncols);
6222       printf (_("  Number of used entries:  %d\n"), nused);
6223       printf (_("  Number of slots:         %d\n\n"), nslots);
6224     }
6225
6226   if (ppool > limit)
6227     {
6228       warn (_("Section %s too small for %d hash table entries\n"),
6229             section->name, nslots);
6230       return 0;
6231     }
6232
6233   if (version == 1)
6234     {
6235       if (!do_display)
6236         prealloc_cu_tu_list ((limit - ppool) / 4);
6237       for (i = 0; i < nslots; i++)
6238         {
6239           unsigned char *shndx_list;
6240           unsigned int shndx;
6241
6242           byte_get_64 (phash, &signature_high, &signature_low);
6243           if (signature_high != 0 || signature_low != 0)
6244             {
6245               j = byte_get (pindex, 4);
6246               shndx_list = ppool + j * 4;
6247               if (do_display)
6248                 printf (_("  [%3d] Signature:  0x%s  Sections: "),
6249                         i, dwarf_vmatoa64 (signature_high, signature_low,
6250                                            buf, sizeof (buf)));
6251               for (;;)
6252                 {
6253                   if (shndx_list >= limit)
6254                     {
6255                       warn (_("Section %s too small for shndx pool\n"),
6256                             section->name);
6257                       return 0;
6258                     }
6259                   shndx = byte_get (shndx_list, 4);
6260                   if (shndx == 0)
6261                     break;
6262                   if (do_display)
6263                     printf (" %d", shndx);
6264                   else
6265                     add_shndx_to_cu_tu_entry (shndx);
6266                   shndx_list += 4;
6267                 }
6268               if (do_display)
6269                 printf ("\n");
6270               else
6271                 end_cu_tu_entry ();
6272             }
6273           phash += 8;
6274           pindex += 4;
6275         }
6276     }
6277   else if (version == 2)
6278     {
6279       unsigned int val;
6280       unsigned int dw_sect;
6281       unsigned char *ph = phash;
6282       unsigned char *pi = pindex;
6283       unsigned char *poffsets = ppool + ncols * 4;
6284       unsigned char *psizes = poffsets + nused * ncols * 4;
6285       unsigned char *pend = psizes + nused * ncols * 4;
6286       bfd_boolean is_tu_index;
6287       struct cu_tu_set *this_set = NULL;
6288       unsigned int row;
6289       unsigned char *prow;
6290
6291       is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
6292
6293       if (pend > limit)
6294         {
6295           warn (_("Section %s too small for offset and size tables\n"),
6296                 section->name);
6297           return 0;
6298         }
6299
6300       if (do_display)
6301         {
6302           printf (_("  Offset table\n"));
6303           printf ("  slot  %-16s  ",
6304                  is_tu_index ? _("signature") : _("dwo_id"));
6305         }
6306       else
6307         {
6308           if (is_tu_index)
6309             {
6310               tu_count = nused;
6311               tu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
6312               this_set = tu_sets;
6313             }
6314           else
6315             {
6316               cu_count = nused;
6317               cu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
6318               this_set = cu_sets;
6319             }
6320         }
6321       if (do_display)
6322         {
6323           for (j = 0; j < ncols; j++)
6324             {
6325               dw_sect = byte_get (ppool + j * 4, 4);
6326               printf (" %8s", get_DW_SECT_short_name (dw_sect));
6327             }
6328           printf ("\n");
6329         }
6330       for (i = 0; i < nslots; i++)
6331         {
6332           byte_get_64 (ph, &signature_high, &signature_low);
6333           row = byte_get (pi, 4);
6334           if (row != 0)
6335             {
6336               if (!do_display)
6337                 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6338               prow = poffsets + (row - 1) * ncols * 4;
6339               if (do_display)
6340                 printf (_("  [%3d] 0x%s"),
6341                         i, dwarf_vmatoa64 (signature_high, signature_low,
6342                                            buf, sizeof (buf)));
6343               for (j = 0; j < ncols; j++)
6344                 {
6345                   val = byte_get (prow + j * 4, 4);
6346                   if (do_display)
6347                     printf (" %8d", val);
6348                   else
6349                     {
6350                       dw_sect = byte_get (ppool + j * 4, 4);
6351                       this_set [row - 1].section_offsets [dw_sect] = val;
6352                     }
6353                 }
6354               if (do_display)
6355                 printf ("\n");
6356             }
6357           ph += 8;
6358           pi += 4;
6359         }
6360
6361       ph = phash;
6362       pi = pindex;
6363       if (do_display)
6364         {
6365           printf ("\n");
6366           printf (_("  Size table\n"));
6367           printf ("  slot  %-16s  ",
6368                  is_tu_index ? _("signature") : _("dwo_id"));
6369         }
6370       for (j = 0; j < ncols; j++)
6371         {
6372           val = byte_get (ppool + j * 4, 4);
6373           if (do_display)
6374             printf (" %8s", get_DW_SECT_short_name (val));
6375         }
6376       if (do_display)
6377         printf ("\n");
6378       for (i = 0; i < nslots; i++)
6379         {
6380           byte_get_64 (ph, &signature_high, &signature_low);
6381           row = byte_get (pi, 4);
6382           if (row != 0)
6383             {
6384               prow = psizes + (row - 1) * ncols * 4;
6385               if (do_display)
6386                 printf (_("  [%3d] 0x%s"),
6387                         i, dwarf_vmatoa64 (signature_high, signature_low,
6388                                            buf, sizeof (buf)));
6389               for (j = 0; j < ncols; j++)
6390                 {
6391                   val = byte_get (prow + j * 4, 4);
6392                   if (do_display)
6393                     printf (" %8d", val);
6394                   else
6395                     {
6396                       dw_sect = byte_get (ppool + j * 4, 4);
6397                       this_set [row - 1].section_sizes [dw_sect] = val;
6398                     }
6399                 }
6400               if (do_display)
6401                 printf ("\n");
6402             }
6403           ph += 8;
6404           pi += 4;
6405         }
6406     }
6407   else if (do_display)
6408     printf (_("  Unsupported version\n"));
6409
6410   if (do_display)
6411       printf ("\n");
6412
6413   return 1;
6414 }
6415
6416 /* Load the CU and TU indexes if present.  This will build a list of
6417    section sets that we can use to associate a .debug_info.dwo section
6418    with its associated .debug_abbrev.dwo section in a .dwp file.  */
6419
6420 static void
6421 load_cu_tu_indexes (void *file)
6422 {
6423   /* If we have already loaded (or tried to load) the CU and TU indexes
6424      then do not bother to repeat the task.  */
6425   if (cu_tu_indexes_read)
6426     return;
6427
6428   if (load_debug_section (dwp_cu_index, file))
6429     process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
6430
6431   if (load_debug_section (dwp_tu_index, file))
6432     process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
6433
6434   cu_tu_indexes_read = 1;
6435 }
6436
6437 /* Find the set of sections that includes section SHNDX.  */
6438
6439 unsigned int *
6440 find_cu_tu_set (void *file, unsigned int shndx)
6441 {
6442   unsigned int i;
6443
6444   load_cu_tu_indexes (file);
6445
6446   /* Find SHNDX in the shndx pool.  */
6447   for (i = 0; i < shndx_pool_used; i++)
6448     if (shndx_pool [i] == shndx)
6449       break;
6450
6451   if (i >= shndx_pool_used)
6452     return NULL;
6453
6454   /* Now backup to find the first entry in the set.  */
6455   while (i > 0 && shndx_pool [i - 1] != 0)
6456     i--;
6457
6458   return shndx_pool + i;
6459 }
6460
6461 /* Display a .debug_cu_index or .debug_tu_index section.  */
6462
6463 static int
6464 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
6465 {
6466   return process_cu_tu_index (section, 1);
6467 }
6468
6469 static int
6470 display_debug_not_supported (struct dwarf_section *section,
6471                              void *file ATTRIBUTE_UNUSED)
6472 {
6473   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6474             section->name);
6475
6476   return 1;
6477 }
6478
6479 void *
6480 cmalloc (size_t nmemb, size_t size)
6481 {
6482   /* Check for overflow.  */
6483   if (nmemb >= ~(size_t) 0 / size)
6484     return NULL;
6485   else
6486     return malloc (nmemb * size);
6487 }
6488
6489 void *
6490 xcmalloc (size_t nmemb, size_t size)
6491 {
6492   /* Check for overflow.  */
6493   if (nmemb >= ~(size_t) 0 / size)
6494     return NULL;
6495   else
6496     return xmalloc (nmemb * size);
6497 }
6498
6499 void *
6500 xcrealloc (void *ptr, size_t nmemb, size_t size)
6501 {
6502   /* Check for overflow.  */
6503   if (nmemb >= ~(size_t) 0 / size)
6504     return NULL;
6505   else
6506     return xrealloc (ptr, nmemb * size);
6507 }
6508
6509 void
6510 free_debug_memory (void)
6511 {
6512   unsigned int i;
6513
6514   free_abbrevs ();
6515
6516   for (i = 0; i < max; i++)
6517     free_debug_section ((enum dwarf_section_display_enum) i);
6518
6519   if (debug_information != NULL)
6520     {
6521       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
6522         {
6523           for (i = 0; i < num_debug_info_entries; i++)
6524             {
6525               if (!debug_information [i].max_loc_offsets)
6526                 {
6527                   free (debug_information [i].loc_offsets);
6528                   free (debug_information [i].have_frame_base);
6529                 }
6530               if (!debug_information [i].max_range_lists)
6531                 free (debug_information [i].range_lists);
6532             }
6533         }
6534
6535       free (debug_information);
6536       debug_information = NULL;
6537       num_debug_info_entries = 0;
6538     }
6539 }
6540
6541 void
6542 dwarf_select_sections_by_names (const char *names)
6543 {
6544   typedef struct
6545   {
6546     const char * option;
6547     int *        variable;
6548     int          val;
6549   }
6550   debug_dump_long_opts;
6551
6552   static const debug_dump_long_opts opts_table [] =
6553     {
6554       /* Please keep this table alpha- sorted.  */
6555       { "Ranges", & do_debug_ranges, 1 },
6556       { "abbrev", & do_debug_abbrevs, 1 },
6557       { "addr", & do_debug_addr, 1 },
6558       { "aranges", & do_debug_aranges, 1 },
6559       { "cu_index", & do_debug_cu_index, 1 },
6560       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
6561       { "frames", & do_debug_frames, 1 },
6562       { "frames-interp", & do_debug_frames_interp, 1 },
6563       /* The special .gdb_index section.  */
6564       { "gdb_index", & do_gdb_index, 1 },
6565       { "info", & do_debug_info, 1 },
6566       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
6567       { "loc",  & do_debug_loc, 1 },
6568       { "macro", & do_debug_macinfo, 1 },
6569       { "pubnames", & do_debug_pubnames, 1 },
6570       { "pubtypes", & do_debug_pubtypes, 1 },
6571       /* This entry is for compatability
6572          with earlier versions of readelf.  */
6573       { "ranges", & do_debug_aranges, 1 },
6574       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
6575       { "str", & do_debug_str, 1 },
6576       /* These trace_* sections are used by Itanium VMS.  */
6577       { "trace_abbrev", & do_trace_abbrevs, 1 },
6578       { "trace_aranges", & do_trace_aranges, 1 },
6579       { "trace_info", & do_trace_info, 1 },
6580       { NULL, NULL, 0 }
6581     };
6582
6583   const char *p;
6584
6585   p = names;
6586   while (*p)
6587     {
6588       const debug_dump_long_opts * entry;
6589
6590       for (entry = opts_table; entry->option; entry++)
6591         {
6592           size_t len = strlen (entry->option);
6593
6594           if (strncmp (p, entry->option, len) == 0
6595               && (p[len] == ',' || p[len] == '\0'))
6596             {
6597               * entry->variable |= entry->val;
6598
6599               /* The --debug-dump=frames-interp option also
6600                  enables the --debug-dump=frames option.  */
6601               if (do_debug_frames_interp)
6602                 do_debug_frames = 1;
6603
6604               p += len;
6605               break;
6606             }
6607         }
6608
6609       if (entry->option == NULL)
6610         {
6611           warn (_("Unrecognized debug option '%s'\n"), p);
6612           p = strchr (p, ',');
6613           if (p == NULL)
6614             break;
6615         }
6616
6617       if (*p == ',')
6618         p++;
6619     }
6620 }
6621
6622 void
6623 dwarf_select_sections_by_letters (const char *letters)
6624 {
6625   unsigned int lindex = 0;
6626
6627   while (letters[lindex])
6628     switch (letters[lindex++])
6629       {
6630       case 'i':
6631         do_debug_info = 1;
6632         break;
6633
6634       case 'a':
6635         do_debug_abbrevs = 1;
6636         break;
6637
6638       case 'l':
6639         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
6640         break;
6641
6642       case 'L':
6643         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
6644         break;
6645
6646       case 'p':
6647         do_debug_pubnames = 1;
6648         break;
6649
6650       case 't':
6651         do_debug_pubtypes = 1;
6652         break;
6653
6654       case 'r':
6655         do_debug_aranges = 1;
6656         break;
6657
6658       case 'R':
6659         do_debug_ranges = 1;
6660         break;
6661
6662       case 'F':
6663         do_debug_frames_interp = 1;
6664       case 'f':
6665         do_debug_frames = 1;
6666         break;
6667
6668       case 'm':
6669         do_debug_macinfo = 1;
6670         break;
6671
6672       case 's':
6673         do_debug_str = 1;
6674         break;
6675
6676       case 'o':
6677         do_debug_loc = 1;
6678         break;
6679
6680       default:
6681         warn (_("Unrecognized debug option '%s'\n"), optarg);
6682         break;
6683       }
6684 }
6685
6686 void
6687 dwarf_select_sections_all (void)
6688 {
6689   do_debug_info = 1;
6690   do_debug_abbrevs = 1;
6691   do_debug_lines = FLAG_DEBUG_LINES_RAW;
6692   do_debug_pubnames = 1;
6693   do_debug_pubtypes = 1;
6694   do_debug_aranges = 1;
6695   do_debug_ranges = 1;
6696   do_debug_frames = 1;
6697   do_debug_macinfo = 1;
6698   do_debug_str = 1;
6699   do_debug_loc = 1;
6700   do_gdb_index = 1;
6701   do_trace_info = 1;
6702   do_trace_abbrevs = 1;
6703   do_trace_aranges = 1;
6704   do_debug_addr = 1;
6705   do_debug_cu_index = 1;
6706 }
6707
6708 struct dwarf_section_display debug_displays[] =
6709 {
6710   { { ".debug_abbrev",      ".zdebug_abbrev",   NULL, NULL, 0, 0, 0 },
6711     display_debug_abbrev,   &do_debug_abbrevs,  0 },
6712   { { ".debug_aranges",     ".zdebug_aranges",  NULL, NULL, 0, 0, 0 },
6713     display_debug_aranges,  &do_debug_aranges,  1 },
6714   { { ".debug_frame",       ".zdebug_frame",    NULL, NULL, 0, 0, 0 },
6715     display_debug_frames,   &do_debug_frames,   1 },
6716   { { ".debug_info",        ".zdebug_info",     NULL, NULL, 0, 0, abbrev },
6717     display_debug_info,     &do_debug_info,     1 },
6718   { { ".debug_line",        ".zdebug_line",     NULL, NULL, 0, 0, 0 },
6719     display_debug_lines,    &do_debug_lines,    1 },
6720   { { ".debug_pubnames",    ".zdebug_pubnames", NULL, NULL, 0, 0, 0 },
6721     display_debug_pubnames, &do_debug_pubnames, 0 },
6722   { { ".eh_frame",          "",                 NULL, NULL, 0, 0, 0 },
6723     display_debug_frames,   &do_debug_frames,   1 },
6724   { { ".debug_macinfo",     ".zdebug_macinfo",  NULL, NULL, 0, 0, 0 },
6725     display_debug_macinfo,  &do_debug_macinfo,  0 },
6726   { { ".debug_macro",       ".zdebug_macro",    NULL, NULL, 0, 0, 0 },
6727     display_debug_macro,    &do_debug_macinfo,  1 },
6728   { { ".debug_str",         ".zdebug_str",      NULL, NULL, 0, 0, 0 },
6729     display_debug_str,      &do_debug_str,      0 },
6730   { { ".debug_loc",         ".zdebug_loc",      NULL, NULL, 0, 0, 0 },
6731     display_debug_loc,      &do_debug_loc,      1 },
6732   { { ".debug_pubtypes",    ".zdebug_pubtypes", NULL, NULL, 0, 0, 0 },
6733     display_debug_pubnames, &do_debug_pubtypes, 0 },
6734   { { ".debug_ranges",      ".zdebug_ranges",   NULL, NULL, 0, 0, 0 },
6735     display_debug_ranges,   &do_debug_ranges,   1 },
6736   { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0 },
6737     display_debug_not_supported, NULL,          0 },
6738   { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0 },
6739     display_debug_not_supported, NULL,          0 },
6740   { { ".debug_types",       ".zdebug_types",    NULL, NULL, 0, 0, abbrev },
6741     display_debug_types,    &do_debug_info,     1 },
6742   { { ".debug_weaknames",   ".zdebug_weaknames", NULL, NULL, 0, 0, 0 },
6743     display_debug_not_supported, NULL,          0 },
6744   { { ".gdb_index",         "",                 NULL, NULL, 0, 0, 0 },
6745     display_gdb_index,      &do_gdb_index,      0 },
6746   { { ".trace_info",        "",                 NULL, NULL, 0, 0, trace_abbrev },
6747     display_trace_info,     &do_trace_info,     1 },
6748   { { ".trace_abbrev",      "",                 NULL, NULL, 0, 0, 0 },
6749     display_debug_abbrev,   &do_trace_abbrevs,  0 },
6750   { { ".trace_aranges",     "",                 NULL, NULL, 0, 0, 0 },
6751     display_debug_aranges,  &do_trace_aranges,  0 },
6752   { { ".debug_info.dwo",    ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo },
6753     display_debug_info,     &do_debug_info,     1 },
6754   { { ".debug_abbrev.dwo",  ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0 },
6755     display_debug_abbrev,   &do_debug_abbrevs,  0 },
6756   { { ".debug_types.dwo",   ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
6757     display_debug_types,    &do_debug_info,     1 },
6758   { { ".debug_line.dwo",    ".zdebug_line.dwo", NULL, NULL, 0, 0, 0 },
6759     display_debug_lines,    &do_debug_lines,    1 },
6760   { { ".debug_loc.dwo",     ".zdebug_loc.dwo",  NULL, NULL, 0, 0, 0 },
6761     display_debug_loc,      &do_debug_loc,      1 },
6762   { { ".debug_macro.dwo",   ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0 },
6763     display_debug_macro,    &do_debug_macinfo,  1 },
6764   { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0 },
6765     display_debug_macinfo,  &do_debug_macinfo,  0 },
6766   { { ".debug_str.dwo",     ".zdebug_str.dwo",  NULL, NULL, 0, 0, 0 },
6767     display_debug_str,      &do_debug_str,      1 },
6768   { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0 },
6769     display_debug_str_offsets, NULL,            0 },
6770   { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0 },
6771     display_debug_str_offsets, NULL,            0 },
6772   { { ".debug_addr",        ".zdebug_addr",     NULL, NULL, 0, 0, 0 },
6773     display_debug_addr,     &do_debug_addr,     1 },
6774   { { ".debug_cu_index",    "",                 NULL, NULL, 0, 0, 0 },
6775     display_cu_index,       &do_debug_cu_index, 0 },
6776   { { ".debug_tu_index",    "",                 NULL, NULL, 0, 0, 0 },
6777     display_cu_index,       &do_debug_cu_index, 0 },
6778 };