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", uvalue ? cu_offset + uvalue : 0));
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", uvalue ? cu_offset + uvalue : 0));
1189           break;
1190         case DW_OP_GNU_parameter_ref:
1191           printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1192                   dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
1193           data += 4;
1194           break;
1195
1196           /* HP extensions.  */
1197         case DW_OP_HP_is_value:
1198           printf ("DW_OP_HP_is_value");
1199           /* FIXME: Is there data associated with this OP ?  */
1200           break;
1201         case DW_OP_HP_fltconst4:
1202           printf ("DW_OP_HP_fltconst4");
1203           /* FIXME: Is there data associated with this OP ?  */
1204           break;
1205         case DW_OP_HP_fltconst8:
1206           printf ("DW_OP_HP_fltconst8");
1207           /* FIXME: Is there data associated with this OP ?  */
1208           break;
1209         case DW_OP_HP_mod_range:
1210           printf ("DW_OP_HP_mod_range");
1211           /* FIXME: Is there data associated with this OP ?  */
1212           break;
1213         case DW_OP_HP_unmod_range:
1214           printf ("DW_OP_HP_unmod_range");
1215           /* FIXME: Is there data associated with this OP ?  */
1216           break;
1217         case DW_OP_HP_tls:
1218           printf ("DW_OP_HP_tls");
1219           /* FIXME: Is there data associated with this OP ?  */
1220           break;
1221
1222           /* PGI (STMicroelectronics) extensions.  */
1223         case DW_OP_PGI_omp_thread_num:
1224           /* Pushes the thread number for the current thread as it would be
1225              returned by the standard OpenMP library function:
1226              omp_get_thread_num().  The "current thread" is the thread for
1227              which the expression is being evaluated.  */
1228           printf ("DW_OP_PGI_omp_thread_num");
1229           break;
1230
1231         default:
1232           if (op >= DW_OP_lo_user
1233               && op <= DW_OP_hi_user)
1234             printf (_("(User defined location op)"));
1235           else
1236             printf (_("(Unknown location op)"));
1237           /* No way to tell where the next op is, so just bail.  */
1238           return need_frame_base;
1239         }
1240
1241       /* Separate the ops.  */
1242       if (data < end)
1243         printf ("; ");
1244     }
1245
1246   return need_frame_base;
1247 }
1248
1249 static unsigned char *
1250 read_and_display_attr_value (unsigned long attribute,
1251                              unsigned long form,
1252                              unsigned char * data,
1253                              dwarf_vma cu_offset,
1254                              dwarf_vma pointer_size,
1255                              dwarf_vma offset_size,
1256                              int dwarf_version,
1257                              debug_info * debug_info_p,
1258                              int do_loc,
1259                              struct dwarf_section * section)
1260 {
1261   dwarf_vma uvalue = 0;
1262   unsigned char *block_start = NULL;
1263   unsigned char * orig_data = data;
1264   unsigned int bytes_read;
1265
1266   switch (form)
1267     {
1268     default:
1269       break;
1270
1271     case DW_FORM_ref_addr:
1272       if (dwarf_version == 2)
1273         {
1274           uvalue = byte_get (data, pointer_size);
1275           data += pointer_size;
1276         }
1277       else if (dwarf_version == 3 || dwarf_version == 4)
1278         {
1279           uvalue = byte_get (data, offset_size);
1280           data += offset_size;
1281         }
1282       else
1283         error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1284
1285       break;
1286
1287     case DW_FORM_addr:
1288       uvalue = byte_get (data, pointer_size);
1289       data += pointer_size;
1290       break;
1291
1292     case DW_FORM_strp:
1293     case DW_FORM_sec_offset:
1294       uvalue = byte_get (data, offset_size);
1295       data += offset_size;
1296       break;
1297
1298     case DW_FORM_flag_present:
1299       uvalue = 1;
1300       break;
1301
1302     case DW_FORM_ref1:
1303     case DW_FORM_flag:
1304     case DW_FORM_data1:
1305       uvalue = byte_get (data++, 1);
1306       break;
1307
1308     case DW_FORM_ref2:
1309     case DW_FORM_data2:
1310       uvalue = byte_get (data, 2);
1311       data += 2;
1312       break;
1313
1314     case DW_FORM_ref4:
1315     case DW_FORM_data4:
1316       uvalue = byte_get (data, 4);
1317       data += 4;
1318       break;
1319
1320     case DW_FORM_sdata:
1321       uvalue = read_leb128 (data, & bytes_read, 1);
1322       data += bytes_read;
1323       break;
1324
1325     case DW_FORM_ref_udata:
1326     case DW_FORM_udata:
1327       uvalue = read_leb128 (data, & bytes_read, 0);
1328       data += bytes_read;
1329       break;
1330
1331     case DW_FORM_indirect:
1332       form = read_leb128 (data, & bytes_read, 0);
1333       data += bytes_read;
1334       if (!do_loc)
1335         printf (" %s", get_FORM_name (form));
1336       return read_and_display_attr_value (attribute, form, data,
1337                                           cu_offset, pointer_size,
1338                                           offset_size, dwarf_version,
1339                                           debug_info_p, do_loc,
1340                                           section);
1341     }
1342
1343   switch (form)
1344     {
1345     case DW_FORM_ref_addr:
1346       if (!do_loc)
1347         printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1348       break;
1349
1350     case DW_FORM_ref1:
1351     case DW_FORM_ref2:
1352     case DW_FORM_ref4:
1353     case DW_FORM_ref_udata:
1354       if (!do_loc)
1355         printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1356       break;
1357
1358     case DW_FORM_data4:
1359     case DW_FORM_addr:
1360     case DW_FORM_sec_offset:
1361       if (!do_loc)
1362         printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1363       break;
1364
1365     case DW_FORM_flag_present:
1366     case DW_FORM_flag:
1367     case DW_FORM_data1:
1368     case DW_FORM_data2:
1369     case DW_FORM_sdata:
1370     case DW_FORM_udata:
1371       if (!do_loc)
1372         printf (" %s", dwarf_vmatoa ("d", uvalue));
1373       break;
1374
1375     case DW_FORM_ref8:
1376     case DW_FORM_data8:
1377       if (!do_loc)
1378         {
1379           uvalue = byte_get (data, 4);
1380           printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1381           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1382         }
1383       if ((do_loc || do_debug_loc || do_debug_ranges)
1384           && num_debug_info_entries == 0)
1385         {
1386           if (sizeof (uvalue) == 8)
1387             uvalue = byte_get (data, 8);
1388           else
1389             error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1390         }
1391       data += 8;
1392       break;
1393
1394     case DW_FORM_string:
1395       if (!do_loc)
1396         printf (" %s", data);
1397       data += strlen ((char *) data) + 1;
1398       break;
1399
1400     case DW_FORM_block:
1401     case DW_FORM_exprloc:
1402       uvalue = read_leb128 (data, & bytes_read, 0);
1403       block_start = data + bytes_read;
1404       if (do_loc)
1405         data = block_start + uvalue;
1406       else
1407         data = display_block (block_start, uvalue);
1408       break;
1409
1410     case DW_FORM_block1:
1411       uvalue = byte_get (data, 1);
1412       block_start = data + 1;
1413       if (do_loc)
1414         data = block_start + uvalue;
1415       else
1416         data = display_block (block_start, uvalue);
1417       break;
1418
1419     case DW_FORM_block2:
1420       uvalue = byte_get (data, 2);
1421       block_start = data + 2;
1422       if (do_loc)
1423         data = block_start + uvalue;
1424       else
1425         data = display_block (block_start, uvalue);
1426       break;
1427
1428     case DW_FORM_block4:
1429       uvalue = byte_get (data, 4);
1430       block_start = data + 4;
1431       if (do_loc)
1432         data = block_start + uvalue;
1433       else
1434         data = display_block (block_start, uvalue);
1435       break;
1436
1437     case DW_FORM_strp:
1438       if (!do_loc)
1439         printf (_(" (indirect string, offset: 0x%s): %s"),
1440                 dwarf_vmatoa ("x", uvalue),
1441                 fetch_indirect_string (uvalue));
1442       break;
1443
1444     case DW_FORM_indirect:
1445       /* Handled above.  */
1446       break;
1447
1448     case DW_FORM_ref_sig8:
1449       if (!do_loc)
1450         {
1451           int i;
1452           printf (" signature: ");
1453           for (i = 0; i < 8; i++)
1454             {
1455               printf ("%02x", (unsigned) byte_get (data, 1));
1456               data += 1;
1457             }
1458         }
1459       else
1460         data += 8;
1461       break;
1462
1463     default:
1464       warn (_("Unrecognized form: %lu\n"), form);
1465       break;
1466     }
1467
1468   if ((do_loc || do_debug_loc || do_debug_ranges)
1469       && num_debug_info_entries == 0
1470       && debug_info_p != NULL)
1471     {
1472       switch (attribute)
1473         {
1474         case DW_AT_frame_base:
1475           have_frame_base = 1;
1476         case DW_AT_location:
1477         case DW_AT_string_length:
1478         case DW_AT_return_addr:
1479         case DW_AT_data_member_location:
1480         case DW_AT_vtable_elem_location:
1481         case DW_AT_segment:
1482         case DW_AT_static_link:
1483         case DW_AT_use_location:
1484         case DW_AT_GNU_call_site_value:
1485         case DW_AT_GNU_call_site_data_value:
1486         case DW_AT_GNU_call_site_target:
1487         case DW_AT_GNU_call_site_target_clobbered:
1488           if (form == DW_FORM_data4
1489               || form == DW_FORM_data8
1490               || form == DW_FORM_sec_offset)
1491             {
1492               /* Process location list.  */
1493               unsigned int lmax = debug_info_p->max_loc_offsets;
1494               unsigned int num = debug_info_p->num_loc_offsets;
1495
1496               if (lmax == 0 || num >= lmax)
1497                 {
1498                   lmax += 1024;
1499                   debug_info_p->loc_offsets = (dwarf_vma *)
1500                       xcrealloc (debug_info_p->loc_offsets,
1501                                  lmax, sizeof (*debug_info_p->loc_offsets));
1502                   debug_info_p->have_frame_base = (int *)
1503                       xcrealloc (debug_info_p->have_frame_base,
1504                                  lmax, sizeof (*debug_info_p->have_frame_base));
1505                   debug_info_p->max_loc_offsets = lmax;
1506                 }
1507               debug_info_p->loc_offsets [num] = uvalue;
1508               debug_info_p->have_frame_base [num] = have_frame_base;
1509               debug_info_p->num_loc_offsets++;
1510             }
1511           break;
1512
1513         case DW_AT_low_pc:
1514           if (need_base_address)
1515             debug_info_p->base_address = uvalue;
1516           break;
1517
1518         case DW_AT_ranges:
1519           if (form == DW_FORM_data4
1520               || form == DW_FORM_data8
1521               || form == DW_FORM_sec_offset)
1522             {
1523               /* Process range list.  */
1524               unsigned int lmax = debug_info_p->max_range_lists;
1525               unsigned int num = debug_info_p->num_range_lists;
1526
1527               if (lmax == 0 || num >= lmax)
1528                 {
1529                   lmax += 1024;
1530                   debug_info_p->range_lists = (dwarf_vma *)
1531                       xcrealloc (debug_info_p->range_lists,
1532                                  lmax, sizeof (*debug_info_p->range_lists));
1533                   debug_info_p->max_range_lists = lmax;
1534                 }
1535               debug_info_p->range_lists [num] = uvalue;
1536               debug_info_p->num_range_lists++;
1537             }
1538           break;
1539
1540         default:
1541           break;
1542         }
1543     }
1544
1545   if (do_loc || attribute == 0)
1546     return data;
1547
1548   /* For some attributes we can display further information.  */
1549   printf ("\t");
1550
1551   switch (attribute)
1552     {
1553     case DW_AT_inline:
1554       switch (uvalue)
1555         {
1556         case DW_INL_not_inlined:
1557           printf (_("(not inlined)"));
1558           break;
1559         case DW_INL_inlined:
1560           printf (_("(inlined)"));
1561           break;
1562         case DW_INL_declared_not_inlined:
1563           printf (_("(declared as inline but ignored)"));
1564           break;
1565         case DW_INL_declared_inlined:
1566           printf (_("(declared as inline and inlined)"));
1567           break;
1568         default:
1569           printf (_("  (Unknown inline attribute value: %s)"),
1570                   dwarf_vmatoa ("x", uvalue));
1571           break;
1572         }
1573       break;
1574
1575     case DW_AT_language:
1576       switch (uvalue)
1577         {
1578           /* Ordered by the numeric value of these constants.  */
1579         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1580         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1581         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1582         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1583         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1584         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1585         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1586         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1587         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1588         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1589           /* DWARF 2.1 values.  */
1590         case DW_LANG_Java:              printf ("(Java)"); break;
1591         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1592         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1593         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1594           /* DWARF 3 values.  */
1595         case DW_LANG_PLI:               printf ("(PLI)"); break;
1596         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1597         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1598         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1599         case DW_LANG_D:                 printf ("(D)"); break;
1600           /* DWARF 4 values.  */
1601         case DW_LANG_Python:            printf ("(Python)"); break;
1602           /* MIPS extension.  */
1603         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1604           /* UPC extension.  */
1605         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1606         default:
1607           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1608             printf ("(implementation defined: %s)",
1609                     dwarf_vmatoa ("x", uvalue));
1610           else
1611             printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1612           break;
1613         }
1614       break;
1615
1616     case DW_AT_encoding:
1617       switch (uvalue)
1618         {
1619         case DW_ATE_void:               printf ("(void)"); break;
1620         case DW_ATE_address:            printf ("(machine address)"); break;
1621         case DW_ATE_boolean:            printf ("(boolean)"); break;
1622         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1623         case DW_ATE_float:              printf ("(float)"); break;
1624         case DW_ATE_signed:             printf ("(signed)"); break;
1625         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1626         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1627         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1628           /* DWARF 2.1 values:  */
1629         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1630         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1631           /* DWARF 3 values:  */
1632         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1633         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1634         case DW_ATE_edited:             printf ("(edited)"); break;
1635         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1636         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1637           /* HP extensions:  */
1638         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1639         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1640         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1641         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1642         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1643         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1644         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1645
1646         default:
1647           if (uvalue >= DW_ATE_lo_user
1648               && uvalue <= DW_ATE_hi_user)
1649             printf ("(user defined type)");
1650           else
1651             printf ("(unknown type)");
1652           break;
1653         }
1654       break;
1655
1656     case DW_AT_accessibility:
1657       switch (uvalue)
1658         {
1659         case DW_ACCESS_public:          printf ("(public)"); break;
1660         case DW_ACCESS_protected:       printf ("(protected)"); break;
1661         case DW_ACCESS_private:         printf ("(private)"); break;
1662         default:
1663           printf ("(unknown accessibility)");
1664           break;
1665         }
1666       break;
1667
1668     case DW_AT_visibility:
1669       switch (uvalue)
1670         {
1671         case DW_VIS_local:              printf ("(local)"); break;
1672         case DW_VIS_exported:           printf ("(exported)"); break;
1673         case DW_VIS_qualified:          printf ("(qualified)"); break;
1674         default:                        printf ("(unknown visibility)"); break;
1675         }
1676       break;
1677
1678     case DW_AT_virtuality:
1679       switch (uvalue)
1680         {
1681         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1682         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1683         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1684         default:                        printf ("(unknown virtuality)"); break;
1685         }
1686       break;
1687
1688     case DW_AT_identifier_case:
1689       switch (uvalue)
1690         {
1691         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1692         case DW_ID_up_case:             printf ("(up_case)"); break;
1693         case DW_ID_down_case:           printf ("(down_case)"); break;
1694         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1695         default:                        printf ("(unknown case)"); break;
1696         }
1697       break;
1698
1699     case DW_AT_calling_convention:
1700       switch (uvalue)
1701         {
1702         case DW_CC_normal:      printf ("(normal)"); break;
1703         case DW_CC_program:     printf ("(program)"); break;
1704         case DW_CC_nocall:      printf ("(nocall)"); break;
1705         default:
1706           if (uvalue >= DW_CC_lo_user
1707               && uvalue <= DW_CC_hi_user)
1708             printf ("(user defined)");
1709           else
1710             printf ("(unknown convention)");
1711         }
1712       break;
1713
1714     case DW_AT_ordering:
1715       switch (uvalue)
1716         {
1717         case -1: printf ("(undefined)"); break;
1718         case 0:  printf ("(row major)"); break;
1719         case 1:  printf ("(column major)"); break;
1720         }
1721       break;
1722
1723     case DW_AT_frame_base:
1724       have_frame_base = 1;
1725     case DW_AT_location:
1726     case DW_AT_string_length:
1727     case DW_AT_return_addr:
1728     case DW_AT_data_member_location:
1729     case DW_AT_vtable_elem_location:
1730     case DW_AT_segment:
1731     case DW_AT_static_link:
1732     case DW_AT_use_location:
1733     case DW_AT_GNU_call_site_value:
1734     case DW_AT_GNU_call_site_data_value:
1735     case DW_AT_GNU_call_site_target:
1736     case DW_AT_GNU_call_site_target_clobbered:
1737       if (form == DW_FORM_data4
1738           || form == DW_FORM_data8
1739           || form == DW_FORM_sec_offset)
1740         printf (_("(location list)"));
1741       /* Fall through.  */
1742     case DW_AT_allocated:
1743     case DW_AT_associated:
1744     case DW_AT_data_location:
1745     case DW_AT_stride:
1746     case DW_AT_upper_bound:
1747     case DW_AT_lower_bound:
1748       if (block_start)
1749         {
1750           int need_frame_base;
1751
1752           printf ("(");
1753           need_frame_base = decode_location_expression (block_start,
1754                                                         pointer_size,
1755                                                         offset_size,
1756                                                         dwarf_version,
1757                                                         uvalue,
1758                                                         cu_offset, section);
1759           printf (")");
1760           if (need_frame_base && !have_frame_base)
1761             printf (_(" [without DW_AT_frame_base]"));
1762         }
1763       break;
1764
1765     case DW_AT_import:
1766       {
1767         if (form == DW_FORM_ref_sig8)
1768           break;
1769
1770         if (form == DW_FORM_ref1
1771             || form == DW_FORM_ref2
1772             || form == DW_FORM_ref4)
1773           uvalue += cu_offset;
1774
1775         if (uvalue >= section->size)
1776           warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1777                 dwarf_vmatoa ("x", uvalue),
1778                 (unsigned long) (orig_data - section->start));
1779         else
1780           {
1781             unsigned long abbrev_number;
1782             abbrev_entry * entry;
1783
1784             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1785
1786             printf ("[Abbrev Number: %ld", abbrev_number);
1787             for (entry = first_abbrev; entry != NULL; entry = entry->next)
1788               if (entry->entry == abbrev_number)
1789                 break;
1790             if (entry != NULL)
1791               printf (" (%s)", get_TAG_name (entry->tag));
1792             printf ("]");
1793           }
1794       }
1795       break;
1796
1797     default:
1798       break;
1799     }
1800
1801   return data;
1802 }
1803
1804 static char *
1805 get_AT_name (unsigned long attribute)
1806 {
1807   switch (attribute)
1808     {
1809     case DW_AT_sibling:                 return "DW_AT_sibling";
1810     case DW_AT_location:                return "DW_AT_location";
1811     case DW_AT_name:                    return "DW_AT_name";
1812     case DW_AT_ordering:                return "DW_AT_ordering";
1813     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1814     case DW_AT_byte_size:               return "DW_AT_byte_size";
1815     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1816     case DW_AT_bit_size:                return "DW_AT_bit_size";
1817     case DW_AT_element_list:            return "DW_AT_element_list";
1818     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1819     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1820     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1821     case DW_AT_language:                return "DW_AT_language";
1822     case DW_AT_member:                  return "DW_AT_member";
1823     case DW_AT_discr:                   return "DW_AT_discr";
1824     case DW_AT_discr_value:             return "DW_AT_discr_value";
1825     case DW_AT_visibility:              return "DW_AT_visibility";
1826     case DW_AT_import:                  return "DW_AT_import";
1827     case DW_AT_string_length:           return "DW_AT_string_length";
1828     case DW_AT_common_reference:        return "DW_AT_common_reference";
1829     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1830     case DW_AT_const_value:             return "DW_AT_const_value";
1831     case DW_AT_containing_type:         return "DW_AT_containing_type";
1832     case DW_AT_default_value:           return "DW_AT_default_value";
1833     case DW_AT_inline:                  return "DW_AT_inline";
1834     case DW_AT_is_optional:             return "DW_AT_is_optional";
1835     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1836     case DW_AT_producer:                return "DW_AT_producer";
1837     case DW_AT_prototyped:              return "DW_AT_prototyped";
1838     case DW_AT_return_addr:             return "DW_AT_return_addr";
1839     case DW_AT_start_scope:             return "DW_AT_start_scope";
1840     case DW_AT_stride_size:             return "DW_AT_stride_size";
1841     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1842     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1843     case DW_AT_accessibility:           return "DW_AT_accessibility";
1844     case DW_AT_address_class:           return "DW_AT_address_class";
1845     case DW_AT_artificial:              return "DW_AT_artificial";
1846     case DW_AT_base_types:              return "DW_AT_base_types";
1847     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1848     case DW_AT_count:                   return "DW_AT_count";
1849     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1850     case DW_AT_decl_column:             return "DW_AT_decl_column";
1851     case DW_AT_decl_file:               return "DW_AT_decl_file";
1852     case DW_AT_decl_line:               return "DW_AT_decl_line";
1853     case DW_AT_declaration:             return "DW_AT_declaration";
1854     case DW_AT_discr_list:              return "DW_AT_discr_list";
1855     case DW_AT_encoding:                return "DW_AT_encoding";
1856     case DW_AT_external:                return "DW_AT_external";
1857     case DW_AT_frame_base:              return "DW_AT_frame_base";
1858     case DW_AT_friend:                  return "DW_AT_friend";
1859     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1860     case DW_AT_macro_info:              return "DW_AT_macro_info";
1861     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1862     case DW_AT_priority:                return "DW_AT_priority";
1863     case DW_AT_segment:                 return "DW_AT_segment";
1864     case DW_AT_specification:           return "DW_AT_specification";
1865     case DW_AT_static_link:             return "DW_AT_static_link";
1866     case DW_AT_type:                    return "DW_AT_type";
1867     case DW_AT_use_location:            return "DW_AT_use_location";
1868     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1869     case DW_AT_virtuality:              return "DW_AT_virtuality";
1870     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1871       /* DWARF 2.1 values.  */
1872     case DW_AT_allocated:               return "DW_AT_allocated";
1873     case DW_AT_associated:              return "DW_AT_associated";
1874     case DW_AT_data_location:           return "DW_AT_data_location";
1875     case DW_AT_stride:                  return "DW_AT_stride";
1876     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1877     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1878     case DW_AT_extension:               return "DW_AT_extension";
1879     case DW_AT_ranges:                  return "DW_AT_ranges";
1880     case DW_AT_trampoline:              return "DW_AT_trampoline";
1881     case DW_AT_call_column:             return "DW_AT_call_column";
1882     case DW_AT_call_file:               return "DW_AT_call_file";
1883     case DW_AT_call_line:               return "DW_AT_call_line";
1884     case DW_AT_description:             return "DW_AT_description";
1885     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1886     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1887     case DW_AT_small:                   return "DW_AT_small";
1888     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1889     case DW_AT_digit_count:             return "DW_AT_digit_count";
1890     case DW_AT_picture_string:          return "DW_AT_picture_string";
1891     case DW_AT_mutable:                 return "DW_AT_mutable";
1892     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1893     case DW_AT_explicit:                return "DW_AT_explicit";
1894     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1895     case DW_AT_endianity:               return "DW_AT_endianity";
1896     case DW_AT_elemental:               return "DW_AT_elemental";
1897     case DW_AT_pure:                    return "DW_AT_pure";
1898     case DW_AT_recursive:               return "DW_AT_recursive";
1899       /* DWARF 4 values.  */
1900     case DW_AT_signature:               return "DW_AT_signature";
1901     case DW_AT_main_subprogram:         return "DW_AT_main_subprogram";
1902     case DW_AT_data_bit_offset:         return "DW_AT_data_bit_offset";
1903     case DW_AT_const_expr:              return "DW_AT_const_expr";
1904     case DW_AT_enum_class:              return "DW_AT_enum_class";
1905     case DW_AT_linkage_name:            return "DW_AT_linkage_name";
1906
1907       /* HP and SGI/MIPS extensions.  */
1908     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1909     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1910     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1911     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1912     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1913     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1914     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1915     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1916     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1917     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1918
1919       /* HP Extensions.  */
1920     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1921     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1922     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1923     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1924     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1925     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1926     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1927     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1928     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1929     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1930     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1931     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1932     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1933
1934       /* One value is shared by the MIPS and HP extensions:  */
1935     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1936
1937       /* GNU extensions.  */
1938     case DW_AT_sf_names:                        return "DW_AT_sf_names";
1939     case DW_AT_src_info:                        return "DW_AT_src_info";
1940     case DW_AT_mac_info:                        return "DW_AT_mac_info";
1941     case DW_AT_src_coords:                      return "DW_AT_src_coords";
1942     case DW_AT_body_begin:                      return "DW_AT_body_begin";
1943     case DW_AT_body_end:                        return "DW_AT_body_end";
1944     case DW_AT_GNU_vector:                      return "DW_AT_GNU_vector";
1945     case DW_AT_GNU_guarded_by:                  return "DW_AT_GNU_guarded_by";
1946     case DW_AT_GNU_pt_guarded_by:               return "DW_AT_GNU_pt_guarded_by";
1947     case DW_AT_GNU_guarded:                     return "DW_AT_GNU_guarded";
1948     case DW_AT_GNU_pt_guarded:                  return "DW_AT_GNU_pt_guarded";
1949     case DW_AT_GNU_locks_excluded:              return "DW_AT_GNU_locks_excluded";
1950     case DW_AT_GNU_exclusive_locks_required:    return "DW_AT_GNU_exclusive_locks_required";
1951     case DW_AT_GNU_shared_locks_required:       return "DW_AT_GNU_shared_locks_required";
1952     case DW_AT_GNU_odr_signature:               return "DW_AT_GNU_odr_signature";
1953     case DW_AT_use_GNAT_descriptive_type:       return "DW_AT_use_GNAT_descriptive_type";
1954     case DW_AT_GNAT_descriptive_type:           return "DW_AT_GNAT_descriptive_type";
1955     case DW_AT_GNU_call_site_value:             return "DW_AT_GNU_call_site_value";
1956     case DW_AT_GNU_call_site_data_value:        return "DW_AT_GNU_call_site_data_value";
1957     case DW_AT_GNU_call_site_target:            return "DW_AT_GNU_call_site_target";
1958     case DW_AT_GNU_call_site_target_clobbered:  return "DW_AT_GNU_call_site_target_clobbered";
1959     case DW_AT_GNU_tail_call:                   return "DW_AT_GNU_tail_call";
1960     case DW_AT_GNU_all_tail_call_sites:         return "DW_AT_GNU_all_tail_call_sites";
1961     case DW_AT_GNU_all_call_sites:              return "DW_AT_GNU_all_call_sites";
1962     case DW_AT_GNU_all_source_call_sites:       return "DW_AT_GNU_all_source_call_sites";
1963     case DW_AT_GNU_macros:                      return "DW_AT_GNU_macros";
1964
1965       /* UPC extension.  */
1966     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1967
1968     /* PGI (STMicroelectronics) extensions.  */
1969     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1970     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1971     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1972
1973     default:
1974       {
1975         static char buffer[100];
1976
1977         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1978                   attribute);
1979         return buffer;
1980       }
1981     }
1982 }
1983
1984 static unsigned char *
1985 read_and_display_attr (unsigned long attribute,
1986                        unsigned long form,
1987                        unsigned char * data,
1988                        dwarf_vma cu_offset,
1989                        dwarf_vma pointer_size,
1990                        dwarf_vma offset_size,
1991                        int dwarf_version,
1992                        debug_info * debug_info_p,
1993                        int do_loc,
1994                        struct dwarf_section * section)
1995 {
1996   if (!do_loc)
1997     printf ("   %-18s:", get_AT_name (attribute));
1998   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1999                                       pointer_size, offset_size,
2000                                       dwarf_version, debug_info_p,
2001                                       do_loc, section);
2002   if (!do_loc)
2003     printf ("\n");
2004   return data;
2005 }
2006
2007
2008 /* Process the contents of a .debug_info section.  If do_loc is non-zero
2009    then we are scanning for location lists and we do not want to display
2010    anything to the user.  If do_types is non-zero, we are processing
2011    a .debug_types section instead of a .debug_info section.  */
2012
2013 static int
2014 process_debug_info (struct dwarf_section *section,
2015                     void *file,
2016                     enum dwarf_section_display_enum abbrev_sec,
2017                     int do_loc,
2018                     int do_types)
2019 {
2020   unsigned char *start = section->start;
2021   unsigned char *end = start + section->size;
2022   unsigned char *section_begin;
2023   unsigned int unit;
2024   unsigned int num_units = 0;
2025
2026   if ((do_loc || do_debug_loc || do_debug_ranges)
2027       && num_debug_info_entries == 0
2028       && ! do_types)
2029     {
2030       dwarf_vma length;
2031
2032       /* First scan the section to get the number of comp units.  */
2033       for (section_begin = start, num_units = 0; section_begin < end;
2034            num_units ++)
2035         {
2036           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2037              will be the length.  For a 64-bit DWARF section, it'll be
2038              the escape code 0xffffffff followed by an 8 byte length.  */
2039           length = byte_get (section_begin, 4);
2040
2041           if (length == 0xffffffff)
2042             {
2043               length = byte_get (section_begin + 4, 8);
2044               section_begin += length + 12;
2045             }
2046           else if (length >= 0xfffffff0 && length < 0xffffffff)
2047             {
2048               warn (_("Reserved length value (0x%s) found in section %s\n"),
2049                     dwarf_vmatoa ("x", length), section->name);
2050               return 0;
2051             }
2052           else
2053             section_begin += length + 4;
2054
2055           /* Negative values are illegal, they may even cause infinite
2056              looping.  This can happen if we can't accurately apply
2057              relocations to an object file.  */
2058           if ((signed long) length <= 0)
2059             {
2060               warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2061                     dwarf_vmatoa ("x", length), section->name);
2062               return 0;
2063             }
2064         }
2065
2066       if (num_units == 0)
2067         {
2068           error (_("No comp units in %s section ?"), section->name);
2069           return 0;
2070         }
2071
2072       /* Then allocate an array to hold the information.  */
2073       debug_information = (debug_info *) cmalloc (num_units,
2074                                                   sizeof (* debug_information));
2075       if (debug_information == NULL)
2076         {
2077           error (_("Not enough memory for a debug info array of %u entries"),
2078                  num_units);
2079           return 0;
2080         }
2081     }
2082
2083   if (!do_loc)
2084     {
2085       if (dwarf_start_die == 0)
2086         printf (_("Contents of the %s section:\n\n"), section->name);
2087
2088       load_debug_section (str, file);
2089     }
2090
2091   load_debug_section (abbrev_sec, file);
2092   if (debug_displays [abbrev_sec].section.start == NULL)
2093     {
2094       warn (_("Unable to locate %s section!\n"),
2095             debug_displays [abbrev_sec].section.name);
2096       return 0;
2097     }
2098
2099   for (section_begin = start, unit = 0; start < end; unit++)
2100     {
2101       DWARF2_Internal_CompUnit compunit;
2102       unsigned char *hdrptr;
2103       unsigned char *tags;
2104       int level, last_level, saved_level;
2105       dwarf_vma cu_offset;
2106       int offset_size;
2107       int initial_length_size;
2108       unsigned char signature[8] = { 0 };
2109       dwarf_vma type_offset = 0;
2110
2111       hdrptr = start;
2112
2113       compunit.cu_length = byte_get (hdrptr, 4);
2114       hdrptr += 4;
2115
2116       if (compunit.cu_length == 0xffffffff)
2117         {
2118           compunit.cu_length = byte_get (hdrptr, 8);
2119           hdrptr += 8;
2120           offset_size = 8;
2121           initial_length_size = 12;
2122         }
2123       else
2124         {
2125           offset_size = 4;
2126           initial_length_size = 4;
2127         }
2128
2129       compunit.cu_version = byte_get (hdrptr, 2);
2130       hdrptr += 2;
2131
2132       cu_offset = start - section_begin;
2133
2134       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2135       hdrptr += offset_size;
2136
2137       compunit.cu_pointer_size = byte_get (hdrptr, 1);
2138       hdrptr += 1;
2139
2140       if (do_types)
2141         {
2142           int i;
2143
2144           for (i = 0; i < 8; i++)
2145             {
2146               signature[i] = byte_get (hdrptr, 1);
2147               hdrptr += 1;
2148             }
2149
2150           type_offset = byte_get (hdrptr, offset_size);
2151           hdrptr += offset_size;
2152         }
2153
2154       if ((do_loc || do_debug_loc || do_debug_ranges)
2155           && num_debug_info_entries == 0
2156           && ! do_types)
2157         {
2158           debug_information [unit].cu_offset = cu_offset;
2159           debug_information [unit].pointer_size
2160             = compunit.cu_pointer_size;
2161           debug_information [unit].offset_size = offset_size;
2162           debug_information [unit].dwarf_version = compunit.cu_version;
2163           debug_information [unit].base_address = 0;
2164           debug_information [unit].loc_offsets = NULL;
2165           debug_information [unit].have_frame_base = NULL;
2166           debug_information [unit].max_loc_offsets = 0;
2167           debug_information [unit].num_loc_offsets = 0;
2168           debug_information [unit].range_lists = NULL;
2169           debug_information [unit].max_range_lists= 0;
2170           debug_information [unit].num_range_lists = 0;
2171         }
2172
2173       if (!do_loc && dwarf_start_die == 0)
2174         {
2175           printf (_("  Compilation Unit @ offset 0x%s:\n"),
2176                   dwarf_vmatoa ("x", cu_offset));
2177           printf (_("   Length:        0x%s (%s)\n"),
2178                   dwarf_vmatoa ("x", compunit.cu_length),
2179                   offset_size == 8 ? "64-bit" : "32-bit");
2180           printf (_("   Version:       %d\n"), compunit.cu_version);
2181           printf (_("   Abbrev Offset: %s\n"),
2182                   dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2183           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2184           if (do_types)
2185             {
2186               int i;
2187               printf (_("   Signature:     "));
2188               for (i = 0; i < 8; i++)
2189                 printf ("%02x", signature[i]);
2190               printf ("\n");
2191              printf (_("   Type Offset:   0x%s\n"),
2192                      dwarf_vmatoa ("x", type_offset));
2193             }
2194         }
2195
2196       if (cu_offset + compunit.cu_length + initial_length_size
2197           > section->size)
2198         {
2199           warn (_("Debug info is corrupted, length of CU at %s"
2200                   " extends beyond end of section (length = %s)\n"),
2201                 dwarf_vmatoa ("x", cu_offset),
2202                 dwarf_vmatoa ("x", compunit.cu_length));
2203           break;
2204         }
2205       tags = hdrptr;
2206       start += compunit.cu_length + initial_length_size;
2207
2208       if (compunit.cu_version != 2
2209           && compunit.cu_version != 3
2210           && compunit.cu_version != 4)
2211         {
2212           warn (_("CU at offset %s contains corrupt or "
2213                   "unsupported version number: %d.\n"),
2214                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2215           continue;
2216         }
2217
2218       free_abbrevs ();
2219
2220       /* Process the abbrevs used by this compilation unit. DWARF
2221          sections under Mach-O have non-zero addresses.  */
2222       if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2223         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2224               (unsigned long) compunit.cu_abbrev_offset,
2225               (unsigned long) debug_displays [abbrev_sec].section.size);
2226       else
2227         process_abbrev_section
2228           ((unsigned char *) debug_displays [abbrev_sec].section.start
2229            + compunit.cu_abbrev_offset,
2230            (unsigned char *) debug_displays [abbrev_sec].section.start
2231            + debug_displays [abbrev_sec].section.size);
2232
2233       level = 0;
2234       last_level = level;
2235       saved_level = -1;
2236       while (tags < start)
2237         {
2238           unsigned int bytes_read;
2239           unsigned long abbrev_number;
2240           unsigned long die_offset;
2241           abbrev_entry *entry;
2242           abbrev_attr *attr;
2243           int do_printing = 1;
2244
2245           die_offset = tags - section_begin;
2246
2247           abbrev_number = read_leb128 (tags, & bytes_read, 0);
2248           tags += bytes_read;
2249
2250           /* A null DIE marks the end of a list of siblings or it may also be
2251              a section padding.  */
2252           if (abbrev_number == 0)
2253             {
2254               /* Check if it can be a section padding for the last CU.  */
2255               if (level == 0 && start == end)
2256                 {
2257                   unsigned char *chk;
2258
2259                   for (chk = tags; chk < start; chk++)
2260                     if (*chk != 0)
2261                       break;
2262                   if (chk == start)
2263                     break;
2264                 }
2265
2266               --level;
2267               if (level < 0)
2268                 {
2269                   static unsigned num_bogus_warns = 0;
2270
2271                   if (num_bogus_warns < 3)
2272                     {
2273                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2274                             die_offset);
2275                       num_bogus_warns ++;
2276                       if (num_bogus_warns == 3)
2277                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2278                     }
2279                 }
2280               if (dwarf_start_die != 0 && level < saved_level)
2281                 return 1;
2282               continue;
2283             }
2284
2285           if (!do_loc)
2286             {
2287               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2288                 do_printing = 0;
2289               else
2290                 {
2291                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2292                     saved_level = level;
2293                   do_printing = (dwarf_cutoff_level == -1
2294                                  || level < dwarf_cutoff_level);
2295                   if (do_printing)
2296                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2297                             level, die_offset, abbrev_number);
2298                   else if (dwarf_cutoff_level == -1
2299                            || last_level < dwarf_cutoff_level)
2300                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2301                   last_level = level;
2302                 }
2303             }
2304
2305           /* Scan through the abbreviation list until we reach the
2306              correct entry.  */
2307           for (entry = first_abbrev;
2308                entry && entry->entry != abbrev_number;
2309                entry = entry->next)
2310             continue;
2311
2312           if (entry == NULL)
2313             {
2314               if (!do_loc && do_printing)
2315                 {
2316                   printf ("\n");
2317                   fflush (stdout);
2318                 }
2319               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2320                     die_offset, abbrev_number);
2321               return 0;
2322             }
2323
2324           if (!do_loc && do_printing)
2325             printf (" (%s)\n", get_TAG_name (entry->tag));
2326
2327           switch (entry->tag)
2328             {
2329             default:
2330               need_base_address = 0;
2331               break;
2332             case DW_TAG_compile_unit:
2333               need_base_address = 1;
2334               break;
2335             case DW_TAG_entry_point:
2336             case DW_TAG_subprogram:
2337               need_base_address = 0;
2338               /* Assuming that there is no DW_AT_frame_base.  */
2339               have_frame_base = 0;
2340               break;
2341             }
2342
2343           for (attr = entry->first_attr; attr; attr = attr->next)
2344             {
2345               debug_info *arg;
2346
2347               if (! do_loc && do_printing)
2348                 /* Show the offset from where the tag was extracted.  */
2349                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2350
2351               arg = debug_information;
2352               if (debug_information)
2353                 arg += unit;
2354
2355               tags = read_and_display_attr (attr->attribute,
2356                                             attr->form,
2357                                             tags, cu_offset,
2358                                             compunit.cu_pointer_size,
2359                                             offset_size,
2360                                             compunit.cu_version,
2361                                             arg,
2362                                             do_loc || ! do_printing, section);
2363             }
2364
2365           if (entry->children)
2366             ++level;
2367         }
2368     }
2369
2370   /* Set num_debug_info_entries here so that it can be used to check if
2371      we need to process .debug_loc and .debug_ranges sections.  */
2372   if ((do_loc || do_debug_loc || do_debug_ranges)
2373       && num_debug_info_entries == 0
2374       && ! do_types)
2375     num_debug_info_entries = num_units;
2376
2377   if (!do_loc)
2378     printf ("\n");
2379
2380   return 1;
2381 }
2382
2383 /* Locate and scan the .debug_info section in the file and record the pointer
2384    sizes and offsets for the compilation units in it.  Usually an executable
2385    will have just one pointer size, but this is not guaranteed, and so we try
2386    not to make any assumptions.  Returns zero upon failure, or the number of
2387    compilation units upon success.  */
2388
2389 static unsigned int
2390 load_debug_info (void * file)
2391 {
2392   /* Reset the last pointer size so that we can issue correct error
2393      messages if we are displaying the contents of more than one section.  */
2394   last_pointer_size = 0;
2395   warned_about_missing_comp_units = FALSE;
2396
2397   /* If we have already tried and failed to load the .debug_info
2398      section then do not bother to repear the task.  */
2399   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2400     return 0;
2401
2402   /* If we already have the information there is nothing else to do.  */
2403   if (num_debug_info_entries > 0)
2404     return num_debug_info_entries;
2405
2406   if (load_debug_section (info, file)
2407       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2408     return num_debug_info_entries;
2409
2410   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2411   return 0;
2412 }
2413
2414 static int
2415 display_debug_lines_raw (struct dwarf_section *section,
2416                          unsigned char *data,
2417                          unsigned char *end)
2418 {
2419   unsigned char *start = section->start;
2420
2421   printf (_("Raw dump of debug contents of section %s:\n\n"),
2422           section->name);
2423
2424   while (data < end)
2425     {
2426       DWARF2_Internal_LineInfo linfo;
2427       unsigned char *standard_opcodes;
2428       unsigned char *end_of_sequence;
2429       unsigned char *hdrptr;
2430       unsigned long hdroff;
2431       int initial_length_size;
2432       int offset_size;
2433       int i;
2434
2435       hdrptr = data;
2436       hdroff = hdrptr - start;
2437
2438       /* Check the length of the block.  */
2439       linfo.li_length = byte_get (hdrptr, 4);
2440       hdrptr += 4;
2441
2442       if (linfo.li_length == 0xffffffff)
2443         {
2444           /* This section is 64-bit DWARF 3.  */
2445           linfo.li_length = byte_get (hdrptr, 8);
2446           hdrptr += 8;
2447           offset_size = 8;
2448           initial_length_size = 12;
2449         }
2450       else
2451         {
2452           offset_size = 4;
2453           initial_length_size = 4;
2454         }
2455
2456       if (linfo.li_length + initial_length_size > section->size)
2457         {
2458           warn
2459             (_("The information in section %s appears to be corrupt - the section is too small\n"),
2460              section->name);
2461           return 0;
2462         }
2463
2464       /* Check its version number.  */
2465       linfo.li_version = byte_get (hdrptr, 2);
2466       hdrptr += 2;
2467       if (linfo.li_version != 2
2468           && linfo.li_version != 3
2469           && linfo.li_version != 4)
2470         {
2471           warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2472           return 0;
2473         }
2474
2475       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2476       hdrptr += offset_size;
2477       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2478       hdrptr++;
2479       if (linfo.li_version >= 4)
2480         {
2481           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2482           hdrptr++;
2483           if (linfo.li_max_ops_per_insn == 0)
2484             {
2485               warn (_("Invalid maximum operations per insn.\n"));
2486               return 0;
2487             }
2488         }
2489       else
2490         linfo.li_max_ops_per_insn = 1;
2491       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2492       hdrptr++;
2493       linfo.li_line_base = byte_get (hdrptr, 1);
2494       hdrptr++;
2495       linfo.li_line_range = byte_get (hdrptr, 1);
2496       hdrptr++;
2497       linfo.li_opcode_base = byte_get (hdrptr, 1);
2498       hdrptr++;
2499
2500       /* Sign extend the line base field.  */
2501       linfo.li_line_base <<= 24;
2502       linfo.li_line_base >>= 24;
2503
2504       printf (_("  Offset:                      0x%lx\n"), hdroff);
2505       printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2506       printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2507       printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
2508       printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2509       if (linfo.li_version >= 4)
2510         printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2511       printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2512       printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2513       printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2514       printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2515
2516       end_of_sequence = data + linfo.li_length + initial_length_size;
2517
2518       reset_state_machine (linfo.li_default_is_stmt);
2519
2520       /* Display the contents of the Opcodes table.  */
2521       standard_opcodes = hdrptr;
2522
2523       printf (_("\n Opcodes:\n"));
2524
2525       for (i = 1; i < linfo.li_opcode_base; i++)
2526         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2527
2528       /* Display the contents of the Directory table.  */
2529       data = standard_opcodes + linfo.li_opcode_base - 1;
2530
2531       if (*data == 0)
2532         printf (_("\n The Directory Table is empty.\n"));
2533       else
2534         {
2535           printf (_("\n The Directory Table:\n"));
2536
2537           while (*data != 0)
2538             {
2539               printf ("  %s\n", data);
2540
2541               data += strlen ((char *) data) + 1;
2542             }
2543         }
2544
2545       /* Skip the NUL at the end of the table.  */
2546       data++;
2547
2548       /* Display the contents of the File Name table.  */
2549       if (*data == 0)
2550         printf (_("\n The File Name Table is empty.\n"));
2551       else
2552         {
2553           printf (_("\n The File Name Table:\n"));
2554           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2555
2556           while (*data != 0)
2557             {
2558               unsigned char *name;
2559               unsigned int bytes_read;
2560
2561               printf ("  %d\t", ++state_machine_regs.last_file_entry);
2562               name = data;
2563
2564               data += strlen ((char *) data) + 1;
2565
2566               printf ("%s\t",
2567                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2568               data += bytes_read;
2569               printf ("%s\t",
2570                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2571               data += bytes_read;
2572               printf ("%s\t",
2573                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2574               data += bytes_read;
2575               printf ("%s\n", name);
2576             }
2577         }
2578
2579       /* Skip the NUL at the end of the table.  */
2580       data++;
2581
2582       /* Now display the statements.  */
2583       printf (_("\n Line Number Statements:\n"));
2584
2585       while (data < end_of_sequence)
2586         {
2587           unsigned char op_code;
2588           dwarf_signed_vma adv;
2589           dwarf_vma uladv;
2590           unsigned int bytes_read;
2591
2592           op_code = *data++;
2593
2594           if (op_code >= linfo.li_opcode_base)
2595             {
2596               op_code -= linfo.li_opcode_base;
2597               uladv = (op_code / linfo.li_line_range);
2598               if (linfo.li_max_ops_per_insn == 1)
2599                 {
2600                   uladv *= linfo.li_min_insn_length;
2601                   state_machine_regs.address += uladv;
2602                   printf (_("  Special opcode %d: "
2603                             "advance Address by %s to 0x%s"),
2604                           op_code, dwarf_vmatoa ("u", uladv),
2605                           dwarf_vmatoa ("x", state_machine_regs.address));
2606                 }
2607               else
2608                 {
2609                   state_machine_regs.address
2610                     += ((state_machine_regs.op_index + uladv)
2611                         / linfo.li_max_ops_per_insn)
2612                        * linfo.li_min_insn_length;
2613                   state_machine_regs.op_index
2614                     = (state_machine_regs.op_index + uladv)
2615                       % linfo.li_max_ops_per_insn;
2616                   printf (_("  Special opcode %d: "
2617                             "advance Address by %s to 0x%s[%d]"),
2618                           op_code, dwarf_vmatoa ("u", uladv),
2619                           dwarf_vmatoa ("x", state_machine_regs.address),
2620                           state_machine_regs.op_index);
2621                 }
2622               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2623               state_machine_regs.line += adv;
2624               printf (_(" and Line by %s to %d\n"),
2625                       dwarf_vmatoa ("d", adv), state_machine_regs.line);
2626             }
2627           else switch (op_code)
2628             {
2629             case DW_LNS_extended_op:
2630               data += process_extended_line_op (data, linfo.li_default_is_stmt);
2631               break;
2632
2633             case DW_LNS_copy:
2634               printf (_("  Copy\n"));
2635               break;
2636
2637             case DW_LNS_advance_pc:
2638               uladv = read_leb128 (data, & bytes_read, 0);
2639               data += bytes_read;
2640               if (linfo.li_max_ops_per_insn == 1)
2641                 {
2642                   uladv *= linfo.li_min_insn_length;
2643                   state_machine_regs.address += uladv;
2644                   printf (_("  Advance PC by %s to 0x%s\n"),
2645                           dwarf_vmatoa ("u", uladv),
2646                           dwarf_vmatoa ("x", state_machine_regs.address));
2647                 }
2648               else
2649                 {
2650                   state_machine_regs.address
2651                     += ((state_machine_regs.op_index + uladv)
2652                         / linfo.li_max_ops_per_insn)
2653                        * linfo.li_min_insn_length;
2654                   state_machine_regs.op_index
2655                     = (state_machine_regs.op_index + uladv)
2656                       % linfo.li_max_ops_per_insn;
2657                   printf (_("  Advance PC by %s to 0x%s[%d]\n"),
2658                           dwarf_vmatoa ("u", uladv),
2659                           dwarf_vmatoa ("x", state_machine_regs.address),
2660                           state_machine_regs.op_index);
2661                 }
2662               break;
2663
2664             case DW_LNS_advance_line:
2665               adv = read_sleb128 (data, & bytes_read);
2666               data += bytes_read;
2667               state_machine_regs.line += adv;
2668               printf (_("  Advance Line by %s to %d\n"),
2669                         dwarf_vmatoa ("d", adv),
2670                         state_machine_regs.line);
2671               break;
2672
2673             case DW_LNS_set_file:
2674               adv = read_leb128 (data, & bytes_read, 0);
2675               data += bytes_read;
2676               printf (_("  Set File Name to entry %s in the File Name Table\n"),
2677                       dwarf_vmatoa ("d", adv));
2678               state_machine_regs.file = adv;
2679               break;
2680
2681             case DW_LNS_set_column:
2682               uladv = read_leb128 (data, & bytes_read, 0);
2683               data += bytes_read;
2684               printf (_("  Set column to %s\n"),
2685                       dwarf_vmatoa ("u", uladv));
2686               state_machine_regs.column = uladv;
2687               break;
2688
2689             case DW_LNS_negate_stmt:
2690               adv = state_machine_regs.is_stmt;
2691               adv = ! adv;
2692               printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2693               state_machine_regs.is_stmt = adv;
2694               break;
2695
2696             case DW_LNS_set_basic_block:
2697               printf (_("  Set basic block\n"));
2698               state_machine_regs.basic_block = 1;
2699               break;
2700
2701             case DW_LNS_const_add_pc:
2702               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2703               if (linfo.li_max_ops_per_insn)
2704                 {
2705                   uladv *= linfo.li_min_insn_length;
2706                   state_machine_regs.address += uladv;
2707                   printf (_("  Advance PC by constant %s to 0x%s\n"),
2708                           dwarf_vmatoa ("u", uladv),
2709                           dwarf_vmatoa ("x", state_machine_regs.address));
2710                 }
2711               else
2712                 {
2713                   state_machine_regs.address
2714                     += ((state_machine_regs.op_index + uladv)
2715                         / linfo.li_max_ops_per_insn)
2716                        * linfo.li_min_insn_length;
2717                   state_machine_regs.op_index
2718                     = (state_machine_regs.op_index + uladv)
2719                       % linfo.li_max_ops_per_insn;
2720                   printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
2721                           dwarf_vmatoa ("u", uladv),
2722                           dwarf_vmatoa ("x", state_machine_regs.address),
2723                           state_machine_regs.op_index);
2724                 }
2725               break;
2726
2727             case DW_LNS_fixed_advance_pc:
2728               uladv = byte_get (data, 2);
2729               data += 2;
2730               state_machine_regs.address += uladv;
2731               state_machine_regs.op_index = 0;
2732               printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
2733                       dwarf_vmatoa ("u", uladv),
2734                       dwarf_vmatoa ("x", state_machine_regs.address));
2735               break;
2736
2737             case DW_LNS_set_prologue_end:
2738               printf (_("  Set prologue_end to true\n"));
2739               break;
2740
2741             case DW_LNS_set_epilogue_begin:
2742               printf (_("  Set epilogue_begin to true\n"));
2743               break;
2744
2745             case DW_LNS_set_isa:
2746               uladv = read_leb128 (data, & bytes_read, 0);
2747               data += bytes_read;
2748               printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2749               break;
2750
2751             default:
2752               printf (_("  Unknown opcode %d with operands: "), op_code);
2753
2754               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2755                 {
2756                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2757                                                          &bytes_read, 0)),
2758                           i == 1 ? "" : ", ");
2759                   data += bytes_read;
2760                 }
2761               putchar ('\n');
2762               break;
2763             }
2764         }
2765       putchar ('\n');
2766     }
2767
2768   return 1;
2769 }
2770
2771 typedef struct
2772 {
2773   unsigned char *name;
2774   unsigned int directory_index;
2775   unsigned int modification_date;
2776   unsigned int length;
2777 } File_Entry;
2778
2779 /* Output a decoded representation of the .debug_line section.  */
2780
2781 static int
2782 display_debug_lines_decoded (struct dwarf_section *section,
2783                              unsigned char *data,
2784                              unsigned char *end)
2785 {
2786   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2787           section->name);
2788
2789   while (data < end)
2790     {
2791       /* This loop amounts to one iteration per compilation unit.  */
2792       DWARF2_Internal_LineInfo linfo;
2793       unsigned char *standard_opcodes;
2794       unsigned char *end_of_sequence;
2795       unsigned char *hdrptr;
2796       int initial_length_size;
2797       int offset_size;
2798       int i;
2799       File_Entry *file_table = NULL;
2800       unsigned char **directory_table = NULL;
2801
2802       hdrptr = data;
2803
2804       /* Extract information from the Line Number Program Header.
2805         (section 6.2.4 in the Dwarf3 doc).  */
2806
2807       /* Get the length of this CU's line number information block.  */
2808       linfo.li_length = byte_get (hdrptr, 4);
2809       hdrptr += 4;
2810
2811       if (linfo.li_length == 0xffffffff)
2812         {
2813           /* This section is 64-bit DWARF 3.  */
2814           linfo.li_length = byte_get (hdrptr, 8);
2815           hdrptr += 8;
2816           offset_size = 8;
2817           initial_length_size = 12;
2818         }
2819       else
2820         {
2821           offset_size = 4;
2822           initial_length_size = 4;
2823         }
2824
2825       if (linfo.li_length + initial_length_size > section->size)
2826         {
2827           warn (_("The line info appears to be corrupt - "
2828                   "the section is too small\n"));
2829           return 0;
2830         }
2831
2832       /* Get this CU's Line Number Block version number.  */
2833       linfo.li_version = byte_get (hdrptr, 2);
2834       hdrptr += 2;
2835       if (linfo.li_version != 2
2836           && linfo.li_version != 3
2837           && linfo.li_version != 4)
2838         {
2839           warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2840                 "supported.\n"));
2841           return 0;
2842         }
2843
2844       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2845       hdrptr += offset_size;
2846       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2847       hdrptr++;
2848       if (linfo.li_version >= 4)
2849         {
2850           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2851           hdrptr++;
2852           if (linfo.li_max_ops_per_insn == 0)
2853             {
2854               warn (_("Invalid maximum operations per insn.\n"));
2855               return 0;
2856             }
2857         }
2858       else
2859         linfo.li_max_ops_per_insn = 1;
2860       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2861       hdrptr++;
2862       linfo.li_line_base = byte_get (hdrptr, 1);
2863       hdrptr++;
2864       linfo.li_line_range = byte_get (hdrptr, 1);
2865       hdrptr++;
2866       linfo.li_opcode_base = byte_get (hdrptr, 1);
2867       hdrptr++;
2868
2869       /* Sign extend the line base field.  */
2870       linfo.li_line_base <<= 24;
2871       linfo.li_line_base >>= 24;
2872
2873       /* Find the end of this CU's Line Number Information Block.  */
2874       end_of_sequence = data + linfo.li_length + initial_length_size;
2875
2876       reset_state_machine (linfo.li_default_is_stmt);
2877
2878       /* Save a pointer to the contents of the Opcodes table.  */
2879       standard_opcodes = hdrptr;
2880
2881       /* Traverse the Directory table just to count entries.  */
2882       data = standard_opcodes + linfo.li_opcode_base - 1;
2883       if (*data != 0)
2884         {
2885           unsigned int n_directories = 0;
2886           unsigned char *ptr_directory_table = data;
2887
2888           while (*data != 0)
2889             {
2890               data += strlen ((char *) data) + 1;
2891               n_directories++;
2892             }
2893
2894           /* Go through the directory table again to save the directories.  */
2895           directory_table = (unsigned char **)
2896               xmalloc (n_directories * sizeof (unsigned char *));
2897
2898           i = 0;
2899           while (*ptr_directory_table != 0)
2900             {
2901               directory_table[i] = ptr_directory_table;
2902               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2903               i++;
2904             }
2905         }
2906       /* Skip the NUL at the end of the table.  */
2907       data++;
2908
2909       /* Traverse the File Name table just to count the entries.  */
2910       if (*data != 0)
2911         {
2912           unsigned int n_files = 0;
2913           unsigned char *ptr_file_name_table = data;
2914
2915           while (*data != 0)
2916             {
2917               unsigned int bytes_read;
2918
2919               /* Skip Name, directory index, last modification time and length
2920                  of file.  */
2921               data += strlen ((char *) data) + 1;
2922               read_leb128 (data, & bytes_read, 0);
2923               data += bytes_read;
2924               read_leb128 (data, & bytes_read, 0);
2925               data += bytes_read;
2926               read_leb128 (data, & bytes_read, 0);
2927               data += bytes_read;
2928
2929               n_files++;
2930             }
2931
2932           /* Go through the file table again to save the strings.  */
2933           file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2934
2935           i = 0;
2936           while (*ptr_file_name_table != 0)
2937             {
2938               unsigned int bytes_read;
2939
2940               file_table[i].name = ptr_file_name_table;
2941               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2942
2943               /* We are not interested in directory, time or size.  */
2944               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2945                                                            & bytes_read, 0);
2946               ptr_file_name_table += bytes_read;
2947               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2948                                                              & bytes_read, 0);
2949               ptr_file_name_table += bytes_read;
2950               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2951               ptr_file_name_table += bytes_read;
2952               i++;
2953             }
2954           i = 0;
2955
2956           /* Print the Compilation Unit's name and a header.  */
2957           if (directory_table == NULL)
2958             {
2959               printf (_("CU: %s:\n"), file_table[0].name);
2960               printf (_("File name                            Line number    Starting address\n"));
2961             }
2962           else
2963             {
2964               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2965                 printf (_("CU: %s/%s:\n"), directory_table[0],
2966                         file_table[0].name);
2967               else
2968                 printf ("%s:\n", file_table[0].name);
2969
2970               printf (_("File name                            Line number    Starting address\n"));
2971             }
2972         }
2973
2974       /* Skip the NUL at the end of the table.  */
2975       data++;
2976
2977       /* This loop iterates through the Dwarf Line Number Program.  */
2978       while (data < end_of_sequence)
2979         {
2980           unsigned char op_code;
2981           int adv;
2982           unsigned long int uladv;
2983           unsigned int bytes_read;
2984           int is_special_opcode = 0;
2985
2986           op_code = *data++;
2987
2988           if (op_code >= linfo.li_opcode_base)
2989             {
2990               op_code -= linfo.li_opcode_base;
2991               uladv = (op_code / linfo.li_line_range);
2992               if (linfo.li_max_ops_per_insn == 1)
2993                 {
2994                   uladv *= linfo.li_min_insn_length;
2995                   state_machine_regs.address += uladv;
2996                 }
2997               else
2998                 {
2999                   state_machine_regs.address
3000                     += ((state_machine_regs.op_index + uladv)
3001                         / linfo.li_max_ops_per_insn)
3002                        * linfo.li_min_insn_length;
3003                   state_machine_regs.op_index
3004                     = (state_machine_regs.op_index + uladv)
3005                       % linfo.li_max_ops_per_insn;
3006                 }
3007
3008               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3009               state_machine_regs.line += adv;
3010               is_special_opcode = 1;
3011             }
3012           else switch (op_code)
3013             {
3014             case DW_LNS_extended_op:
3015               {
3016                 unsigned int ext_op_code_len;
3017                 unsigned char ext_op_code;
3018                 unsigned char *op_code_data = data;
3019
3020                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3021                 op_code_data += bytes_read;
3022
3023                 if (ext_op_code_len == 0)
3024                   {
3025                     warn (_("badly formed extended line op encountered!\n"));
3026                     break;
3027                   }
3028                 ext_op_code_len += bytes_read;
3029                 ext_op_code = *op_code_data++;
3030
3031                 switch (ext_op_code)
3032                   {
3033                   case DW_LNE_end_sequence:
3034                     reset_state_machine (linfo.li_default_is_stmt);
3035                     break;
3036                   case DW_LNE_set_address:
3037                     state_machine_regs.address =
3038                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3039                     state_machine_regs.op_index = 0;
3040                     break;
3041                   case DW_LNE_define_file:
3042                     {
3043                       unsigned int dir_index = 0;
3044
3045                       ++state_machine_regs.last_file_entry;
3046                       op_code_data += strlen ((char *) op_code_data) + 1;
3047                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3048                       op_code_data += bytes_read;
3049                       read_leb128 (op_code_data, & bytes_read, 0);
3050                       op_code_data += bytes_read;
3051                       read_leb128 (op_code_data, & bytes_read, 0);
3052
3053                       printf ("%s:\n", directory_table[dir_index]);
3054                       break;
3055                     }
3056                   default:
3057                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3058                     break;
3059                   }
3060                 data += ext_op_code_len;
3061                 break;
3062               }
3063             case DW_LNS_copy:
3064               break;
3065
3066             case DW_LNS_advance_pc:
3067               uladv = read_leb128 (data, & bytes_read, 0);
3068               data += bytes_read;
3069               if (linfo.li_max_ops_per_insn == 1)
3070                 {
3071                   uladv *= linfo.li_min_insn_length;
3072                   state_machine_regs.address += uladv;
3073                 }
3074               else
3075                 {
3076                   state_machine_regs.address
3077                     += ((state_machine_regs.op_index + uladv)
3078                         / linfo.li_max_ops_per_insn)
3079                        * linfo.li_min_insn_length;
3080                   state_machine_regs.op_index
3081                     = (state_machine_regs.op_index + uladv)
3082                       % linfo.li_max_ops_per_insn;
3083                 }
3084               break;
3085
3086             case DW_LNS_advance_line:
3087               adv = read_sleb128 (data, & bytes_read);
3088               data += bytes_read;
3089               state_machine_regs.line += adv;
3090               break;
3091
3092             case DW_LNS_set_file:
3093               adv = read_leb128 (data, & bytes_read, 0);
3094               data += bytes_read;
3095               state_machine_regs.file = adv;
3096               if (file_table[state_machine_regs.file - 1].directory_index == 0)
3097                 {
3098                   /* If directory index is 0, that means current directory.  */
3099                   printf ("\n./%s:[++]\n",
3100                           file_table[state_machine_regs.file - 1].name);
3101                 }
3102               else
3103                 {
3104                   /* The directory index starts counting at 1.  */
3105                   printf ("\n%s/%s:\n",
3106                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3107                           file_table[state_machine_regs.file - 1].name);
3108                 }
3109               break;
3110
3111             case DW_LNS_set_column:
3112               uladv = read_leb128 (data, & bytes_read, 0);
3113               data += bytes_read;
3114               state_machine_regs.column = uladv;
3115               break;
3116
3117             case DW_LNS_negate_stmt:
3118               adv = state_machine_regs.is_stmt;
3119               adv = ! adv;
3120               state_machine_regs.is_stmt = adv;
3121               break;
3122
3123             case DW_LNS_set_basic_block:
3124               state_machine_regs.basic_block = 1;
3125               break;
3126
3127             case DW_LNS_const_add_pc:
3128               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3129               if (linfo.li_max_ops_per_insn == 1)
3130                 {
3131                   uladv *= linfo.li_min_insn_length;
3132                   state_machine_regs.address += uladv;
3133                 }
3134               else
3135                 {
3136                   state_machine_regs.address
3137                     += ((state_machine_regs.op_index + uladv)
3138                         / linfo.li_max_ops_per_insn)
3139                        * linfo.li_min_insn_length;
3140                   state_machine_regs.op_index
3141                     = (state_machine_regs.op_index + uladv)
3142                       % linfo.li_max_ops_per_insn;
3143                 }
3144               break;
3145
3146             case DW_LNS_fixed_advance_pc:
3147               uladv = byte_get (data, 2);
3148               data += 2;
3149               state_machine_regs.address += uladv;
3150               state_machine_regs.op_index = 0;
3151               break;
3152
3153             case DW_LNS_set_prologue_end:
3154               break;
3155
3156             case DW_LNS_set_epilogue_begin:
3157               break;
3158
3159             case DW_LNS_set_isa:
3160               uladv = read_leb128 (data, & bytes_read, 0);
3161               data += bytes_read;
3162               printf (_("  Set ISA to %lu\n"), uladv);
3163               break;
3164
3165             default:
3166               printf (_("  Unknown opcode %d with operands: "), op_code);
3167
3168               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3169                 {
3170                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3171                                                          &bytes_read, 0)),
3172                           i == 1 ? "" : ", ");
3173                   data += bytes_read;
3174                 }
3175               putchar ('\n');
3176               break;
3177             }
3178
3179           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3180              to the DWARF address/line matrix.  */
3181           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3182               || (op_code == DW_LNS_copy))
3183             {
3184               const unsigned int MAX_FILENAME_LENGTH = 35;
3185               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3186               char *newFileName = NULL;
3187               size_t fileNameLength = strlen (fileName);
3188
3189               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3190                 {
3191                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3192                   /* Truncate file name */
3193                   strncpy (newFileName,
3194                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3195                            MAX_FILENAME_LENGTH + 1);
3196                 }
3197               else
3198                 {
3199                   newFileName = (char *) xmalloc (fileNameLength + 1);
3200                   strncpy (newFileName, fileName, fileNameLength + 1);
3201                 }
3202
3203               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3204                 {
3205                   if (linfo.li_max_ops_per_insn == 1)
3206                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3207                             newFileName, state_machine_regs.line,
3208                             state_machine_regs.address);
3209                   else
3210                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3211                             newFileName, state_machine_regs.line,
3212                             state_machine_regs.address,
3213                             state_machine_regs.op_index);
3214                 }
3215               else
3216                 {
3217                   if (linfo.li_max_ops_per_insn == 1)
3218                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3219                             newFileName, state_machine_regs.line,
3220                             state_machine_regs.address);
3221                   else
3222                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3223                             newFileName, state_machine_regs.line,
3224                             state_machine_regs.address,
3225                             state_machine_regs.op_index);
3226                 }
3227
3228               if (op_code == DW_LNE_end_sequence)
3229                 printf ("\n");
3230
3231               free (newFileName);
3232             }
3233         }
3234       free (file_table);
3235       file_table = NULL;
3236       free (directory_table);
3237       directory_table = NULL;
3238       putchar ('\n');
3239     }
3240
3241   return 1;
3242 }
3243
3244 static int
3245 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3246 {
3247   unsigned char *data = section->start;
3248   unsigned char *end = data + section->size;
3249   int retValRaw = 1;
3250   int retValDecoded = 1;
3251
3252   if (do_debug_lines == 0)
3253     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3254
3255   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3256     retValRaw = display_debug_lines_raw (section, data, end);
3257
3258   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3259     retValDecoded = display_debug_lines_decoded (section, data, end);
3260
3261   if (!retValRaw || !retValDecoded)
3262     return 0;
3263
3264   return 1;
3265 }
3266
3267 static debug_info *
3268 find_debug_info_for_offset (unsigned long offset)
3269 {
3270   unsigned int i;
3271
3272   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3273     return NULL;
3274
3275   for (i = 0; i < num_debug_info_entries; i++)
3276     if (debug_information[i].cu_offset == offset)
3277       return debug_information + i;
3278
3279   return NULL;
3280 }
3281
3282 static int
3283 display_debug_pubnames (struct dwarf_section *section,
3284                         void *file ATTRIBUTE_UNUSED)
3285 {
3286   DWARF2_Internal_PubNames names;
3287   unsigned char *start = section->start;
3288   unsigned char *end = start + section->size;
3289
3290   /* It does not matter if this load fails,
3291      we test for that later on.  */
3292   load_debug_info (file);
3293
3294   printf (_("Contents of the %s section:\n\n"), section->name);
3295
3296   while (start < end)
3297     {
3298       unsigned char *data;
3299       unsigned long offset;
3300       int offset_size, initial_length_size;
3301
3302       data = start;
3303
3304       names.pn_length = byte_get (data, 4);
3305       data += 4;
3306       if (names.pn_length == 0xffffffff)
3307         {
3308           names.pn_length = byte_get (data, 8);
3309           data += 8;
3310           offset_size = 8;
3311           initial_length_size = 12;
3312         }
3313       else
3314         {
3315           offset_size = 4;
3316           initial_length_size = 4;
3317         }
3318
3319       names.pn_version = byte_get (data, 2);
3320       data += 2;
3321
3322       names.pn_offset = byte_get (data, offset_size);
3323       data += offset_size;
3324
3325       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3326           && num_debug_info_entries > 0
3327           && find_debug_info_for_offset (names.pn_offset) == NULL)
3328         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3329               (unsigned long) names.pn_offset, section->name);
3330
3331       names.pn_size = byte_get (data, offset_size);
3332       data += offset_size;
3333
3334       start += names.pn_length + initial_length_size;
3335
3336       if (names.pn_version != 2 && names.pn_version != 3)
3337         {
3338           static int warned = 0;
3339
3340           if (! warned)
3341             {
3342               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3343               warned = 1;
3344             }
3345
3346           continue;
3347         }
3348
3349       printf (_("  Length:                              %ld\n"),
3350               (long) names.pn_length);
3351       printf (_("  Version:                             %d\n"),
3352               names.pn_version);
3353       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3354               (unsigned long) names.pn_offset);
3355       printf (_("  Size of area in .debug_info section: %ld\n"),
3356               (long) names.pn_size);
3357
3358       printf (_("\n    Offset\tName\n"));
3359
3360       do
3361         {
3362           offset = byte_get (data, offset_size);
3363
3364           if (offset != 0)
3365             {
3366               data += offset_size;
3367               printf ("    %-6lx\t%s\n", offset, data);
3368               data += strlen ((char *) data) + 1;
3369             }
3370         }
3371       while (offset != 0);
3372     }
3373
3374   printf ("\n");
3375   return 1;
3376 }
3377
3378 static int
3379 display_debug_macinfo (struct dwarf_section *section,
3380                        void *file ATTRIBUTE_UNUSED)
3381 {
3382   unsigned char *start = section->start;
3383   unsigned char *end = start + section->size;
3384   unsigned char *curr = start;
3385   unsigned int bytes_read;
3386   enum dwarf_macinfo_record_type op;
3387
3388   printf (_("Contents of the %s section:\n\n"), section->name);
3389
3390   while (curr < end)
3391     {
3392       unsigned int lineno;
3393       const char *string;
3394
3395       op = (enum dwarf_macinfo_record_type) *curr;
3396       curr++;
3397
3398       switch (op)
3399         {
3400         case DW_MACINFO_start_file:
3401           {
3402             unsigned int filenum;
3403
3404             lineno = read_leb128 (curr, & bytes_read, 0);
3405             curr += bytes_read;
3406             filenum = read_leb128 (curr, & bytes_read, 0);
3407             curr += bytes_read;
3408
3409             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3410                     lineno, filenum);
3411           }
3412           break;
3413
3414         case DW_MACINFO_end_file:
3415           printf (_(" DW_MACINFO_end_file\n"));
3416           break;
3417
3418         case DW_MACINFO_define:
3419           lineno = read_leb128 (curr, & bytes_read, 0);
3420           curr += bytes_read;
3421           string = (char *) curr;
3422           curr += strlen (string) + 1;
3423           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3424                   lineno, string);
3425           break;
3426
3427         case DW_MACINFO_undef:
3428           lineno = read_leb128 (curr, & bytes_read, 0);
3429           curr += bytes_read;
3430           string = (char *) curr;
3431           curr += strlen (string) + 1;
3432           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3433                   lineno, string);
3434           break;
3435
3436         case DW_MACINFO_vendor_ext:
3437           {
3438             unsigned int constant;
3439
3440             constant = read_leb128 (curr, & bytes_read, 0);
3441             curr += bytes_read;
3442             string = (char *) curr;
3443             curr += strlen (string) + 1;
3444             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3445                     constant, string);
3446           }
3447           break;
3448         }
3449     }
3450
3451   return 1;
3452 }
3453
3454 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3455    filename and dirname corresponding to file name table entry with index
3456    FILEIDX.  Return NULL on failure.  */
3457
3458 static unsigned char *
3459 get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
3460                                unsigned char **dir_name)
3461 {
3462   struct dwarf_section *section = &debug_displays [line].section;
3463   unsigned char *hdrptr, *dirtable, *file_name;
3464   unsigned int offset_size, initial_length_size;
3465   unsigned int version, opcode_base, bytes_read;
3466   dwarf_vma length, diridx;
3467
3468   *dir_name = NULL;
3469   if (section->start == NULL
3470       || line_offset >= section->size
3471       || fileidx == 0)
3472     return NULL;
3473
3474   hdrptr = section->start + line_offset;
3475   length = byte_get (hdrptr, 4);
3476   hdrptr += 4;
3477   if (length == 0xffffffff)
3478     {
3479       /* This section is 64-bit DWARF 3.  */
3480       length = byte_get (hdrptr, 8);
3481       hdrptr += 8;
3482       offset_size = 8;
3483       initial_length_size = 12;
3484     }
3485   else
3486     {
3487       offset_size = 4;
3488       initial_length_size = 4;
3489     }
3490   if (length + initial_length_size > section->size)
3491     return NULL;
3492   version = byte_get (hdrptr, 2);
3493   hdrptr += 2;
3494   if (version != 2 && version != 3 && version != 4)
3495     return NULL;
3496   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
3497   if (version >= 4)
3498     hdrptr++;               /* Skip max_ops_per_insn.  */
3499   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
3500   opcode_base = byte_get (hdrptr, 1);
3501   if (opcode_base == 0)
3502     return NULL;
3503   hdrptr++;
3504   hdrptr += opcode_base - 1;
3505   dirtable = hdrptr;
3506   /* Skip over dirname table.  */
3507   while (*hdrptr != '\0')
3508     hdrptr += strlen ((char *) hdrptr) + 1;
3509   hdrptr++;                 /* Skip the NUL at the end of the table.  */
3510   /* Now skip over preceding filename table entries.  */
3511   for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3512     {
3513       hdrptr += strlen ((char *) hdrptr) + 1;
3514       read_leb128 (hdrptr, &bytes_read, 0);
3515       hdrptr += bytes_read;
3516       read_leb128 (hdrptr, &bytes_read, 0);
3517       hdrptr += bytes_read;
3518       read_leb128 (hdrptr, &bytes_read, 0);
3519       hdrptr += bytes_read;
3520     }
3521   if (*hdrptr == '\0')
3522     return NULL;
3523   file_name = hdrptr;
3524   hdrptr += strlen ((char *) hdrptr) + 1;
3525   diridx = read_leb128 (hdrptr, &bytes_read, 0);
3526   if (diridx == 0)
3527     return file_name;
3528   for (; *dirtable != '\0' && diridx > 1; diridx--)
3529     dirtable += strlen ((char *) dirtable) + 1;
3530   if (*dirtable == '\0')
3531     return NULL;
3532   *dir_name = dirtable;
3533   return file_name;
3534 }
3535
3536 static int
3537 display_debug_macro (struct dwarf_section *section,
3538                      void *file)
3539 {
3540   unsigned char *start = section->start;
3541   unsigned char *end = start + section->size;
3542   unsigned char *curr = start;
3543   unsigned char *extended_op_buf[256];
3544   unsigned int bytes_read;
3545
3546   load_debug_section (str, file);
3547   load_debug_section (line, file);
3548
3549   printf (_("Contents of the %s section:\n\n"), section->name);
3550
3551   while (curr < end)
3552     {
3553       unsigned int lineno, version, flags;
3554       unsigned int offset_size = 4;
3555       const char *string;
3556       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3557       unsigned char **extended_ops = NULL;
3558
3559       version = byte_get (curr, 2);
3560       curr += 2;
3561
3562       if (version != 4)
3563         {
3564           error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3565                  section->name);
3566           return 0;
3567         }
3568
3569       flags = byte_get (curr++, 1);
3570       if (flags & 1)
3571         offset_size = 8;
3572       printf (_("  Offset:                      0x%lx\n"),
3573               (unsigned long) sec_offset);
3574       printf (_("  Version:                     %d\n"), version);
3575       printf (_("  Offset size:                 %d\n"), offset_size);
3576       if (flags & 2)
3577         {
3578           line_offset = byte_get (curr, offset_size);
3579           curr += offset_size;
3580           printf (_("  Offset into .debug_line:     0x%lx\n"),
3581                   (unsigned long) line_offset);
3582         }
3583       if (flags & 4)
3584         {
3585           unsigned int i, count = byte_get (curr++, 1), op;
3586           dwarf_vma nargs, n;
3587           memset (extended_op_buf, 0, sizeof (extended_op_buf));
3588           extended_ops = extended_op_buf;
3589           if (count)
3590             {
3591               printf (_("  Extension opcode arguments:\n"));
3592               for (i = 0; i < count; i++)
3593                 {
3594                   op = byte_get (curr++, 1);
3595                   extended_ops[op] = curr;
3596                   nargs = read_leb128 (curr, &bytes_read, 0);
3597                   curr += bytes_read;
3598                   if (nargs == 0)
3599                     printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
3600                   else
3601                     {
3602                       printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
3603                       for (n = 0; n < nargs; n++)
3604                         {
3605                           unsigned int form = byte_get (curr++, 1);
3606                           printf ("%s%s", get_FORM_name (form),
3607                                   n == nargs - 1 ? "\n" : ", ");
3608                           switch (form)
3609                             {
3610                             case DW_FORM_data1:
3611                             case DW_FORM_data2:
3612                             case DW_FORM_data4:
3613                             case DW_FORM_data8:
3614                             case DW_FORM_sdata:
3615                             case DW_FORM_udata:
3616                             case DW_FORM_block:
3617                             case DW_FORM_block1:
3618                             case DW_FORM_block2:
3619                             case DW_FORM_block4:
3620                             case DW_FORM_flag:
3621                             case DW_FORM_string:
3622                             case DW_FORM_strp:
3623                             case DW_FORM_sec_offset:
3624                               break;
3625                             default:
3626                               error (_("Invalid extension opcode form %s\n"),
3627                                      get_FORM_name (form));
3628                               return 0;
3629                             }
3630                         }
3631                     }
3632                 }
3633             }
3634         }
3635       printf ("\n");
3636
3637       while (1)
3638         {
3639           unsigned int op;
3640
3641           if (curr >= end)
3642             {
3643               error (_(".debug_macro section not zero terminated\n"));
3644               return 0;
3645             }
3646
3647           op = byte_get (curr++, 1);
3648           if (op == 0)
3649             break;
3650
3651           switch (op)
3652             {
3653             case DW_MACRO_GNU_start_file:
3654               {
3655                 unsigned int filenum;
3656                 unsigned char *file_name = NULL, *dir_name = NULL;
3657
3658                 lineno = read_leb128 (curr, &bytes_read, 0);
3659                 curr += bytes_read;
3660                 filenum = read_leb128 (curr, &bytes_read, 0);
3661                 curr += bytes_read;
3662
3663                 if ((flags & 2) == 0)
3664                   error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3665                 else
3666                   file_name
3667                     = get_line_filename_and_dirname (line_offset, filenum,
3668                                                      &dir_name);
3669                 if (file_name == NULL)
3670                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3671                           lineno, filenum);
3672                 else
3673                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3674                           lineno, filenum,
3675                           dir_name != NULL ? (const char *) dir_name : "",
3676                           dir_name != NULL ? "/" : "", file_name);
3677               }
3678               break;
3679
3680             case DW_MACRO_GNU_end_file:
3681               printf (_(" DW_MACRO_GNU_end_file\n"));
3682               break;
3683
3684             case DW_MACRO_GNU_define:
3685               lineno = read_leb128 (curr, &bytes_read, 0);
3686               curr += bytes_read;
3687               string = (char *) curr;
3688               curr += strlen (string) + 1;
3689               printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3690                       lineno, string);
3691               break;
3692
3693             case DW_MACRO_GNU_undef:
3694               lineno = read_leb128 (curr, &bytes_read, 0);
3695               curr += bytes_read;
3696               string = (char *) curr;
3697               curr += strlen (string) + 1;
3698               printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3699                       lineno, string);
3700               break;
3701
3702             case DW_MACRO_GNU_define_indirect:
3703               lineno = read_leb128 (curr, &bytes_read, 0);
3704               curr += bytes_read;
3705               offset = byte_get (curr, offset_size);
3706               curr += offset_size;
3707               string = fetch_indirect_string (offset);
3708               printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3709                       lineno, string);
3710               break;
3711
3712             case DW_MACRO_GNU_undef_indirect:
3713               lineno = read_leb128 (curr, &bytes_read, 0);
3714               curr += bytes_read;
3715               offset = byte_get (curr, offset_size);
3716               curr += offset_size;
3717               string = fetch_indirect_string (offset);
3718               printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3719                       lineno, string);
3720               break;
3721
3722             case DW_MACRO_GNU_transparent_include:
3723               offset = byte_get (curr, offset_size);
3724               curr += offset_size;
3725               printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3726                       (unsigned long) offset);
3727               break;
3728
3729             default:
3730               if (extended_ops == NULL || extended_ops[op] == NULL)
3731                 {
3732                   error (_(" Unknown macro opcode %02x seen\n"), op);
3733                   return 0;
3734                 }
3735               else
3736                 {
3737                   /* Skip over unhandled opcodes.  */
3738                   dwarf_vma nargs, n;
3739                   unsigned char *desc = extended_ops[op];
3740                   nargs = read_leb128 (desc, &bytes_read, 0);
3741                   desc += bytes_read;
3742                   if (nargs == 0)
3743                     {
3744                       printf (_(" DW_MACRO_GNU_%02x\n"), op);
3745                       break;
3746                     }
3747                   printf (_(" DW_MACRO_GNU_%02x -"), op);
3748                   for (n = 0; n < nargs; n++)
3749                     {
3750                       curr
3751                         = read_and_display_attr_value (0, byte_get (desc++, 1),
3752                                                        curr, 0, 0, offset_size,
3753                                                        version, NULL, 0, NULL);
3754                       if (n != nargs - 1)
3755                         printf (",");
3756                     }
3757                   printf ("\n");
3758                 }
3759               break;
3760             }
3761         }
3762
3763       printf ("\n");
3764     }
3765
3766   return 1;
3767 }
3768
3769 static int
3770 display_debug_abbrev (struct dwarf_section *section,
3771                       void *file ATTRIBUTE_UNUSED)
3772 {
3773   abbrev_entry *entry;
3774   unsigned char *start = section->start;
3775   unsigned char *end = start + section->size;
3776
3777   printf (_("Contents of the %s section:\n\n"), section->name);
3778
3779   do
3780     {
3781       free_abbrevs ();
3782
3783       start = process_abbrev_section (start, end);
3784
3785       if (first_abbrev == NULL)
3786         continue;
3787
3788       printf (_("  Number TAG\n"));
3789
3790       for (entry = first_abbrev; entry; entry = entry->next)
3791         {
3792           abbrev_attr *attr;
3793
3794           printf ("   %ld      %s    [%s]\n",
3795                   entry->entry,
3796                   get_TAG_name (entry->tag),
3797                   entry->children ? _("has children") : _("no children"));
3798
3799           for (attr = entry->first_attr; attr; attr = attr->next)
3800             printf ("    %-18s %s\n",
3801                     get_AT_name (attr->attribute),
3802                     get_FORM_name (attr->form));
3803         }
3804     }
3805   while (start);
3806
3807   printf ("\n");
3808
3809   return 1;
3810 }
3811
3812 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
3813
3814 static dwarf_vma *loc_offsets;
3815
3816 static int
3817 loc_offsets_compar (const void *ap, const void *bp)
3818 {
3819   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3820   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3821
3822   return (a > b) - (b > a);
3823 }
3824
3825 static int
3826 display_debug_loc (struct dwarf_section *section, void *file)
3827 {
3828   unsigned char *start = section->start;
3829   unsigned char *section_end;
3830   unsigned long bytes;
3831   unsigned char *section_begin = start;
3832   unsigned int num_loc_list = 0;
3833   unsigned long last_offset = 0;
3834   unsigned int first = 0;
3835   unsigned int i;
3836   unsigned int j;
3837   unsigned int k;
3838   int seen_first_offset = 0;
3839   int locs_sorted = 1;
3840   unsigned char *next;
3841   unsigned int *array = NULL;
3842
3843   bytes = section->size;
3844   section_end = start + bytes;
3845
3846   if (bytes == 0)
3847     {
3848       printf (_("\nThe %s section is empty.\n"), section->name);
3849       return 0;
3850     }
3851
3852   if (load_debug_info (file) == 0)
3853     {
3854       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3855             section->name);
3856       return 0;
3857     }
3858
3859   /* Check the order of location list in .debug_info section. If
3860      offsets of location lists are in the ascending order, we can
3861      use `debug_information' directly.  */
3862   for (i = 0; i < num_debug_info_entries; i++)
3863     {
3864       unsigned int num;
3865
3866       num = debug_information [i].num_loc_offsets;
3867       if (num > num_loc_list)
3868         num_loc_list = num;
3869
3870       /* Check if we can use `debug_information' directly.  */
3871       if (locs_sorted && num != 0)
3872         {
3873           if (!seen_first_offset)
3874             {
3875               /* This is the first location list.  */
3876               last_offset = debug_information [i].loc_offsets [0];
3877               first = i;
3878               seen_first_offset = 1;
3879               j = 1;
3880             }
3881           else
3882             j = 0;
3883
3884           for (; j < num; j++)
3885             {
3886               if (last_offset >
3887                   debug_information [i].loc_offsets [j])
3888                 {
3889                   locs_sorted = 0;
3890                   break;
3891                 }
3892               last_offset = debug_information [i].loc_offsets [j];
3893             }
3894         }
3895     }
3896
3897   if (!seen_first_offset)
3898     error (_("No location lists in .debug_info section!\n"));
3899
3900   /* DWARF sections under Mach-O have non-zero addresses.  */
3901   if (debug_information [first].num_loc_offsets > 0
3902       && debug_information [first].loc_offsets [0] != section->address)
3903     warn (_("Location lists in %s section start at 0x%s\n"),
3904           section->name,
3905           dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
3906
3907   if (!locs_sorted)
3908     array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
3909   printf (_("Contents of the %s section:\n\n"), section->name);
3910   printf (_("    Offset   Begin    End      Expression\n"));
3911
3912   seen_first_offset = 0;
3913   for (i = first; i < num_debug_info_entries; i++)
3914     {
3915       dwarf_vma begin;
3916       dwarf_vma end;
3917       unsigned short length;
3918       unsigned long offset;
3919       unsigned int pointer_size;
3920       unsigned int offset_size;
3921       int dwarf_version;
3922       unsigned long cu_offset;
3923       unsigned long base_address;
3924       int need_frame_base;
3925       int has_frame_base;
3926
3927       pointer_size = debug_information [i].pointer_size;
3928       cu_offset = debug_information [i].cu_offset;
3929       offset_size = debug_information [i].offset_size;
3930       dwarf_version = debug_information [i].dwarf_version;
3931       if (!locs_sorted)
3932         {
3933           for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3934             array[k] = k;
3935           loc_offsets = debug_information [i].loc_offsets;
3936           qsort (array, debug_information [i].num_loc_offsets,
3937                  sizeof (*array), loc_offsets_compar);
3938         }
3939
3940       for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3941         {
3942           j = locs_sorted ? k : array[k];
3943           if (k
3944               && debug_information [i].loc_offsets [locs_sorted
3945                                                     ? k - 1 : array [k - 1]]
3946                  == debug_information [i].loc_offsets [j])
3947             continue;
3948           has_frame_base = debug_information [i].have_frame_base [j];
3949           /* DWARF sections under Mach-O have non-zero addresses.  */
3950           offset = debug_information [i].loc_offsets [j] - section->address;
3951           next = section_begin + offset;
3952           base_address = debug_information [i].base_address;
3953
3954           if (!seen_first_offset)
3955             seen_first_offset = 1;
3956           else
3957             {
3958               if (start < next)
3959                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3960                       (unsigned long) (start - section_begin),
3961                       (unsigned long) (next - section_begin));
3962               else if (start > next)
3963                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3964                       (unsigned long) (start - section_begin),
3965                       (unsigned long) (next - section_begin));
3966             }
3967           start = next;
3968
3969           if (offset >= bytes)
3970             {
3971               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3972                     offset);
3973               continue;
3974             }
3975
3976           while (1)
3977             {
3978               if (start + 2 * pointer_size > section_end)
3979                 {
3980                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3981                         offset);
3982                   break;
3983                 }
3984
3985               /* Note: we use sign extension here in order to be sure that
3986                  we can detect the -1 escape value.  Sign extension into the
3987                  top 32 bits of a 32-bit address will not affect the values
3988                  that we display since we always show hex values, and always
3989                  the bottom 32-bits.  */
3990               begin = byte_get_signed (start, pointer_size);
3991               start += pointer_size;
3992               end = byte_get_signed (start, pointer_size);
3993               start += pointer_size;
3994
3995               printf ("    %8.8lx ", offset);
3996
3997               if (begin == 0 && end == 0)
3998                 {
3999                   printf (_("<End of list>\n"));
4000                   break;
4001                 }
4002
4003               /* Check base address specifiers.  */
4004               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4005                 {
4006                   base_address = end;
4007                   print_dwarf_vma (begin, pointer_size);
4008                   print_dwarf_vma (end, pointer_size);
4009                   printf (_("(base address)\n"));
4010                   continue;
4011                 }
4012
4013               if (start + 2 > section_end)
4014                 {
4015                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4016                         offset);
4017                   break;
4018                 }
4019
4020               length = byte_get (start, 2);
4021               start += 2;
4022
4023               if (start + length > section_end)
4024                 {
4025                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4026                         offset);
4027                   break;
4028                 }
4029
4030               print_dwarf_vma (begin + base_address, pointer_size);
4031               print_dwarf_vma (end + base_address, pointer_size);
4032
4033               putchar ('(');
4034               need_frame_base = decode_location_expression (start,
4035                                                             pointer_size,
4036                                                             offset_size,
4037                                                             dwarf_version,
4038                                                             length,
4039                                                             cu_offset, section);
4040               putchar (')');
4041
4042               if (need_frame_base && !has_frame_base)
4043                 printf (_(" [without DW_AT_frame_base]"));
4044
4045               if (begin == end)
4046                 fputs (_(" (start == end)"), stdout);
4047               else if (begin > end)
4048                 fputs (_(" (start > end)"), stdout);
4049
4050               putchar ('\n');
4051
4052               start += length;
4053             }
4054         }
4055     }
4056
4057   if (start < section_end)
4058     warn (_("There are %ld unused bytes at the end of section %s\n"),
4059           (long) (section_end - start), section->name);
4060   putchar ('\n');
4061   free (array);
4062   return 1;
4063 }
4064
4065 static int
4066 display_debug_str (struct dwarf_section *section,
4067                    void *file ATTRIBUTE_UNUSED)
4068 {
4069   unsigned char *start = section->start;
4070   unsigned long bytes = section->size;
4071   dwarf_vma addr = section->address;
4072
4073   if (bytes == 0)
4074     {
4075       printf (_("\nThe %s section is empty.\n"), section->name);
4076       return 0;
4077     }
4078
4079   printf (_("Contents of the %s section:\n\n"), section->name);
4080
4081   while (bytes)
4082     {
4083       int j;
4084       int k;
4085       int lbytes;
4086
4087       lbytes = (bytes > 16 ? 16 : bytes);
4088
4089       printf ("  0x%8.8lx ", (unsigned long) addr);
4090
4091       for (j = 0; j < 16; j++)
4092         {
4093           if (j < lbytes)
4094             printf ("%2.2x", start[j]);
4095           else
4096             printf ("  ");
4097
4098           if ((j & 3) == 3)
4099             printf (" ");
4100         }
4101
4102       for (j = 0; j < lbytes; j++)
4103         {
4104           k = start[j];
4105           if (k >= ' ' && k < 0x80)
4106             printf ("%c", k);
4107           else
4108             printf (".");
4109         }
4110
4111       putchar ('\n');
4112
4113       start += lbytes;
4114       addr  += lbytes;
4115       bytes -= lbytes;
4116     }
4117
4118   putchar ('\n');
4119
4120   return 1;
4121 }
4122
4123 static int
4124 display_debug_info (struct dwarf_section *section, void *file)
4125 {
4126   return process_debug_info (section, file, abbrev, 0, 0);
4127 }
4128
4129 static int
4130 display_debug_types (struct dwarf_section *section, void *file)
4131 {
4132   return process_debug_info (section, file, abbrev, 0, 1);
4133 }
4134
4135 static int
4136 display_trace_info (struct dwarf_section *section, void *file)
4137 {
4138   return process_debug_info (section, file, trace_abbrev, 0, 0);
4139 }
4140
4141 static int
4142 display_debug_aranges (struct dwarf_section *section,
4143                        void *file ATTRIBUTE_UNUSED)
4144 {
4145   unsigned char *start = section->start;
4146   unsigned char *end = start + section->size;
4147
4148   printf (_("Contents of the %s section:\n\n"), section->name);
4149
4150   /* It does not matter if this load fails,
4151      we test for that later on.  */
4152   load_debug_info (file);
4153
4154   while (start < end)
4155     {
4156       unsigned char *hdrptr;
4157       DWARF2_Internal_ARange arange;
4158       unsigned char *addr_ranges;
4159       dwarf_vma length;
4160       dwarf_vma address;
4161       unsigned char address_size;
4162       int excess;
4163       int offset_size;
4164       int initial_length_size;
4165
4166       hdrptr = start;
4167
4168       arange.ar_length = byte_get (hdrptr, 4);
4169       hdrptr += 4;
4170
4171       if (arange.ar_length == 0xffffffff)
4172         {
4173           arange.ar_length = byte_get (hdrptr, 8);
4174           hdrptr += 8;
4175           offset_size = 8;
4176           initial_length_size = 12;
4177         }
4178       else
4179         {
4180           offset_size = 4;
4181           initial_length_size = 4;
4182         }
4183
4184       arange.ar_version = byte_get (hdrptr, 2);
4185       hdrptr += 2;
4186
4187       arange.ar_info_offset = byte_get (hdrptr, offset_size);
4188       hdrptr += offset_size;
4189
4190       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4191           && num_debug_info_entries > 0
4192           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4193         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4194               (unsigned long) arange.ar_info_offset, section->name);
4195
4196       arange.ar_pointer_size = byte_get (hdrptr, 1);
4197       hdrptr += 1;
4198
4199       arange.ar_segment_size = byte_get (hdrptr, 1);
4200       hdrptr += 1;
4201
4202       if (arange.ar_version != 2 && arange.ar_version != 3)
4203         {
4204           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4205           break;
4206         }
4207
4208       printf (_("  Length:                   %ld\n"),
4209               (long) arange.ar_length);
4210       printf (_("  Version:                  %d\n"), arange.ar_version);
4211       printf (_("  Offset into .debug_info:  0x%lx\n"),
4212               (unsigned long) arange.ar_info_offset);
4213       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
4214       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
4215
4216       address_size = arange.ar_pointer_size + arange.ar_segment_size;
4217
4218       /* The DWARF spec does not require that the address size be a power
4219          of two, but we do.  This will have to change if we ever encounter
4220          an uneven architecture.  */
4221       if ((address_size & (address_size - 1)) != 0)
4222         {
4223           warn (_("Pointer size + Segment size is not a power of two.\n"));
4224           break;
4225         }
4226
4227       if (address_size > 4)
4228         printf (_("\n    Address            Length\n"));
4229       else
4230         printf (_("\n    Address    Length\n"));
4231
4232       addr_ranges = hdrptr;
4233
4234       /* Must pad to an alignment boundary that is twice the address size.  */
4235       excess = (hdrptr - start) % (2 * address_size);
4236       if (excess)
4237         addr_ranges += (2 * address_size) - excess;
4238
4239       start += arange.ar_length + initial_length_size;
4240
4241       while (addr_ranges + 2 * address_size <= start)
4242         {
4243           address = byte_get (addr_ranges, address_size);
4244
4245           addr_ranges += address_size;
4246
4247           length  = byte_get (addr_ranges, address_size);
4248
4249           addr_ranges += address_size;
4250
4251           printf ("    ");
4252           print_dwarf_vma (address, address_size);
4253           print_dwarf_vma (length, address_size);
4254           putchar ('\n');
4255         }
4256     }
4257
4258   printf ("\n");
4259
4260   return 1;
4261 }
4262
4263 /* Each debug_information[x].range_lists[y] gets this representation for
4264    sorting purposes.  */
4265
4266 struct range_entry
4267 {
4268   /* The debug_information[x].range_lists[y] value.  */
4269   unsigned long ranges_offset;
4270
4271   /* Original debug_information to find parameters of the data.  */
4272   debug_info *debug_info_p;
4273 };
4274
4275 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
4276
4277 static int
4278 range_entry_compar (const void *ap, const void *bp)
4279 {
4280   const struct range_entry *a_re = (const struct range_entry *) ap;
4281   const struct range_entry *b_re = (const struct range_entry *) bp;
4282   const unsigned long a = a_re->ranges_offset;
4283   const unsigned long b = b_re->ranges_offset;
4284
4285   return (a > b) - (b > a);
4286 }
4287
4288 static int
4289 display_debug_ranges (struct dwarf_section *section,
4290                       void *file ATTRIBUTE_UNUSED)
4291 {
4292   unsigned char *start = section->start;
4293   unsigned long bytes;
4294   unsigned char *section_begin = start;
4295   unsigned int num_range_list, i;
4296   struct range_entry *range_entries, *range_entry_fill;
4297
4298   bytes = section->size;
4299
4300   if (bytes == 0)
4301     {
4302       printf (_("\nThe %s section is empty.\n"), section->name);
4303       return 0;
4304     }
4305
4306   if (load_debug_info (file) == 0)
4307     {
4308       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4309             section->name);
4310       return 0;
4311     }
4312
4313   num_range_list = 0;
4314   for (i = 0; i < num_debug_info_entries; i++)
4315     num_range_list += debug_information [i].num_range_lists;
4316
4317   if (num_range_list == 0)
4318     error (_("No range lists in .debug_info section!\n"));
4319
4320   range_entries = (struct range_entry *)
4321       xmalloc (sizeof (*range_entries) * num_range_list);
4322   range_entry_fill = range_entries;
4323
4324   for (i = 0; i < num_debug_info_entries; i++)
4325     {
4326       debug_info *debug_info_p = &debug_information[i];
4327       unsigned int j;
4328
4329       for (j = 0; j < debug_info_p->num_range_lists; j++)
4330         {
4331           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4332           range_entry_fill->debug_info_p = debug_info_p;
4333           range_entry_fill++;
4334         }
4335     }
4336
4337   qsort (range_entries, num_range_list, sizeof (*range_entries),
4338          range_entry_compar);
4339
4340   /* DWARF sections under Mach-O have non-zero addresses.  */
4341   if (range_entries[0].ranges_offset != section->address)
4342     warn (_("Range lists in %s section start at 0x%lx\n"),
4343           section->name, range_entries[0].ranges_offset);
4344
4345   printf (_("Contents of the %s section:\n\n"), section->name);
4346   printf (_("    Offset   Begin    End\n"));
4347
4348   for (i = 0; i < num_range_list; i++)
4349     {
4350       struct range_entry *range_entry = &range_entries[i];
4351       debug_info *debug_info_p = range_entry->debug_info_p;
4352       unsigned int pointer_size;
4353       unsigned long offset;
4354       unsigned char *next;
4355       unsigned long base_address;
4356
4357       pointer_size = debug_info_p->pointer_size;
4358
4359       /* DWARF sections under Mach-O have non-zero addresses.  */
4360       offset = range_entry->ranges_offset - section->address;
4361       next = section_begin + offset;
4362       base_address = debug_info_p->base_address;
4363
4364       if (i > 0)
4365         {
4366           if (start < next)
4367             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4368                   (unsigned long) (start - section_begin),
4369                   (unsigned long) (next - section_begin), section->name);
4370           else if (start > next)
4371             warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4372                   (unsigned long) (start - section_begin),
4373                   (unsigned long) (next - section_begin), section->name);
4374         }
4375       start = next;
4376
4377       while (1)
4378         {
4379           dwarf_vma begin;
4380           dwarf_vma end;
4381
4382           /* Note: we use sign extension here in order to be sure that
4383              we can detect the -1 escape value.  Sign extension into the
4384              top 32 bits of a 32-bit address will not affect the values
4385              that we display since we always show hex values, and always
4386              the bottom 32-bits.  */
4387           begin = byte_get_signed (start, pointer_size);
4388           start += pointer_size;
4389           end = byte_get_signed (start, pointer_size);
4390           start += pointer_size;
4391
4392           printf ("    %8.8lx ", offset);
4393
4394           if (begin == 0 && end == 0)
4395             {
4396               printf (_("<End of list>\n"));
4397               break;
4398             }
4399
4400           /* Check base address specifiers.  */
4401           if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4402             {
4403               base_address = end;
4404               print_dwarf_vma (begin, pointer_size);
4405               print_dwarf_vma (end, pointer_size);
4406               printf ("(base address)\n");
4407               continue;
4408             }
4409
4410           print_dwarf_vma (begin + base_address, pointer_size);
4411           print_dwarf_vma (end + base_address, pointer_size);
4412
4413           if (begin == end)
4414             fputs (_("(start == end)"), stdout);
4415           else if (begin > end)
4416             fputs (_("(start > end)"), stdout);
4417
4418           putchar ('\n');
4419         }
4420     }
4421   putchar ('\n');
4422
4423   free (range_entries);
4424
4425   return 1;
4426 }
4427
4428 typedef struct Frame_Chunk
4429 {
4430   struct Frame_Chunk *next;
4431   unsigned char *chunk_start;
4432   int ncols;
4433   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
4434   short int *col_type;
4435   int *col_offset;
4436   char *augmentation;
4437   unsigned int code_factor;
4438   int data_factor;
4439   unsigned long pc_begin;
4440   unsigned long pc_range;
4441   int cfa_reg;
4442   int cfa_offset;
4443   int ra;
4444   unsigned char fde_encoding;
4445   unsigned char cfa_exp;
4446   unsigned char ptr_size;
4447   unsigned char segment_size;
4448 }
4449 Frame_Chunk;
4450
4451 static const char *const *dwarf_regnames;
4452 static unsigned int dwarf_regnames_count;
4453
4454 /* A marker for a col_type that means this column was never referenced
4455    in the frame info.  */
4456 #define DW_CFA_unreferenced (-1)
4457
4458 /* Return 0 if not more space is needed, 1 if more space is needed,
4459    -1 for invalid reg.  */
4460
4461 static int
4462 frame_need_space (Frame_Chunk *fc, unsigned int reg)
4463 {
4464   int prev = fc->ncols;
4465
4466   if (reg < (unsigned int) fc->ncols)
4467     return 0;
4468
4469   if (dwarf_regnames_count
4470       && reg > dwarf_regnames_count)
4471     return -1;
4472
4473   fc->ncols = reg + 1;
4474   fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4475                                           sizeof (short int));
4476   fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
4477
4478   while (prev < fc->ncols)
4479     {
4480       fc->col_type[prev] = DW_CFA_unreferenced;
4481       fc->col_offset[prev] = 0;
4482       prev++;
4483     }
4484   return 1;
4485 }
4486
4487 static const char *const dwarf_regnames_i386[] =
4488 {
4489   "eax", "ecx", "edx", "ebx",
4490   "esp", "ebp", "esi", "edi",
4491   "eip", "eflags", NULL,
4492   "st0", "st1", "st2", "st3",
4493   "st4", "st5", "st6", "st7",
4494   NULL, NULL,
4495   "xmm0", "xmm1", "xmm2", "xmm3",
4496   "xmm4", "xmm5", "xmm6", "xmm7",
4497   "mm0", "mm1", "mm2", "mm3",
4498   "mm4", "mm5", "mm6", "mm7",
4499   "fcw", "fsw", "mxcsr",
4500   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4501   "tr", "ldtr"
4502 };
4503
4504 void
4505 init_dwarf_regnames_i386 (void)
4506 {
4507   dwarf_regnames = dwarf_regnames_i386;
4508   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4509 }
4510
4511 static const char *const dwarf_regnames_x86_64[] =
4512 {
4513   "rax", "rdx", "rcx", "rbx",
4514   "rsi", "rdi", "rbp", "rsp",
4515   "r8",  "r9",  "r10", "r11",
4516   "r12", "r13", "r14", "r15",
4517   "rip",
4518   "xmm0",  "xmm1",  "xmm2",  "xmm3",
4519   "xmm4",  "xmm5",  "xmm6",  "xmm7",
4520   "xmm8",  "xmm9",  "xmm10", "xmm11",
4521   "xmm12", "xmm13", "xmm14", "xmm15",
4522   "st0", "st1", "st2", "st3",
4523   "st4", "st5", "st6", "st7",
4524   "mm0", "mm1", "mm2", "mm3",
4525   "mm4", "mm5", "mm6", "mm7",
4526   "rflags",
4527   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4528   "fs.base", "gs.base", NULL, NULL,
4529   "tr", "ldtr",
4530   "mxcsr", "fcw", "fsw"
4531 };
4532
4533 void
4534 init_dwarf_regnames_x86_64 (void)
4535 {
4536   dwarf_regnames = dwarf_regnames_x86_64;
4537   dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4538 }
4539
4540 void
4541 init_dwarf_regnames (unsigned int e_machine)
4542 {
4543   switch (e_machine)
4544     {
4545     case EM_386:
4546     case EM_486:
4547       init_dwarf_regnames_i386 ();
4548       break;
4549
4550     case EM_X86_64:
4551     case EM_L1OM:
4552     case EM_K1OM:
4553       init_dwarf_regnames_x86_64 ();
4554       break;
4555
4556     default:
4557       break;
4558     }
4559 }
4560
4561 static const char *
4562 regname (unsigned int regno, int row)
4563 {
4564   static char reg[64];
4565   if (dwarf_regnames
4566       && regno < dwarf_regnames_count
4567       && dwarf_regnames [regno] != NULL)
4568     {
4569       if (row)
4570         return dwarf_regnames [regno];
4571       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4572                 dwarf_regnames [regno]);
4573     }
4574   else
4575     snprintf (reg, sizeof (reg), "r%d", regno);
4576   return reg;
4577 }
4578
4579 static void
4580 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4581 {
4582   int r;
4583   char tmp[100];
4584
4585   if (*max_regs < fc->ncols)
4586     *max_regs = fc->ncols;
4587
4588   if (*need_col_headers)
4589     {
4590       static const char *sloc = "   LOC";
4591
4592       *need_col_headers = 0;
4593
4594       printf ("%-*s CFA      ", eh_addr_size * 2, sloc);
4595
4596       for (r = 0; r < *max_regs; r++)
4597         if (fc->col_type[r] != DW_CFA_unreferenced)
4598           {
4599             if (r == fc->ra)
4600               printf ("ra      ");
4601             else
4602               printf ("%-5s ", regname (r, 1));
4603           }
4604
4605       printf ("\n");
4606     }
4607
4608   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
4609   if (fc->cfa_exp)
4610     strcpy (tmp, "exp");
4611   else
4612     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
4613   printf ("%-8s ", tmp);
4614
4615   for (r = 0; r < fc->ncols; r++)
4616     {
4617       if (fc->col_type[r] != DW_CFA_unreferenced)
4618         {
4619           switch (fc->col_type[r])
4620             {
4621             case DW_CFA_undefined:
4622               strcpy (tmp, "u");
4623               break;
4624             case DW_CFA_same_value:
4625               strcpy (tmp, "s");
4626               break;
4627             case DW_CFA_offset:
4628               sprintf (tmp, "c%+d", fc->col_offset[r]);
4629               break;
4630             case DW_CFA_val_offset:
4631               sprintf (tmp, "v%+d", fc->col_offset[r]);
4632               break;
4633             case DW_CFA_register:
4634               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
4635               break;
4636             case DW_CFA_expression:
4637               strcpy (tmp, "exp");
4638               break;
4639             case DW_CFA_val_expression:
4640               strcpy (tmp, "vexp");
4641               break;
4642             default:
4643               strcpy (tmp, "n/a");
4644               break;
4645             }
4646           printf ("%-5s ", tmp);
4647         }
4648     }
4649   printf ("\n");
4650 }
4651
4652 #define GET(N)  byte_get (start, N); start += N
4653 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
4654 #define SLEB()  read_sleb128 (start, & length_return); start += length_return
4655
4656 static int
4657 display_debug_frames (struct dwarf_section *section,
4658                       void *file ATTRIBUTE_UNUSED)
4659 {
4660   unsigned char *start = section->start;
4661   unsigned char *end = start + section->size;
4662   unsigned char *section_start = start;
4663   Frame_Chunk *chunks = 0;
4664   Frame_Chunk *remembered_state = 0;
4665   Frame_Chunk *rs;
4666   int is_eh = strcmp (section->name, ".eh_frame") == 0;
4667   unsigned int length_return;
4668   int max_regs = 0;
4669   const char *bad_reg = _("bad register: ");
4670   int saved_eh_addr_size = eh_addr_size;
4671
4672   printf (_("Contents of the %s section:\n"), section->name);
4673
4674   while (start < end)
4675     {
4676       unsigned char *saved_start;
4677       unsigned char *block_end;
4678       unsigned long length;
4679       unsigned long cie_id;
4680       Frame_Chunk *fc;
4681       Frame_Chunk *cie;
4682       int need_col_headers = 1;
4683       unsigned char *augmentation_data = NULL;
4684       unsigned long augmentation_data_len = 0;
4685       int encoded_ptr_size = saved_eh_addr_size;
4686       int offset_size;
4687       int initial_length_size;
4688
4689       saved_start = start;
4690       length = byte_get (start, 4); start += 4;
4691
4692       if (length == 0)
4693         {
4694           printf ("\n%08lx ZERO terminator\n\n",
4695                     (unsigned long)(saved_start - section_start));
4696           continue;
4697         }
4698
4699       if (length == 0xffffffff)
4700         {
4701           length = byte_get (start, 8);
4702           start += 8;
4703           offset_size = 8;
4704           initial_length_size = 12;
4705         }
4706       else
4707         {
4708           offset_size = 4;
4709           initial_length_size = 4;
4710         }
4711
4712       block_end = saved_start + length + initial_length_size;
4713       if (block_end > end)
4714         {
4715           warn ("Invalid length %#08lx in FDE at %#08lx\n",
4716                 length, (unsigned long)(saved_start - section_start));
4717           block_end = end;
4718         }
4719       cie_id = byte_get (start, offset_size); start += offset_size;
4720
4721       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4722         {
4723           int version;
4724
4725           fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
4726           memset (fc, 0, sizeof (Frame_Chunk));
4727
4728           fc->next = chunks;
4729           chunks = fc;
4730           fc->chunk_start = saved_start;
4731           fc->ncols = 0;
4732           fc->col_type = (short int *) xmalloc (sizeof (short int));
4733           fc->col_offset = (int *) xmalloc (sizeof (int));
4734           frame_need_space (fc, max_regs - 1);
4735
4736           version = *start++;
4737
4738           fc->augmentation = (char *) start;
4739           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4740
4741           if (strcmp (fc->augmentation, "eh") == 0)
4742             start += eh_addr_size;
4743
4744           if (version >= 4)
4745             {
4746               fc->ptr_size = GET (1);
4747               fc->segment_size = GET (1);
4748               eh_addr_size = fc->ptr_size;
4749             }
4750           else
4751             {
4752               fc->ptr_size = eh_addr_size;
4753               fc->segment_size = 0;
4754             }
4755           fc->code_factor = LEB ();
4756           fc->data_factor = SLEB ();
4757           if (version == 1)
4758             {
4759               fc->ra = GET (1);
4760             }
4761           else
4762             {
4763               fc->ra = LEB ();
4764             }
4765
4766           if (fc->augmentation[0] == 'z')
4767             {
4768               augmentation_data_len = LEB ();
4769               augmentation_data = start;
4770               start += augmentation_data_len;
4771             }
4772           cie = fc;
4773
4774           if (do_debug_frames_interp)
4775             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4776                     (unsigned long)(saved_start - section_start), length, cie_id,
4777                     fc->augmentation, fc->code_factor, fc->data_factor,
4778                     fc->ra);
4779           else
4780             {
4781               printf ("\n%08lx %08lx %08lx CIE\n",
4782                       (unsigned long)(saved_start - section_start), length, cie_id);
4783               printf ("  Version:               %d\n", version);
4784               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
4785               if (version >= 4)
4786                 {
4787                   printf ("  Pointer Size:          %u\n", fc->ptr_size);
4788                   printf ("  Segment Size:          %u\n", fc->segment_size);
4789                 }
4790               printf ("  Code alignment factor: %u\n", fc->code_factor);
4791               printf ("  Data alignment factor: %d\n", fc->data_factor);
4792               printf ("  Return address column: %d\n", fc->ra);
4793
4794               if (augmentation_data_len)
4795                 {
4796                   unsigned long i;
4797                   printf ("  Augmentation data:    ");
4798                   for (i = 0; i < augmentation_data_len; ++i)
4799                     printf (" %02x", augmentation_data[i]);
4800                   putchar ('\n');
4801                 }
4802               putchar ('\n');
4803             }
4804
4805           if (augmentation_data_len)
4806             {
4807               unsigned char *p, *q;
4808               p = (unsigned char *) fc->augmentation + 1;
4809               q = augmentation_data;
4810
4811               while (1)
4812                 {
4813                   if (*p == 'L')
4814                     q++;
4815                   else if (*p == 'P')
4816                     q += 1 + size_of_encoded_value (*q);
4817                   else if (*p == 'R')
4818                     fc->fde_encoding = *q++;
4819                   else if (*p == 'S')
4820                     ;
4821                   else
4822                     break;
4823                   p++;
4824                 }
4825
4826               if (fc->fde_encoding)
4827                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4828             }
4829
4830           frame_need_space (fc, fc->ra);
4831         }
4832       else
4833         {
4834           unsigned char *look_for;
4835           static Frame_Chunk fde_fc;
4836           unsigned long segment_selector;
4837
4838           fc = & fde_fc;
4839           memset (fc, 0, sizeof (Frame_Chunk));
4840
4841           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4842
4843           for (cie = chunks; cie ; cie = cie->next)
4844             if (cie->chunk_start == look_for)
4845               break;
4846
4847           if (!cie)
4848             {
4849               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4850                     cie_id, (unsigned long)(saved_start - section_start));
4851               fc->ncols = 0;
4852               fc->col_type = (short int *) xmalloc (sizeof (short int));
4853               fc->col_offset = (int *) xmalloc (sizeof (int));
4854               frame_need_space (fc, max_regs - 1);
4855               cie = fc;
4856               fc->augmentation = "";
4857               fc->fde_encoding = 0;
4858               fc->ptr_size = eh_addr_size;
4859               fc->segment_size = 0;
4860             }
4861           else
4862             {
4863               fc->ncols = cie->ncols;
4864               fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4865               fc->col_offset =  (int *) xcmalloc (fc->ncols, sizeof (int));
4866               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4867               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4868               fc->augmentation = cie->augmentation;
4869               fc->ptr_size = cie->ptr_size;
4870               eh_addr_size = cie->ptr_size;
4871               fc->segment_size = cie->segment_size;
4872               fc->code_factor = cie->code_factor;
4873               fc->data_factor = cie->data_factor;
4874               fc->cfa_reg = cie->cfa_reg;
4875               fc->cfa_offset = cie->cfa_offset;
4876               fc->ra = cie->ra;
4877               frame_need_space (fc, max_regs - 1);
4878               fc->fde_encoding = cie->fde_encoding;
4879             }
4880
4881           if (fc->fde_encoding)
4882             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4883
4884           segment_selector = 0;
4885           if (fc->segment_size)
4886             {
4887               segment_selector = byte_get (start, fc->segment_size);
4888               start += fc->segment_size;
4889             }
4890           fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
4891           start += encoded_ptr_size;
4892           fc->pc_range = byte_get (start, encoded_ptr_size);
4893           start += encoded_ptr_size;
4894
4895           if (cie->augmentation[0] == 'z')
4896             {
4897               augmentation_data_len = LEB ();
4898               augmentation_data = start;
4899               start += augmentation_data_len;
4900             }
4901
4902           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
4903                   (unsigned long)(saved_start - section_start), length, cie_id,
4904                   (unsigned long)(cie->chunk_start - section_start));
4905           if (fc->segment_size)
4906             printf ("%04lx:", segment_selector);
4907           printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
4908           if (! do_debug_frames_interp && augmentation_data_len)
4909             {
4910               unsigned long i;
4911
4912               printf ("  Augmentation data:    ");
4913               for (i = 0; i < augmentation_data_len; ++i)
4914                 printf (" %02x", augmentation_data[i]);
4915               putchar ('\n');
4916               putchar ('\n');
4917             }
4918         }
4919
4920       /* At this point, fc is the current chunk, cie (if any) is set, and
4921          we're about to interpret instructions for the chunk.  */
4922       /* ??? At present we need to do this always, since this sizes the
4923          fc->col_type and fc->col_offset arrays, which we write into always.
4924          We should probably split the interpreted and non-interpreted bits
4925          into two different routines, since there's so much that doesn't
4926          really overlap between them.  */
4927       if (1 || do_debug_frames_interp)
4928         {
4929           /* Start by making a pass over the chunk, allocating storage
4930              and taking note of what registers are used.  */
4931           unsigned char *tmp = start;
4932
4933           while (start < block_end)
4934             {
4935               unsigned op, opa;
4936               unsigned long reg, temp;
4937
4938               op = *start++;
4939               opa = op & 0x3f;
4940               if (op & 0xc0)
4941                 op &= 0xc0;
4942
4943               /* Warning: if you add any more cases to this switch, be
4944                  sure to add them to the corresponding switch below.  */
4945               switch (op)
4946                 {
4947                 case DW_CFA_advance_loc:
4948                   break;
4949                 case DW_CFA_offset:
4950                   LEB ();
4951                   if (frame_need_space (fc, opa) >= 0)
4952                     fc->col_type[opa] = DW_CFA_undefined;
4953                   break;
4954                 case DW_CFA_restore:
4955                   if (frame_need_space (fc, opa) >= 0)
4956                     fc->col_type[opa] = DW_CFA_undefined;
4957                   break;
4958                 case DW_CFA_set_loc:
4959                   start += encoded_ptr_size;
4960                   break;
4961                 case DW_CFA_advance_loc1:
4962                   start += 1;
4963                   break;
4964                 case DW_CFA_advance_loc2:
4965                   start += 2;
4966                   break;
4967                 case DW_CFA_advance_loc4:
4968                   start += 4;
4969                   break;
4970                 case DW_CFA_offset_extended:
4971                 case DW_CFA_val_offset:
4972                   reg = LEB (); LEB ();
4973                   if (frame_need_space (fc, reg) >= 0)
4974                     fc->col_type[reg] = DW_CFA_undefined;
4975                   break;
4976                 case DW_CFA_restore_extended:
4977                   reg = LEB ();
4978                   frame_need_space (fc, reg);
4979                   if (frame_need_space (fc, reg) >= 0)
4980                     fc->col_type[reg] = DW_CFA_undefined;
4981                   break;
4982                 case DW_CFA_undefined:
4983                   reg = LEB ();
4984                   if (frame_need_space (fc, reg) >= 0)
4985                     fc->col_type[reg] = DW_CFA_undefined;
4986                   break;
4987                 case DW_CFA_same_value:
4988                   reg = LEB ();
4989                   if (frame_need_space (fc, reg) >= 0)
4990                     fc->col_type[reg] = DW_CFA_undefined;
4991                   break;
4992                 case DW_CFA_register:
4993                   reg = LEB (); LEB ();
4994                   if (frame_need_space (fc, reg) >= 0)
4995                     fc->col_type[reg] = DW_CFA_undefined;
4996                   break;
4997                 case DW_CFA_def_cfa:
4998                   LEB (); LEB ();
4999                   break;
5000                 case DW_CFA_def_cfa_register:
5001                   LEB ();
5002                   break;
5003                 case DW_CFA_def_cfa_offset:
5004                   LEB ();
5005                   break;
5006                 case DW_CFA_def_cfa_expression:
5007                   temp = LEB ();
5008                   start += temp;
5009                   break;
5010                 case DW_CFA_expression:
5011                 case DW_CFA_val_expression:
5012                   reg = LEB ();
5013                   temp = LEB ();
5014                   start += temp;
5015                   if (frame_need_space (fc, reg) >= 0)
5016                     fc->col_type[reg] = DW_CFA_undefined;
5017                   break;
5018                 case DW_CFA_offset_extended_sf:
5019                 case DW_CFA_val_offset_sf:
5020                   reg = LEB (); SLEB ();
5021                   if (frame_need_space (fc, reg) >= 0)
5022                     fc->col_type[reg] = DW_CFA_undefined;
5023                   break;
5024                 case DW_CFA_def_cfa_sf:
5025                   LEB (); SLEB ();
5026                   break;
5027                 case DW_CFA_def_cfa_offset_sf:
5028                   SLEB ();
5029                   break;
5030                 case DW_CFA_MIPS_advance_loc8:
5031                   start += 8;
5032                   break;
5033                 case DW_CFA_GNU_args_size:
5034                   LEB ();
5035                   break;
5036                 case DW_CFA_GNU_negative_offset_extended:
5037                   reg = LEB (); LEB ();
5038                   if (frame_need_space (fc, reg) >= 0)
5039                     fc->col_type[reg] = DW_CFA_undefined;
5040                   break;
5041                 default:
5042                   break;
5043                 }
5044             }
5045           start = tmp;
5046         }
5047
5048       /* Now we know what registers are used, make a second pass over
5049          the chunk, this time actually printing out the info.  */
5050
5051       while (start < block_end)
5052         {
5053           unsigned op, opa;
5054           unsigned long ul, reg, roffs;
5055           long l, ofs;
5056           dwarf_vma vma;
5057           const char *reg_prefix = "";
5058
5059           op = *start++;
5060           opa = op & 0x3f;
5061           if (op & 0xc0)
5062             op &= 0xc0;
5063
5064           /* Warning: if you add any more cases to this switch, be
5065              sure to add them to the corresponding switch above.  */
5066           switch (op)
5067             {
5068             case DW_CFA_advance_loc:
5069               if (do_debug_frames_interp)
5070                 frame_display_row (fc, &need_col_headers, &max_regs);
5071               else
5072                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
5073                         opa * fc->code_factor,
5074                         fc->pc_begin + opa * fc->code_factor);
5075               fc->pc_begin += opa * fc->code_factor;
5076               break;
5077
5078             case DW_CFA_offset:
5079               roffs = LEB ();
5080               if (opa >= (unsigned int) fc->ncols)
5081                 reg_prefix = bad_reg;
5082               if (! do_debug_frames_interp || *reg_prefix != '\0')
5083                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
5084                         reg_prefix, regname (opa, 0),
5085                         roffs * fc->data_factor);
5086               if (*reg_prefix == '\0')
5087                 {
5088                   fc->col_type[opa] = DW_CFA_offset;
5089                   fc->col_offset[opa] = roffs * fc->data_factor;
5090                 }
5091               break;
5092
5093             case DW_CFA_restore:
5094               if (opa >= (unsigned int) cie->ncols
5095                   || opa >= (unsigned int) fc->ncols)
5096                 reg_prefix = bad_reg;
5097               if (! do_debug_frames_interp || *reg_prefix != '\0')
5098                 printf ("  DW_CFA_restore: %s%s\n",
5099                         reg_prefix, regname (opa, 0));
5100               if (*reg_prefix == '\0')
5101                 {
5102                   fc->col_type[opa] = cie->col_type[opa];
5103                   fc->col_offset[opa] = cie->col_offset[opa];
5104                 }
5105               break;
5106
5107             case DW_CFA_set_loc:
5108               vma = get_encoded_value (start, fc->fde_encoding, section);
5109               start += encoded_ptr_size;
5110               if (do_debug_frames_interp)
5111                 frame_display_row (fc, &need_col_headers, &max_regs);
5112               else
5113                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
5114               fc->pc_begin = vma;
5115               break;
5116
5117             case DW_CFA_advance_loc1:
5118               ofs = byte_get (start, 1); start += 1;
5119               if (do_debug_frames_interp)
5120                 frame_display_row (fc, &need_col_headers, &max_regs);
5121               else
5122                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
5123                         ofs * fc->code_factor,
5124                         fc->pc_begin + ofs * fc->code_factor);
5125               fc->pc_begin += ofs * fc->code_factor;
5126               break;
5127
5128             case DW_CFA_advance_loc2:
5129               ofs = byte_get (start, 2); start += 2;
5130               if (do_debug_frames_interp)
5131                 frame_display_row (fc, &need_col_headers, &max_regs);
5132               else
5133                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
5134                         ofs * fc->code_factor,
5135                         fc->pc_begin + ofs * fc->code_factor);
5136               fc->pc_begin += ofs * fc->code_factor;
5137               break;
5138
5139             case DW_CFA_advance_loc4:
5140               ofs = byte_get (start, 4); start += 4;
5141               if (do_debug_frames_interp)
5142                 frame_display_row (fc, &need_col_headers, &max_regs);
5143               else
5144                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
5145                         ofs * fc->code_factor,
5146                         fc->pc_begin + ofs * fc->code_factor);
5147               fc->pc_begin += ofs * fc->code_factor;
5148               break;
5149
5150             case DW_CFA_offset_extended:
5151               reg = LEB ();
5152               roffs = LEB ();
5153               if (reg >= (unsigned int) fc->ncols)
5154                 reg_prefix = bad_reg;
5155               if (! do_debug_frames_interp || *reg_prefix != '\0')
5156                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5157                         reg_prefix, regname (reg, 0),
5158                         roffs * fc->data_factor);
5159               if (*reg_prefix == '\0')
5160                 {
5161                   fc->col_type[reg] = DW_CFA_offset;
5162                   fc->col_offset[reg] = roffs * fc->data_factor;
5163                 }
5164               break;
5165
5166             case DW_CFA_val_offset:
5167               reg = LEB ();
5168               roffs = LEB ();
5169               if (reg >= (unsigned int) fc->ncols)
5170                 reg_prefix = bad_reg;
5171               if (! do_debug_frames_interp || *reg_prefix != '\0')
5172                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
5173                         reg_prefix, regname (reg, 0),
5174                         roffs * fc->data_factor);
5175               if (*reg_prefix == '\0')
5176                 {
5177                   fc->col_type[reg] = DW_CFA_val_offset;
5178                   fc->col_offset[reg] = roffs * fc->data_factor;
5179                 }
5180               break;
5181
5182             case DW_CFA_restore_extended:
5183               reg = LEB ();
5184               if (reg >= (unsigned int) cie->ncols
5185                   || reg >= (unsigned int) fc->ncols)
5186                 reg_prefix = bad_reg;
5187               if (! do_debug_frames_interp || *reg_prefix != '\0')
5188                 printf ("  DW_CFA_restore_extended: %s%s\n",
5189                         reg_prefix, regname (reg, 0));
5190               if (*reg_prefix == '\0')
5191                 {
5192                   fc->col_type[reg] = cie->col_type[reg];
5193                   fc->col_offset[reg] = cie->col_offset[reg];
5194                 }
5195               break;
5196
5197             case DW_CFA_undefined:
5198               reg = LEB ();
5199               if (reg >= (unsigned int) fc->ncols)
5200                 reg_prefix = bad_reg;
5201               if (! do_debug_frames_interp || *reg_prefix != '\0')
5202                 printf ("  DW_CFA_undefined: %s%s\n",
5203                         reg_prefix, regname (reg, 0));
5204               if (*reg_prefix == '\0')
5205                 {
5206                   fc->col_type[reg] = DW_CFA_undefined;
5207                   fc->col_offset[reg] = 0;
5208                 }
5209               break;
5210
5211             case DW_CFA_same_value:
5212               reg = LEB ();
5213               if (reg >= (unsigned int) fc->ncols)
5214                 reg_prefix = bad_reg;
5215               if (! do_debug_frames_interp || *reg_prefix != '\0')
5216                 printf ("  DW_CFA_same_value: %s%s\n",
5217                         reg_prefix, regname (reg, 0));
5218               if (*reg_prefix == '\0')
5219                 {
5220                   fc->col_type[reg] = DW_CFA_same_value;
5221                   fc->col_offset[reg] = 0;
5222                 }
5223               break;
5224
5225             case DW_CFA_register:
5226               reg = LEB ();
5227               roffs = LEB ();
5228               if (reg >= (unsigned int) fc->ncols)
5229                 reg_prefix = bad_reg;
5230               if (! do_debug_frames_interp || *reg_prefix != '\0')
5231                 {
5232                   printf ("  DW_CFA_register: %s%s in ",
5233                           reg_prefix, regname (reg, 0));
5234                   puts (regname (roffs, 0));
5235                 }
5236               if (*reg_prefix == '\0')
5237                 {
5238                   fc->col_type[reg] = DW_CFA_register;
5239                   fc->col_offset[reg] = roffs;
5240                 }
5241               break;
5242
5243             case DW_CFA_remember_state:
5244               if (! do_debug_frames_interp)
5245                 printf ("  DW_CFA_remember_state\n");
5246               rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5247               rs->ncols = fc->ncols;
5248               rs->col_type = (short int *) xcmalloc (rs->ncols,
5249                                                      sizeof (short int));
5250               rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
5251               memcpy (rs->col_type, fc->col_type, rs->ncols);
5252               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5253               rs->next = remembered_state;
5254               remembered_state = rs;
5255               break;
5256
5257             case DW_CFA_restore_state:
5258               if (! do_debug_frames_interp)
5259                 printf ("  DW_CFA_restore_state\n");
5260               rs = remembered_state;
5261               if (rs)
5262                 {
5263                   remembered_state = rs->next;
5264                   frame_need_space (fc, rs->ncols - 1);
5265                   memcpy (fc->col_type, rs->col_type, rs->ncols);
5266                   memcpy (fc->col_offset, rs->col_offset,
5267                           rs->ncols * sizeof (int));
5268                   free (rs->col_type);
5269                   free (rs->col_offset);
5270                   free (rs);
5271                 }
5272               else if (do_debug_frames_interp)
5273                 printf ("Mismatched DW_CFA_restore_state\n");
5274               break;
5275
5276             case DW_CFA_def_cfa:
5277               fc->cfa_reg = LEB ();
5278               fc->cfa_offset = LEB ();
5279               fc->cfa_exp = 0;
5280               if (! do_debug_frames_interp)
5281                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
5282                         regname (fc->cfa_reg, 0), fc->cfa_offset);
5283               break;
5284
5285             case DW_CFA_def_cfa_register:
5286               fc->cfa_reg = LEB ();
5287               fc->cfa_exp = 0;
5288               if (! do_debug_frames_interp)
5289                 printf ("  DW_CFA_def_cfa_register: %s\n",
5290                         regname (fc->cfa_reg, 0));
5291               break;
5292
5293             case DW_CFA_def_cfa_offset:
5294               fc->cfa_offset = LEB ();
5295               if (! do_debug_frames_interp)
5296                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5297               break;
5298
5299             case DW_CFA_nop:
5300               if (! do_debug_frames_interp)
5301                 printf ("  DW_CFA_nop\n");
5302               break;
5303
5304             case DW_CFA_def_cfa_expression:
5305               ul = LEB ();
5306               if (! do_debug_frames_interp)
5307                 {
5308                   printf ("  DW_CFA_def_cfa_expression (");
5309                   decode_location_expression (start, eh_addr_size, 0, -1,
5310                                               ul, 0, section);
5311                   printf (")\n");
5312                 }
5313               fc->cfa_exp = 1;
5314               start += ul;
5315               break;
5316
5317             case DW_CFA_expression:
5318               reg = LEB ();
5319               ul = LEB ();
5320               if (reg >= (unsigned int) fc->ncols)
5321                 reg_prefix = bad_reg;
5322               if (! do_debug_frames_interp || *reg_prefix != '\0')
5323                 {
5324                   printf ("  DW_CFA_expression: %s%s (",
5325                           reg_prefix, regname (reg, 0));
5326                   decode_location_expression (start, eh_addr_size, 0, -1,
5327                                               ul, 0, section);
5328                   printf (")\n");
5329                 }
5330               if (*reg_prefix == '\0')
5331                 fc->col_type[reg] = DW_CFA_expression;
5332               start += ul;
5333               break;
5334
5335             case DW_CFA_val_expression:
5336               reg = LEB ();
5337               ul = LEB ();
5338               if (reg >= (unsigned int) fc->ncols)
5339                 reg_prefix = bad_reg;
5340               if (! do_debug_frames_interp || *reg_prefix != '\0')
5341                 {
5342                   printf ("  DW_CFA_val_expression: %s%s (",
5343                           reg_prefix, regname (reg, 0));
5344                   decode_location_expression (start, eh_addr_size, 0, -1,
5345                                               ul, 0, section);
5346                   printf (")\n");
5347                 }
5348               if (*reg_prefix == '\0')
5349                 fc->col_type[reg] = DW_CFA_val_expression;
5350               start += ul;
5351               break;
5352
5353             case DW_CFA_offset_extended_sf:
5354               reg = LEB ();
5355               l = SLEB ();
5356               if (frame_need_space (fc, reg) < 0)
5357                 reg_prefix = bad_reg;
5358               if (! do_debug_frames_interp || *reg_prefix != '\0')
5359                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5360                         reg_prefix, regname (reg, 0),
5361                         l * fc->data_factor);
5362               if (*reg_prefix == '\0')
5363                 {
5364                   fc->col_type[reg] = DW_CFA_offset;
5365                   fc->col_offset[reg] = l * fc->data_factor;
5366                 }
5367               break;
5368
5369             case DW_CFA_val_offset_sf:
5370               reg = LEB ();
5371               l = SLEB ();
5372               if (frame_need_space (fc, reg) < 0)
5373                 reg_prefix = bad_reg;
5374               if (! do_debug_frames_interp || *reg_prefix != '\0')
5375                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5376                         reg_prefix, regname (reg, 0),
5377                         l * fc->data_factor);
5378               if (*reg_prefix == '\0')
5379                 {
5380                   fc->col_type[reg] = DW_CFA_val_offset;
5381                   fc->col_offset[reg] = l * fc->data_factor;
5382                 }
5383               break;
5384
5385             case DW_CFA_def_cfa_sf:
5386               fc->cfa_reg = LEB ();
5387               fc->cfa_offset = SLEB ();
5388               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5389               fc->cfa_exp = 0;
5390               if (! do_debug_frames_interp)
5391                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
5392                         regname (fc->cfa_reg, 0), fc->cfa_offset);
5393               break;
5394
5395             case DW_CFA_def_cfa_offset_sf:
5396               fc->cfa_offset = SLEB ();
5397               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5398               if (! do_debug_frames_interp)
5399                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5400               break;
5401
5402             case DW_CFA_MIPS_advance_loc8:
5403               ofs = byte_get (start, 8); start += 8;
5404               if (do_debug_frames_interp)
5405                 frame_display_row (fc, &need_col_headers, &max_regs);
5406               else
5407                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5408                         ofs * fc->code_factor,
5409                         fc->pc_begin + ofs * fc->code_factor);
5410               fc->pc_begin += ofs * fc->code_factor;
5411               break;
5412
5413             case DW_CFA_GNU_window_save:
5414               if (! do_debug_frames_interp)
5415                 printf ("  DW_CFA_GNU_window_save\n");
5416               break;
5417
5418             case DW_CFA_GNU_args_size:
5419               ul = LEB ();
5420               if (! do_debug_frames_interp)
5421                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
5422               break;
5423
5424             case DW_CFA_GNU_negative_offset_extended:
5425               reg = LEB ();
5426               l = - LEB ();
5427               if (frame_need_space (fc, reg) < 0)
5428                 reg_prefix = bad_reg;
5429               if (! do_debug_frames_interp || *reg_prefix != '\0')
5430                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5431                         reg_prefix, regname (reg, 0),
5432                         l * fc->data_factor);
5433               if (*reg_prefix == '\0')
5434                 {
5435                   fc->col_type[reg] = DW_CFA_offset;
5436                   fc->col_offset[reg] = l * fc->data_factor;
5437                 }
5438               break;
5439
5440             default:
5441               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5442                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5443               else
5444                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
5445               start = block_end;
5446             }
5447         }
5448
5449       if (do_debug_frames_interp)
5450         frame_display_row (fc, &need_col_headers, &max_regs);
5451
5452       start = block_end;
5453       eh_addr_size = saved_eh_addr_size;
5454     }
5455
5456   printf ("\n");
5457
5458   return 1;
5459 }
5460
5461 #undef GET
5462 #undef LEB
5463 #undef SLEB
5464
5465 static int
5466 display_gdb_index (struct dwarf_section *section,
5467                    void *file ATTRIBUTE_UNUSED)
5468 {
5469   unsigned char *start = section->start;
5470   uint32_t version;
5471   uint32_t cu_list_offset, tu_list_offset;
5472   uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5473   unsigned int cu_list_elements, tu_list_elements;
5474   unsigned int address_table_size, symbol_table_slots;
5475   unsigned char *cu_list, *tu_list;
5476   unsigned char *address_table, *symbol_table, *constant_pool;
5477   unsigned int i;
5478
5479   /* The documentation for the format of this file is in gdb/dwarf2read.c.  */
5480
5481   printf (_("Contents of the %s section:\n"), section->name);
5482
5483   if (section->size < 6 * sizeof (uint32_t))
5484     {
5485       warn (_("Truncated header in the %s section.\n"), section->name);
5486       return 0;
5487     }
5488
5489   version = byte_get_little_endian (start, 4);
5490   printf (_("Version %ld\n"), (long) version);
5491
5492   /* Prior versions are obsolete, and future versions may not be
5493      backwards compatible.  */
5494   switch (version)
5495     {
5496     case 3:
5497       warn (_("The address table data in version 3 may be wrong.\n"));
5498       break;
5499     case 4:
5500       warn (_("Version 4 does not support case insensitive lookups.\n"));
5501       break;
5502     case 5:
5503       break;
5504     default:
5505       warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5506       return 0;
5507     }
5508
5509   cu_list_offset = byte_get_little_endian (start + 4, 4);
5510   tu_list_offset = byte_get_little_endian (start + 8, 4);
5511   address_table_offset = byte_get_little_endian (start + 12, 4);
5512   symbol_table_offset = byte_get_little_endian (start + 16, 4);
5513   constant_pool_offset = byte_get_little_endian (start + 20, 4);
5514
5515   if (cu_list_offset > section->size
5516       || tu_list_offset > section->size
5517       || address_table_offset > section->size
5518       || symbol_table_offset > section->size
5519       || constant_pool_offset > section->size)
5520     {
5521       warn (_("Corrupt header in the %s section.\n"), section->name);
5522       return 0;
5523     }
5524
5525   cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5526   tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5527   address_table_size = symbol_table_offset - address_table_offset;
5528   symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5529
5530   cu_list = start + cu_list_offset;
5531   tu_list = start + tu_list_offset;
5532   address_table = start + address_table_offset;
5533   symbol_table = start + symbol_table_offset;
5534   constant_pool = start + constant_pool_offset;
5535
5536   printf (_("\nCU table:\n"));
5537   for (i = 0; i < cu_list_elements; i += 2)
5538     {
5539       uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5540       uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5541
5542       printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5543               (unsigned long) cu_offset,
5544               (unsigned long) (cu_offset + cu_length - 1));
5545     }
5546
5547   printf (_("\nTU table:\n"));
5548   for (i = 0; i < tu_list_elements; i += 3)
5549     {
5550       uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5551       uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5552       uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5553
5554       printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5555               (unsigned long) tu_offset,
5556               (unsigned long) type_offset);
5557       print_dwarf_vma (signature, 8);
5558       printf ("\n");
5559     }
5560
5561   printf (_("\nAddress table:\n"));
5562   for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5563     {
5564       uint64_t low = byte_get_little_endian (address_table + i, 8);
5565       uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5566       uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5567
5568       print_dwarf_vma (low, 8);
5569       print_dwarf_vma (high, 8);
5570       printf (_("%lu\n"), (unsigned long) cu_index);
5571     }
5572
5573   printf (_("\nSymbol table:\n"));
5574   for (i = 0; i < symbol_table_slots; ++i)
5575     {
5576       uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5577       uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5578       uint32_t num_cus, cu;
5579
5580       if (name_offset != 0
5581           || cu_vector_offset != 0)
5582         {
5583           unsigned int j;
5584
5585           printf ("[%3u] %s:", i, constant_pool + name_offset);
5586           num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5587           for (j = 0; j < num_cus; ++j)
5588             {
5589               cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5590               /* Convert to TU number if it's for a type unit.  */
5591               if (cu >= cu_list_elements / 2)
5592                 printf (" T%lu", (unsigned long) (cu - cu_list_elements / 2));
5593               else
5594                 printf (" %lu", (unsigned long) cu);
5595             }
5596           printf ("\n");
5597         }
5598     }
5599
5600   return 1;
5601 }
5602
5603 static int
5604 display_debug_not_supported (struct dwarf_section *section,
5605                              void *file ATTRIBUTE_UNUSED)
5606 {
5607   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5608             section->name);
5609
5610   return 1;
5611 }
5612
5613 void *
5614 cmalloc (size_t nmemb, size_t size)
5615 {
5616   /* Check for overflow.  */
5617   if (nmemb >= ~(size_t) 0 / size)
5618     return NULL;
5619   else
5620     return malloc (nmemb * size);
5621 }
5622
5623 void *
5624 xcmalloc (size_t nmemb, size_t size)
5625 {
5626   /* Check for overflow.  */
5627   if (nmemb >= ~(size_t) 0 / size)
5628     return NULL;
5629   else
5630     return xmalloc (nmemb * size);
5631 }
5632
5633 void *
5634 xcrealloc (void *ptr, size_t nmemb, size_t size)
5635 {
5636   /* Check for overflow.  */
5637   if (nmemb >= ~(size_t) 0 / size)
5638     return NULL;
5639   else
5640     return xrealloc (ptr, nmemb * size);
5641 }
5642
5643 void
5644 free_debug_memory (void)
5645 {
5646   unsigned int i;
5647
5648   free_abbrevs ();
5649
5650   for (i = 0; i < max; i++)
5651     free_debug_section ((enum dwarf_section_display_enum) i);
5652
5653   if (debug_information != NULL)
5654     {
5655       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
5656         {
5657           for (i = 0; i < num_debug_info_entries; i++)
5658             {
5659               if (!debug_information [i].max_loc_offsets)
5660                 {
5661                   free (debug_information [i].loc_offsets);
5662                   free (debug_information [i].have_frame_base);
5663                 }
5664               if (!debug_information [i].max_range_lists)
5665                 free (debug_information [i].range_lists);
5666             }
5667         }
5668
5669       free (debug_information);
5670       debug_information = NULL;
5671       num_debug_info_entries = 0;
5672     }
5673 }
5674
5675 void
5676 dwarf_select_sections_by_names (const char *names)
5677 {
5678   typedef struct
5679   {
5680     const char * option;
5681     int *        variable;
5682     int          val;
5683   }
5684   debug_dump_long_opts;
5685
5686   static const debug_dump_long_opts opts_table [] =
5687     {
5688       /* Please keep this table alpha- sorted.  */
5689       { "Ranges", & do_debug_ranges, 1 },
5690       { "abbrev", & do_debug_abbrevs, 1 },
5691       { "aranges", & do_debug_aranges, 1 },
5692       { "frames", & do_debug_frames, 1 },
5693       { "frames-interp", & do_debug_frames_interp, 1 },
5694       { "info", & do_debug_info, 1 },
5695       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
5696       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5697       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5698       { "loc",  & do_debug_loc, 1 },
5699       { "macro", & do_debug_macinfo, 1 },
5700       { "pubnames", & do_debug_pubnames, 1 },
5701       { "pubtypes", & do_debug_pubtypes, 1 },
5702       /* This entry is for compatability
5703          with earlier versions of readelf.  */
5704       { "ranges", & do_debug_aranges, 1 },
5705       { "str", & do_debug_str, 1 },
5706       /* The special .gdb_index section.  */
5707       { "gdb_index", & do_gdb_index, 1 },
5708       /* These trace_* sections are used by Itanium VMS.  */
5709       { "trace_abbrev", & do_trace_abbrevs, 1 },
5710       { "trace_aranges", & do_trace_aranges, 1 },
5711       { "trace_info", & do_trace_info, 1 },
5712       { NULL, NULL, 0 }
5713     };
5714
5715   const char *p;
5716
5717   p = names;
5718   while (*p)
5719     {
5720       const debug_dump_long_opts * entry;
5721
5722       for (entry = opts_table; entry->option; entry++)
5723         {
5724           size_t len = strlen (entry->option);
5725
5726           if (strncmp (p, entry->option, len) == 0
5727               && (p[len] == ',' || p[len] == '\0'))
5728             {
5729               * entry->variable |= entry->val;
5730
5731               /* The --debug-dump=frames-interp option also
5732                  enables the --debug-dump=frames option.  */
5733               if (do_debug_frames_interp)
5734                 do_debug_frames = 1;
5735
5736               p += len;
5737               break;
5738             }
5739         }
5740
5741       if (entry->option == NULL)
5742         {
5743           warn (_("Unrecognized debug option '%s'\n"), p);
5744           p = strchr (p, ',');
5745           if (p == NULL)
5746             break;
5747         }
5748
5749       if (*p == ',')
5750         p++;
5751     }
5752 }
5753
5754 void
5755 dwarf_select_sections_by_letters (const char *letters)
5756 {
5757   unsigned int lindex = 0;
5758
5759   while (letters[lindex])
5760     switch (letters[lindex++])
5761       {
5762       case 'i':
5763         do_debug_info = 1;
5764         break;
5765
5766       case 'a':
5767         do_debug_abbrevs = 1;
5768         break;
5769
5770       case 'l':
5771         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5772         break;
5773
5774       case 'L':
5775         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5776         break;
5777
5778       case 'p':
5779         do_debug_pubnames = 1;
5780         break;
5781
5782       case 't':
5783         do_debug_pubtypes = 1;
5784         break;
5785
5786       case 'r':
5787         do_debug_aranges = 1;
5788         break;
5789
5790       case 'R':
5791         do_debug_ranges = 1;
5792         break;
5793
5794       case 'F':
5795         do_debug_frames_interp = 1;
5796       case 'f':
5797         do_debug_frames = 1;
5798         break;
5799
5800       case 'm':
5801         do_debug_macinfo = 1;
5802         break;
5803
5804       case 's':
5805         do_debug_str = 1;
5806         break;
5807
5808       case 'o':
5809         do_debug_loc = 1;
5810         break;
5811
5812       default:
5813         warn (_("Unrecognized debug option '%s'\n"), optarg);
5814         break;
5815       }
5816 }
5817
5818 void
5819 dwarf_select_sections_all (void)
5820 {
5821   do_debug_info = 1;
5822   do_debug_abbrevs = 1;
5823   do_debug_lines = FLAG_DEBUG_LINES_RAW;
5824   do_debug_pubnames = 1;
5825   do_debug_pubtypes = 1;
5826   do_debug_aranges = 1;
5827   do_debug_ranges = 1;
5828   do_debug_frames = 1;
5829   do_debug_macinfo = 1;
5830   do_debug_str = 1;
5831   do_debug_loc = 1;
5832   do_gdb_index = 1;
5833   do_trace_info = 1;
5834   do_trace_abbrevs = 1;
5835   do_trace_aranges = 1;
5836 }
5837
5838 struct dwarf_section_display debug_displays[] =
5839 {
5840   { { ".debug_abbrev",          ".zdebug_abbrev",       NULL, NULL, 0, 0 },
5841     display_debug_abbrev,               &do_debug_abbrevs,      0 },
5842   { { ".debug_aranges",         ".zdebug_aranges",      NULL, NULL, 0, 0 },
5843     display_debug_aranges,              &do_debug_aranges,      1 },
5844   { { ".debug_frame",           ".zdebug_frame",        NULL, NULL, 0, 0 },
5845     display_debug_frames,               &do_debug_frames,       1 },
5846   { { ".debug_info",            ".zdebug_info",         NULL, NULL, 0, 0 },
5847     display_debug_info,                 &do_debug_info,         1 },
5848   { { ".debug_line",            ".zdebug_line",         NULL, NULL, 0, 0 },
5849     display_debug_lines,                &do_debug_lines,        1 },
5850   { { ".debug_pubnames",        ".zdebug_pubnames",     NULL, NULL, 0, 0 },
5851     display_debug_pubnames,             &do_debug_pubnames,     0 },
5852   { { ".eh_frame",              "",                     NULL, NULL, 0, 0 },
5853     display_debug_frames,               &do_debug_frames,       1 },
5854   { { ".debug_macinfo",         ".zdebug_macinfo",      NULL, NULL, 0, 0 },
5855     display_debug_macinfo,              &do_debug_macinfo,      0 },
5856   { { ".debug_macro",           ".zdebug_macro",        NULL, NULL, 0, 0 },
5857     display_debug_macro,                &do_debug_macinfo,      1 },
5858   { { ".debug_str",             ".zdebug_str",          NULL, NULL, 0, 0 },
5859     display_debug_str,                  &do_debug_str,          0 },
5860   { { ".debug_loc",             ".zdebug_loc",          NULL, NULL, 0, 0 },
5861     display_debug_loc,                  &do_debug_loc,          1 },
5862   { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL, NULL, 0, 0 },
5863     display_debug_pubnames,             &do_debug_pubtypes,     0 },
5864   { { ".debug_ranges",          ".zdebug_ranges",       NULL, NULL, 0, 0 },
5865     display_debug_ranges,               &do_debug_ranges,       1 },
5866   { { ".debug_static_func",     ".zdebug_static_func",  NULL, NULL, 0, 0 },
5867     display_debug_not_supported,        NULL,                   0 },
5868   { { ".debug_static_vars",     ".zdebug_static_vars",  NULL, NULL, 0, 0 },
5869     display_debug_not_supported,        NULL,                   0 },
5870   { { ".debug_types",           ".zdebug_types",        NULL, NULL, 0, 0 },
5871     display_debug_types,                &do_debug_info,         1 },
5872   { { ".debug_weaknames",       ".zdebug_weaknames",    NULL, NULL, 0, 0 },
5873     display_debug_not_supported,        NULL,                   0 },
5874   { { ".gdb_index",             "",                     NULL, NULL, 0, 0 },
5875     display_gdb_index,                  &do_gdb_index,          0 },
5876   { { ".trace_info",            "",                     NULL, NULL, 0, 0 },
5877     display_trace_info,                 &do_trace_info,         1 },
5878   { { ".trace_abbrev",          "",                     NULL, NULL, 0, 0 },
5879     display_debug_abbrev,               &do_trace_abbrevs,      0 },
5880   { { ".trace_aranges",         "",                     NULL, NULL, 0, 0 },
5881     display_debug_aranges,              &do_trace_aranges,      0 }
5882 };