binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "libiberty.h"
  24 #include "bfd.h"
  25 #include "bfd_stdint.h"
  26 #include "bucomm.h"
  27 #include "elfcomm.h"
  28 #include "elf/common.h"
  29 #include "dwarf2.h"
  30 #include "dwarf.h"
  31
  32 static const char *regname (unsigned int regno, int row);
  33
  34 static int have_frame_base;
  35 static int need_base_address;
  36
  37 static unsigned int last_pointer_size = 0;
  38 static int warned_about_missing_comp_units = FALSE;
  39
  40 static unsigned int num_debug_info_entries = 0;
  41 static debug_info *debug_information = NULL;
  42 /* Special value for num_debug_info_entries to indicate
  43    that the .debug_info section could not be loaded/parsed.  */
  44 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
  45
  46 int eh_addr_size;
  47
  48 int do_debug_info;
  49 int do_debug_abbrevs;
  50 int do_debug_lines;
  51 int do_debug_pubnames;
  52 int do_debug_pubtypes;
  53 int do_debug_aranges;
  54 int do_debug_ranges;
  55 int do_debug_frames;
  56 int do_debug_frames_interp;
  57 int do_debug_macinfo;
  58 int do_debug_str;
  59 int do_debug_loc;
  60 int do_gdb_index;
  61 int do_trace_info;
  62 int do_trace_abbrevs;
  63 int do_trace_aranges;
  64 int do_wide;
  65
  66 int dwarf_cutoff_level = -1;
  67 unsigned long dwarf_start_die;
  68
  69 /* Values for do_debug_lines.  */
  70 #define FLAG_DEBUG_LINES_RAW     1
  71 #define FLAG_DEBUG_LINES_DECODED 2
  72
  73 static int
  74 size_of_encoded_value (int encoding)
  75 {
  76   switch (encoding & 0x7)
  77     {
  78     default:    /* ??? */
  79     case 0:     return eh_addr_size;
  80     case 2:     return 2;
  81     case 3:     return 4;
  82     case 4:     return 8;
  83     }
  84 }
  85
  86 static dwarf_vma
  87 get_encoded_value (unsigned char *data,
  88                    int encoding,
  89                    struct dwarf_section *section)
  90 {
  91   int size = size_of_encoded_value (encoding);
  92   dwarf_vma val;
  93
  94   if (encoding & DW_EH_PE_signed)
  95     val = byte_get_signed (data, size);
  96   else
  97     val = byte_get (data, size);
  98
  99   if ((encoding & 0x70) == DW_EH_PE_pcrel)
 100     val += section->address + (data - section->start);
 101   return val;
 102 }
 103
 104 /* Print a dwarf_vma value (typically an address, offset or length) in
 105    hexadecimal format, followed by a space.  The length of the value (and
 106    hence the precision displayed) is determined by the byte_size parameter.  */
 107
 108 static void
 109 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
 110 {
 111   static char buff[18];
 112   int offset = 0;
 113
 114   /* Printf does not have a way of specifiying a maximum field width for an
 115      integer value, so we print the full value into a buffer and then select
 116      the precision we need.  */
 117 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
 118 #ifndef __MINGW32__
 119   snprintf (buff, sizeof (buff), "%16.16llx ", val);
 120 #else
 121   snprintf (buff, sizeof (buff), "%016I64x ", val);
 122 #endif
 123 #else
 124   snprintf (buff, sizeof (buff), "%16.16lx ", val);
 125 #endif
 126
 127   if (byte_size != 0)
 128     {
 129       if (byte_size > 0 && byte_size <= 8)
 130         offset = 16 - 2 * byte_size;
 131       else
 132         error ("Wrong size in print_dwarf_vma");
 133     }
 134
 135   fputs (buff + offset, stdout);
 136 }
 137
 138 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
 139 #ifndef __MINGW32__
 140 #define  DWARF_VMA_FMT "ll"
 141 #else
 142 #define  DWARF_VMA_FMT "I64"
 143 #endif
 144 #else
 145 #define  DWARF_VMA_FMT "l"
 146 #endif
 147
 148 static const char *
 149 dwarf_vmatoa (const char *fmtch, dwarf_vma value)
 150 {
 151   /* As dwarf_vmatoa is used more then once in a printf call
 152      for output, we are cycling through an fixed array of pointers
 153      for return address.  */
 154   static int buf_pos = 0;
 155   static struct dwarf_vmatoa_buf
 156   {
 157     char place[64];
 158   } buf[16];
 159   char fmt[32];
 160   char *ret;
 161
 162   sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
 163
 164   ret = buf[buf_pos++].place;
 165   buf_pos %= ARRAY_SIZE (buf);
 166
 167   snprintf (ret, sizeof (buf[0].place), fmt, value);
 168
 169   return ret;
 170 }
 171
 172 dwarf_vma
 173 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
 174 {
 175   dwarf_vma result = 0;
 176   unsigned int num_read = 0;
 177   unsigned int shift = 0;
 178   unsigned char byte;
 179
 180   do
 181     {
 182       byte = *data++;
 183       num_read++;
 184
 185       result |= ((dwarf_vma) (byte & 0x7f)) << shift;
 186
 187       shift += 7;
 188
 189     }
 190   while (byte & 0x80);
 191
 192   if (length_return != NULL)
 193     *length_return = num_read;
 194
 195   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
 196     result |= -1L << shift;
 197
 198   return result;
 199 }
 200
 201 /* Create a signed version to avoid painful typecasts.  */
 202 static dwarf_signed_vma
 203 read_sleb128 (unsigned char *data, unsigned int *length_return)
 204 {
 205   return (dwarf_signed_vma) read_leb128 (data, length_return, 1);
 206 }
 207
 208 typedef struct State_Machine_Registers
 209 {
 210   dwarf_vma address;
 211   unsigned int file;
 212   unsigned int line;
 213   unsigned int column;
 214   int is_stmt;
 215   int basic_block;
 216   unsigned char op_index;
 217   unsigned char end_sequence;
 218 /* This variable hold the number of the last entry seen
 219    in the File Table.  */
 220   unsigned int last_file_entry;
 221 } SMR;
 222
 223 static SMR state_machine_regs;
 224
 225 static void
 226 reset_state_machine (int is_stmt)
 227 {
 228   state_machine_regs.address = 0;
 229   state_machine_regs.op_index = 0;
 230   state_machine_regs.file = 1;
 231   state_machine_regs.line = 1;
 232   state_machine_regs.column = 0;
 233   state_machine_regs.is_stmt = is_stmt;
 234   state_machine_regs.basic_block = 0;
 235   state_machine_regs.end_sequence = 0;
 236   state_machine_regs.last_file_entry = 0;
 237 }
 238
 239 /* Handled an extend line op.
 240    Returns the number of bytes read.  */
 241
 242 static int
 243 process_extended_line_op (unsigned char *data, int is_stmt)
 244 {
 245   unsigned char op_code;
 246   unsigned int bytes_read;
 247   unsigned int len;
 248   unsigned char *name;
 249   dwarf_vma adr;
 250
 251   len = read_leb128 (data, & bytes_read, 0);
 252   data += bytes_read;
 253
 254   if (len == 0)
 255     {
 256       warn (_("badly formed extended line op encountered!\n"));
 257       return bytes_read;
 258     }
 259
 260   len += bytes_read;
 261   op_code = *data++;
 262
 263   printf (_("  Extended opcode %d: "), op_code);
 264
 265   switch (op_code)
 266     {
 267     case DW_LNE_end_sequence:
 268       printf (_("End of Sequence\n\n"));
 269       reset_state_machine (is_stmt);
 270       break;
 271
 272     case DW_LNE_set_address:
 273       adr = byte_get (data, len - bytes_read - 1);
 274       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
 275       state_machine_regs.address = adr;
 276       state_machine_regs.op_index = 0;
 277       break;
 278
 279     case DW_LNE_define_file:
 280       printf (_("  define new File Table entry\n"));
 281       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 282
 283       printf ("   %d\t", ++state_machine_regs.last_file_entry);
 284       name = data;
 285       data += strlen ((char *) data) + 1;
 286       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
 287       data += bytes_read;
 288       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
 289       data += bytes_read;
 290       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
 291       printf ("%s\n\n", name);
 292       break;
 293
 294     case DW_LNE_set_discriminator:
 295       printf (_("set Discriminator to %s\n"),
 296               dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
 297       break;
 298
 299     /* HP extensions.  */
 300     case DW_LNE_HP_negate_is_UV_update:
 301       printf ("DW_LNE_HP_negate_is_UV_update\n");
 302       break;
 303     case DW_LNE_HP_push_context:
 304       printf ("DW_LNE_HP_push_context\n");
 305       break;
 306     case DW_LNE_HP_pop_context:
 307       printf ("DW_LNE_HP_pop_context\n");
 308       break;
 309     case DW_LNE_HP_set_file_line_column:
 310       printf ("DW_LNE_HP_set_file_line_column\n");
 311       break;
 312     case DW_LNE_HP_set_routine_name:
 313       printf ("DW_LNE_HP_set_routine_name\n");
 314       break;
 315     case DW_LNE_HP_set_sequence:
 316       printf ("DW_LNE_HP_set_sequence\n");
 317       break;
 318     case DW_LNE_HP_negate_post_semantics:
 319       printf ("DW_LNE_HP_negate_post_semantics\n");
 320       break;
 321     case DW_LNE_HP_negate_function_exit:
 322       printf ("DW_LNE_HP_negate_function_exit\n");
 323       break;
 324     case DW_LNE_HP_negate_front_end_logical:
 325       printf ("DW_LNE_HP_negate_front_end_logical\n");
 326       break;
 327     case DW_LNE_HP_define_proc:
 328       printf ("DW_LNE_HP_define_proc\n");
 329       break;
 330     case DW_LNE_HP_source_file_correlation:
 331       {
 332         unsigned char *edata = data + len - bytes_read - 1;
 333
 334         printf ("DW_LNE_HP_source_file_correlation\n");
 335
 336         while (data < edata)
 337           {
 338             unsigned int opc;
 339
 340             opc = read_leb128 (data, & bytes_read, 0);
 341             data += bytes_read;
 342
 343             switch (opc)
 344               {
 345               case DW_LNE_HP_SFC_formfeed:
 346                 printf ("    DW_LNE_HP_SFC_formfeed\n");
 347                 break;
 348               case DW_LNE_HP_SFC_set_listing_line:
 349                 printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
 350                         dwarf_vmatoa ("u",
 351                                       read_leb128 (data, & bytes_read, 0)));
 352                 data += bytes_read;
 353                 break;
 354               case DW_LNE_HP_SFC_associate:
 355                 printf ("    DW_LNE_HP_SFC_associate ");
 356                 printf (_("(%s"),
 357                         dwarf_vmatoa ("u",
 358                                       read_leb128 (data, & bytes_read, 0)));
 359                 data += bytes_read;
 360                 printf (_(",%s"),
 361                         dwarf_vmatoa ("u",
 362                                       read_leb128 (data, & bytes_read, 0)));
 363                 data += bytes_read;
 364                 printf (_(",%s)\n"),
 365                         dwarf_vmatoa ("u",
 366                                       read_leb128 (data, & bytes_read, 0)));
 367                 data += bytes_read;
 368                 break;
 369               default:
 370                 printf ("    UNKNOW DW_LNE_HP_SFC opcode (%u)\n", opc);
 371                 data = edata;
 372                 break;
 373               }
 374           }
 375       }
 376       break;
 377
 378     default:
 379       {
 380         unsigned int rlen = len - bytes_read - 1;
 381
 382         if (op_code >= DW_LNE_lo_user
 383             /* The test against DW_LNW_hi_user is redundant due to
 384                the limited range of the unsigned char data type used
 385                for op_code.  */
 386             /*&& op_code <= DW_LNE_hi_user*/)
 387           printf (_("user defined: "));
 388         else
 389           printf (_("UNKNOWN: "));
 390         printf (_("length %d ["), rlen);
 391         for (; rlen; rlen--)
 392           printf (" %02x", *data++);
 393         printf ("]\n");
 394       }
 395       break;
 396     }
 397
 398   return len;
 399 }
 400
 401 static const char *
 402 fetch_indirect_string (dwarf_vma offset)
 403 {
 404   struct dwarf_section *section = &debug_displays [str].section;
 405
 406   if (section->start == NULL)
 407     return _("<no .debug_str section>");
 408
 409   /* DWARF sections under Mach-O have non-zero addresses.  */
 410   offset -= section->address;
 411   if (offset > section->size)
 412     {
 413       warn (_("DW_FORM_strp offset too big: %s\n"),
 414             dwarf_vmatoa ("x", offset));
 415       return _("<offset is too big>");
 416     }
 417
 418   return (const char *) section->start + offset;
 419 }
 420
 421 /* FIXME:  There are better and more efficient ways to handle
 422    these structures.  For now though, I just want something that
 423    is simple to implement.  */
 424 typedef struct abbrev_attr
 425 {
 426   unsigned long attribute;
 427   unsigned long form;
 428   struct abbrev_attr *next;
 429 }
 430 abbrev_attr;
 431
 432 typedef struct abbrev_entry
 433 {
 434   unsigned long entry;
 435   unsigned long tag;
 436   int children;
 437   struct abbrev_attr *first_attr;
 438   struct abbrev_attr *last_attr;
 439   struct abbrev_entry *next;
 440 }
 441 abbrev_entry;
 442
 443 static abbrev_entry *first_abbrev = NULL;
 444 static abbrev_entry *last_abbrev = NULL;
 445
 446 static void
 447 free_abbrevs (void)
 448 {
 449   abbrev_entry *abbrv;
 450
 451   for (abbrv = first_abbrev; abbrv;)
 452     {
 453       abbrev_entry *next_abbrev = abbrv->next;
 454       abbrev_attr *attr;
 455
 456       for (attr = abbrv->first_attr; attr;)
 457         {
 458           abbrev_attr *next_attr = attr->next;
 459
 460           free (attr);
 461           attr = next_attr;
 462         }
 463
 464       free (abbrv);
 465       abbrv = next_abbrev;
 466     }
 467
 468   last_abbrev = first_abbrev = NULL;
 469 }
 470
 471 static void
 472 add_abbrev (unsigned long number, unsigned long tag, int children)
 473 {
 474   abbrev_entry *entry;
 475
 476   entry = (abbrev_entry *) malloc (sizeof (*entry));
 477   if (entry == NULL)
 478     /* ugg */
 479     return;
 480
 481   entry->entry      = number;
 482   entry->tag        = tag;
 483   entry->children   = children;
 484   entry->first_attr = NULL;
 485   entry->last_attr  = NULL;
 486   entry->next       = NULL;
 487
 488   if (first_abbrev == NULL)
 489     first_abbrev = entry;
 490   else
 491     last_abbrev->next = entry;
 492
 493   last_abbrev = entry;
 494 }
 495
 496 static void
 497 add_abbrev_attr (unsigned long attribute, unsigned long form)
 498 {
 499   abbrev_attr *attr;
 500
 501   attr = (abbrev_attr *) malloc (sizeof (*attr));
 502   if (attr == NULL)
 503     /* ugg */
 504     return;
 505
 506   attr->attribute = attribute;
 507   attr->form      = form;
 508   attr->next      = NULL;
 509
 510   if (last_abbrev->first_attr == NULL)
 511     last_abbrev->first_attr = attr;
 512   else
 513     last_abbrev->last_attr->next = attr;
 514
 515   last_abbrev->last_attr = attr;
 516 }
 517
 518 /* Processes the (partial) contents of a .debug_abbrev section.
 519    Returns NULL if the end of the section was encountered.
 520    Returns the address after the last byte read if the end of
 521    an abbreviation set was found.  */
 522
 523 static unsigned char *
 524 process_abbrev_section (unsigned char *start, unsigned char *end)
 525 {
 526   if (first_abbrev != NULL)
 527     return NULL;
 528
 529   while (start < end)
 530     {
 531       unsigned int bytes_read;
 532       unsigned long entry;
 533       unsigned long tag;
 534       unsigned long attribute;
 535       int children;
 536
 537       entry = read_leb128 (start, & bytes_read, 0);
 538       start += bytes_read;
 539
 540       /* A single zero is supposed to end the section according
 541          to the standard.  If there's more, then signal that to
 542          the caller.  */
 543       if (entry == 0)
 544         return start == end ? NULL : start;
 545
 546       tag = read_leb128 (start, & bytes_read, 0);
 547       start += bytes_read;
 548
 549       children = *start++;
 550
 551       add_abbrev (entry, tag, children);
 552
 553       do
 554         {
 555           unsigned long form;
 556
 557           attribute = read_leb128 (start, & bytes_read, 0);
 558           start += bytes_read;
 559
 560           form = read_leb128 (start, & bytes_read, 0);
 561           start += bytes_read;
 562
 563           if (attribute != 0)
 564             add_abbrev_attr (attribute, form);
 565         }
 566       while (attribute != 0);
 567     }
 568
 569   return NULL;
 570 }
 571
 572 static char *
 573 get_TAG_name (unsigned long tag)
 574 {
 575   switch (tag)
 576     {
 577     case DW_TAG_padding:                return "DW_TAG_padding";
 578     case DW_TAG_array_type:             return "DW_TAG_array_type";
 579     case DW_TAG_class_type:             return "DW_TAG_class_type";
 580     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
 581     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
 582     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
 583     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
 584     case DW_TAG_label:                  return "DW_TAG_label";
 585     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
 586     case DW_TAG_member:                 return "DW_TAG_member";
 587     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
 588     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
 589     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
 590     case DW_TAG_string_type:            return "DW_TAG_string_type";
 591     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
 592     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
 593     case DW_TAG_typedef:                return "DW_TAG_typedef";
 594     case DW_TAG_union_type:             return "DW_TAG_union_type";
 595     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
 596     case DW_TAG_variant:                return "DW_TAG_variant";
 597     case DW_TAG_common_block:           return "DW_TAG_common_block";
 598     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
 599     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
 600     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
 601     case DW_TAG_module:                 return "DW_TAG_module";
 602     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
 603     case DW_TAG_set_type:               return "DW_TAG_set_type";
 604     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
 605     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
 606     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
 607     case DW_TAG_base_type:              return "DW_TAG_base_type";
 608     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
 609     case DW_TAG_const_type:             return "DW_TAG_const_type";
 610     case DW_TAG_constant:               return "DW_TAG_constant";
 611     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
 612     case DW_TAG_file_type:              return "DW_TAG_file_type";
 613     case DW_TAG_friend:                 return "DW_TAG_friend";
 614     case DW_TAG_namelist:               return "DW_TAG_namelist";
 615     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
 616     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
 617     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
 618     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
 619     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
 620     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
 621     case DW_TAG_try_block:              return "DW_TAG_try_block";
 622     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
 623     case DW_TAG_variable:               return "DW_TAG_variable";
 624     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
 625     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
 626     case DW_TAG_format_label:           return "DW_TAG_format_label";
 627     case DW_TAG_function_template:      return "DW_TAG_function_template";
 628     case DW_TAG_class_template:         return "DW_TAG_class_template";
 629       /* DWARF 2.1 values.  */
 630     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
 631     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
 632     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
 633     case DW_TAG_namespace:              return "DW_TAG_namespace";
 634     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
 635     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
 636     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
 637     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
 638     case DW_TAG_condition:              return "DW_TAG_condition";
 639     case DW_TAG_shared_type:            return "DW_TAG_shared_type";
 640       /* DWARF 4 values.  */
 641     case DW_TAG_type_unit:              return "DW_TAG_type_unit";
 642     case DW_TAG_rvalue_reference_type:  return "DW_TAG_rvalue_reference_type";
 643     case DW_TAG_template_alias:         return "DW_TAG_template_alias";
 644       /* UPC values.  */
 645     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
 646     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
 647     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
 648       /* GNU values.  */
 649     case DW_TAG_GNU_call_site:          return "DW_TAG_GNU_call_site";
 650     case DW_TAG_GNU_call_site_parameter:return "DW_TAG_GNU_call_site_parameter";
 651     default:
 652       {
 653         static char buffer[100];
 654
 655         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
 656         return buffer;
 657       }
 658     }
 659 }
 660
 661 static char *
 662 get_FORM_name (unsigned long form)
 663 {
 664   switch (form)
 665     {
 666     case DW_FORM_addr:          return "DW_FORM_addr";
 667     case DW_FORM_block2:        return "DW_FORM_block2";
 668     case DW_FORM_block4:        return "DW_FORM_block4";
 669     case DW_FORM_data2:         return "DW_FORM_data2";
 670     case DW_FORM_data4:         return "DW_FORM_data4";
 671     case DW_FORM_data8:         return "DW_FORM_data8";
 672     case DW_FORM_string:        return "DW_FORM_string";
 673     case DW_FORM_block:         return "DW_FORM_block";
 674     case DW_FORM_block1:        return "DW_FORM_block1";
 675     case DW_FORM_data1:         return "DW_FORM_data1";
 676     case DW_FORM_flag:          return "DW_FORM_flag";
 677     case DW_FORM_sdata:         return "DW_FORM_sdata";
 678     case DW_FORM_strp:          return "DW_FORM_strp";
 679     case DW_FORM_udata:         return "DW_FORM_udata";
 680     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
 681     case DW_FORM_ref1:          return "DW_FORM_ref1";
 682     case DW_FORM_ref2:          return "DW_FORM_ref2";
 683     case DW_FORM_ref4:          return "DW_FORM_ref4";
 684     case DW_FORM_ref8:          return "DW_FORM_ref8";
 685     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
 686     case DW_FORM_indirect:      return "DW_FORM_indirect";
 687       /* DWARF 4 values.  */
 688     case DW_FORM_sec_offset:    return "DW_FORM_sec_offset";
 689     case DW_FORM_exprloc:       return "DW_FORM_exprloc";
 690     case DW_FORM_flag_present:  return "DW_FORM_flag_present";
 691     case DW_FORM_ref_sig8:      return "DW_FORM_ref_sig8";
 692     default:
 693       {
 694         static char buffer[100];
 695
 696         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
 697         return buffer;
 698       }
 699     }
 700 }
 701
 702 static unsigned char *
 703 display_block (unsigned char *data, dwarf_vma length)
 704 {
 705   printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
 706
 707   while (length --)
 708     printf ("%lx ", (unsigned long) byte_get (data++, 1));
 709
 710   return data;
 711 }
 712
 713 static int
 714 decode_location_expression (unsigned char * data,
 715                             unsigned int pointer_size,
 716                             unsigned int offset_size,
 717                             int dwarf_version,
 718                             dwarf_vma length,
 719                             dwarf_vma cu_offset,
 720                             struct dwarf_section * section)
 721 {
 722   unsigned op;
 723   unsigned int bytes_read;
 724   dwarf_vma uvalue;
 725   unsigned char *end = data + length;
 726   int need_frame_base = 0;
 727
 728   while (data < end)
 729     {
 730       op = *data++;
 731
 732       switch (op)
 733         {
 734         case DW_OP_addr:
 735          printf ("DW_OP_addr: %s",
 736                  dwarf_vmatoa ("x", byte_get (data, pointer_size)));
 737           data += pointer_size;
 738           break;
 739         case DW_OP_deref:
 740           printf ("DW_OP_deref");
 741           break;
 742         case DW_OP_const1u:
 743           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
 744           break;
 745         case DW_OP_const1s:
 746           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
 747           break;
 748         case DW_OP_const2u:
 749           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
 750           data += 2;
 751           break;
 752         case DW_OP_const2s:
 753           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
 754           data += 2;
 755           break;
 756         case DW_OP_const4u:
 757           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
 758           data += 4;
 759           break;
 760         case DW_OP_const4s:
 761           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
 762           data += 4;
 763           break;
 764         case DW_OP_const8u:
 765           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
 766                   (unsigned long) byte_get (data + 4, 4));
 767           data += 8;
 768           break;
 769         case DW_OP_const8s:
 770           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
 771                   (long) byte_get (data + 4, 4));
 772           data += 8;
 773           break;
 774         case DW_OP_constu:
 775           printf ("DW_OP_constu: %s",
 776                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
 777           data += bytes_read;
 778           break;
 779         case DW_OP_consts:
 780           printf ("DW_OP_consts: %s",
 781                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
 782           data += bytes_read;
 783           break;
 784         case DW_OP_dup:
 785           printf ("DW_OP_dup");
 786           break;
 787         case DW_OP_drop:
 788           printf ("DW_OP_drop");
 789           break;
 790         case DW_OP_over:
 791           printf ("DW_OP_over");
 792           break;
 793         case DW_OP_pick:
 794           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
 795           break;
 796         case DW_OP_swap:
 797           printf ("DW_OP_swap");
 798           break;
 799         case DW_OP_rot:
 800           printf ("DW_OP_rot");
 801           break;
 802         case DW_OP_xderef:
 803           printf ("DW_OP_xderef");
 804           break;
 805         case DW_OP_abs:
 806           printf ("DW_OP_abs");
 807           break;
 808         case DW_OP_and:
 809           printf ("DW_OP_and");
 810           break;
 811         case DW_OP_div:
 812           printf ("DW_OP_div");
 813           break;
 814         case DW_OP_minus:
 815           printf ("DW_OP_minus");
 816           break;
 817         case DW_OP_mod:
 818           printf ("DW_OP_mod");
 819           break;
 820         case DW_OP_mul:
 821           printf ("DW_OP_mul");
 822           break;
 823         case DW_OP_neg:
 824           printf ("DW_OP_neg");
 825           break;
 826         case DW_OP_not:
 827           printf ("DW_OP_not");
 828           break;
 829         case DW_OP_or:
 830           printf ("DW_OP_or");
 831           break;
 832         case DW_OP_plus:
 833           printf ("DW_OP_plus");
 834           break;
 835         case DW_OP_plus_uconst:
 836           printf ("DW_OP_plus_uconst: %s",
 837                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
 838           data += bytes_read;
 839           break;
 840         case DW_OP_shl:
 841           printf ("DW_OP_shl");
 842           break;
 843         case DW_OP_shr:
 844           printf ("DW_OP_shr");
 845           break;
 846         case DW_OP_shra:
 847           printf ("DW_OP_shra");
 848           break;
 849         case DW_OP_xor:
 850           printf ("DW_OP_xor");
 851           break;
 852         case DW_OP_bra:
 853           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
 854           data += 2;
 855           break;
 856         case DW_OP_eq:
 857           printf ("DW_OP_eq");
 858           break;
 859         case DW_OP_ge:
 860           printf ("DW_OP_ge");
 861           break;
 862         case DW_OP_gt:
 863           printf ("DW_OP_gt");
 864           break;
 865         case DW_OP_le:
 866           printf ("DW_OP_le");
 867           break;
 868         case DW_OP_lt:
 869           printf ("DW_OP_lt");
 870           break;
 871         case DW_OP_ne:
 872           printf ("DW_OP_ne");
 873           break;
 874         case DW_OP_skip:
 875           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
 876           data += 2;
 877           break;
 878
 879         case DW_OP_lit0:
 880         case DW_OP_lit1:
 881         case DW_OP_lit2:
 882         case DW_OP_lit3:
 883         case DW_OP_lit4:
 884         case DW_OP_lit5:
 885         case DW_OP_lit6:
 886         case DW_OP_lit7:
 887         case DW_OP_lit8:
 888         case DW_OP_lit9:
 889         case DW_OP_lit10:
 890         case DW_OP_lit11:
 891         case DW_OP_lit12:
 892         case DW_OP_lit13:
 893         case DW_OP_lit14:
 894         case DW_OP_lit15:
 895         case DW_OP_lit16:
 896         case DW_OP_lit17:
 897         case DW_OP_lit18:
 898         case DW_OP_lit19:
 899         case DW_OP_lit20:
 900         case DW_OP_lit21:
 901         case DW_OP_lit22:
 902         case DW_OP_lit23:
 903         case DW_OP_lit24:
 904         case DW_OP_lit25:
 905         case DW_OP_lit26:
 906         case DW_OP_lit27:
 907         case DW_OP_lit28:
 908         case DW_OP_lit29:
 909         case DW_OP_lit30:
 910         case DW_OP_lit31:
 911           printf ("DW_OP_lit%d", op - DW_OP_lit0);
 912           break;
 913
 914         case DW_OP_reg0:
 915         case DW_OP_reg1:
 916         case DW_OP_reg2:
 917         case DW_OP_reg3:
 918         case DW_OP_reg4:
 919         case DW_OP_reg5:
 920         case DW_OP_reg6:
 921         case DW_OP_reg7:
 922         case DW_OP_reg8:
 923         case DW_OP_reg9:
 924         case DW_OP_reg10:
 925         case DW_OP_reg11:
 926         case DW_OP_reg12:
 927         case DW_OP_reg13:
 928         case DW_OP_reg14:
 929         case DW_OP_reg15:
 930         case DW_OP_reg16:
 931         case DW_OP_reg17:
 932         case DW_OP_reg18:
 933         case DW_OP_reg19:
 934         case DW_OP_reg20:
 935         case DW_OP_reg21:
 936         case DW_OP_reg22:
 937         case DW_OP_reg23:
 938         case DW_OP_reg24:
 939         case DW_OP_reg25:
 940         case DW_OP_reg26:
 941         case DW_OP_reg27:
 942         case DW_OP_reg28:
 943         case DW_OP_reg29:
 944         case DW_OP_reg30:
 945         case DW_OP_reg31:
 946           printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
 947                   regname (op - DW_OP_reg0, 1));
 948           break;
 949
 950         case DW_OP_breg0:
 951         case DW_OP_breg1:
 952         case DW_OP_breg2:
 953         case DW_OP_breg3:
 954         case DW_OP_breg4:
 955         case DW_OP_breg5:
 956         case DW_OP_breg6:
 957         case DW_OP_breg7:
 958         case DW_OP_breg8:
 959         case DW_OP_breg9:
 960         case DW_OP_breg10:
 961         case DW_OP_breg11:
 962         case DW_OP_breg12:
 963         case DW_OP_breg13:
 964         case DW_OP_breg14:
 965         case DW_OP_breg15:
 966         case DW_OP_breg16:
 967         case DW_OP_breg17:
 968         case DW_OP_breg18:
 969         case DW_OP_breg19:
 970         case DW_OP_breg20:
 971         case DW_OP_breg21:
 972         case DW_OP_breg22:
 973         case DW_OP_breg23:
 974         case DW_OP_breg24:
 975         case DW_OP_breg25:
 976         case DW_OP_breg26:
 977         case DW_OP_breg27:
 978         case DW_OP_breg28:
 979         case DW_OP_breg29:
 980         case DW_OP_breg30:
 981         case DW_OP_breg31:
 982           printf ("DW_OP_breg%d (%s): %s",
 983                   op - DW_OP_breg0,
 984                   regname (op - DW_OP_breg0, 1),
 985                   dwarf_vmatoa ("d", (dwarf_signed_vma)
 986                     read_leb128 (data, &bytes_read, 1)));
 987           data += bytes_read;
 988           break;
 989
 990         case DW_OP_regx:
 991           uvalue = read_leb128 (data, &bytes_read, 0);
 992           data += bytes_read;
 993           printf ("DW_OP_regx: %s (%s)",
 994                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
 995           break;
 996         case DW_OP_fbreg:
 997           need_frame_base = 1;
 998           printf ("DW_OP_fbreg: %s",
 999                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1000           data += bytes_read;
1001           break;
1002         case DW_OP_bregx:
1003           uvalue = read_leb128 (data, &bytes_read, 0);
1004           data += bytes_read;
1005           printf ("DW_OP_bregx: %s (%s) %s",
1006                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1007                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1008           data += bytes_read;
1009           break;
1010         case DW_OP_piece:
1011           printf ("DW_OP_piece: %s",
1012                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1013           data += bytes_read;
1014           break;
1015         case DW_OP_deref_size:
1016           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1017           break;
1018         case DW_OP_xderef_size:
1019           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1020           break;
1021         case DW_OP_nop:
1022           printf ("DW_OP_nop");
1023           break;
1024
1025           /* DWARF 3 extensions.  */
1026         case DW_OP_push_object_address:
1027           printf ("DW_OP_push_object_address");
1028           break;
1029         case DW_OP_call2:
1030           /* XXX: Strictly speaking for 64-bit DWARF3 files
1031              this ought to be an 8-byte wide computation.  */
1032           printf ("DW_OP_call2: <0x%s>",
1033                   dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2)
1034                                      + cu_offset));
1035           data += 2;
1036           break;
1037         case DW_OP_call4:
1038           /* XXX: Strictly speaking for 64-bit DWARF3 files
1039              this ought to be an 8-byte wide computation.  */
1040           printf ("DW_OP_call4: <0x%s>",
1041                   dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4)
1042                                      + cu_offset));
1043           data += 4;
1044           break;
1045         case DW_OP_call_ref:
1046           /* XXX: Strictly speaking for 64-bit DWARF3 files
1047              this ought to be an 8-byte wide computation.  */
1048           if (dwarf_version == -1)
1049             {
1050               printf (_("(DW_OP_call_ref in frame info)"));
1051               /* No way to tell where the next op is, so just bail.  */
1052               return need_frame_base;
1053             }
1054           if (dwarf_version == 2)
1055             {
1056               printf ("DW_OP_call_ref: <0x%s>",
1057                       dwarf_vmatoa ("x", byte_get (data, pointer_size)));
1058               data += pointer_size;
1059             }
1060           else
1061             {
1062               printf ("DW_OP_call_ref: <0x%s>",
1063                       dwarf_vmatoa ("x", byte_get (data, offset_size)));
1064               data += offset_size;
1065             }
1066           break;
1067         case DW_OP_form_tls_address:
1068           printf ("DW_OP_form_tls_address");
1069           break;
1070         case DW_OP_call_frame_cfa:
1071           printf ("DW_OP_call_frame_cfa");
1072           break;
1073         case DW_OP_bit_piece:
1074           printf ("DW_OP_bit_piece: ");
1075           printf ("size: %s ",
1076                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1077           data += bytes_read;
1078           printf ("offset: %s ",
1079                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1080           data += bytes_read;
1081           break;
1082
1083           /* DWARF 4 extensions.  */
1084         case DW_OP_stack_value:
1085           printf ("DW_OP_stack_value");
1086           break;
1087
1088         case DW_OP_implicit_value:
1089           printf ("DW_OP_implicit_value");
1090           uvalue = read_leb128 (data, &bytes_read, 0);
1091           data += bytes_read;
1092           display_block (data, uvalue);
1093           data += uvalue;
1094           break;
1095
1096           /* GNU extensions.  */
1097         case DW_OP_GNU_push_tls_address:
1098           printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1099           break;
1100         case DW_OP_GNU_uninit:
1101           printf ("DW_OP_GNU_uninit");
1102           /* FIXME: Is there data associated with this OP ?  */
1103           break;
1104         case DW_OP_GNU_encoded_addr:
1105           {
1106             int encoding;
1107             dwarf_vma addr;
1108
1109             encoding = *data++;
1110             addr = get_encoded_value (data, encoding, section);
1111             data += size_of_encoded_value (encoding);
1112
1113             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1114             print_dwarf_vma (addr, pointer_size);
1115           }
1116           break;
1117         case DW_OP_GNU_implicit_pointer:
1118           /* XXX: Strictly speaking for 64-bit DWARF3 files
1119              this ought to be an 8-byte wide computation.  */
1120           if (dwarf_version == -1)
1121             {
1122               printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1123               /* No way to tell where the next op is, so just bail.  */
1124               return need_frame_base;
1125             }
1126           if (dwarf_version == 2)
1127             {
1128               printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1129                       dwarf_vmatoa ("x", byte_get (data, pointer_size)),
1130                       dwarf_vmatoa ("d", read_sleb128 (data + pointer_size,
1131                                      &bytes_read)));
1132               data += pointer_size + bytes_read;
1133             }
1134           else
1135             {
1136               printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1137                       dwarf_vmatoa ("x", byte_get (data, offset_size)),
1138                       dwarf_vmatoa ("d", read_sleb128 (data + offset_size,
1139                                      &bytes_read)));
1140               data += offset_size + bytes_read;
1141             }
1142           break;
1143         case DW_OP_GNU_entry_value:
1144           uvalue = read_leb128 (data, &bytes_read, 0);
1145           data += bytes_read;
1146           printf ("DW_OP_GNU_entry_value: (");
1147           if (decode_location_expression (data, pointer_size, offset_size,
1148                                           dwarf_version, uvalue,
1149                                           cu_offset, section))
1150             need_frame_base = 1;
1151           putchar (')');
1152           data += uvalue;
1153           break;
1154         case DW_OP_GNU_const_type:
1155           uvalue = read_leb128 (data, &bytes_read, 0);
1156           data += bytes_read;
1157           printf ("DW_OP_GNU_const_type: <0x%s> ",
1158                   dwarf_vmatoa ("x", cu_offset + uvalue));
1159           uvalue = byte_get (data++, 1);
1160           display_block (data, uvalue);
1161           data += uvalue;
1162           break;
1163         case DW_OP_GNU_regval_type:
1164           uvalue = read_leb128 (data, &bytes_read, 0);
1165           data += bytes_read;
1166           printf ("DW_OP_GNU_regval_type: %s (%s)",
1167                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1168           uvalue = read_leb128 (data, &bytes_read, 0);
1169           data += bytes_read;
1170           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1171           break;
1172         case DW_OP_GNU_deref_type:
1173           printf ("DW_OP_GNU_deref_type: %ld", (long) byte_get (data++, 1));
1174           uvalue = read_leb128 (data, &bytes_read, 0);
1175           data += bytes_read;
1176           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1177           break;
1178         case DW_OP_GNU_convert:
1179           uvalue = read_leb128 (data, &bytes_read, 0);
1180           data += bytes_read;
1181           printf ("DW_OP_GNU_convert <0x%s>",
1182                   dwarf_vmatoa ("x", cu_offset + uvalue));
1183           break;
1184         case DW_OP_GNU_reinterpret:
1185           uvalue = read_leb128 (data, &bytes_read, 0);
1186           data += bytes_read;
1187           printf ("DW_OP_GNU_reinterpret <0x%s>",
1188                   dwarf_vmatoa ("x", cu_offset + uvalue));
1189           break;
1190
1191           /* HP extensions.  */
1192         case DW_OP_HP_is_value:
1193           printf ("DW_OP_HP_is_value");
1194           /* FIXME: Is there data associated with this OP ?  */
1195           break;
1196         case DW_OP_HP_fltconst4:
1197           printf ("DW_OP_HP_fltconst4");
1198           /* FIXME: Is there data associated with this OP ?  */
1199           break;
1200         case DW_OP_HP_fltconst8:
1201           printf ("DW_OP_HP_fltconst8");
1202           /* FIXME: Is there data associated with this OP ?  */
1203           break;
1204         case DW_OP_HP_mod_range:
1205           printf ("DW_OP_HP_mod_range");
1206           /* FIXME: Is there data associated with this OP ?  */
1207           break;
1208         case DW_OP_HP_unmod_range:
1209           printf ("DW_OP_HP_unmod_range");
1210           /* FIXME: Is there data associated with this OP ?  */
1211           break;
1212         case DW_OP_HP_tls:
1213           printf ("DW_OP_HP_tls");
1214           /* FIXME: Is there data associated with this OP ?  */
1215           break;
1216
1217           /* PGI (STMicroelectronics) extensions.  */
1218         case DW_OP_PGI_omp_thread_num:
1219           /* Pushes the thread number for the current thread as it would be
1220              returned by the standard OpenMP library function:
1221              omp_get_thread_num().  The "current thread" is the thread for
1222              which the expression is being evaluated.  */
1223           printf ("DW_OP_PGI_omp_thread_num");
1224           break;
1225
1226         default:
1227           if (op >= DW_OP_lo_user
1228               && op <= DW_OP_hi_user)
1229             printf (_("(User defined location op)"));
1230           else
1231             printf (_("(Unknown location op)"));
1232           /* No way to tell where the next op is, so just bail.  */
1233           return need_frame_base;
1234         }
1235
1236       /* Separate the ops.  */
1237       if (data < end)
1238         printf ("; ");
1239     }
1240
1241   return need_frame_base;
1242 }
1243
1244 static unsigned char *
1245 read_and_display_attr_value (unsigned long attribute,
1246                              unsigned long form,
1247                              unsigned char * data,
1248                              dwarf_vma cu_offset,
1249                              dwarf_vma pointer_size,
1250                              dwarf_vma offset_size,
1251                              int dwarf_version,
1252                              debug_info * debug_info_p,
1253                              int do_loc,
1254                              struct dwarf_section * section)
1255 {
1256   dwarf_vma uvalue = 0;
1257   unsigned char *block_start = NULL;
1258   unsigned char * orig_data = data;
1259   unsigned int bytes_read;
1260
1261   switch (form)
1262     {
1263     default:
1264       break;
1265
1266     case DW_FORM_ref_addr:
1267       if (dwarf_version == 2)
1268         {
1269           uvalue = byte_get (data, pointer_size);
1270           data += pointer_size;
1271         }
1272       else if (dwarf_version == 3 || dwarf_version == 4)
1273         {
1274           uvalue = byte_get (data, offset_size);
1275           data += offset_size;
1276         }
1277       else
1278         error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1279
1280       break;
1281
1282     case DW_FORM_addr:
1283       uvalue = byte_get (data, pointer_size);
1284       data += pointer_size;
1285       break;
1286
1287     case DW_FORM_strp:
1288     case DW_FORM_sec_offset:
1289       uvalue = byte_get (data, offset_size);
1290       data += offset_size;
1291       break;
1292
1293     case DW_FORM_flag_present:
1294       uvalue = 1;
1295       break;
1296
1297     case DW_FORM_ref1:
1298     case DW_FORM_flag:
1299     case DW_FORM_data1:
1300       uvalue = byte_get (data++, 1);
1301       break;
1302
1303     case DW_FORM_ref2:
1304     case DW_FORM_data2:
1305       uvalue = byte_get (data, 2);
1306       data += 2;
1307       break;
1308
1309     case DW_FORM_ref4:
1310     case DW_FORM_data4:
1311       uvalue = byte_get (data, 4);
1312       data += 4;
1313       break;
1314
1315     case DW_FORM_sdata:
1316       uvalue = read_leb128 (data, & bytes_read, 1);
1317       data += bytes_read;
1318       break;
1319
1320     case DW_FORM_ref_udata:
1321     case DW_FORM_udata:
1322       uvalue = read_leb128 (data, & bytes_read, 0);
1323       data += bytes_read;
1324       break;
1325
1326     case DW_FORM_indirect:
1327       form = read_leb128 (data, & bytes_read, 0);
1328       data += bytes_read;
1329       if (!do_loc)
1330         printf (" %s", get_FORM_name (form));
1331       return read_and_display_attr_value (attribute, form, data,
1332                                           cu_offset, pointer_size,
1333                                           offset_size, dwarf_version,
1334                                           debug_info_p, do_loc,
1335                                           section);
1336     }
1337
1338   switch (form)
1339     {
1340     case DW_FORM_ref_addr:
1341       if (!do_loc)
1342         printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1343       break;
1344
1345     case DW_FORM_ref1:
1346     case DW_FORM_ref2:
1347     case DW_FORM_ref4:
1348     case DW_FORM_ref_udata:
1349       if (!do_loc)
1350         printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1351       break;
1352
1353     case DW_FORM_data4:
1354     case DW_FORM_addr:
1355     case DW_FORM_sec_offset:
1356       if (!do_loc)
1357         printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1358       break;
1359
1360     case DW_FORM_flag_present:
1361     case DW_FORM_flag:
1362     case DW_FORM_data1:
1363     case DW_FORM_data2:
1364     case DW_FORM_sdata:
1365     case DW_FORM_udata:
1366       if (!do_loc)
1367         printf (" %s", dwarf_vmatoa ("d", uvalue));
1368       break;
1369
1370     case DW_FORM_ref8:
1371     case DW_FORM_data8:
1372       if (!do_loc)
1373         {
1374           uvalue = byte_get (data, 4);
1375           printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1376           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1377         }
1378       if ((do_loc || do_debug_loc || do_debug_ranges)
1379           && num_debug_info_entries == 0)
1380         {
1381           if (sizeof (uvalue) == 8)
1382             uvalue = byte_get (data, 8);
1383           else
1384             error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1385         }
1386       data += 8;
1387       break;
1388
1389     case DW_FORM_string:
1390       if (!do_loc)
1391         printf (" %s", data);
1392       data += strlen ((char *) data) + 1;
1393       break;
1394
1395     case DW_FORM_block:
1396     case DW_FORM_exprloc:
1397       uvalue = read_leb128 (data, & bytes_read, 0);
1398       block_start = data + bytes_read;
1399       if (do_loc)
1400         data = block_start + uvalue;
1401       else
1402         data = display_block (block_start, uvalue);
1403       break;
1404
1405     case DW_FORM_block1:
1406       uvalue = byte_get (data, 1);
1407       block_start = data + 1;
1408       if (do_loc)
1409         data = block_start + uvalue;
1410       else
1411         data = display_block (block_start, uvalue);
1412       break;
1413
1414     case DW_FORM_block2:
1415       uvalue = byte_get (data, 2);
1416       block_start = data + 2;
1417       if (do_loc)
1418         data = block_start + uvalue;
1419       else
1420         data = display_block (block_start, uvalue);
1421       break;
1422
1423     case DW_FORM_block4:
1424       uvalue = byte_get (data, 4);
1425       block_start = data + 4;
1426       if (do_loc)
1427         data = block_start + uvalue;
1428       else
1429         data = display_block (block_start, uvalue);
1430       break;
1431
1432     case DW_FORM_strp:
1433       if (!do_loc)
1434         printf (_(" (indirect string, offset: 0x%s): %s"),
1435                 dwarf_vmatoa ("x", uvalue),
1436                 fetch_indirect_string (uvalue));
1437       break;
1438
1439     case DW_FORM_indirect:
1440       /* Handled above.  */
1441       break;
1442
1443     case DW_FORM_ref_sig8:
1444       if (!do_loc)
1445         {
1446           int i;
1447           printf (" signature: ");
1448           for (i = 0; i < 8; i++)
1449             {
1450               printf ("%02x", (unsigned) byte_get (data, 1));
1451               data += 1;
1452             }
1453         }
1454       else
1455         data += 8;
1456       break;
1457
1458     default:
1459       warn (_("Unrecognized form: %lu\n"), form);
1460       break;
1461     }
1462
1463   if ((do_loc || do_debug_loc || do_debug_ranges)
1464       && num_debug_info_entries == 0
1465       && debug_info_p != NULL)
1466     {
1467       switch (attribute)
1468         {
1469         case DW_AT_frame_base:
1470           have_frame_base = 1;
1471         case DW_AT_location:
1472         case DW_AT_string_length:
1473         case DW_AT_return_addr:
1474         case DW_AT_data_member_location:
1475         case DW_AT_vtable_elem_location:
1476         case DW_AT_segment:
1477         case DW_AT_static_link:
1478         case DW_AT_use_location:
1479         case DW_AT_GNU_call_site_value:
1480         case DW_AT_GNU_call_site_data_value:
1481         case DW_AT_GNU_call_site_target:
1482         case DW_AT_GNU_call_site_target_clobbered:
1483           if (form == DW_FORM_data4
1484               || form == DW_FORM_data8
1485               || form == DW_FORM_sec_offset)
1486             {
1487               /* Process location list.  */
1488               unsigned int lmax = debug_info_p->max_loc_offsets;
1489               unsigned int num = debug_info_p->num_loc_offsets;
1490
1491               if (lmax == 0 || num >= lmax)
1492                 {
1493                   lmax += 1024;
1494                   debug_info_p->loc_offsets = (dwarf_vma *)
1495                       xcrealloc (debug_info_p->loc_offsets,
1496                                  lmax, sizeof (*debug_info_p->loc_offsets));
1497                   debug_info_p->have_frame_base = (int *)
1498                       xcrealloc (debug_info_p->have_frame_base,
1499                                  lmax, sizeof (*debug_info_p->have_frame_base));
1500                   debug_info_p->max_loc_offsets = lmax;
1501                 }
1502               debug_info_p->loc_offsets [num] = uvalue;
1503               debug_info_p->have_frame_base [num] = have_frame_base;
1504               debug_info_p->num_loc_offsets++;
1505             }
1506           break;
1507
1508         case DW_AT_low_pc:
1509           if (need_base_address)
1510             debug_info_p->base_address = uvalue;
1511           break;
1512
1513         case DW_AT_ranges:
1514           if (form == DW_FORM_data4
1515               || form == DW_FORM_data8
1516               || form == DW_FORM_sec_offset)
1517             {
1518               /* Process range list.  */
1519               unsigned int lmax = debug_info_p->max_range_lists;
1520               unsigned int num = debug_info_p->num_range_lists;
1521
1522               if (lmax == 0 || num >= lmax)
1523                 {
1524                   lmax += 1024;
1525                   debug_info_p->range_lists = (dwarf_vma *)
1526                       xcrealloc (debug_info_p->range_lists,
1527                                  lmax, sizeof (*debug_info_p->range_lists));
1528                   debug_info_p->max_range_lists = lmax;
1529                 }
1530               debug_info_p->range_lists [num] = uvalue;
1531               debug_info_p->num_range_lists++;
1532             }
1533           break;
1534
1535         default:
1536           break;
1537         }
1538     }
1539
1540   if (do_loc)
1541     return data;
1542
1543   /* For some attributes we can display further information.  */
1544   printf ("\t");
1545
1546   switch (attribute)
1547     {
1548     case DW_AT_inline:
1549       switch (uvalue)
1550         {
1551         case DW_INL_not_inlined:
1552           printf (_("(not inlined)"));
1553           break;
1554         case DW_INL_inlined:
1555           printf (_("(inlined)"));
1556           break;
1557         case DW_INL_declared_not_inlined:
1558           printf (_("(declared as inline but ignored)"));
1559           break;
1560         case DW_INL_declared_inlined:
1561           printf (_("(declared as inline and inlined)"));
1562           break;
1563         default:
1564           printf (_("  (Unknown inline attribute value: %s)"),
1565                   dwarf_vmatoa ("x", uvalue));
1566           break;
1567         }
1568       break;
1569
1570     case DW_AT_language:
1571       switch (uvalue)
1572         {
1573           /* Ordered by the numeric value of these constants.  */
1574         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1575         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1576         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1577         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1578         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1579         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1580         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1581         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1582         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1583         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1584           /* DWARF 2.1 values.  */
1585         case DW_LANG_Java:              printf ("(Java)"); break;
1586         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1587         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1588         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1589           /* DWARF 3 values.  */
1590         case DW_LANG_PLI:               printf ("(PLI)"); break;
1591         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1592         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1593         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1594         case DW_LANG_D:                 printf ("(D)"); break;
1595           /* DWARF 4 values.  */
1596         case DW_LANG_Python:            printf ("(Python)"); break;
1597           /* MIPS extension.  */
1598         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1599           /* UPC extension.  */
1600         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1601         default:
1602           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1603             printf ("(implementation defined: %s)",
1604                     dwarf_vmatoa ("x", uvalue));
1605           else
1606             printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1607           break;
1608         }
1609       break;
1610
1611     case DW_AT_encoding:
1612       switch (uvalue)
1613         {
1614         case DW_ATE_void:               printf ("(void)"); break;
1615         case DW_ATE_address:            printf ("(machine address)"); break;
1616         case DW_ATE_boolean:            printf ("(boolean)"); break;
1617         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1618         case DW_ATE_float:              printf ("(float)"); break;
1619         case DW_ATE_signed:             printf ("(signed)"); break;
1620         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1621         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1622         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1623           /* DWARF 2.1 values:  */
1624         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1625         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1626           /* DWARF 3 values:  */
1627         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1628         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1629         case DW_ATE_edited:             printf ("(edited)"); break;
1630         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1631         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1632           /* HP extensions:  */
1633         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1634         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1635         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1636         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1637         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1638         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1639         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1640
1641         default:
1642           if (uvalue >= DW_ATE_lo_user
1643               && uvalue <= DW_ATE_hi_user)
1644             printf ("(user defined type)");
1645           else
1646             printf ("(unknown type)");
1647           break;
1648         }
1649       break;
1650
1651     case DW_AT_accessibility:
1652       switch (uvalue)
1653         {
1654         case DW_ACCESS_public:          printf ("(public)"); break;
1655         case DW_ACCESS_protected:       printf ("(protected)"); break;
1656         case DW_ACCESS_private:         printf ("(private)"); break;
1657         default:
1658           printf ("(unknown accessibility)");
1659           break;
1660         }
1661       break;
1662
1663     case DW_AT_visibility:
1664       switch (uvalue)
1665         {
1666         case DW_VIS_local:              printf ("(local)"); break;
1667         case DW_VIS_exported:           printf ("(exported)"); break;
1668         case DW_VIS_qualified:          printf ("(qualified)"); break;
1669         default:                        printf ("(unknown visibility)"); break;
1670         }
1671       break;
1672
1673     case DW_AT_virtuality:
1674       switch (uvalue)
1675         {
1676         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1677         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1678         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1679         default:                        printf ("(unknown virtuality)"); break;
1680         }
1681       break;
1682
1683     case DW_AT_identifier_case:
1684       switch (uvalue)
1685         {
1686         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1687         case DW_ID_up_case:             printf ("(up_case)"); break;
1688         case DW_ID_down_case:           printf ("(down_case)"); break;
1689         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1690         default:                        printf ("(unknown case)"); break;
1691         }
1692       break;
1693
1694     case DW_AT_calling_convention:
1695       switch (uvalue)
1696         {
1697         case DW_CC_normal:      printf ("(normal)"); break;
1698         case DW_CC_program:     printf ("(program)"); break;
1699         case DW_CC_nocall:      printf ("(nocall)"); break;
1700         default:
1701           if (uvalue >= DW_CC_lo_user
1702               && uvalue <= DW_CC_hi_user)
1703             printf ("(user defined)");
1704           else
1705             printf ("(unknown convention)");
1706         }
1707       break;
1708
1709     case DW_AT_ordering:
1710       switch (uvalue)
1711         {
1712         case -1: printf ("(undefined)"); break;
1713         case 0:  printf ("(row major)"); break;
1714         case 1:  printf ("(column major)"); break;
1715         }
1716       break;
1717
1718     case DW_AT_frame_base:
1719       have_frame_base = 1;
1720     case DW_AT_location:
1721     case DW_AT_string_length:
1722     case DW_AT_return_addr:
1723     case DW_AT_data_member_location:
1724     case DW_AT_vtable_elem_location:
1725     case DW_AT_segment:
1726     case DW_AT_static_link:
1727     case DW_AT_use_location:
1728     case DW_AT_GNU_call_site_value:
1729     case DW_AT_GNU_call_site_data_value:
1730     case DW_AT_GNU_call_site_target:
1731     case DW_AT_GNU_call_site_target_clobbered:
1732       if (form == DW_FORM_data4
1733           || form == DW_FORM_data8
1734           || form == DW_FORM_sec_offset)
1735         printf (_("(location list)"));
1736       /* Fall through.  */
1737     case DW_AT_allocated:
1738     case DW_AT_associated:
1739     case DW_AT_data_location:
1740     case DW_AT_stride:
1741     case DW_AT_upper_bound:
1742     case DW_AT_lower_bound:
1743       if (block_start)
1744         {
1745           int need_frame_base;
1746
1747           printf ("(");
1748           need_frame_base = decode_location_expression (block_start,
1749                                                         pointer_size,
1750                                                         offset_size,
1751                                                         dwarf_version,
1752                                                         uvalue,
1753                                                         cu_offset, section);
1754           printf (")");
1755           if (need_frame_base && !have_frame_base)
1756             printf (_(" [without DW_AT_frame_base]"));
1757         }
1758       break;
1759
1760     case DW_AT_import:
1761       {
1762         if (form == DW_FORM_ref_sig8)
1763           break;
1764
1765         if (form == DW_FORM_ref1
1766             || form == DW_FORM_ref2
1767             || form == DW_FORM_ref4)
1768           uvalue += cu_offset;
1769
1770         if (uvalue >= section->size)
1771           warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1772                 dwarf_vmatoa ("x", uvalue),
1773                 (unsigned long) (orig_data - section->start));
1774         else
1775           {
1776             unsigned long abbrev_number;
1777             abbrev_entry * entry;
1778
1779             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1780
1781             printf ("[Abbrev Number: %ld", abbrev_number);
1782             for (entry = first_abbrev; entry != NULL; entry = entry->next)
1783               if (entry->entry == abbrev_number)
1784                 break;
1785             if (entry != NULL)
1786               printf (" (%s)", get_TAG_name (entry->tag));
1787             printf ("]");
1788           }
1789       }
1790       break;
1791
1792     default:
1793       break;
1794     }
1795
1796   return data;
1797 }
1798
1799 static char *
1800 get_AT_name (unsigned long attribute)
1801 {
1802   switch (attribute)
1803     {
1804     case DW_AT_sibling:                 return "DW_AT_sibling";
1805     case DW_AT_location:                return "DW_AT_location";
1806     case DW_AT_name:                    return "DW_AT_name";
1807     case DW_AT_ordering:                return "DW_AT_ordering";
1808     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1809     case DW_AT_byte_size:               return "DW_AT_byte_size";
1810     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1811     case DW_AT_bit_size:                return "DW_AT_bit_size";
1812     case DW_AT_element_list:            return "DW_AT_element_list";
1813     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1814     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1815     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1816     case DW_AT_language:                return "DW_AT_language";
1817     case DW_AT_member:                  return "DW_AT_member";
1818     case DW_AT_discr:                   return "DW_AT_discr";
1819     case DW_AT_discr_value:             return "DW_AT_discr_value";
1820     case DW_AT_visibility:              return "DW_AT_visibility";
1821     case DW_AT_import:                  return "DW_AT_import";
1822     case DW_AT_string_length:           return "DW_AT_string_length";
1823     case DW_AT_common_reference:        return "DW_AT_common_reference";
1824     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1825     case DW_AT_const_value:             return "DW_AT_const_value";
1826     case DW_AT_containing_type:         return "DW_AT_containing_type";
1827     case DW_AT_default_value:           return "DW_AT_default_value";
1828     case DW_AT_inline:                  return "DW_AT_inline";
1829     case DW_AT_is_optional:             return "DW_AT_is_optional";
1830     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1831     case DW_AT_producer:                return "DW_AT_producer";
1832     case DW_AT_prototyped:              return "DW_AT_prototyped";
1833     case DW_AT_return_addr:             return "DW_AT_return_addr";
1834     case DW_AT_start_scope:             return "DW_AT_start_scope";
1835     case DW_AT_stride_size:             return "DW_AT_stride_size";
1836     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1837     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1838     case DW_AT_accessibility:           return "DW_AT_accessibility";
1839     case DW_AT_address_class:           return "DW_AT_address_class";
1840     case DW_AT_artificial:              return "DW_AT_artificial";
1841     case DW_AT_base_types:              return "DW_AT_base_types";
1842     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1843     case DW_AT_count:                   return "DW_AT_count";
1844     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1845     case DW_AT_decl_column:             return "DW_AT_decl_column";
1846     case DW_AT_decl_file:               return "DW_AT_decl_file";
1847     case DW_AT_decl_line:               return "DW_AT_decl_line";
1848     case DW_AT_declaration:             return "DW_AT_declaration";
1849     case DW_AT_discr_list:              return "DW_AT_discr_list";
1850     case DW_AT_encoding:                return "DW_AT_encoding";
1851     case DW_AT_external:                return "DW_AT_external";
1852     case DW_AT_frame_base:              return "DW_AT_frame_base";
1853     case DW_AT_friend:                  return "DW_AT_friend";
1854     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1855     case DW_AT_macro_info:              return "DW_AT_macro_info";
1856     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1857     case DW_AT_priority:                return "DW_AT_priority";
1858     case DW_AT_segment:                 return "DW_AT_segment";
1859     case DW_AT_specification:           return "DW_AT_specification";
1860     case DW_AT_static_link:             return "DW_AT_static_link";
1861     case DW_AT_type:                    return "DW_AT_type";
1862     case DW_AT_use_location:            return "DW_AT_use_location";
1863     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1864     case DW_AT_virtuality:              return "DW_AT_virtuality";
1865     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1866       /* DWARF 2.1 values.  */
1867     case DW_AT_allocated:               return "DW_AT_allocated";
1868     case DW_AT_associated:              return "DW_AT_associated";
1869     case DW_AT_data_location:           return "DW_AT_data_location";
1870     case DW_AT_stride:                  return "DW_AT_stride";
1871     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1872     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1873     case DW_AT_extension:               return "DW_AT_extension";
1874     case DW_AT_ranges:                  return "DW_AT_ranges";
1875     case DW_AT_trampoline:              return "DW_AT_trampoline";
1876     case DW_AT_call_column:             return "DW_AT_call_column";
1877     case DW_AT_call_file:               return "DW_AT_call_file";
1878     case DW_AT_call_line:               return "DW_AT_call_line";
1879     case DW_AT_description:             return "DW_AT_description";
1880     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1881     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1882     case DW_AT_small:                   return "DW_AT_small";
1883     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1884     case DW_AT_digit_count:             return "DW_AT_digit_count";
1885     case DW_AT_picture_string:          return "DW_AT_picture_string";
1886     case DW_AT_mutable:                 return "DW_AT_mutable";
1887     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1888     case DW_AT_explicit:                return "DW_AT_explicit";
1889     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1890     case DW_AT_endianity:               return "DW_AT_endianity";
1891     case DW_AT_elemental:               return "DW_AT_elemental";
1892     case DW_AT_pure:                    return "DW_AT_pure";
1893     case DW_AT_recursive:               return "DW_AT_recursive";
1894       /* DWARF 4 values.  */
1895     case DW_AT_signature:               return "DW_AT_signature";
1896     case DW_AT_main_subprogram:         return "DW_AT_main_subprogram";
1897     case DW_AT_data_bit_offset:         return "DW_AT_data_bit_offset";
1898     case DW_AT_const_expr:              return "DW_AT_const_expr";
1899     case DW_AT_enum_class:              return "DW_AT_enum_class";
1900     case DW_AT_linkage_name:            return "DW_AT_linkage_name";
1901
1902       /* HP and SGI/MIPS extensions.  */
1903     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1904     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1905     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1906     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1907     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1908     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1909     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1910     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1911     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1912     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1913
1914       /* HP Extensions.  */
1915     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1916     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1917     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1918     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1919     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1920     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1921     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1922     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1923     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1924     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1925     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1926     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1927     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1928
1929       /* One value is shared by the MIPS and HP extensions:  */
1930     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1931
1932       /* GNU extensions.  */
1933     case DW_AT_sf_names:                        return "DW_AT_sf_names";
1934     case DW_AT_src_info:                        return "DW_AT_src_info";
1935     case DW_AT_mac_info:                        return "DW_AT_mac_info";
1936     case DW_AT_src_coords:                      return "DW_AT_src_coords";
1937     case DW_AT_body_begin:                      return "DW_AT_body_begin";
1938     case DW_AT_body_end:                        return "DW_AT_body_end";
1939     case DW_AT_GNU_vector:                      return "DW_AT_GNU_vector";
1940     case DW_AT_GNU_guarded_by:                  return "DW_AT_GNU_guarded_by";
1941     case DW_AT_GNU_pt_guarded_by:               return "DW_AT_GNU_pt_guarded_by";
1942     case DW_AT_GNU_guarded:                     return "DW_AT_GNU_guarded";
1943     case DW_AT_GNU_pt_guarded:                  return "DW_AT_GNU_pt_guarded";
1944     case DW_AT_GNU_locks_excluded:              return "DW_AT_GNU_locks_excluded";
1945     case DW_AT_GNU_exclusive_locks_required:    return "DW_AT_GNU_exclusive_locks_required";
1946     case DW_AT_GNU_shared_locks_required:       return "DW_AT_GNU_shared_locks_required";
1947     case DW_AT_GNU_odr_signature:               return "DW_AT_GNU_odr_signature";
1948     case DW_AT_use_GNAT_descriptive_type:       return "DW_AT_use_GNAT_descriptive_type";
1949     case DW_AT_GNAT_descriptive_type:           return "DW_AT_GNAT_descriptive_type";
1950     case DW_AT_GNU_call_site_value:             return "DW_AT_GNU_call_site_value";
1951     case DW_AT_GNU_call_site_data_value:        return "DW_AT_GNU_call_site_data_value";
1952     case DW_AT_GNU_call_site_target:            return "DW_AT_GNU_call_site_target";
1953     case DW_AT_GNU_call_site_target_clobbered:  return "DW_AT_GNU_call_site_target_clobbered";
1954     case DW_AT_GNU_tail_call:                   return "DW_AT_GNU_tail_call";
1955     case DW_AT_GNU_all_tail_call_sites:         return "DW_AT_GNU_all_tail_call_sites";
1956     case DW_AT_GNU_all_call_sites:              return "DW_AT_GNU_all_call_sites";
1957     case DW_AT_GNU_all_source_call_sites:       return "DW_AT_GNU_all_source_call_sites";
1958
1959       /* UPC extension.  */
1960     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1961
1962     /* PGI (STMicroelectronics) extensions.  */
1963     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1964     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1965     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1966
1967     default:
1968       {
1969         static char buffer[100];
1970
1971         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1972                   attribute);
1973         return buffer;
1974       }
1975     }
1976 }
1977
1978 static unsigned char *
1979 read_and_display_attr (unsigned long attribute,
1980                        unsigned long form,
1981                        unsigned char * data,
1982                        dwarf_vma cu_offset,
1983                        dwarf_vma pointer_size,
1984                        dwarf_vma offset_size,
1985                        int dwarf_version,
1986                        debug_info * debug_info_p,
1987                        int do_loc,
1988                        struct dwarf_section * section)
1989 {
1990   if (!do_loc)
1991     printf ("   %-18s:", get_AT_name (attribute));
1992   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1993                                       pointer_size, offset_size,
1994                                       dwarf_version, debug_info_p,
1995                                       do_loc, section);
1996   if (!do_loc)
1997     printf ("\n");
1998   return data;
1999 }
2000
2001
2002 /* Process the contents of a .debug_info section.  If do_loc is non-zero
2003    then we are scanning for location lists and we do not want to display
2004    anything to the user.  If do_types is non-zero, we are processing
2005    a .debug_types section instead of a .debug_info section.  */
2006
2007 static int
2008 process_debug_info (struct dwarf_section *section,
2009                     void *file,
2010                     enum dwarf_section_display_enum abbrev_sec,
2011                     int do_loc,
2012                     int do_types)
2013 {
2014   unsigned char *start = section->start;
2015   unsigned char *end = start + section->size;
2016   unsigned char *section_begin;
2017   unsigned int unit;
2018   unsigned int num_units = 0;
2019
2020   if ((do_loc || do_debug_loc || do_debug_ranges)
2021       && num_debug_info_entries == 0
2022       && ! do_types)
2023     {
2024       dwarf_vma length;
2025
2026       /* First scan the section to get the number of comp units.  */
2027       for (section_begin = start, num_units = 0; section_begin < end;
2028            num_units ++)
2029         {
2030           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2031              will be the length.  For a 64-bit DWARF section, it'll be
2032              the escape code 0xffffffff followed by an 8 byte length.  */
2033           length = byte_get (section_begin, 4);
2034
2035           if (length == 0xffffffff)
2036             {
2037               length = byte_get (section_begin + 4, 8);
2038               section_begin += length + 12;
2039             }
2040           else if (length >= 0xfffffff0 && length < 0xffffffff)
2041             {
2042               warn (_("Reserved length value (0x%s) found in section %s\n"),
2043                     dwarf_vmatoa ("x", length), section->name);
2044               return 0;
2045             }
2046           else
2047             section_begin += length + 4;
2048
2049           /* Negative values are illegal, they may even cause infinite
2050              looping.  This can happen if we can't accurately apply
2051              relocations to an object file.  */
2052           if ((signed long) length <= 0)
2053             {
2054               warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2055                     dwarf_vmatoa ("x", length), section->name);
2056               return 0;
2057             }
2058         }
2059
2060       if (num_units == 0)
2061         {
2062           error (_("No comp units in %s section ?"), section->name);
2063           return 0;
2064         }
2065
2066       /* Then allocate an array to hold the information.  */
2067       debug_information = (debug_info *) cmalloc (num_units,
2068                                                   sizeof (* debug_information));
2069       if (debug_information == NULL)
2070         {
2071           error (_("Not enough memory for a debug info array of %u entries"),
2072                  num_units);
2073           return 0;
2074         }
2075     }
2076
2077   if (!do_loc)
2078     {
2079       if (dwarf_start_die == 0)
2080         printf (_("Contents of the %s section:\n\n"), section->name);
2081
2082       load_debug_section (str, file);
2083     }
2084
2085   load_debug_section (abbrev_sec, file);
2086   if (debug_displays [abbrev_sec].section.start == NULL)
2087     {
2088       warn (_("Unable to locate %s section!\n"),
2089             debug_displays [abbrev_sec].section.name);
2090       return 0;
2091     }
2092
2093   for (section_begin = start, unit = 0; start < end; unit++)
2094     {
2095       DWARF2_Internal_CompUnit compunit;
2096       unsigned char *hdrptr;
2097       unsigned char *tags;
2098       int level, last_level, saved_level;
2099       dwarf_vma cu_offset;
2100       int offset_size;
2101       int initial_length_size;
2102       unsigned char signature[8] = { 0 };
2103       dwarf_vma type_offset = 0;
2104
2105       hdrptr = start;
2106
2107       compunit.cu_length = byte_get (hdrptr, 4);
2108       hdrptr += 4;
2109
2110       if (compunit.cu_length == 0xffffffff)
2111         {
2112           compunit.cu_length = byte_get (hdrptr, 8);
2113           hdrptr += 8;
2114           offset_size = 8;
2115           initial_length_size = 12;
2116         }
2117       else
2118         {
2119           offset_size = 4;
2120           initial_length_size = 4;
2121         }
2122
2123       compunit.cu_version = byte_get (hdrptr, 2);
2124       hdrptr += 2;
2125
2126       cu_offset = start - section_begin;
2127
2128       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2129       hdrptr += offset_size;
2130
2131       compunit.cu_pointer_size = byte_get (hdrptr, 1);
2132       hdrptr += 1;
2133
2134       if (do_types)
2135         {
2136           int i;
2137
2138           for (i = 0; i < 8; i++)
2139             {
2140               signature[i] = byte_get (hdrptr, 1);
2141               hdrptr += 1;
2142             }
2143
2144           type_offset = byte_get (hdrptr, offset_size);
2145           hdrptr += offset_size;
2146         }
2147
2148       if ((do_loc || do_debug_loc || do_debug_ranges)
2149           && num_debug_info_entries == 0
2150           && ! do_types)
2151         {
2152           debug_information [unit].cu_offset = cu_offset;
2153           debug_information [unit].pointer_size
2154             = compunit.cu_pointer_size;
2155           debug_information [unit].offset_size = offset_size;
2156           debug_information [unit].dwarf_version = compunit.cu_version;
2157           debug_information [unit].base_address = 0;
2158           debug_information [unit].loc_offsets = NULL;
2159           debug_information [unit].have_frame_base = NULL;
2160           debug_information [unit].max_loc_offsets = 0;
2161           debug_information [unit].num_loc_offsets = 0;
2162           debug_information [unit].range_lists = NULL;
2163           debug_information [unit].max_range_lists= 0;
2164           debug_information [unit].num_range_lists = 0;
2165         }
2166
2167       if (!do_loc && dwarf_start_die == 0)
2168         {
2169           printf (_("  Compilation Unit @ offset 0x%s:\n"),
2170                   dwarf_vmatoa ("x", cu_offset));
2171           printf (_("   Length:        0x%s (%s)\n"),
2172                   dwarf_vmatoa ("x", compunit.cu_length),
2173                   offset_size == 8 ? "64-bit" : "32-bit");
2174           printf (_("   Version:       %d\n"), compunit.cu_version);
2175           printf (_("   Abbrev Offset: %s\n"),
2176                   dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2177           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2178           if (do_types)
2179             {
2180               int i;
2181               printf (_("   Signature:     "));
2182               for (i = 0; i < 8; i++)
2183                 printf ("%02x", signature[i]);
2184               printf ("\n");
2185              printf (_("   Type Offset:   0x%s\n"),
2186                      dwarf_vmatoa ("x", type_offset));
2187             }
2188         }
2189
2190       if (cu_offset + compunit.cu_length + initial_length_size
2191           > section->size)
2192         {
2193           warn (_("Debug info is corrupted, length of CU at %s"
2194                   " extends beyond end of section (length = %s)\n"),
2195                 dwarf_vmatoa ("x", cu_offset),
2196                 dwarf_vmatoa ("x", compunit.cu_length));
2197           break;
2198         }
2199       tags = hdrptr;
2200       start += compunit.cu_length + initial_length_size;
2201
2202       if (compunit.cu_version != 2
2203           && compunit.cu_version != 3
2204           && compunit.cu_version != 4)
2205         {
2206           warn (_("CU at offset %s contains corrupt or "
2207                   "unsupported version number: %d.\n"),
2208                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2209           continue;
2210         }
2211
2212       free_abbrevs ();
2213
2214       /* Process the abbrevs used by this compilation unit. DWARF
2215          sections under Mach-O have non-zero addresses.  */
2216       if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2217         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2218               (unsigned long) compunit.cu_abbrev_offset,
2219               (unsigned long) debug_displays [abbrev_sec].section.size);
2220       else
2221         process_abbrev_section
2222           ((unsigned char *) debug_displays [abbrev_sec].section.start
2223            + compunit.cu_abbrev_offset,
2224            (unsigned char *) debug_displays [abbrev_sec].section.start
2225            + debug_displays [abbrev_sec].section.size);
2226
2227       level = 0;
2228       last_level = level;
2229       saved_level = -1;
2230       while (tags < start)
2231         {
2232           unsigned int bytes_read;
2233           unsigned long abbrev_number;
2234           unsigned long die_offset;
2235           abbrev_entry *entry;
2236           abbrev_attr *attr;
2237           int do_printing = 1;
2238
2239           die_offset = tags - section_begin;
2240
2241           abbrev_number = read_leb128 (tags, & bytes_read, 0);
2242           tags += bytes_read;
2243
2244           /* A null DIE marks the end of a list of siblings or it may also be
2245              a section padding.  */
2246           if (abbrev_number == 0)
2247             {
2248               /* Check if it can be a section padding for the last CU.  */
2249               if (level == 0 && start == end)
2250                 {
2251                   unsigned char *chk;
2252
2253                   for (chk = tags; chk < start; chk++)
2254                     if (*chk != 0)
2255                       break;
2256                   if (chk == start)
2257                     break;
2258                 }
2259
2260               --level;
2261               if (level < 0)
2262                 {
2263                   static unsigned num_bogus_warns = 0;
2264
2265                   if (num_bogus_warns < 3)
2266                     {
2267                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2268                             die_offset);
2269                       num_bogus_warns ++;
2270                       if (num_bogus_warns == 3)
2271                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2272                     }
2273                 }
2274               if (dwarf_start_die != 0 && level < saved_level)
2275                 return 1;
2276               continue;
2277             }
2278
2279           if (!do_loc)
2280             {
2281               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2282                 do_printing = 0;
2283               else
2284                 {
2285                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2286                     saved_level = level;
2287                   do_printing = (dwarf_cutoff_level == -1
2288                                  || level < dwarf_cutoff_level);
2289                   if (do_printing)
2290                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2291                             level, die_offset, abbrev_number);
2292                   else if (dwarf_cutoff_level == -1
2293                            || last_level < dwarf_cutoff_level)
2294                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2295                   last_level = level;
2296                 }
2297             }
2298
2299           /* Scan through the abbreviation list until we reach the
2300              correct entry.  */
2301           for (entry = first_abbrev;
2302                entry && entry->entry != abbrev_number;
2303                entry = entry->next)
2304             continue;
2305
2306           if (entry == NULL)
2307             {
2308               if (!do_loc && do_printing)
2309                 {
2310                   printf ("\n");
2311                   fflush (stdout);
2312                 }
2313               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2314                     die_offset, abbrev_number);
2315               return 0;
2316             }
2317
2318           if (!do_loc && do_printing)
2319             printf (" (%s)\n", get_TAG_name (entry->tag));
2320
2321           switch (entry->tag)
2322             {
2323             default:
2324               need_base_address = 0;
2325               break;
2326             case DW_TAG_compile_unit:
2327               need_base_address = 1;
2328               break;
2329             case DW_TAG_entry_point:
2330             case DW_TAG_subprogram:
2331               need_base_address = 0;
2332               /* Assuming that there is no DW_AT_frame_base.  */
2333               have_frame_base = 0;
2334               break;
2335             }
2336
2337           for (attr = entry->first_attr; attr; attr = attr->next)
2338             {
2339               debug_info *arg;
2340
2341               if (! do_loc && do_printing)
2342                 /* Show the offset from where the tag was extracted.  */
2343                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2344
2345               arg = debug_information;
2346               if (debug_information)
2347                 arg += unit;
2348
2349               tags = read_and_display_attr (attr->attribute,
2350                                             attr->form,
2351                                             tags, cu_offset,
2352                                             compunit.cu_pointer_size,
2353                                             offset_size,
2354                                             compunit.cu_version,
2355                                             arg,
2356                                             do_loc || ! do_printing, section);
2357             }
2358
2359           if (entry->children)
2360             ++level;
2361         }
2362     }
2363
2364   /* Set num_debug_info_entries here so that it can be used to check if
2365      we need to process .debug_loc and .debug_ranges sections.  */
2366   if ((do_loc || do_debug_loc || do_debug_ranges)
2367       && num_debug_info_entries == 0
2368       && ! do_types)
2369     num_debug_info_entries = num_units;
2370
2371   if (!do_loc)
2372     printf ("\n");
2373
2374   return 1;
2375 }
2376
2377 /* Locate and scan the .debug_info section in the file and record the pointer
2378    sizes and offsets for the compilation units in it.  Usually an executable
2379    will have just one pointer size, but this is not guaranteed, and so we try
2380    not to make any assumptions.  Returns zero upon failure, or the number of
2381    compilation units upon success.  */
2382
2383 static unsigned int
2384 load_debug_info (void * file)
2385 {
2386   /* Reset the last pointer size so that we can issue correct error
2387      messages if we are displaying the contents of more than one section.  */
2388   last_pointer_size = 0;
2389   warned_about_missing_comp_units = FALSE;
2390
2391   /* If we have already tried and failed to load the .debug_info
2392      section then do not bother to repear the task.  */
2393   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2394     return 0;
2395
2396   /* If we already have the information there is nothing else to do.  */
2397   if (num_debug_info_entries > 0)
2398     return num_debug_info_entries;
2399
2400   if (load_debug_section (info, file)
2401       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2402     return num_debug_info_entries;
2403
2404   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2405   return 0;
2406 }
2407
2408 static int
2409 display_debug_lines_raw (struct dwarf_section *section,
2410                          unsigned char *data,
2411                          unsigned char *end)
2412 {
2413   unsigned char *start = section->start;
2414
2415   printf (_("Raw dump of debug contents of section %s:\n\n"),
2416           section->name);
2417
2418   while (data < end)
2419     {
2420       DWARF2_Internal_LineInfo linfo;
2421       unsigned char *standard_opcodes;
2422       unsigned char *end_of_sequence;
2423       unsigned char *hdrptr;
2424       unsigned long hdroff;
2425       int initial_length_size;
2426       int offset_size;
2427       int i;
2428
2429       hdrptr = data;
2430       hdroff = hdrptr - start;
2431
2432       /* Check the length of the block.  */
2433       linfo.li_length = byte_get (hdrptr, 4);
2434       hdrptr += 4;
2435
2436       if (linfo.li_length == 0xffffffff)
2437         {
2438           /* This section is 64-bit DWARF 3.  */
2439           linfo.li_length = byte_get (hdrptr, 8);
2440           hdrptr += 8;
2441           offset_size = 8;
2442           initial_length_size = 12;
2443         }
2444       else
2445         {
2446           offset_size = 4;
2447           initial_length_size = 4;
2448         }
2449
2450       if (linfo.li_length + initial_length_size > section->size)
2451         {
2452           warn
2453             (_("The information in section %s appears to be corrupt - the section is too small\n"),
2454              section->name);
2455           return 0;
2456         }
2457
2458       /* Check its version number.  */
2459       linfo.li_version = byte_get (hdrptr, 2);
2460       hdrptr += 2;
2461       if (linfo.li_version != 2
2462           && linfo.li_version != 3
2463           && linfo.li_version != 4)
2464         {
2465           warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2466           return 0;
2467         }
2468
2469       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2470       hdrptr += offset_size;
2471       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2472       hdrptr++;
2473       if (linfo.li_version >= 4)
2474         {
2475           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2476           hdrptr++;
2477           if (linfo.li_max_ops_per_insn == 0)
2478             {
2479               warn (_("Invalid maximum operations per insn.\n"));
2480               return 0;
2481             }
2482         }
2483       else
2484         linfo.li_max_ops_per_insn = 1;
2485       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2486       hdrptr++;
2487       linfo.li_line_base = byte_get (hdrptr, 1);
2488       hdrptr++;
2489       linfo.li_line_range = byte_get (hdrptr, 1);
2490       hdrptr++;
2491       linfo.li_opcode_base = byte_get (hdrptr, 1);
2492       hdrptr++;
2493
2494       /* Sign extend the line base field.  */
2495       linfo.li_line_base <<= 24;
2496       linfo.li_line_base >>= 24;
2497
2498       printf (_("  Offset:                      0x%lx\n"), hdroff);
2499       printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2500       printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2501       printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
2502       printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2503       if (linfo.li_version >= 4)
2504         printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2505       printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2506       printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2507       printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2508       printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2509
2510       end_of_sequence = data + linfo.li_length + initial_length_size;
2511
2512       reset_state_machine (linfo.li_default_is_stmt);
2513
2514       /* Display the contents of the Opcodes table.  */
2515       standard_opcodes = hdrptr;
2516
2517       printf (_("\n Opcodes:\n"));
2518
2519       for (i = 1; i < linfo.li_opcode_base; i++)
2520         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2521
2522       /* Display the contents of the Directory table.  */
2523       data = standard_opcodes + linfo.li_opcode_base - 1;
2524
2525       if (*data == 0)
2526         printf (_("\n The Directory Table is empty.\n"));
2527       else
2528         {
2529           printf (_("\n The Directory Table:\n"));
2530
2531           while (*data != 0)
2532             {
2533               printf ("  %s\n", data);
2534
2535               data += strlen ((char *) data) + 1;
2536             }
2537         }
2538
2539       /* Skip the NUL at the end of the table.  */
2540       data++;
2541
2542       /* Display the contents of the File Name table.  */
2543       if (*data == 0)
2544         printf (_("\n The File Name Table is empty.\n"));
2545       else
2546         {
2547           printf (_("\n The File Name Table:\n"));
2548           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2549
2550           while (*data != 0)
2551             {
2552               unsigned char *name;
2553               unsigned int bytes_read;
2554
2555               printf ("  %d\t", ++state_machine_regs.last_file_entry);
2556               name = data;
2557
2558               data += strlen ((char *) data) + 1;
2559
2560               printf ("%s\t",
2561                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2562               data += bytes_read;
2563               printf ("%s\t",
2564                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2565               data += bytes_read;
2566               printf ("%s\t",
2567                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2568               data += bytes_read;
2569               printf ("%s\n", name);
2570             }
2571         }
2572
2573       /* Skip the NUL at the end of the table.  */
2574       data++;
2575
2576       /* Now display the statements.  */
2577       printf (_("\n Line Number Statements:\n"));
2578
2579       while (data < end_of_sequence)
2580         {
2581           unsigned char op_code;
2582           dwarf_signed_vma adv;
2583           dwarf_vma uladv;
2584           unsigned int bytes_read;
2585
2586           op_code = *data++;
2587
2588           if (op_code >= linfo.li_opcode_base)
2589             {
2590               op_code -= linfo.li_opcode_base;
2591               uladv = (op_code / linfo.li_line_range);
2592               if (linfo.li_max_ops_per_insn == 1)
2593                 {
2594                   uladv *= linfo.li_min_insn_length;
2595                   state_machine_regs.address += uladv;
2596                   printf (_("  Special opcode %d: "
2597                             "advance Address by %s to 0x%s"),
2598                           op_code, dwarf_vmatoa ("u", uladv),
2599                           dwarf_vmatoa ("x", state_machine_regs.address));
2600                 }
2601               else
2602                 {
2603                   state_machine_regs.address
2604                     += ((state_machine_regs.op_index + uladv)
2605                         / linfo.li_max_ops_per_insn)
2606                        * linfo.li_min_insn_length;
2607                   state_machine_regs.op_index
2608                     = (state_machine_regs.op_index + uladv)
2609                       % linfo.li_max_ops_per_insn;
2610                   printf (_("  Special opcode %d: "
2611                             "advance Address by %s to 0x%s[%d]"),
2612                           op_code, dwarf_vmatoa ("u", uladv),
2613                           dwarf_vmatoa ("x", state_machine_regs.address),
2614                           state_machine_regs.op_index);
2615                 }
2616               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2617               state_machine_regs.line += adv;
2618               printf (_(" and Line by %s to %d\n"),
2619                       dwarf_vmatoa ("d", adv), state_machine_regs.line);
2620             }
2621           else switch (op_code)
2622             {
2623             case DW_LNS_extended_op:
2624               data += process_extended_line_op (data, linfo.li_default_is_stmt);
2625               break;
2626
2627             case DW_LNS_copy:
2628               printf (_("  Copy\n"));
2629               break;
2630
2631             case DW_LNS_advance_pc:
2632               uladv = read_leb128 (data, & bytes_read, 0);
2633               data += bytes_read;
2634               if (linfo.li_max_ops_per_insn == 1)
2635                 {
2636                   uladv *= linfo.li_min_insn_length;
2637                   state_machine_regs.address += uladv;
2638                   printf (_("  Advance PC by %s to 0x%s\n"),
2639                           dwarf_vmatoa ("u", uladv),
2640                           dwarf_vmatoa ("x", state_machine_regs.address));
2641                 }
2642               else
2643                 {
2644                   state_machine_regs.address
2645                     += ((state_machine_regs.op_index + uladv)
2646                         / linfo.li_max_ops_per_insn)
2647                        * linfo.li_min_insn_length;
2648                   state_machine_regs.op_index
2649                     = (state_machine_regs.op_index + uladv)
2650                       % linfo.li_max_ops_per_insn;
2651                   printf (_("  Advance PC by %s to 0x%s[%d]\n"),
2652                           dwarf_vmatoa ("u", uladv),
2653                           dwarf_vmatoa ("x", state_machine_regs.address),
2654                           state_machine_regs.op_index);
2655                 }
2656               break;
2657
2658             case DW_LNS_advance_line:
2659               adv = read_sleb128 (data, & bytes_read);
2660               data += bytes_read;
2661               state_machine_regs.line += adv;
2662               printf (_("  Advance Line by %s to %d\n"),
2663                         dwarf_vmatoa ("d", adv),
2664                         state_machine_regs.line);
2665               break;
2666
2667             case DW_LNS_set_file:
2668               adv = read_leb128 (data, & bytes_read, 0);
2669               data += bytes_read;
2670               printf (_("  Set File Name to entry %s in the File Name Table\n"),
2671                       dwarf_vmatoa ("d", adv));
2672               state_machine_regs.file = adv;
2673               break;
2674
2675             case DW_LNS_set_column:
2676               uladv = read_leb128 (data, & bytes_read, 0);
2677               data += bytes_read;
2678               printf (_("  Set column to %s\n"),
2679                       dwarf_vmatoa ("u", uladv));
2680               state_machine_regs.column = uladv;
2681               break;
2682
2683             case DW_LNS_negate_stmt:
2684               adv = state_machine_regs.is_stmt;
2685               adv = ! adv;
2686               printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2687               state_machine_regs.is_stmt = adv;
2688               break;
2689
2690             case DW_LNS_set_basic_block:
2691               printf (_("  Set basic block\n"));
2692               state_machine_regs.basic_block = 1;
2693               break;
2694
2695             case DW_LNS_const_add_pc:
2696               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2697               if (linfo.li_max_ops_per_insn)
2698                 {
2699                   uladv *= linfo.li_min_insn_length;
2700                   state_machine_regs.address += uladv;
2701                   printf (_("  Advance PC by constant %s to 0x%s\n"),
2702                           dwarf_vmatoa ("u", uladv),
2703                           dwarf_vmatoa ("x", state_machine_regs.address));
2704                 }
2705               else
2706                 {
2707                   state_machine_regs.address
2708                     += ((state_machine_regs.op_index + uladv)
2709                         / linfo.li_max_ops_per_insn)
2710                        * linfo.li_min_insn_length;
2711                   state_machine_regs.op_index
2712                     = (state_machine_regs.op_index + uladv)
2713                       % linfo.li_max_ops_per_insn;
2714                   printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
2715                           dwarf_vmatoa ("u", uladv),
2716                           dwarf_vmatoa ("x", state_machine_regs.address),
2717                           state_machine_regs.op_index);
2718                 }
2719               break;
2720
2721             case DW_LNS_fixed_advance_pc:
2722               uladv = byte_get (data, 2);
2723               data += 2;
2724               state_machine_regs.address += uladv;
2725               state_machine_regs.op_index = 0;
2726               printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
2727                       dwarf_vmatoa ("u", uladv),
2728                       dwarf_vmatoa ("x", state_machine_regs.address));
2729               break;
2730
2731             case DW_LNS_set_prologue_end:
2732               printf (_("  Set prologue_end to true\n"));
2733               break;
2734
2735             case DW_LNS_set_epilogue_begin:
2736               printf (_("  Set epilogue_begin to true\n"));
2737               break;
2738
2739             case DW_LNS_set_isa:
2740               uladv = read_leb128 (data, & bytes_read, 0);
2741               data += bytes_read;
2742               printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2743               break;
2744
2745             default:
2746               printf (_("  Unknown opcode %d with operands: "), op_code);
2747
2748               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2749                 {
2750                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2751                                                          &bytes_read, 0)),
2752                           i == 1 ? "" : ", ");
2753                   data += bytes_read;
2754                 }
2755               putchar ('\n');
2756               break;
2757             }
2758         }
2759       putchar ('\n');
2760     }
2761
2762   return 1;
2763 }
2764
2765 typedef struct
2766 {
2767   unsigned char *name;
2768   unsigned int directory_index;
2769   unsigned int modification_date;
2770   unsigned int length;
2771 } File_Entry;
2772
2773 /* Output a decoded representation of the .debug_line section.  */
2774
2775 static int
2776 display_debug_lines_decoded (struct dwarf_section *section,
2777                              unsigned char *data,
2778                              unsigned char *end)
2779 {
2780   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2781           section->name);
2782
2783   while (data < end)
2784     {
2785       /* This loop amounts to one iteration per compilation unit.  */
2786       DWARF2_Internal_LineInfo linfo;
2787       unsigned char *standard_opcodes;
2788       unsigned char *end_of_sequence;
2789       unsigned char *hdrptr;
2790       int initial_length_size;
2791       int offset_size;
2792       int i;
2793       File_Entry *file_table = NULL;
2794       unsigned char **directory_table = NULL;
2795
2796       hdrptr = data;
2797
2798       /* Extract information from the Line Number Program Header.
2799         (section 6.2.4 in the Dwarf3 doc).  */
2800
2801       /* Get the length of this CU's line number information block.  */
2802       linfo.li_length = byte_get (hdrptr, 4);
2803       hdrptr += 4;
2804
2805       if (linfo.li_length == 0xffffffff)
2806         {
2807           /* This section is 64-bit DWARF 3.  */
2808           linfo.li_length = byte_get (hdrptr, 8);
2809           hdrptr += 8;
2810           offset_size = 8;
2811           initial_length_size = 12;
2812         }
2813       else
2814         {
2815           offset_size = 4;
2816           initial_length_size = 4;
2817         }
2818
2819       if (linfo.li_length + initial_length_size > section->size)
2820         {
2821           warn (_("The line info appears to be corrupt - "
2822                   "the section is too small\n"));
2823           return 0;
2824         }
2825
2826       /* Get this CU's Line Number Block version number.  */
2827       linfo.li_version = byte_get (hdrptr, 2);
2828       hdrptr += 2;
2829       if (linfo.li_version != 2
2830           && linfo.li_version != 3
2831           && linfo.li_version != 4)
2832         {
2833           warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2834                 "supported.\n"));
2835           return 0;
2836         }
2837
2838       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2839       hdrptr += offset_size;
2840       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2841       hdrptr++;
2842       if (linfo.li_version >= 4)
2843         {
2844           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2845           hdrptr++;
2846           if (linfo.li_max_ops_per_insn == 0)
2847             {
2848               warn (_("Invalid maximum operations per insn.\n"));
2849               return 0;
2850             }
2851         }
2852       else
2853         linfo.li_max_ops_per_insn = 1;
2854       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2855       hdrptr++;
2856       linfo.li_line_base = byte_get (hdrptr, 1);
2857       hdrptr++;
2858       linfo.li_line_range = byte_get (hdrptr, 1);
2859       hdrptr++;
2860       linfo.li_opcode_base = byte_get (hdrptr, 1);
2861       hdrptr++;
2862
2863       /* Sign extend the line base field.  */
2864       linfo.li_line_base <<= 24;
2865       linfo.li_line_base >>= 24;
2866
2867       /* Find the end of this CU's Line Number Information Block.  */
2868       end_of_sequence = data + linfo.li_length + initial_length_size;
2869
2870       reset_state_machine (linfo.li_default_is_stmt);
2871
2872       /* Save a pointer to the contents of the Opcodes table.  */
2873       standard_opcodes = hdrptr;
2874
2875       /* Traverse the Directory table just to count entries.  */
2876       data = standard_opcodes + linfo.li_opcode_base - 1;
2877       if (*data != 0)
2878         {
2879           unsigned int n_directories = 0;
2880           unsigned char *ptr_directory_table = data;
2881
2882           while (*data != 0)
2883             {
2884               data += strlen ((char *) data) + 1;
2885               n_directories++;
2886             }
2887
2888           /* Go through the directory table again to save the directories.  */
2889           directory_table = (unsigned char **)
2890               xmalloc (n_directories * sizeof (unsigned char *));
2891
2892           i = 0;
2893           while (*ptr_directory_table != 0)
2894             {
2895               directory_table[i] = ptr_directory_table;
2896               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2897               i++;
2898             }
2899         }
2900       /* Skip the NUL at the end of the table.  */
2901       data++;
2902
2903       /* Traverse the File Name table just to count the entries.  */
2904       if (*data != 0)
2905         {
2906           unsigned int n_files = 0;
2907           unsigned char *ptr_file_name_table = data;
2908
2909           while (*data != 0)
2910             {
2911               unsigned int bytes_read;
2912
2913               /* Skip Name, directory index, last modification time and length
2914                  of file.  */
2915               data += strlen ((char *) data) + 1;
2916               read_leb128 (data, & bytes_read, 0);
2917               data += bytes_read;
2918               read_leb128 (data, & bytes_read, 0);
2919               data += bytes_read;
2920               read_leb128 (data, & bytes_read, 0);
2921               data += bytes_read;
2922
2923               n_files++;
2924             }
2925
2926           /* Go through the file table again to save the strings.  */
2927           file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2928
2929           i = 0;
2930           while (*ptr_file_name_table != 0)
2931             {
2932               unsigned int bytes_read;
2933
2934               file_table[i].name = ptr_file_name_table;
2935               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2936
2937               /* We are not interested in directory, time or size.  */
2938               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2939                                                            & bytes_read, 0);
2940               ptr_file_name_table += bytes_read;
2941               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2942                                                              & bytes_read, 0);
2943               ptr_file_name_table += bytes_read;
2944               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2945               ptr_file_name_table += bytes_read;
2946               i++;
2947             }
2948           i = 0;
2949
2950           /* Print the Compilation Unit's name and a header.  */
2951           if (directory_table == NULL)
2952             {
2953               printf (_("CU: %s:\n"), file_table[0].name);
2954               printf (_("File name                            Line number    Starting address\n"));
2955             }
2956           else
2957             {
2958               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2959                 printf (_("CU: %s/%s:\n"), directory_table[0],
2960                         file_table[0].name);
2961               else
2962                 printf ("%s:\n", file_table[0].name);
2963
2964               printf (_("File name                            Line number    Starting address\n"));
2965             }
2966         }
2967
2968       /* Skip the NUL at the end of the table.  */
2969       data++;
2970
2971       /* This loop iterates through the Dwarf Line Number Program.  */
2972       while (data < end_of_sequence)
2973         {
2974           unsigned char op_code;
2975           int adv;
2976           unsigned long int uladv;
2977           unsigned int bytes_read;
2978           int is_special_opcode = 0;
2979
2980           op_code = *data++;
2981
2982           if (op_code >= linfo.li_opcode_base)
2983             {
2984               op_code -= linfo.li_opcode_base;
2985               uladv = (op_code / linfo.li_line_range);
2986               if (linfo.li_max_ops_per_insn == 1)
2987                 {
2988                   uladv *= linfo.li_min_insn_length;
2989                   state_machine_regs.address += uladv;
2990                 }
2991               else
2992                 {
2993                   state_machine_regs.address
2994                     += ((state_machine_regs.op_index + uladv)
2995                         / linfo.li_max_ops_per_insn)
2996                        * linfo.li_min_insn_length;
2997                   state_machine_regs.op_index
2998                     = (state_machine_regs.op_index + uladv)
2999                       % linfo.li_max_ops_per_insn;
3000                 }
3001
3002               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3003               state_machine_regs.line += adv;
3004               is_special_opcode = 1;
3005             }
3006           else switch (op_code)
3007             {
3008             case DW_LNS_extended_op:
3009               {
3010                 unsigned int ext_op_code_len;
3011                 unsigned char ext_op_code;
3012                 unsigned char *op_code_data = data;
3013
3014                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3015                 op_code_data += bytes_read;
3016
3017                 if (ext_op_code_len == 0)
3018                   {
3019                     warn (_("badly formed extended line op encountered!\n"));
3020                     break;
3021                   }
3022                 ext_op_code_len += bytes_read;
3023                 ext_op_code = *op_code_data++;
3024
3025                 switch (ext_op_code)
3026                   {
3027                   case DW_LNE_end_sequence:
3028                     reset_state_machine (linfo.li_default_is_stmt);
3029                     break;
3030                   case DW_LNE_set_address:
3031                     state_machine_regs.address =
3032                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3033                     state_machine_regs.op_index = 0;
3034                     break;
3035                   case DW_LNE_define_file:
3036                     {
3037                       unsigned int dir_index = 0;
3038
3039                       ++state_machine_regs.last_file_entry;
3040                       op_code_data += strlen ((char *) op_code_data) + 1;
3041                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3042                       op_code_data += bytes_read;
3043                       read_leb128 (op_code_data, & bytes_read, 0);
3044                       op_code_data += bytes_read;
3045                       read_leb128 (op_code_data, & bytes_read, 0);
3046
3047                       printf ("%s:\n", directory_table[dir_index]);
3048                       break;
3049                     }
3050                   default:
3051                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3052                     break;
3053                   }
3054                 data += ext_op_code_len;
3055                 break;
3056               }
3057             case DW_LNS_copy:
3058               break;
3059
3060             case DW_LNS_advance_pc:
3061               uladv = read_leb128 (data, & bytes_read, 0);
3062               data += bytes_read;
3063               if (linfo.li_max_ops_per_insn == 1)
3064                 {
3065                   uladv *= linfo.li_min_insn_length;
3066                   state_machine_regs.address += uladv;
3067                 }
3068               else
3069                 {
3070                   state_machine_regs.address
3071                     += ((state_machine_regs.op_index + uladv)
3072                         / linfo.li_max_ops_per_insn)
3073                        * linfo.li_min_insn_length;
3074                   state_machine_regs.op_index
3075                     = (state_machine_regs.op_index + uladv)
3076                       % linfo.li_max_ops_per_insn;
3077                 }
3078               break;
3079
3080             case DW_LNS_advance_line:
3081               adv = read_sleb128 (data, & bytes_read);
3082               data += bytes_read;
3083               state_machine_regs.line += adv;
3084               break;
3085
3086             case DW_LNS_set_file:
3087               adv = read_leb128 (data, & bytes_read, 0);
3088               data += bytes_read;
3089               state_machine_regs.file = adv;
3090               if (file_table[state_machine_regs.file - 1].directory_index == 0)
3091                 {
3092                   /* If directory index is 0, that means current directory.  */
3093                   printf ("\n./%s:[++]\n",
3094                           file_table[state_machine_regs.file - 1].name);
3095                 }
3096               else
3097                 {
3098                   /* The directory index starts counting at 1.  */
3099                   printf ("\n%s/%s:\n",
3100                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3101                           file_table[state_machine_regs.file - 1].name);
3102                 }
3103               break;
3104
3105             case DW_LNS_set_column:
3106               uladv = read_leb128 (data, & bytes_read, 0);
3107               data += bytes_read;
3108               state_machine_regs.column = uladv;
3109               break;
3110
3111             case DW_LNS_negate_stmt:
3112               adv = state_machine_regs.is_stmt;
3113               adv = ! adv;
3114               state_machine_regs.is_stmt = adv;
3115               break;
3116
3117             case DW_LNS_set_basic_block:
3118               state_machine_regs.basic_block = 1;
3119               break;
3120
3121             case DW_LNS_const_add_pc:
3122               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3123               if (linfo.li_max_ops_per_insn == 1)
3124                 {
3125                   uladv *= linfo.li_min_insn_length;
3126                   state_machine_regs.address += uladv;
3127                 }
3128               else
3129                 {
3130                   state_machine_regs.address
3131                     += ((state_machine_regs.op_index + uladv)
3132                         / linfo.li_max_ops_per_insn)
3133                        * linfo.li_min_insn_length;
3134                   state_machine_regs.op_index
3135                     = (state_machine_regs.op_index + uladv)
3136                       % linfo.li_max_ops_per_insn;
3137                 }
3138               break;
3139
3140             case DW_LNS_fixed_advance_pc:
3141               uladv = byte_get (data, 2);
3142               data += 2;
3143               state_machine_regs.address += uladv;
3144               state_machine_regs.op_index = 0;
3145               break;
3146
3147             case DW_LNS_set_prologue_end:
3148               break;
3149
3150             case DW_LNS_set_epilogue_begin:
3151               break;
3152
3153             case DW_LNS_set_isa:
3154               uladv = read_leb128 (data, & bytes_read, 0);
3155               data += bytes_read;
3156               printf (_("  Set ISA to %lu\n"), uladv);
3157               break;
3158
3159             default:
3160               printf (_("  Unknown opcode %d with operands: "), op_code);
3161
3162               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3163                 {
3164                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3165                                                          &bytes_read, 0)),
3166                           i == 1 ? "" : ", ");
3167                   data += bytes_read;
3168                 }
3169               putchar ('\n');
3170               break;
3171             }
3172
3173           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3174              to the DWARF address/line matrix.  */
3175           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3176               || (op_code == DW_LNS_copy))
3177             {
3178               const unsigned int MAX_FILENAME_LENGTH = 35;
3179               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3180               char *newFileName = NULL;
3181               size_t fileNameLength = strlen (fileName);
3182
3183               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3184                 {
3185                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3186                   /* Truncate file name */
3187                   strncpy (newFileName,
3188                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3189                            MAX_FILENAME_LENGTH + 1);
3190                 }
3191               else
3192                 {
3193                   newFileName = (char *) xmalloc (fileNameLength + 1);
3194                   strncpy (newFileName, fileName, fileNameLength + 1);
3195                 }
3196
3197               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3198                 {
3199                   if (linfo.li_max_ops_per_insn == 1)
3200                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3201                             newFileName, state_machine_regs.line,
3202                             state_machine_regs.address);
3203                   else
3204                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3205                             newFileName, state_machine_regs.line,
3206                             state_machine_regs.address,
3207                             state_machine_regs.op_index);
3208                 }
3209               else
3210                 {
3211                   if (linfo.li_max_ops_per_insn == 1)
3212                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3213                             newFileName, state_machine_regs.line,
3214                             state_machine_regs.address);
3215                   else
3216                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3217                             newFileName, state_machine_regs.line,
3218                             state_machine_regs.address,
3219                             state_machine_regs.op_index);
3220                 }
3221
3222               if (op_code == DW_LNE_end_sequence)
3223                 printf ("\n");
3224
3225               free (newFileName);
3226             }
3227         }
3228       free (file_table);
3229       file_table = NULL;
3230       free (directory_table);
3231       directory_table = NULL;
3232       putchar ('\n');
3233     }
3234
3235   return 1;
3236 }
3237
3238 static int
3239 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3240 {
3241   unsigned char *data = section->start;
3242   unsigned char *end = data + section->size;
3243   int retValRaw = 1;
3244   int retValDecoded = 1;
3245
3246   if (do_debug_lines == 0)
3247     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3248
3249   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3250     retValRaw = display_debug_lines_raw (section, data, end);
3251
3252   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3253     retValDecoded = display_debug_lines_decoded (section, data, end);
3254
3255   if (!retValRaw || !retValDecoded)
3256     return 0;
3257
3258   return 1;
3259 }
3260
3261 static debug_info *
3262 find_debug_info_for_offset (unsigned long offset)
3263 {
3264   unsigned int i;
3265
3266   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3267     return NULL;
3268
3269   for (i = 0; i < num_debug_info_entries; i++)
3270     if (debug_information[i].cu_offset == offset)
3271       return debug_information + i;
3272
3273   return NULL;
3274 }
3275
3276 static int
3277 display_debug_pubnames (struct dwarf_section *section,
3278                         void *file ATTRIBUTE_UNUSED)
3279 {
3280   DWARF2_Internal_PubNames names;
3281   unsigned char *start = section->start;
3282   unsigned char *end = start + section->size;
3283
3284   /* It does not matter if this load fails,
3285      we test for that later on.  */
3286   load_debug_info (file);
3287
3288   printf (_("Contents of the %s section:\n\n"), section->name);
3289
3290   while (start < end)
3291     {
3292       unsigned char *data;
3293       unsigned long offset;
3294       int offset_size, initial_length_size;
3295
3296       data = start;
3297
3298       names.pn_length = byte_get (data, 4);
3299       data += 4;
3300       if (names.pn_length == 0xffffffff)
3301         {
3302           names.pn_length = byte_get (data, 8);
3303           data += 8;
3304           offset_size = 8;
3305           initial_length_size = 12;
3306         }
3307       else
3308         {
3309           offset_size = 4;
3310           initial_length_size = 4;
3311         }
3312
3313       names.pn_version = byte_get (data, 2);
3314       data += 2;
3315
3316       names.pn_offset = byte_get (data, offset_size);
3317       data += offset_size;
3318
3319       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3320           && num_debug_info_entries > 0
3321           && find_debug_info_for_offset (names.pn_offset) == NULL)
3322         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3323               (unsigned long) names.pn_offset, section->name);
3324
3325       names.pn_size = byte_get (data, offset_size);
3326       data += offset_size;
3327
3328       start += names.pn_length + initial_length_size;
3329
3330       if (names.pn_version != 2 && names.pn_version != 3)
3331         {
3332           static int warned = 0;
3333
3334           if (! warned)
3335             {
3336               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3337               warned = 1;
3338             }
3339
3340           continue;
3341         }
3342
3343       printf (_("  Length:                              %ld\n"),
3344               (long) names.pn_length);
3345       printf (_("  Version:                             %d\n"),
3346               names.pn_version);
3347       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3348               (unsigned long) names.pn_offset);
3349       printf (_("  Size of area in .debug_info section: %ld\n"),
3350               (long) names.pn_size);
3351
3352       printf (_("\n    Offset\tName\n"));
3353
3354       do
3355         {
3356           offset = byte_get (data, offset_size);
3357
3358           if (offset != 0)
3359             {
3360               data += offset_size;
3361               printf ("    %-6lx\t%s\n", offset, data);
3362               data += strlen ((char *) data) + 1;
3363             }
3364         }
3365       while (offset != 0);
3366     }
3367
3368   printf ("\n");
3369   return 1;
3370 }
3371
3372 static int
3373 display_debug_macinfo (struct dwarf_section *section,
3374                        void *file ATTRIBUTE_UNUSED)
3375 {
3376   unsigned char *start = section->start;
3377   unsigned char *end = start + section->size;
3378   unsigned char *curr = start;
3379   unsigned int bytes_read;
3380   enum dwarf_macinfo_record_type op;
3381
3382   printf (_("Contents of the %s section:\n\n"), section->name);
3383
3384   while (curr < end)
3385     {
3386       unsigned int lineno;
3387       const char *string;
3388
3389       op = (enum dwarf_macinfo_record_type) *curr;
3390       curr++;
3391
3392       switch (op)
3393         {
3394         case DW_MACINFO_start_file:
3395           {
3396             unsigned int filenum;
3397
3398             lineno = read_leb128 (curr, & bytes_read, 0);
3399             curr += bytes_read;
3400             filenum = read_leb128 (curr, & bytes_read, 0);
3401             curr += bytes_read;
3402
3403             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3404                     lineno, filenum);
3405           }
3406           break;
3407
3408         case DW_MACINFO_end_file:
3409           printf (_(" DW_MACINFO_end_file\n"));
3410           break;
3411
3412         case DW_MACINFO_define:
3413           lineno = read_leb128 (curr, & bytes_read, 0);
3414           curr += bytes_read;
3415           string = (char *) curr;
3416           curr += strlen (string) + 1;
3417           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3418                   lineno, string);
3419           break;
3420
3421         case DW_MACINFO_undef:
3422           lineno = read_leb128 (curr, & bytes_read, 0);
3423           curr += bytes_read;
3424           string = (char *) curr;
3425           curr += strlen (string) + 1;
3426           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3427                   lineno, string);
3428           break;
3429
3430         case DW_MACINFO_vendor_ext:
3431           {
3432             unsigned int constant;
3433
3434             constant = read_leb128 (curr, & bytes_read, 0);
3435             curr += bytes_read;
3436             string = (char *) curr;
3437             curr += strlen (string) + 1;
3438             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3439                     constant, string);
3440           }
3441           break;
3442         }
3443     }
3444
3445   return 1;
3446 }
3447
3448 static int
3449 display_debug_abbrev (struct dwarf_section *section,
3450                       void *file ATTRIBUTE_UNUSED)
3451 {
3452   abbrev_entry *entry;
3453   unsigned char *start = section->start;
3454   unsigned char *end = start + section->size;
3455
3456   printf (_("Contents of the %s section:\n\n"), section->name);
3457
3458   do
3459     {
3460       free_abbrevs ();
3461
3462       start = process_abbrev_section (start, end);
3463
3464       if (first_abbrev == NULL)
3465         continue;
3466
3467       printf (_("  Number TAG\n"));
3468
3469       for (entry = first_abbrev; entry; entry = entry->next)
3470         {
3471           abbrev_attr *attr;
3472
3473           printf ("   %ld      %s    [%s]\n",
3474                   entry->entry,
3475                   get_TAG_name (entry->tag),
3476                   entry->children ? _("has children") : _("no children"));
3477
3478           for (attr = entry->first_attr; attr; attr = attr->next)
3479             printf ("    %-18s %s\n",
3480                     get_AT_name (attr->attribute),
3481                     get_FORM_name (attr->form));
3482         }
3483     }
3484   while (start);
3485
3486   printf ("\n");
3487
3488   return 1;
3489 }
3490
3491 static int
3492 display_debug_loc (struct dwarf_section *section, void *file)
3493 {
3494   unsigned char *start = section->start;
3495   unsigned char *section_end;
3496   unsigned long bytes;
3497   unsigned char *section_begin = start;
3498   unsigned int num_loc_list = 0;
3499   unsigned long last_offset = 0;
3500   unsigned int first = 0;
3501   unsigned int i;
3502   unsigned int j;
3503   int seen_first_offset = 0;
3504   int use_debug_info = 1;
3505   unsigned char *next;
3506
3507   bytes = section->size;
3508   section_end = start + bytes;
3509
3510   if (bytes == 0)
3511     {
3512       printf (_("\nThe %s section is empty.\n"), section->name);
3513       return 0;
3514     }
3515
3516   if (load_debug_info (file) == 0)
3517     {
3518       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3519             section->name);
3520       return 0;
3521     }
3522
3523   /* Check the order of location list in .debug_info section. If
3524      offsets of location lists are in the ascending order, we can
3525      use `debug_information' directly.  */
3526   for (i = 0; i < num_debug_info_entries; i++)
3527     {
3528       unsigned int num;
3529
3530       num = debug_information [i].num_loc_offsets;
3531       num_loc_list += num;
3532
3533       /* Check if we can use `debug_information' directly.  */
3534       if (use_debug_info && num != 0)
3535         {
3536           if (!seen_first_offset)
3537             {
3538               /* This is the first location list.  */
3539               last_offset = debug_information [i].loc_offsets [0];
3540               first = i;
3541               seen_first_offset = 1;
3542               j = 1;
3543             }
3544           else
3545             j = 0;
3546
3547           for (; j < num; j++)
3548             {
3549               if (last_offset >
3550                   debug_information [i].loc_offsets [j])
3551                 {
3552                   use_debug_info = 0;
3553                   break;
3554                 }
3555               last_offset = debug_information [i].loc_offsets [j];
3556             }
3557         }
3558     }
3559
3560   if (!use_debug_info)
3561     /* FIXME: Should we handle this case?  */
3562     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3563
3564   if (!seen_first_offset)
3565     error (_("No location lists in .debug_info section!\n"));
3566
3567   /* DWARF sections under Mach-O have non-zero addresses.  */
3568   if (debug_information [first].num_loc_offsets > 0
3569       && debug_information [first].loc_offsets [0] != section->address)
3570     warn (_("Location lists in %s section start at 0x%s\n"),
3571           section->name,
3572           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
3573
3574   printf (_("Contents of the %s section:\n\n"), section->name);
3575   printf (_("    Offset   Begin    End      Expression\n"));
3576
3577   seen_first_offset = 0;
3578   for (i = first; i < num_debug_info_entries; i++)
3579     {
3580       dwarf_vma begin;
3581       dwarf_vma end;
3582       unsigned short length;
3583       unsigned long offset;
3584       unsigned int pointer_size;
3585       unsigned int offset_size;
3586       int dwarf_version;
3587       unsigned long cu_offset;
3588       unsigned long base_address;
3589       int need_frame_base;
3590       int has_frame_base;
3591
3592       pointer_size = debug_information [i].pointer_size;
3593       cu_offset = debug_information [i].cu_offset;
3594       offset_size = debug_information [i].offset_size;
3595       dwarf_version = debug_information [i].dwarf_version;
3596
3597       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3598         {
3599           has_frame_base = debug_information [i].have_frame_base [j];
3600           /* DWARF sections under Mach-O have non-zero addresses.  */
3601           offset = debug_information [i].loc_offsets [j] - section->address;
3602           next = section_begin + offset;
3603           base_address = debug_information [i].base_address;
3604
3605           if (!seen_first_offset)
3606             seen_first_offset = 1;
3607           else
3608             {
3609               if (start < next)
3610                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3611                       (unsigned long) (start - section_begin),
3612                       (unsigned long) (next - section_begin));
3613               else if (start > next)
3614                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3615                       (unsigned long) (start - section_begin),
3616                       (unsigned long) (next - section_begin));
3617             }
3618           start = next;
3619
3620           if (offset >= bytes)
3621             {
3622               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3623                     offset);
3624               continue;
3625             }
3626
3627           while (1)
3628             {
3629               if (start + 2 * pointer_size > section_end)
3630                 {
3631                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3632                         offset);
3633                   break;
3634                 }
3635
3636               /* Note: we use sign extension here in order to be sure that
3637                  we can detect the -1 escape value.  Sign extension into the
3638                  top 32 bits of a 32-bit address will not affect the values
3639                  that we display since we always show hex values, and always
3640                  the bottom 32-bits.  */
3641               begin = byte_get_signed (start, pointer_size);
3642               start += pointer_size;
3643               end = byte_get_signed (start, pointer_size);
3644               start += pointer_size;
3645
3646               printf ("    %8.8lx ", offset);
3647
3648               if (begin == 0 && end == 0)
3649                 {
3650                   printf (_("<End of list>\n"));
3651                   break;
3652                 }
3653
3654               /* Check base address specifiers.  */
3655               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3656                 {
3657                   base_address = end;
3658                   print_dwarf_vma (begin, pointer_size);
3659                   print_dwarf_vma (end, pointer_size);
3660                   printf (_("(base address)\n"));
3661                   continue;
3662                 }
3663
3664               if (start + 2 > section_end)
3665                 {
3666                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3667                         offset);
3668                   break;
3669                 }
3670
3671               length = byte_get (start, 2);
3672               start += 2;
3673
3674               if (start + length > section_end)
3675                 {
3676                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3677                         offset);
3678                   break;
3679                 }
3680
3681               print_dwarf_vma (begin + base_address, pointer_size);
3682               print_dwarf_vma (end + base_address, pointer_size);
3683
3684               putchar ('(');
3685               need_frame_base = decode_location_expression (start,
3686                                                             pointer_size,
3687                                                             offset_size,
3688                                                             dwarf_version,
3689                                                             length,
3690                                                             cu_offset, section);
3691               putchar (')');
3692
3693               if (need_frame_base && !has_frame_base)
3694                 printf (_(" [without DW_AT_frame_base]"));
3695
3696               if (begin == end)
3697                 fputs (_(" (start == end)"), stdout);
3698               else if (begin > end)
3699                 fputs (_(" (start > end)"), stdout);
3700
3701               putchar ('\n');
3702
3703               start += length;
3704             }
3705         }
3706     }
3707
3708   if (start < section_end)
3709     warn (_("There are %ld unused bytes at the end of section %s\n"),
3710           (long) (section_end - start), section->name);
3711   putchar ('\n');
3712   return 1;
3713 }
3714
3715 static int
3716 display_debug_str (struct dwarf_section *section,
3717                    void *file ATTRIBUTE_UNUSED)
3718 {
3719   unsigned char *start = section->start;
3720   unsigned long bytes = section->size;
3721   dwarf_vma addr = section->address;
3722
3723   if (bytes == 0)
3724     {
3725       printf (_("\nThe %s section is empty.\n"), section->name);
3726       return 0;
3727     }
3728
3729   printf (_("Contents of the %s section:\n\n"), section->name);
3730
3731   while (bytes)
3732     {
3733       int j;
3734       int k;
3735       int lbytes;
3736
3737       lbytes = (bytes > 16 ? 16 : bytes);
3738
3739       printf ("  0x%8.8lx ", (unsigned long) addr);
3740
3741       for (j = 0; j < 16; j++)
3742         {
3743           if (j < lbytes)
3744             printf ("%2.2x", start[j]);
3745           else
3746             printf ("  ");
3747
3748           if ((j & 3) == 3)
3749             printf (" ");
3750         }
3751
3752       for (j = 0; j < lbytes; j++)
3753         {
3754           k = start[j];
3755           if (k >= ' ' && k < 0x80)
3756             printf ("%c", k);
3757           else
3758             printf (".");
3759         }
3760
3761       putchar ('\n');
3762
3763       start += lbytes;
3764       addr  += lbytes;
3765       bytes -= lbytes;
3766     }
3767
3768   putchar ('\n');
3769
3770   return 1;
3771 }
3772
3773 static int
3774 display_debug_info (struct dwarf_section *section, void *file)
3775 {
3776   return process_debug_info (section, file, abbrev, 0, 0);
3777 }
3778
3779 static int
3780 display_debug_types (struct dwarf_section *section, void *file)
3781 {
3782   return process_debug_info (section, file, abbrev, 0, 1);
3783 }
3784
3785 static int
3786 display_trace_info (struct dwarf_section *section, void *file)
3787 {
3788   return process_debug_info (section, file, trace_abbrev, 0, 0);
3789 }
3790
3791 static int
3792 display_debug_aranges (struct dwarf_section *section,
3793                        void *file ATTRIBUTE_UNUSED)
3794 {
3795   unsigned char *start = section->start;
3796   unsigned char *end = start + section->size;
3797
3798   printf (_("Contents of the %s section:\n\n"), section->name);
3799
3800   /* It does not matter if this load fails,
3801      we test for that later on.  */
3802   load_debug_info (file);
3803
3804   while (start < end)
3805     {
3806       unsigned char *hdrptr;
3807       DWARF2_Internal_ARange arange;
3808       unsigned char *addr_ranges;
3809       dwarf_vma length;
3810       dwarf_vma address;
3811       unsigned char address_size;
3812       int excess;
3813       int offset_size;
3814       int initial_length_size;
3815
3816       hdrptr = start;
3817
3818       arange.ar_length = byte_get (hdrptr, 4);
3819       hdrptr += 4;
3820
3821       if (arange.ar_length == 0xffffffff)
3822         {
3823           arange.ar_length = byte_get (hdrptr, 8);
3824           hdrptr += 8;
3825           offset_size = 8;
3826           initial_length_size = 12;
3827         }
3828       else
3829         {
3830           offset_size = 4;
3831           initial_length_size = 4;
3832         }
3833
3834       arange.ar_version = byte_get (hdrptr, 2);
3835       hdrptr += 2;
3836
3837       arange.ar_info_offset = byte_get (hdrptr, offset_size);
3838       hdrptr += offset_size;
3839
3840       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3841           && num_debug_info_entries > 0
3842           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3843         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3844               (unsigned long) arange.ar_info_offset, section->name);
3845
3846       arange.ar_pointer_size = byte_get (hdrptr, 1);
3847       hdrptr += 1;
3848
3849       arange.ar_segment_size = byte_get (hdrptr, 1);
3850       hdrptr += 1;
3851
3852       if (arange.ar_version != 2 && arange.ar_version != 3)
3853         {
3854           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3855           break;
3856         }
3857
3858       printf (_("  Length:                   %ld\n"),
3859               (long) arange.ar_length);
3860       printf (_("  Version:                  %d\n"), arange.ar_version);
3861       printf (_("  Offset into .debug_info:  0x%lx\n"),
3862               (unsigned long) arange.ar_info_offset);
3863       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
3864       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
3865
3866       address_size = arange.ar_pointer_size + arange.ar_segment_size;
3867
3868       /* The DWARF spec does not require that the address size be a power
3869          of two, but we do.  This will have to change if we ever encounter
3870          an uneven architecture.  */
3871       if ((address_size & (address_size - 1)) != 0)
3872         {
3873           warn (_("Pointer size + Segment size is not a power of two.\n"));
3874           break;
3875         }
3876
3877       if (address_size > 4)
3878         printf (_("\n    Address            Length\n"));
3879       else
3880         printf (_("\n    Address    Length\n"));
3881
3882       addr_ranges = hdrptr;
3883
3884       /* Must pad to an alignment boundary that is twice the address size.  */
3885       excess = (hdrptr - start) % (2 * address_size);
3886       if (excess)
3887         addr_ranges += (2 * address_size) - excess;
3888
3889       start += arange.ar_length + initial_length_size;
3890
3891       while (addr_ranges + 2 * address_size <= start)
3892         {
3893           address = byte_get (addr_ranges, address_size);
3894
3895           addr_ranges += address_size;
3896
3897           length  = byte_get (addr_ranges, address_size);
3898
3899           addr_ranges += address_size;
3900
3901           printf ("    ");
3902           print_dwarf_vma (address, address_size);
3903           print_dwarf_vma (length, address_size);
3904           putchar ('\n');
3905         }
3906     }
3907
3908   printf ("\n");
3909
3910   return 1;
3911 }
3912
3913 /* Each debug_information[x].range_lists[y] gets this representation for
3914    sorting purposes.  */
3915
3916 struct range_entry
3917 {
3918   /* The debug_information[x].range_lists[y] value.  */
3919   unsigned long ranges_offset;
3920
3921   /* Original debug_information to find parameters of the data.  */
3922   debug_info *debug_info_p;
3923 };
3924
3925 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
3926
3927 static int
3928 range_entry_compar (const void *ap, const void *bp)
3929 {
3930   const struct range_entry *a_re = (const struct range_entry *) ap;
3931   const struct range_entry *b_re = (const struct range_entry *) bp;
3932   const unsigned long a = a_re->ranges_offset;
3933   const unsigned long b = b_re->ranges_offset;
3934
3935   return (a > b) - (b > a);
3936 }
3937
3938 static int
3939 display_debug_ranges (struct dwarf_section *section,
3940                       void *file ATTRIBUTE_UNUSED)
3941 {
3942   unsigned char *start = section->start;
3943   unsigned long bytes;
3944   unsigned char *section_begin = start;
3945   unsigned int num_range_list, i;
3946   struct range_entry *range_entries, *range_entry_fill;
3947
3948   bytes = section->size;
3949
3950   if (bytes == 0)
3951     {
3952       printf (_("\nThe %s section is empty.\n"), section->name);
3953       return 0;
3954     }
3955
3956   if (load_debug_info (file) == 0)
3957     {
3958       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3959             section->name);
3960       return 0;
3961     }
3962
3963   num_range_list = 0;
3964   for (i = 0; i < num_debug_info_entries; i++)
3965     num_range_list += debug_information [i].num_range_lists;
3966
3967   if (num_range_list == 0)
3968     error (_("No range lists in .debug_info section!\n"));
3969
3970   range_entries = (struct range_entry *)
3971       xmalloc (sizeof (*range_entries) * num_range_list);
3972   range_entry_fill = range_entries;
3973
3974   for (i = 0; i < num_debug_info_entries; i++)
3975     {
3976       debug_info *debug_info_p = &debug_information[i];
3977       unsigned int j;
3978
3979       for (j = 0; j < debug_info_p->num_range_lists; j++)
3980         {
3981           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
3982           range_entry_fill->debug_info_p = debug_info_p;
3983           range_entry_fill++;
3984         }
3985     }
3986
3987   qsort (range_entries, num_range_list, sizeof (*range_entries),
3988          range_entry_compar);
3989
3990   /* DWARF sections under Mach-O have non-zero addresses.  */
3991   if (range_entries[0].ranges_offset != section->address)
3992     warn (_("Range lists in %s section start at 0x%lx\n"),
3993           section->name, range_entries[0].ranges_offset);
3994
3995   printf (_("Contents of the %s section:\n\n"), section->name);
3996   printf (_("    Offset   Begin    End\n"));
3997
3998   for (i = 0; i < num_range_list; i++)
3999     {
4000       struct range_entry *range_entry = &range_entries[i];
4001       debug_info *debug_info_p = range_entry->debug_info_p;
4002       unsigned int pointer_size;
4003       unsigned long offset;
4004       unsigned char *next;
4005       unsigned long base_address;
4006
4007       pointer_size = debug_info_p->pointer_size;
4008
4009       /* DWARF sections under Mach-O have non-zero addresses.  */
4010       offset = range_entry->ranges_offset - section->address;
4011       next = section_begin + offset;
4012       base_address = debug_info_p->base_address;
4013
4014       if (i > 0)
4015         {
4016           if (start < next)
4017             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4018                   (unsigned long) (start - section_begin),
4019                   (unsigned long) (next - section_begin), section->name);
4020           else if (start > next)
4021             warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4022                   (unsigned long) (start - section_begin),
4023                   (unsigned long) (next - section_begin), section->name);
4024         }
4025       start = next;
4026
4027       while (1)
4028         {
4029           dwarf_vma begin;
4030           dwarf_vma end;
4031
4032           /* Note: we use sign extension here in order to be sure that
4033              we can detect the -1 escape value.  Sign extension into the
4034              top 32 bits of a 32-bit address will not affect the values
4035              that we display since we always show hex values, and always
4036              the bottom 32-bits.  */
4037           begin = byte_get_signed (start, pointer_size);
4038           start += pointer_size;
4039           end = byte_get_signed (start, pointer_size);
4040           start += pointer_size;
4041
4042           printf ("    %8.8lx ", offset);
4043
4044           if (begin == 0 && end == 0)
4045             {
4046               printf (_("<End of list>\n"));
4047               break;
4048             }
4049
4050           /* Check base address specifiers.  */
4051           if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4052             {
4053               base_address = end;
4054               print_dwarf_vma (begin, pointer_size);
4055               print_dwarf_vma (end, pointer_size);
4056               printf ("(base address)\n");
4057               continue;
4058             }
4059
4060           print_dwarf_vma (begin + base_address, pointer_size);
4061           print_dwarf_vma (end + base_address, pointer_size);
4062
4063           if (begin == end)
4064             fputs (_("(start == end)"), stdout);
4065           else if (begin > end)
4066             fputs (_("(start > end)"), stdout);
4067
4068           putchar ('\n');
4069         }
4070     }
4071   putchar ('\n');
4072
4073   free (range_entries);
4074
4075   return 1;
4076 }
4077
4078 typedef struct Frame_Chunk
4079 {
4080   struct Frame_Chunk *next;
4081   unsigned char *chunk_start;
4082   int ncols;
4083   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
4084   short int *col_type;
4085   int *col_offset;
4086   char *augmentation;
4087   unsigned int code_factor;
4088   int data_factor;
4089   unsigned long pc_begin;
4090   unsigned long pc_range;
4091   int cfa_reg;
4092   int cfa_offset;
4093   int ra;
4094   unsigned char fde_encoding;
4095   unsigned char cfa_exp;
4096   unsigned char ptr_size;
4097   unsigned char segment_size;
4098 }
4099 Frame_Chunk;
4100
4101 static const char *const *dwarf_regnames;
4102 static unsigned int dwarf_regnames_count;
4103
4104 /* A marker for a col_type that means this column was never referenced
4105    in the frame info.  */
4106 #define DW_CFA_unreferenced (-1)
4107
4108 /* Return 0 if not more space is needed, 1 if more space is needed,
4109    -1 for invalid reg.  */
4110
4111 static int
4112 frame_need_space (Frame_Chunk *fc, unsigned int reg)
4113 {
4114   int prev = fc->ncols;
4115
4116   if (reg < (unsigned int) fc->ncols)
4117     return 0;
4118
4119   if (dwarf_regnames_count
4120       && reg > dwarf_regnames_count)
4121     return -1;
4122
4123   fc->ncols = reg + 1;
4124   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4125                                           sizeof (short int));
4126   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
4127
4128   while (prev < fc->ncols)
4129     {
4130       fc->col_type[prev] = DW_CFA_unreferenced;
4131       fc->col_offset[prev] = 0;
4132       prev++;
4133     }
4134   return 1;
4135 }
4136
4137 static const char *const dwarf_regnames_i386[] =
4138 {
4139   "eax", "ecx", "edx", "ebx",
4140   "esp", "ebp", "esi", "edi",
4141   "eip", "eflags", NULL,
4142   "st0", "st1", "st2", "st3",
4143   "st4", "st5", "st6", "st7",
4144   NULL, NULL,
4145   "xmm0", "xmm1", "xmm2", "xmm3",
4146   "xmm4", "xmm5", "xmm6", "xmm7",
4147   "mm0", "mm1", "mm2", "mm3",
4148   "mm4", "mm5", "mm6", "mm7",
4149   "fcw", "fsw", "mxcsr",
4150   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4151   "tr", "ldtr"
4152 };
4153
4154 void
4155 init_dwarf_regnames_i386 (void)
4156 {
4157   dwarf_regnames = dwarf_regnames_i386;
4158   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4159 }
4160
4161 static const char *const dwarf_regnames_x86_64[] =
4162 {
4163   "rax", "rdx", "rcx", "rbx",
4164   "rsi", "rdi", "rbp", "rsp",
4165   "r8",  "r9",  "r10", "r11",
4166   "r12", "r13", "r14", "r15",
4167   "rip",
4168   "xmm0",  "xmm1",  "xmm2",  "xmm3",
4169   "xmm4",  "xmm5",  "xmm6",  "xmm7",
4170   "xmm8",  "xmm9",  "xmm10", "xmm11",
4171   "xmm12", "xmm13", "xmm14", "xmm15",
4172   "st0", "st1", "st2", "st3",
4173   "st4", "st5", "st6", "st7",
4174   "mm0", "mm1", "mm2", "mm3",
4175   "mm4", "mm5", "mm6", "mm7",
4176   "rflags",
4177   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4178   "fs.base", "gs.base", NULL, NULL,
4179   "tr", "ldtr",
4180   "mxcsr", "fcw", "fsw"
4181 };
4182
4183 void
4184 init_dwarf_regnames_x86_64 (void)
4185 {
4186   dwarf_regnames = dwarf_regnames_x86_64;
4187   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4188 }
4189
4190 void
4191 init_dwarf_regnames (unsigned int e_machine)
4192 {
4193   switch (e_machine)
4194     {
4195     case EM_386:
4196     case EM_486:
4197       init_dwarf_regnames_i386 ();
4198       break;
4199
4200     case EM_X86_64:
4201     case EM_L1OM:
4202       init_dwarf_regnames_x86_64 ();
4203       break;
4204
4205     default:
4206       break;
4207     }
4208 }
4209
4210 static const char *
4211 regname (unsigned int regno, int row)
4212 {
4213   static char reg[64];
4214   if (dwarf_regnames
4215       && regno < dwarf_regnames_count
4216       && dwarf_regnames [regno] != NULL)
4217     {
4218       if (row)
4219         return dwarf_regnames [regno];
4220       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4221                 dwarf_regnames [regno]);
4222     }
4223   else
4224     snprintf (reg, sizeof (reg), "r%d", regno);
4225   return reg;
4226 }
4227
4228 static void
4229 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4230 {
4231   int r;
4232   char tmp[100];
4233
4234   if (*max_regs < fc->ncols)
4235     *max_regs = fc->ncols;
4236
4237   if (*need_col_headers)
4238     {
4239       static const char *sloc = "   LOC";
4240
4241       *need_col_headers = 0;
4242
4243       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
4244
4245       for (r = 0; r < *max_regs; r++)
4246         if (fc->col_type[r] != DW_CFA_unreferenced)
4247           {
4248             if (r == fc->ra)
4249               printf ("ra      ");
4250             else
4251               printf ("%-5s ", regname (r, 1));
4252           }
4253
4254       printf ("\n");
4255     }
4256
4257   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4258   if (fc->cfa_exp)
4259     strcpy (tmp, "exp");
4260   else
4261     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4262   printf ("%-8s ", tmp);
4263
4264   for (r = 0; r < fc->ncols; r++)
4265     {
4266       if (fc->col_type[r] != DW_CFA_unreferenced)
4267         {
4268           switch (fc->col_type[r])
4269             {
4270             case DW_CFA_undefined:
4271               strcpy (tmp, "u");
4272               break;
4273             case DW_CFA_same_value:
4274               strcpy (tmp, "s");
4275               break;
4276             case DW_CFA_offset:
4277               sprintf (tmp, "c%+d", fc->col_offset[r]);
4278               break;
4279             case DW_CFA_val_offset:
4280               sprintf (tmp, "v%+d", fc->col_offset[r]);
4281               break;
4282             case DW_CFA_register:
4283               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4284               break;
4285             case DW_CFA_expression:
4286               strcpy (tmp, "exp");
4287               break;
4288             case DW_CFA_val_expression:
4289               strcpy (tmp, "vexp");
4290               break;
4291             default:
4292               strcpy (tmp, "n/a");
4293               break;
4294             }
4295           printf ("%-5s ", tmp);
4296         }
4297     }
4298   printf ("\n");
4299 }
4300
4301 #define GET(N)  byte_get (start, N); start += N
4302 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
4303 #define SLEB()  read_sleb128 (start, & length_return); start += length_return
4304
4305 static int
4306 display_debug_frames (struct dwarf_section *section,
4307                       void *file ATTRIBUTE_UNUSED)
4308 {
4309   unsigned char *start = section->start;
4310   unsigned char *end = start + section->size;
4311   unsigned char *section_start = start;
4312   Frame_Chunk *chunks = 0;
4313   Frame_Chunk *remembered_state = 0;
4314   Frame_Chunk *rs;
4315   int is_eh = strcmp (section->name, ".eh_frame") == 0;
4316   unsigned int length_return;
4317   int max_regs = 0;
4318   const char *bad_reg = _("bad register: ");
4319   int saved_eh_addr_size = eh_addr_size;
4320
4321   printf (_("Contents of the %s section:\n"), section->name);
4322
4323   while (start < end)
4324     {
4325       unsigned char *saved_start;
4326       unsigned char *block_end;
4327       unsigned long length;
4328       unsigned long cie_id;
4329       Frame_Chunk *fc;
4330       Frame_Chunk *cie;
4331       int need_col_headers = 1;
4332       unsigned char *augmentation_data = NULL;
4333       unsigned long augmentation_data_len = 0;
4334       int encoded_ptr_size = saved_eh_addr_size;
4335       int offset_size;
4336       int initial_length_size;
4337
4338       saved_start = start;
4339       length = byte_get (start, 4); start += 4;
4340
4341       if (length == 0)
4342         {
4343           printf ("\n%08lx ZERO terminator\n\n",
4344                     (unsigned long)(saved_start - section_start));
4345           continue;
4346         }
4347
4348       if (length == 0xffffffff)
4349         {
4350           length = byte_get (start, 8);
4351           start += 8;
4352           offset_size = 8;
4353           initial_length_size = 12;
4354         }
4355       else
4356         {
4357           offset_size = 4;
4358           initial_length_size = 4;
4359         }
4360
4361       block_end = saved_start + length + initial_length_size;
4362       if (block_end > end)
4363         {
4364           warn ("Invalid length %#08lx in FDE at %#08lx\n",
4365                 length, (unsigned long)(saved_start - section_start));
4366           block_end = end;
4367         }
4368       cie_id = byte_get (start, offset_size); start += offset_size;
4369
4370       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4371         {
4372           int version;
4373
4374           fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4375           memset (fc, 0, sizeof (Frame_Chunk));
4376
4377           fc->next = chunks;
4378           chunks = fc;
4379           fc->chunk_start = saved_start;
4380           fc->ncols = 0;
4381           fc->col_type = (short int *) xmalloc (sizeof (short int));
4382           fc->col_offset = (int *) xmalloc (sizeof (int));
4383           frame_need_space (fc, max_regs - 1);
4384
4385           version = *start++;
4386
4387           fc->augmentation = (char *) start;
4388           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4389
4390           if (strcmp (fc->augmentation, "eh") == 0)
4391             start += eh_addr_size;
4392
4393           if (version >= 4)
4394             {
4395               fc->ptr_size = GET (1);
4396               fc->segment_size = GET (1);
4397               eh_addr_size = fc->ptr_size;
4398             }
4399           else
4400             {
4401               fc->ptr_size = eh_addr_size;
4402               fc->segment_size = 0;
4403             }
4404           fc->code_factor = LEB ();
4405           fc->data_factor = SLEB ();
4406           if (version == 1)
4407             {
4408               fc->ra = GET (1);
4409             }
4410           else
4411             {
4412               fc->ra = LEB ();
4413             }
4414
4415           if (fc->augmentation[0] == 'z')
4416             {
4417               augmentation_data_len = LEB ();
4418               augmentation_data = start;
4419               start += augmentation_data_len;
4420             }
4421           cie = fc;
4422
4423           if (do_debug_frames_interp)
4424             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4425                     (unsigned long)(saved_start - section_start), length, cie_id,
4426                     fc->augmentation, fc->code_factor, fc->data_factor,
4427                     fc->ra);
4428           else
4429             {
4430               printf ("\n%08lx %08lx %08lx CIE\n",
4431                       (unsigned long)(saved_start - section_start), length, cie_id);
4432               printf ("  Version:               %d\n", version);
4433               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
4434               if (version >= 4)
4435                 {
4436                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
4437                   printf ("  Segment Size:          %u\n", fc->segment_size);
4438                 }
4439               printf ("  Code alignment factor: %u\n", fc->code_factor);
4440               printf ("  Data alignment factor: %d\n", fc->data_factor);
4441               printf ("  Return address column: %d\n", fc->ra);
4442
4443               if (augmentation_data_len)
4444                 {
4445                   unsigned long i;
4446                   printf ("  Augmentation data:    ");
4447                   for (i = 0; i < augmentation_data_len; ++i)
4448                     printf (" %02x", augmentation_data[i]);
4449                   putchar ('\n');
4450                 }
4451               putchar ('\n');
4452             }
4453
4454           if (augmentation_data_len)
4455             {
4456               unsigned char *p, *q;
4457               p = (unsigned char *) fc->augmentation + 1;
4458               q = augmentation_data;
4459
4460               while (1)
4461                 {
4462                   if (*p == 'L')
4463                     q++;
4464                   else if (*p == 'P')
4465                     q += 1 + size_of_encoded_value (*q);
4466                   else if (*p == 'R')
4467                     fc->fde_encoding = *q++;
4468                   else if (*p == 'S')
4469                     ;
4470                   else
4471                     break;
4472                   p++;
4473                 }
4474
4475               if (fc->fde_encoding)
4476                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4477             }
4478
4479           frame_need_space (fc, fc->ra);
4480         }
4481       else
4482         {
4483           unsigned char *look_for;
4484           static Frame_Chunk fde_fc;
4485           unsigned long segment_selector;
4486
4487           fc = & fde_fc;
4488           memset (fc, 0, sizeof (Frame_Chunk));
4489
4490           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4491
4492           for (cie = chunks; cie ; cie = cie->next)
4493             if (cie->chunk_start == look_for)
4494               break;
4495
4496           if (!cie)
4497             {
4498               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4499                     cie_id, (unsigned long)(saved_start - section_start));
4500               fc->ncols = 0;
4501               fc->col_type = (short int *) xmalloc (sizeof (short int));
4502               fc->col_offset = (int *) xmalloc (sizeof (int));
4503               frame_need_space (fc, max_regs - 1);
4504               cie = fc;
4505               fc->augmentation = "";
4506               fc->fde_encoding = 0;
4507               fc->ptr_size = eh_addr_size;
4508               fc->segment_size = 0;
4509             }
4510           else
4511             {
4512               fc->ncols = cie->ncols;
4513               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4514               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
4515               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4516               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4517               fc->augmentation = cie->augmentation;
4518               fc->ptr_size = cie->ptr_size;
4519               eh_addr_size = cie->ptr_size;
4520               fc->segment_size = cie->segment_size;
4521               fc->code_factor = cie->code_factor;
4522               fc->data_factor = cie->data_factor;
4523               fc->cfa_reg = cie->cfa_reg;
4524               fc->cfa_offset = cie->cfa_offset;
4525               fc->ra = cie->ra;
4526               frame_need_space (fc, max_regs - 1);
4527               fc->fde_encoding = cie->fde_encoding;
4528             }
4529
4530           if (fc->fde_encoding)
4531             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4532
4533           segment_selector = 0;
4534           if (fc->segment_size)
4535             {
4536               segment_selector = byte_get (start, fc->segment_size);
4537               start += fc->segment_size;
4538             }
4539           fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
4540           start += encoded_ptr_size;
4541           fc->pc_range = byte_get (start, encoded_ptr_size);
4542           start += encoded_ptr_size;
4543
4544           if (cie->augmentation[0] == 'z')
4545             {
4546               augmentation_data_len = LEB ();
4547               augmentation_data = start;
4548               start += augmentation_data_len;
4549             }
4550
4551           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4552                   (unsigned long)(saved_start - section_start), length, cie_id,
4553                   (unsigned long)(cie->chunk_start - section_start));
4554           if (fc->segment_size)
4555             printf ("%04lx:", segment_selector);
4556           printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4557           if (! do_debug_frames_interp && augmentation_data_len)
4558             {
4559               unsigned long i;
4560
4561               printf ("  Augmentation data:    ");
4562               for (i = 0; i < augmentation_data_len; ++i)
4563                 printf (" %02x", augmentation_data[i]);
4564               putchar ('\n');
4565               putchar ('\n');
4566             }
4567         }
4568
4569       /* At this point, fc is the current chunk, cie (if any) is set, and
4570          we're about to interpret instructions for the chunk.  */
4571       /* ??? At present we need to do this always, since this sizes the
4572          fc->col_type and fc->col_offset arrays, which we write into always.
4573          We should probably split the interpreted and non-interpreted bits
4574          into two different routines, since there's so much that doesn't
4575          really overlap between them.  */
4576       if (1 || do_debug_frames_interp)
4577         {
4578           /* Start by making a pass over the chunk, allocating storage
4579              and taking note of what registers are used.  */
4580           unsigned char *tmp = start;
4581
4582           while (start < block_end)
4583             {
4584               unsigned op, opa;
4585               unsigned long reg, temp;
4586
4587               op = *start++;
4588               opa = op & 0x3f;
4589               if (op & 0xc0)
4590                 op &= 0xc0;
4591
4592               /* Warning: if you add any more cases to this switch, be
4593                  sure to add them to the corresponding switch below.  */
4594               switch (op)
4595                 {
4596                 case DW_CFA_advance_loc:
4597                   break;
4598                 case DW_CFA_offset:
4599                   LEB ();
4600                   if (frame_need_space (fc, opa) >= 0)
4601                     fc->col_type[opa] = DW_CFA_undefined;
4602                   break;
4603                 case DW_CFA_restore:
4604                   if (frame_need_space (fc, opa) >= 0)
4605                     fc->col_type[opa] = DW_CFA_undefined;
4606                   break;
4607                 case DW_CFA_set_loc:
4608                   start += encoded_ptr_size;
4609                   break;
4610                 case DW_CFA_advance_loc1:
4611                   start += 1;
4612                   break;
4613                 case DW_CFA_advance_loc2:
4614                   start += 2;
4615                   break;
4616                 case DW_CFA_advance_loc4:
4617                   start += 4;
4618                   break;
4619                 case DW_CFA_offset_extended:
4620                 case DW_CFA_val_offset:
4621                   reg = LEB (); LEB ();
4622                   if (frame_need_space (fc, reg) >= 0)
4623                     fc->col_type[reg] = DW_CFA_undefined;
4624                   break;
4625                 case DW_CFA_restore_extended:
4626                   reg = LEB ();
4627                   frame_need_space (fc, reg);
4628                   if (frame_need_space (fc, reg) >= 0)
4629                     fc->col_type[reg] = DW_CFA_undefined;
4630                   break;
4631                 case DW_CFA_undefined:
4632                   reg = LEB ();
4633                   if (frame_need_space (fc, reg) >= 0)
4634                     fc->col_type[reg] = DW_CFA_undefined;
4635                   break;
4636                 case DW_CFA_same_value:
4637                   reg = LEB ();
4638                   if (frame_need_space (fc, reg) >= 0)
4639                     fc->col_type[reg] = DW_CFA_undefined;
4640                   break;
4641                 case DW_CFA_register:
4642                   reg = LEB (); LEB ();
4643                   if (frame_need_space (fc, reg) >= 0)
4644                     fc->col_type[reg] = DW_CFA_undefined;
4645                   break;
4646                 case DW_CFA_def_cfa:
4647                   LEB (); LEB ();
4648                   break;
4649                 case DW_CFA_def_cfa_register:
4650                   LEB ();
4651                   break;
4652                 case DW_CFA_def_cfa_offset:
4653                   LEB ();
4654                   break;
4655                 case DW_CFA_def_cfa_expression:
4656                   temp = LEB ();
4657                   start += temp;
4658                   break;
4659                 case DW_CFA_expression:
4660                 case DW_CFA_val_expression:
4661                   reg = LEB ();
4662                   temp = LEB ();
4663                   start += temp;
4664                   if (frame_need_space (fc, reg) >= 0)
4665                     fc->col_type[reg] = DW_CFA_undefined;
4666                   break;
4667                 case DW_CFA_offset_extended_sf:
4668                 case DW_CFA_val_offset_sf:
4669                   reg = LEB (); SLEB ();
4670                   if (frame_need_space (fc, reg) >= 0)
4671                     fc->col_type[reg] = DW_CFA_undefined;
4672                   break;
4673                 case DW_CFA_def_cfa_sf:
4674                   LEB (); SLEB ();
4675                   break;
4676                 case DW_CFA_def_cfa_offset_sf:
4677                   SLEB ();
4678                   break;
4679                 case DW_CFA_MIPS_advance_loc8:
4680                   start += 8;
4681                   break;
4682                 case DW_CFA_GNU_args_size:
4683                   LEB ();
4684                   break;
4685                 case DW_CFA_GNU_negative_offset_extended:
4686                   reg = LEB (); LEB ();
4687                   if (frame_need_space (fc, reg) >= 0)
4688                     fc->col_type[reg] = DW_CFA_undefined;
4689                   break;
4690                 default:
4691                   break;
4692                 }
4693             }
4694           start = tmp;
4695         }
4696
4697       /* Now we know what registers are used, make a second pass over
4698          the chunk, this time actually printing out the info.  */
4699
4700       while (start < block_end)
4701         {
4702           unsigned op, opa;
4703           unsigned long ul, reg, roffs;
4704           long l, ofs;
4705           dwarf_vma vma;
4706           const char *reg_prefix = "";
4707
4708           op = *start++;
4709           opa = op & 0x3f;
4710           if (op & 0xc0)
4711             op &= 0xc0;
4712
4713           /* Warning: if you add any more cases to this switch, be
4714              sure to add them to the corresponding switch above.  */
4715           switch (op)
4716             {
4717             case DW_CFA_advance_loc:
4718               if (do_debug_frames_interp)
4719                 frame_display_row (fc, &need_col_headers, &max_regs);
4720               else
4721                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
4722                         opa * fc->code_factor,
4723                         fc->pc_begin + opa * fc->code_factor);
4724               fc->pc_begin += opa * fc->code_factor;
4725               break;
4726
4727             case DW_CFA_offset:
4728               roffs = LEB ();
4729               if (opa >= (unsigned int) fc->ncols)
4730                 reg_prefix = bad_reg;
4731               if (! do_debug_frames_interp || *reg_prefix != '\0')
4732                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
4733                         reg_prefix, regname (opa, 0),
4734                         roffs * fc->data_factor);
4735               if (*reg_prefix == '\0')
4736                 {
4737                   fc->col_type[opa] = DW_CFA_offset;
4738                   fc->col_offset[opa] = roffs * fc->data_factor;
4739                 }
4740               break;
4741
4742             case DW_CFA_restore:
4743               if (opa >= (unsigned int) cie->ncols
4744                   || opa >= (unsigned int) fc->ncols)
4745                 reg_prefix = bad_reg;
4746               if (! do_debug_frames_interp || *reg_prefix != '\0')
4747                 printf ("  DW_CFA_restore: %s%s\n",
4748                         reg_prefix, regname (opa, 0));
4749               if (*reg_prefix == '\0')
4750                 {
4751                   fc->col_type[opa] = cie->col_type[opa];
4752                   fc->col_offset[opa] = cie->col_offset[opa];
4753                 }
4754               break;
4755
4756             case DW_CFA_set_loc:
4757               vma = get_encoded_value (start, fc->fde_encoding, section);
4758               start += encoded_ptr_size;
4759               if (do_debug_frames_interp)
4760                 frame_display_row (fc, &need_col_headers, &max_regs);
4761               else
4762                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4763               fc->pc_begin = vma;
4764               break;
4765
4766             case DW_CFA_advance_loc1:
4767               ofs = byte_get (start, 1); start += 1;
4768               if (do_debug_frames_interp)
4769                 frame_display_row (fc, &need_col_headers, &max_regs);
4770               else
4771                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
4772                         ofs * fc->code_factor,
4773                         fc->pc_begin + ofs * fc->code_factor);
4774               fc->pc_begin += ofs * fc->code_factor;
4775               break;
4776
4777             case DW_CFA_advance_loc2:
4778               ofs = byte_get (start, 2); start += 2;
4779               if (do_debug_frames_interp)
4780                 frame_display_row (fc, &need_col_headers, &max_regs);
4781               else
4782                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
4783                         ofs * fc->code_factor,
4784                         fc->pc_begin + ofs * fc->code_factor);
4785               fc->pc_begin += ofs * fc->code_factor;
4786               break;
4787
4788             case DW_CFA_advance_loc4:
4789               ofs = byte_get (start, 4); start += 4;
4790               if (do_debug_frames_interp)
4791                 frame_display_row (fc, &need_col_headers, &max_regs);
4792               else
4793                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
4794                         ofs * fc->code_factor,
4795                         fc->pc_begin + ofs * fc->code_factor);
4796               fc->pc_begin += ofs * fc->code_factor;
4797               break;
4798
4799             case DW_CFA_offset_extended:
4800               reg = LEB ();
4801               roffs = LEB ();
4802               if (reg >= (unsigned int) fc->ncols)
4803                 reg_prefix = bad_reg;
4804               if (! do_debug_frames_interp || *reg_prefix != '\0')
4805                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4806                         reg_prefix, regname (reg, 0),
4807                         roffs * fc->data_factor);
4808               if (*reg_prefix == '\0')
4809                 {
4810                   fc->col_type[reg] = DW_CFA_offset;
4811                   fc->col_offset[reg] = roffs * fc->data_factor;
4812                 }
4813               break;
4814
4815             case DW_CFA_val_offset:
4816               reg = LEB ();
4817               roffs = LEB ();
4818               if (reg >= (unsigned int) fc->ncols)
4819                 reg_prefix = bad_reg;
4820               if (! do_debug_frames_interp || *reg_prefix != '\0')
4821                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
4822                         reg_prefix, regname (reg, 0),
4823                         roffs * fc->data_factor);
4824               if (*reg_prefix == '\0')
4825                 {
4826                   fc->col_type[reg] = DW_CFA_val_offset;
4827                   fc->col_offset[reg] = roffs * fc->data_factor;
4828                 }
4829               break;
4830
4831             case DW_CFA_restore_extended:
4832               reg = LEB ();
4833               if (reg >= (unsigned int) cie->ncols
4834                   || reg >= (unsigned int) fc->ncols)
4835                 reg_prefix = bad_reg;
4836               if (! do_debug_frames_interp || *reg_prefix != '\0')
4837                 printf ("  DW_CFA_restore_extended: %s%s\n",
4838                         reg_prefix, regname (reg, 0));
4839               if (*reg_prefix == '\0')
4840                 {
4841                   fc->col_type[reg] = cie->col_type[reg];
4842                   fc->col_offset[reg] = cie->col_offset[reg];
4843                 }
4844               break;
4845
4846             case DW_CFA_undefined:
4847               reg = LEB ();
4848               if (reg >= (unsigned int) fc->ncols)
4849                 reg_prefix = bad_reg;
4850               if (! do_debug_frames_interp || *reg_prefix != '\0')
4851                 printf ("  DW_CFA_undefined: %s%s\n",
4852                         reg_prefix, regname (reg, 0));
4853               if (*reg_prefix == '\0')
4854                 {
4855                   fc->col_type[reg] = DW_CFA_undefined;
4856                   fc->col_offset[reg] = 0;
4857                 }
4858               break;
4859
4860             case DW_CFA_same_value:
4861               reg = LEB ();
4862               if (reg >= (unsigned int) fc->ncols)
4863                 reg_prefix = bad_reg;
4864               if (! do_debug_frames_interp || *reg_prefix != '\0')
4865                 printf ("  DW_CFA_same_value: %s%s\n",
4866                         reg_prefix, regname (reg, 0));
4867               if (*reg_prefix == '\0')
4868                 {
4869                   fc->col_type[reg] = DW_CFA_same_value;
4870                   fc->col_offset[reg] = 0;
4871                 }
4872               break;
4873
4874             case DW_CFA_register:
4875               reg = LEB ();
4876               roffs = LEB ();
4877               if (reg >= (unsigned int) fc->ncols)
4878                 reg_prefix = bad_reg;
4879               if (! do_debug_frames_interp || *reg_prefix != '\0')
4880                 {
4881                   printf ("  DW_CFA_register: %s%s in ",
4882                           reg_prefix, regname (reg, 0));
4883                   puts (regname (roffs, 0));
4884                 }
4885               if (*reg_prefix == '\0')
4886                 {
4887                   fc->col_type[reg] = DW_CFA_register;
4888                   fc->col_offset[reg] = roffs;
4889                 }
4890               break;
4891
4892             case DW_CFA_remember_state:
4893               if (! do_debug_frames_interp)
4894                 printf ("  DW_CFA_remember_state\n");
4895               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4896               rs->ncols = fc->ncols;
4897               rs->col_type = (short int *) xcmalloc (rs->ncols,
4898                                                      sizeof (short int));
4899               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
4900               memcpy (rs->col_type, fc->col_type, rs->ncols);
4901               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4902               rs->next = remembered_state;
4903               remembered_state = rs;
4904               break;
4905
4906             case DW_CFA_restore_state:
4907               if (! do_debug_frames_interp)
4908                 printf ("  DW_CFA_restore_state\n");
4909               rs = remembered_state;
4910               if (rs)
4911                 {
4912                   remembered_state = rs->next;
4913                   frame_need_space (fc, rs->ncols - 1);
4914                   memcpy (fc->col_type, rs->col_type, rs->ncols);
4915                   memcpy (fc->col_offset, rs->col_offset,
4916                           rs->ncols * sizeof (int));
4917                   free (rs->col_type);
4918                   free (rs->col_offset);
4919                   free (rs);
4920                 }
4921               else if (do_debug_frames_interp)
4922                 printf ("Mismatched DW_CFA_restore_state\n");
4923               break;
4924
4925             case DW_CFA_def_cfa:
4926               fc->cfa_reg = LEB ();
4927               fc->cfa_offset = LEB ();
4928               fc->cfa_exp = 0;
4929               if (! do_debug_frames_interp)
4930                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
4931                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4932               break;
4933
4934             case DW_CFA_def_cfa_register:
4935               fc->cfa_reg = LEB ();
4936               fc->cfa_exp = 0;
4937               if (! do_debug_frames_interp)
4938                 printf ("  DW_CFA_def_cfa_register: %s\n",
4939                         regname (fc->cfa_reg, 0));
4940               break;
4941
4942             case DW_CFA_def_cfa_offset:
4943               fc->cfa_offset = LEB ();
4944               if (! do_debug_frames_interp)
4945                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4946               break;
4947
4948             case DW_CFA_nop:
4949               if (! do_debug_frames_interp)
4950                 printf ("  DW_CFA_nop\n");
4951               break;
4952
4953             case DW_CFA_def_cfa_expression:
4954               ul = LEB ();
4955               if (! do_debug_frames_interp)
4956                 {
4957                   printf ("  DW_CFA_def_cfa_expression (");
4958                   decode_location_expression (start, eh_addr_size, 0, -1,
4959                                               ul, 0, section);
4960                   printf (")\n");
4961                 }
4962               fc->cfa_exp = 1;
4963               start += ul;
4964               break;
4965
4966             case DW_CFA_expression:
4967               reg = LEB ();
4968               ul = LEB ();
4969               if (reg >= (unsigned int) fc->ncols)
4970                 reg_prefix = bad_reg;
4971               if (! do_debug_frames_interp || *reg_prefix != '\0')
4972                 {
4973                   printf ("  DW_CFA_expression: %s%s (",
4974                           reg_prefix, regname (reg, 0));
4975                   decode_location_expression (start, eh_addr_size, 0, -1,
4976                                               ul, 0, section);
4977                   printf (")\n");
4978                 }
4979               if (*reg_prefix == '\0')
4980                 fc->col_type[reg] = DW_CFA_expression;
4981               start += ul;
4982               break;
4983
4984             case DW_CFA_val_expression:
4985               reg = LEB ();
4986               ul = LEB ();
4987               if (reg >= (unsigned int) fc->ncols)
4988                 reg_prefix = bad_reg;
4989               if (! do_debug_frames_interp || *reg_prefix != '\0')
4990                 {
4991                   printf ("  DW_CFA_val_expression: %s%s (",
4992                           reg_prefix, regname (reg, 0));
4993                   decode_location_expression (start, eh_addr_size, 0, -1,
4994                                               ul, 0, section);
4995                   printf (")\n");
4996                 }
4997               if (*reg_prefix == '\0')
4998                 fc->col_type[reg] = DW_CFA_val_expression;
4999               start += ul;
5000               break;
5001
5002             case DW_CFA_offset_extended_sf:
5003               reg = LEB ();
5004               l = SLEB ();
5005               if (frame_need_space (fc, reg) < 0)
5006                 reg_prefix = bad_reg;
5007               if (! do_debug_frames_interp || *reg_prefix != '\0')
5008                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5009                         reg_prefix, regname (reg, 0),
5010                         l * fc->data_factor);
5011               if (*reg_prefix == '\0')
5012                 {
5013                   fc->col_type[reg] = DW_CFA_offset;
5014                   fc->col_offset[reg] = l * fc->data_factor;
5015                 }
5016               break;
5017
5018             case DW_CFA_val_offset_sf:
5019               reg = LEB ();
5020               l = SLEB ();
5021               if (frame_need_space (fc, reg) < 0)
5022                 reg_prefix = bad_reg;
5023               if (! do_debug_frames_interp || *reg_prefix != '\0')
5024                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5025                         reg_prefix, regname (reg, 0),
5026                         l * fc->data_factor);
5027               if (*reg_prefix == '\0')
5028                 {
5029                   fc->col_type[reg] = DW_CFA_val_offset;
5030                   fc->col_offset[reg] = l * fc->data_factor;
5031                 }
5032               break;
5033
5034             case DW_CFA_def_cfa_sf:
5035               fc->cfa_reg = LEB ();
5036               fc->cfa_offset = SLEB ();
5037               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5038               fc->cfa_exp = 0;
5039               if (! do_debug_frames_interp)
5040                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
5041                         regname (fc->cfa_reg, 0), fc->cfa_offset);
5042               break;
5043
5044             case DW_CFA_def_cfa_offset_sf:
5045               fc->cfa_offset = SLEB ();
5046               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5047               if (! do_debug_frames_interp)
5048                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5049               break;
5050
5051             case DW_CFA_MIPS_advance_loc8:
5052               ofs = byte_get (start, 8); start += 8;
5053               if (do_debug_frames_interp)
5054                 frame_display_row (fc, &need_col_headers, &max_regs);
5055               else
5056                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5057                         ofs * fc->code_factor,
5058                         fc->pc_begin + ofs * fc->code_factor);
5059               fc->pc_begin += ofs * fc->code_factor;
5060               break;
5061
5062             case DW_CFA_GNU_window_save:
5063               if (! do_debug_frames_interp)
5064                 printf ("  DW_CFA_GNU_window_save\n");
5065               break;
5066
5067             case DW_CFA_GNU_args_size:
5068               ul = LEB ();
5069               if (! do_debug_frames_interp)
5070                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
5071               break;
5072
5073             case DW_CFA_GNU_negative_offset_extended:
5074               reg = LEB ();
5075               l = - LEB ();
5076               if (frame_need_space (fc, reg) < 0)
5077                 reg_prefix = bad_reg;
5078               if (! do_debug_frames_interp || *reg_prefix != '\0')
5079                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5080                         reg_prefix, regname (reg, 0),
5081                         l * fc->data_factor);
5082               if (*reg_prefix == '\0')
5083                 {
5084                   fc->col_type[reg] = DW_CFA_offset;
5085                   fc->col_offset[reg] = l * fc->data_factor;
5086                 }
5087               break;
5088
5089             default:
5090               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5091                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5092               else
5093                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5094               start = block_end;
5095             }
5096         }
5097
5098       if (do_debug_frames_interp)
5099         frame_display_row (fc, &need_col_headers, &max_regs);
5100
5101       start = block_end;
5102       eh_addr_size = saved_eh_addr_size;
5103     }
5104
5105   printf ("\n");
5106
5107   return 1;
5108 }
5109
5110 #undef GET
5111 #undef LEB
5112 #undef SLEB
5113
5114 static int
5115 display_gdb_index (struct dwarf_section *section,
5116                    void *file ATTRIBUTE_UNUSED)
5117 {
5118   unsigned char *start = section->start;
5119   uint32_t version;
5120   uint32_t cu_list_offset, tu_list_offset;
5121   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5122   unsigned int cu_list_elements, tu_list_elements;
5123   unsigned int address_table_size, symbol_table_slots;
5124   unsigned char *cu_list, *tu_list;
5125   unsigned char *address_table, *symbol_table, *constant_pool;
5126   unsigned int i;
5127
5128   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
5129
5130   printf (_("Contents of the %s section:\n"), section->name);
5131
5132   if (section->size < 6 * sizeof (uint32_t))
5133     {
5134       warn (_("Truncated header in the %s section.\n"), section->name);
5135       return 0;
5136     }
5137
5138   version = byte_get_little_endian (start, 4);
5139   printf (_("Version %ld\n"), (long) version);
5140
5141   /* Prior versions are obsolete, and future versions may not be
5142      backwards compatible.  */
5143   switch (version)
5144     {
5145     case 3:
5146       warn (_("The address table data in version 3 may be wrong.\n"));
5147       break;
5148     case 4:
5149       warn (_("Version 4 does not support case insensitive lookups.\n"));
5150       break;
5151     case 5:
5152       break;
5153     default:
5154       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5155       return 0;
5156     }
5157
5158   cu_list_offset = byte_get_little_endian (start + 4, 4);
5159   tu_list_offset = byte_get_little_endian (start + 8, 4);
5160   address_table_offset = byte_get_little_endian (start + 12, 4);
5161   symbol_table_offset = byte_get_little_endian (start + 16, 4);
5162   constant_pool_offset = byte_get_little_endian (start + 20, 4);
5163
5164   if (cu_list_offset > section->size
5165       || tu_list_offset > section->size
5166       || address_table_offset > section->size
5167       || symbol_table_offset > section->size
5168       || constant_pool_offset > section->size)
5169     {
5170       warn (_("Corrupt header in the %s section.\n"), section->name);
5171       return 0;
5172     }
5173
5174   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5175   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5176   address_table_size = symbol_table_offset - address_table_offset;
5177   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5178
5179   cu_list = start + cu_list_offset;
5180   tu_list = start + tu_list_offset;
5181   address_table = start + address_table_offset;
5182   symbol_table = start + symbol_table_offset;
5183   constant_pool = start + constant_pool_offset;
5184
5185   printf (_("\nCU table:\n"));
5186   for (i = 0; i < cu_list_elements; i += 2)
5187     {
5188       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5189       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5190
5191       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5192               (unsigned long) cu_offset,
5193               (unsigned long) (cu_offset + cu_length - 1));
5194     }
5195
5196   printf (_("\nTU table:\n"));
5197   for (i = 0; i < tu_list_elements; i += 3)
5198     {
5199       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5200       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5201       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5202
5203       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5204               (unsigned long) tu_offset,
5205               (unsigned long) type_offset);
5206       print_dwarf_vma (signature, 8);
5207       printf ("\n");
5208     }
5209
5210   printf (_("\nAddress table:\n"));
5211   for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5212     {
5213       uint64_t low = byte_get_little_endian (address_table + i, 8);
5214       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5215       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5216
5217       print_dwarf_vma (low, 8);
5218       print_dwarf_vma (high, 8);
5219       printf (_("%lu\n"), (unsigned long) cu_index);
5220     }
5221
5222   printf (_("\nSymbol table:\n"));
5223   for (i = 0; i < symbol_table_slots; ++i)
5224     {
5225       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5226       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5227       uint32_t num_cus, cu;
5228
5229       if (name_offset != 0
5230           || cu_vector_offset != 0)
5231         {
5232           unsigned int j;
5233
5234           printf ("[%3u] %s:", i, constant_pool + name_offset);
5235           num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5236           for (j = 0; j < num_cus; ++j)
5237             {
5238               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5239               /* Convert to TU number if it's for a type unit.  */
5240               if (cu >= cu_list_elements)
5241                 printf (" T%lu", (unsigned long) (cu - cu_list_elements));
5242               else
5243                 printf (" %lu", (unsigned long) cu);
5244             }
5245           printf ("\n");
5246         }
5247     }
5248
5249   return 1;
5250 }
5251
5252 static int
5253 display_debug_not_supported (struct dwarf_section *section,
5254                              void *file ATTRIBUTE_UNUSED)
5255 {
5256   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5257             section->name);
5258
5259   return 1;
5260 }
5261
5262 void *
5263 cmalloc (size_t nmemb, size_t size)
5264 {
5265   /* Check for overflow.  */
5266   if (nmemb >= ~(size_t) 0 / size)
5267     return NULL;
5268   else
5269     return malloc (nmemb * size);
5270 }
5271
5272 void *
5273 xcmalloc (size_t nmemb, size_t size)
5274 {
5275   /* Check for overflow.  */
5276   if (nmemb >= ~(size_t) 0 / size)
5277     return NULL;
5278   else
5279     return xmalloc (nmemb * size);
5280 }
5281
5282 void *
5283 xcrealloc (void *ptr, size_t nmemb, size_t size)
5284 {
5285   /* Check for overflow.  */
5286   if (nmemb >= ~(size_t) 0 / size)
5287     return NULL;
5288   else
5289     return xrealloc (ptr, nmemb * size);
5290 }
5291
5292 void
5293 free_debug_memory (void)
5294 {
5295   unsigned int i;
5296
5297   free_abbrevs ();
5298
5299   for (i = 0; i < max; i++)
5300     free_debug_section ((enum dwarf_section_display_enum) i);
5301
5302   if (debug_information != NULL)
5303     {
5304       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5305         {
5306           for (i = 0; i < num_debug_info_entries; i++)
5307             {
5308               if (!debug_information [i].max_loc_offsets)
5309                 {
5310                   free (debug_information [i].loc_offsets);
5311                   free (debug_information [i].have_frame_base);
5312                 }
5313               if (!debug_information [i].max_range_lists)
5314                 free (debug_information [i].range_lists);
5315             }
5316         }
5317
5318       free (debug_information);
5319       debug_information = NULL;
5320       num_debug_info_entries = 0;
5321     }
5322 }
5323
5324 void
5325 dwarf_select_sections_by_names (const char *names)
5326 {
5327   typedef struct
5328   {
5329     const char * option;
5330     int *        variable;
5331     int          val;
5332   }
5333   debug_dump_long_opts;
5334
5335   static const debug_dump_long_opts opts_table [] =
5336     {
5337       /* Please keep this table alpha- sorted.  */
5338       { "Ranges", & do_debug_ranges, 1 },
5339       { "abbrev", & do_debug_abbrevs, 1 },
5340       { "aranges", & do_debug_aranges, 1 },
5341       { "frames", & do_debug_frames, 1 },
5342       { "frames-interp", & do_debug_frames_interp, 1 },
5343       { "info", & do_debug_info, 1 },
5344       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
5345       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5346       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5347       { "loc",  & do_debug_loc, 1 },
5348       { "macro", & do_debug_macinfo, 1 },
5349       { "pubnames", & do_debug_pubnames, 1 },
5350       { "pubtypes", & do_debug_pubtypes, 1 },
5351       /* This entry is for compatability
5352          with earlier versions of readelf.  */
5353       { "ranges", & do_debug_aranges, 1 },
5354       { "str", & do_debug_str, 1 },
5355       /* The special .gdb_index section.  */
5356       { "gdb_index", & do_gdb_index, 1 },
5357       /* These trace_* sections are used by Itanium VMS.  */
5358       { "trace_abbrev", & do_trace_abbrevs, 1 },
5359       { "trace_aranges", & do_trace_aranges, 1 },
5360       { "trace_info", & do_trace_info, 1 },
5361       { NULL, NULL, 0 }
5362     };
5363
5364   const char *p;
5365
5366   p = names;
5367   while (*p)
5368     {
5369       const debug_dump_long_opts * entry;
5370
5371       for (entry = opts_table; entry->option; entry++)
5372         {
5373           size_t len = strlen (entry->option);
5374
5375           if (strncmp (p, entry->option, len) == 0
5376               && (p[len] == ',' || p[len] == '\0'))
5377             {
5378               * entry->variable |= entry->val;
5379
5380               /* The --debug-dump=frames-interp option also
5381                  enables the --debug-dump=frames option.  */
5382               if (do_debug_frames_interp)
5383                 do_debug_frames = 1;
5384
5385               p += len;
5386               break;
5387             }
5388         }
5389
5390       if (entry->option == NULL)
5391         {
5392           warn (_("Unrecognized debug option '%s'\n"), p);
5393           p = strchr (p, ',');
5394           if (p == NULL)
5395             break;
5396         }
5397
5398       if (*p == ',')
5399         p++;
5400     }
5401 }
5402
5403 void
5404 dwarf_select_sections_by_letters (const char *letters)
5405 {
5406   unsigned int lindex = 0;
5407
5408   while (letters[lindex])
5409     switch (letters[lindex++])
5410       {
5411       case 'i':
5412         do_debug_info = 1;
5413         break;
5414
5415       case 'a':
5416         do_debug_abbrevs = 1;
5417         break;
5418
5419       case 'l':
5420         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5421         break;
5422
5423       case 'L':
5424         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5425         break;
5426
5427       case 'p':
5428         do_debug_pubnames = 1;
5429         break;
5430
5431       case 't':
5432         do_debug_pubtypes = 1;
5433         break;
5434
5435       case 'r':
5436         do_debug_aranges = 1;
5437         break;
5438
5439       case 'R':
5440         do_debug_ranges = 1;
5441         break;
5442
5443       case 'F':
5444         do_debug_frames_interp = 1;
5445       case 'f':
5446         do_debug_frames = 1;
5447         break;
5448
5449       case 'm':
5450         do_debug_macinfo = 1;
5451         break;
5452
5453       case 's':
5454         do_debug_str = 1;
5455         break;
5456
5457       case 'o':
5458         do_debug_loc = 1;
5459         break;
5460
5461       default:
5462         warn (_("Unrecognized debug option '%s'\n"), optarg);
5463         break;
5464       }
5465 }
5466
5467 void
5468 dwarf_select_sections_all (void)
5469 {
5470   do_debug_info = 1;
5471   do_debug_abbrevs = 1;
5472   do_debug_lines = FLAG_DEBUG_LINES_RAW;
5473   do_debug_pubnames = 1;
5474   do_debug_pubtypes = 1;
5475   do_debug_aranges = 1;
5476   do_debug_ranges = 1;
5477   do_debug_frames = 1;
5478   do_debug_macinfo = 1;
5479   do_debug_str = 1;
5480   do_debug_loc = 1;
5481   do_gdb_index = 1;
5482   do_trace_info = 1;
5483   do_trace_abbrevs = 1;
5484   do_trace_aranges = 1;
5485 }
5486
5487 struct dwarf_section_display debug_displays[] =
5488 {
5489   { { ".debug_abbrev",          ".zdebug_abbrev",       NULL, NULL, 0, 0 },
5490     display_debug_abbrev,               &do_debug_abbrevs,      0 },
5491   { { ".debug_aranges",         ".zdebug_aranges",      NULL, NULL, 0, 0 },
5492     display_debug_aranges,              &do_debug_aranges,      1 },
5493   { { ".debug_frame",           ".zdebug_frame",        NULL, NULL, 0, 0 },
5494     display_debug_frames,               &do_debug_frames,       1 },
5495   { { ".debug_info",            ".zdebug_info",         NULL, NULL, 0, 0 },
5496     display_debug_info,                 &do_debug_info,         1 },
5497   { { ".debug_line",            ".zdebug_line",         NULL, NULL, 0, 0 },
5498     display_debug_lines,                &do_debug_lines,        1 },
5499   { { ".debug_pubnames",        ".zdebug_pubnames",     NULL, NULL, 0, 0 },
5500     display_debug_pubnames,             &do_debug_pubnames,     0 },
5501   { { ".eh_frame",              "",                     NULL, NULL, 0, 0 },
5502     display_debug_frames,               &do_debug_frames,       1 },
5503   { { ".debug_macinfo",         ".zdebug_macinfo",      NULL, NULL, 0, 0 },
5504     display_debug_macinfo,              &do_debug_macinfo,      0 },
5505   { { ".debug_str",             ".zdebug_str",          NULL, NULL, 0, 0 },
5506     display_debug_str,                  &do_debug_str,          0 },
5507   { { ".debug_loc",             ".zdebug_loc",          NULL, NULL, 0, 0 },
5508     display_debug_loc,                  &do_debug_loc,          1 },
5509   { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL, NULL, 0, 0 },
5510     display_debug_pubnames,             &do_debug_pubtypes,     0 },
5511   { { ".debug_ranges",          ".zdebug_ranges",       NULL, NULL, 0, 0 },
5512     display_debug_ranges,               &do_debug_ranges,       1 },
5513   { { ".debug_static_func",     ".zdebug_static_func",  NULL, NULL, 0, 0 },
5514     display_debug_not_supported,        NULL,                   0 },
5515   { { ".debug_static_vars",     ".zdebug_static_vars",  NULL, NULL, 0, 0 },
5516     display_debug_not_supported,        NULL,                   0 },
5517   { { ".debug_types",           ".zdebug_types",        NULL, NULL, 0, 0 },
5518     display_debug_types,                &do_debug_info,         1 },
5519   { { ".debug_weaknames",       ".zdebug_weaknames",    NULL, NULL, 0, 0 },
5520     display_debug_not_supported,        NULL,                   0 },
5521   { { ".gdb_index",             "",                     NULL, NULL, 0, 0 },
5522     display_gdb_index,                  &do_gdb_index,          0 },
5523   { { ".trace_info",            "",                     NULL, NULL, 0, 0 },
5524     display_trace_info,                 &do_trace_info,         1 },
5525   { { ".trace_abbrev",          "",                     NULL, NULL, 0, 0 },
5526     display_debug_abbrev,               &do_trace_abbrevs,      0 },
5527   { { ".trace_aranges",         "",                     NULL, NULL, 0, 0 },
5528     display_debug_aranges,              &do_trace_aranges,      0 }
5529 };