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