binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright 2005, 2006, 2007
   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 "bucomm.h"
  26 #include "elf/dwarf2.h"
  27 #include "dwarf.h"
  28
  29 static int have_frame_base;
  30 static int need_base_address;
  31
  32 static unsigned int last_pointer_size = 0;
  33 static int warned_about_missing_comp_units = FALSE;
  34
  35 static unsigned int num_debug_info_entries = 0;
  36 static debug_info *debug_information = NULL;
  37
  38 dwarf_vma eh_addr_size;
  39
  40 int do_debug_info;
  41 int do_debug_abbrevs;
  42 int do_debug_lines;
  43 int do_debug_pubnames;
  44 int do_debug_aranges;
  45 int do_debug_ranges;
  46 int do_debug_frames;
  47 int do_debug_frames_interp;
  48 int do_debug_macinfo;
  49 int do_debug_str;
  50 int do_debug_loc;
  51
  52 dwarf_vma (*byte_get) (unsigned char *, int);
  53
  54 dwarf_vma
  55 byte_get_little_endian (unsigned char *field, int size)
  56 {
  57   switch (size)
  58     {
  59     case 1:
  60       return *field;
  61
  62     case 2:
  63       return  ((unsigned int) (field[0]))
  64         |    (((unsigned int) (field[1])) << 8);
  65
  66     case 4:
  67       return  ((unsigned long) (field[0]))
  68         |    (((unsigned long) (field[1])) << 8)
  69         |    (((unsigned long) (field[2])) << 16)
  70         |    (((unsigned long) (field[3])) << 24);
  71
  72     case 8:
  73       if (sizeof (dwarf_vma) == 8)
  74         return  ((dwarf_vma) (field[0]))
  75           |    (((dwarf_vma) (field[1])) << 8)
  76           |    (((dwarf_vma) (field[2])) << 16)
  77           |    (((dwarf_vma) (field[3])) << 24)
  78           |    (((dwarf_vma) (field[4])) << 32)
  79           |    (((dwarf_vma) (field[5])) << 40)
  80           |    (((dwarf_vma) (field[6])) << 48)
  81           |    (((dwarf_vma) (field[7])) << 56);
  82       else if (sizeof (dwarf_vma) == 4)
  83         /* We want to extract data from an 8 byte wide field and
  84            place it into a 4 byte wide field.  Since this is a little
  85            endian source we can just use the 4 byte extraction code.  */
  86         return  ((unsigned long) (field[0]))
  87           |    (((unsigned long) (field[1])) << 8)
  88           |    (((unsigned long) (field[2])) << 16)
  89           |    (((unsigned long) (field[3])) << 24);
  90
  91     default:
  92       error (_("Unhandled data length: %d\n"), size);
  93       abort ();
  94     }
  95 }
  96
  97 dwarf_vma
  98 byte_get_big_endian (unsigned char *field, int size)
  99 {
 100   switch (size)
 101     {
 102     case 1:
 103       return *field;
 104
 105     case 2:
 106       return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 107
 108     case 4:
 109       return ((unsigned long) (field[3]))
 110         |   (((unsigned long) (field[2])) << 8)
 111         |   (((unsigned long) (field[1])) << 16)
 112         |   (((unsigned long) (field[0])) << 24);
 113
 114     case 8:
 115       if (sizeof (dwarf_vma) == 8)
 116         return ((dwarf_vma) (field[7]))
 117           |   (((dwarf_vma) (field[6])) << 8)
 118           |   (((dwarf_vma) (field[5])) << 16)
 119           |   (((dwarf_vma) (field[4])) << 24)
 120           |   (((dwarf_vma) (field[3])) << 32)
 121           |   (((dwarf_vma) (field[2])) << 40)
 122           |   (((dwarf_vma) (field[1])) << 48)
 123           |   (((dwarf_vma) (field[0])) << 56);
 124       else if (sizeof (dwarf_vma) == 4)
 125         {
 126           /* Although we are extracing data from an 8 byte wide field,
 127              we are returning only 4 bytes of data.  */
 128           field += 4;
 129           return ((unsigned long) (field[3]))
 130             |   (((unsigned long) (field[2])) << 8)
 131             |   (((unsigned long) (field[1])) << 16)
 132             |   (((unsigned long) (field[0])) << 24);
 133         }
 134
 135     default:
 136       error (_("Unhandled data length: %d\n"), size);
 137       abort ();
 138     }
 139 }
 140
 141 static dwarf_vma
 142 byte_get_signed (unsigned char *field, int size)
 143 {
 144   dwarf_vma x = byte_get (field, size);
 145
 146   switch (size)
 147     {
 148     case 1:
 149       return (x ^ 0x80) - 0x80;
 150     case 2:
 151       return (x ^ 0x8000) - 0x8000;
 152     case 4:
 153       return (x ^ 0x80000000) - 0x80000000;
 154     case 8:
 155       return x;
 156     default:
 157       abort ();
 158     }
 159 }
 160
 161 static unsigned long int
 162 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
 163 {
 164   unsigned long int result = 0;
 165   unsigned int num_read = 0;
 166   unsigned int shift = 0;
 167   unsigned char byte;
 168
 169   do
 170     {
 171       byte = *data++;
 172       num_read++;
 173
 174       result |= ((unsigned long int) (byte & 0x7f)) << shift;
 175
 176       shift += 7;
 177
 178     }
 179   while (byte & 0x80);
 180
 181   if (length_return != NULL)
 182     *length_return = num_read;
 183
 184   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
 185     result |= -1L << shift;
 186
 187   return result;
 188 }
 189
 190 typedef struct State_Machine_Registers
 191 {
 192   unsigned long address;
 193   unsigned int file;
 194   unsigned int line;
 195   unsigned int column;
 196   int is_stmt;
 197   int basic_block;
 198   int end_sequence;
 199 /* This variable hold the number of the last entry seen
 200    in the File Table.  */
 201   unsigned int last_file_entry;
 202 } SMR;
 203
 204 static SMR state_machine_regs;
 205
 206 static void
 207 reset_state_machine (int is_stmt)
 208 {
 209   state_machine_regs.address = 0;
 210   state_machine_regs.file = 1;
 211   state_machine_regs.line = 1;
 212   state_machine_regs.column = 0;
 213   state_machine_regs.is_stmt = is_stmt;
 214   state_machine_regs.basic_block = 0;
 215   state_machine_regs.end_sequence = 0;
 216   state_machine_regs.last_file_entry = 0;
 217 }
 218
 219 /* Handled an extend line op.
 220    Returns the number of bytes read.  */
 221
 222 static int
 223 process_extended_line_op (unsigned char *data, int is_stmt)
 224 {
 225   unsigned char op_code;
 226   unsigned int bytes_read;
 227   unsigned int len;
 228   unsigned char *name;
 229   unsigned long adr;
 230
 231   len = read_leb128 (data, & bytes_read, 0);
 232   data += bytes_read;
 233
 234   if (len == 0)
 235     {
 236       warn (_("badly formed extended line op encountered!\n"));
 237       return bytes_read;
 238     }
 239
 240   len += bytes_read;
 241   op_code = *data++;
 242
 243   printf (_("  Extended opcode %d: "), op_code);
 244
 245   switch (op_code)
 246     {
 247     case DW_LNE_end_sequence:
 248       printf (_("End of Sequence\n\n"));
 249       reset_state_machine (is_stmt);
 250       break;
 251
 252     case DW_LNE_set_address:
 253       adr = byte_get (data, len - bytes_read - 1);
 254       printf (_("set Address to 0x%lx\n"), adr);
 255       state_machine_regs.address = adr;
 256       break;
 257
 258     case DW_LNE_define_file:
 259       printf (_("  define new File Table entry\n"));
 260       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 261
 262       printf (_("   %d\t"), ++state_machine_regs.last_file_entry);
 263       name = data;
 264       data += strlen ((char *) data) + 1;
 265       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 266       data += bytes_read;
 267       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 268       data += bytes_read;
 269       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 270       printf (_("%s\n\n"), name);
 271       break;
 272
 273     /* HP extensions.  */
 274     case DW_LNE_HP_negate_is_UV_update:
 275       printf ("DW_LNE_HP_negate_is_UV_update");
 276       break;
 277     case DW_LNE_HP_push_context:
 278       printf ("DW_LNE_HP_push_context");
 279       break;
 280     case DW_LNE_HP_pop_context:
 281       printf ("DW_LNE_HP_pop_context");
 282       break;
 283     case DW_LNE_HP_set_file_line_column:
 284       printf ("DW_LNE_HP_set_file_line_column");
 285       break;
 286     case DW_LNE_HP_set_routine_name:
 287       printf ("DW_LNE_HP_set_routine_name");
 288       break;
 289     case DW_LNE_HP_set_sequence:
 290       printf ("DW_LNE_HP_set_sequence");
 291       break;
 292     case DW_LNE_HP_negate_post_semantics:
 293       printf ("DW_LNE_HP_negate_post_semantics");
 294       break;
 295     case DW_LNE_HP_negate_function_exit:
 296       printf ("DW_LNE_HP_negate_function_exit");
 297       break;
 298     case DW_LNE_HP_negate_front_end_logical:
 299       printf ("DW_LNE_HP_negate_front_end_logical");
 300       break;
 301     case DW_LNE_HP_define_proc:
 302       printf ("DW_LNE_HP_define_proc");
 303       break;
 304
 305     default:
 306       if (op_code >= DW_LNE_lo_user
 307           /* The test against DW_LNW_hi_user is redundant due to
 308              the limited range of the unsigned char data type used
 309              for op_code.  */
 310           /*&& op_code <= DW_LNE_hi_user*/)
 311         printf (_("user defined: length %d\n"), len - bytes_read);
 312       else
 313         printf (_("UNKNOWN: length %d\n"), len - bytes_read);
 314       break;
 315     }
 316
 317   return len;
 318 }
 319
 320 static const char *
 321 fetch_indirect_string (unsigned long offset)
 322 {
 323   struct dwarf_section *section = &debug_displays [str].section;
 324
 325   if (section->start == NULL)
 326     return _("<no .debug_str section>");
 327
 328   /* DWARF sections under Mach-O have non-zero addresses.  */
 329   offset -= section->address;
 330   if (offset > section->size)
 331     {
 332       warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
 333       return _("<offset is too big>");
 334     }
 335
 336   return (const char *) section->start + offset;
 337 }
 338
 339 /* FIXME:  There are better and more efficient ways to handle
 340    these structures.  For now though, I just want something that
 341    is simple to implement.  */
 342 typedef struct abbrev_attr
 343 {
 344   unsigned long attribute;
 345   unsigned long form;
 346   struct abbrev_attr *next;
 347 }
 348 abbrev_attr;
 349
 350 typedef struct abbrev_entry
 351 {
 352   unsigned long entry;
 353   unsigned long tag;
 354   int children;
 355   struct abbrev_attr *first_attr;
 356   struct abbrev_attr *last_attr;
 357   struct abbrev_entry *next;
 358 }
 359 abbrev_entry;
 360
 361 static abbrev_entry *first_abbrev = NULL;
 362 static abbrev_entry *last_abbrev = NULL;
 363
 364 static void
 365 free_abbrevs (void)
 366 {
 367   abbrev_entry *abbrev;
 368
 369   for (abbrev = first_abbrev; abbrev;)
 370     {
 371       abbrev_entry *next = abbrev->next;
 372       abbrev_attr *attr;
 373
 374       for (attr = abbrev->first_attr; attr;)
 375         {
 376           abbrev_attr *next = attr->next;
 377
 378           free (attr);
 379           attr = next;
 380         }
 381
 382       free (abbrev);
 383       abbrev = next;
 384     }
 385
 386   last_abbrev = first_abbrev = NULL;
 387 }
 388
 389 static void
 390 add_abbrev (unsigned long number, unsigned long tag, int children)
 391 {
 392   abbrev_entry *entry;
 393
 394   entry = malloc (sizeof (*entry));
 395
 396   if (entry == NULL)
 397     /* ugg */
 398     return;
 399
 400   entry->entry      = number;
 401   entry->tag        = tag;
 402   entry->children   = children;
 403   entry->first_attr = NULL;
 404   entry->last_attr  = NULL;
 405   entry->next       = NULL;
 406
 407   if (first_abbrev == NULL)
 408     first_abbrev = entry;
 409   else
 410     last_abbrev->next = entry;
 411
 412   last_abbrev = entry;
 413 }
 414
 415 static void
 416 add_abbrev_attr (unsigned long attribute, unsigned long form)
 417 {
 418   abbrev_attr *attr;
 419
 420   attr = malloc (sizeof (*attr));
 421
 422   if (attr == NULL)
 423     /* ugg */
 424     return;
 425
 426   attr->attribute = attribute;
 427   attr->form      = form;
 428   attr->next      = NULL;
 429
 430   if (last_abbrev->first_attr == NULL)
 431     last_abbrev->first_attr = attr;
 432   else
 433     last_abbrev->last_attr->next = attr;
 434
 435   last_abbrev->last_attr = attr;
 436 }
 437
 438 /* Processes the (partial) contents of a .debug_abbrev section.
 439    Returns NULL if the end of the section was encountered.
 440    Returns the address after the last byte read if the end of
 441    an abbreviation set was found.  */
 442
 443 static unsigned char *
 444 process_abbrev_section (unsigned char *start, unsigned char *end)
 445 {
 446   if (first_abbrev != NULL)
 447     return NULL;
 448
 449   while (start < end)
 450     {
 451       unsigned int bytes_read;
 452       unsigned long entry;
 453       unsigned long tag;
 454       unsigned long attribute;
 455       int children;
 456
 457       entry = read_leb128 (start, & bytes_read, 0);
 458       start += bytes_read;
 459
 460       /* A single zero is supposed to end the section according
 461          to the standard.  If there's more, then signal that to
 462          the caller.  */
 463       if (entry == 0)
 464         return start == end ? NULL : start;
 465
 466       tag = read_leb128 (start, & bytes_read, 0);
 467       start += bytes_read;
 468
 469       children = *start++;
 470
 471       add_abbrev (entry, tag, children);
 472
 473       do
 474         {
 475           unsigned long form;
 476
 477           attribute = read_leb128 (start, & bytes_read, 0);
 478           start += bytes_read;
 479
 480           form = read_leb128 (start, & bytes_read, 0);
 481           start += bytes_read;
 482
 483           if (attribute != 0)
 484             add_abbrev_attr (attribute, form);
 485         }
 486       while (attribute != 0);
 487     }
 488
 489   return NULL;
 490 }
 491
 492 static char *
 493 get_TAG_name (unsigned long tag)
 494 {
 495   switch (tag)
 496     {
 497     case DW_TAG_padding:                return "DW_TAG_padding";
 498     case DW_TAG_array_type:             return "DW_TAG_array_type";
 499     case DW_TAG_class_type:             return "DW_TAG_class_type";
 500     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
 501     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
 502     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
 503     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
 504     case DW_TAG_label:                  return "DW_TAG_label";
 505     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
 506     case DW_TAG_member:                 return "DW_TAG_member";
 507     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
 508     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
 509     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
 510     case DW_TAG_string_type:            return "DW_TAG_string_type";
 511     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
 512     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
 513     case DW_TAG_typedef:                return "DW_TAG_typedef";
 514     case DW_TAG_union_type:             return "DW_TAG_union_type";
 515     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
 516     case DW_TAG_variant:                return "DW_TAG_variant";
 517     case DW_TAG_common_block:           return "DW_TAG_common_block";
 518     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
 519     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
 520     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
 521     case DW_TAG_module:                 return "DW_TAG_module";
 522     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
 523     case DW_TAG_set_type:               return "DW_TAG_set_type";
 524     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
 525     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
 526     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
 527     case DW_TAG_base_type:              return "DW_TAG_base_type";
 528     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
 529     case DW_TAG_const_type:             return "DW_TAG_const_type";
 530     case DW_TAG_constant:               return "DW_TAG_constant";
 531     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
 532     case DW_TAG_file_type:              return "DW_TAG_file_type";
 533     case DW_TAG_friend:                 return "DW_TAG_friend";
 534     case DW_TAG_namelist:               return "DW_TAG_namelist";
 535     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
 536     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
 537     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
 538     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
 539     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
 540     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
 541     case DW_TAG_try_block:              return "DW_TAG_try_block";
 542     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
 543     case DW_TAG_variable:               return "DW_TAG_variable";
 544     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
 545     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
 546     case DW_TAG_format_label:           return "DW_TAG_format_label";
 547     case DW_TAG_function_template:      return "DW_TAG_function_template";
 548     case DW_TAG_class_template:         return "DW_TAG_class_template";
 549       /* DWARF 2.1 values.  */
 550     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
 551     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
 552     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
 553     case DW_TAG_namespace:              return "DW_TAG_namespace";
 554     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
 555     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
 556     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
 557     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
 558       /* UPC values.  */
 559     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
 560     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
 561     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
 562     default:
 563       {
 564         static char buffer[100];
 565
 566         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
 567         return buffer;
 568       }
 569     }
 570 }
 571
 572 static char *
 573 get_FORM_name (unsigned long form)
 574 {
 575   switch (form)
 576     {
 577     case DW_FORM_addr:          return "DW_FORM_addr";
 578     case DW_FORM_block2:        return "DW_FORM_block2";
 579     case DW_FORM_block4:        return "DW_FORM_block4";
 580     case DW_FORM_data2:         return "DW_FORM_data2";
 581     case DW_FORM_data4:         return "DW_FORM_data4";
 582     case DW_FORM_data8:         return "DW_FORM_data8";
 583     case DW_FORM_string:        return "DW_FORM_string";
 584     case DW_FORM_block:         return "DW_FORM_block";
 585     case DW_FORM_block1:        return "DW_FORM_block1";
 586     case DW_FORM_data1:         return "DW_FORM_data1";
 587     case DW_FORM_flag:          return "DW_FORM_flag";
 588     case DW_FORM_sdata:         return "DW_FORM_sdata";
 589     case DW_FORM_strp:          return "DW_FORM_strp";
 590     case DW_FORM_udata:         return "DW_FORM_udata";
 591     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
 592     case DW_FORM_ref1:          return "DW_FORM_ref1";
 593     case DW_FORM_ref2:          return "DW_FORM_ref2";
 594     case DW_FORM_ref4:          return "DW_FORM_ref4";
 595     case DW_FORM_ref8:          return "DW_FORM_ref8";
 596     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
 597     case DW_FORM_indirect:      return "DW_FORM_indirect";
 598     default:
 599       {
 600         static char buffer[100];
 601
 602         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
 603         return buffer;
 604       }
 605     }
 606 }
 607
 608 static unsigned char *
 609 display_block (unsigned char *data, unsigned long length)
 610 {
 611   printf (_(" %lu byte block: "), length);
 612
 613   while (length --)
 614     printf ("%lx ", (unsigned long) byte_get (data++, 1));
 615
 616   return data;
 617 }
 618
 619 static int
 620 decode_location_expression (unsigned char * data,
 621                             unsigned int pointer_size,
 622                             unsigned long length,
 623                             unsigned long cu_offset)
 624 {
 625   unsigned op;
 626   unsigned int bytes_read;
 627   unsigned long uvalue;
 628   unsigned char *end = data + length;
 629   int need_frame_base = 0;
 630
 631   while (data < end)
 632     {
 633       op = *data++;
 634
 635       switch (op)
 636         {
 637         case DW_OP_addr:
 638           printf ("DW_OP_addr: %lx",
 639                   (unsigned long) byte_get (data, pointer_size));
 640           data += pointer_size;
 641           break;
 642         case DW_OP_deref:
 643           printf ("DW_OP_deref");
 644           break;
 645         case DW_OP_const1u:
 646           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
 647           break;
 648         case DW_OP_const1s:
 649           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
 650           break;
 651         case DW_OP_const2u:
 652           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
 653           data += 2;
 654           break;
 655         case DW_OP_const2s:
 656           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
 657           data += 2;
 658           break;
 659         case DW_OP_const4u:
 660           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
 661           data += 4;
 662           break;
 663         case DW_OP_const4s:
 664           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
 665           data += 4;
 666           break;
 667         case DW_OP_const8u:
 668           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
 669                   (unsigned long) byte_get (data + 4, 4));
 670           data += 8;
 671           break;
 672         case DW_OP_const8s:
 673           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
 674                   (long) byte_get (data + 4, 4));
 675           data += 8;
 676           break;
 677         case DW_OP_constu:
 678           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
 679           data += bytes_read;
 680           break;
 681         case DW_OP_consts:
 682           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
 683           data += bytes_read;
 684           break;
 685         case DW_OP_dup:
 686           printf ("DW_OP_dup");
 687           break;
 688         case DW_OP_drop:
 689           printf ("DW_OP_drop");
 690           break;
 691         case DW_OP_over:
 692           printf ("DW_OP_over");
 693           break;
 694         case DW_OP_pick:
 695           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
 696           break;
 697         case DW_OP_swap:
 698           printf ("DW_OP_swap");
 699           break;
 700         case DW_OP_rot:
 701           printf ("DW_OP_rot");
 702           break;
 703         case DW_OP_xderef:
 704           printf ("DW_OP_xderef");
 705           break;
 706         case DW_OP_abs:
 707           printf ("DW_OP_abs");
 708           break;
 709         case DW_OP_and:
 710           printf ("DW_OP_and");
 711           break;
 712         case DW_OP_div:
 713           printf ("DW_OP_div");
 714           break;
 715         case DW_OP_minus:
 716           printf ("DW_OP_minus");
 717           break;
 718         case DW_OP_mod:
 719           printf ("DW_OP_mod");
 720           break;
 721         case DW_OP_mul:
 722           printf ("DW_OP_mul");
 723           break;
 724         case DW_OP_neg:
 725           printf ("DW_OP_neg");
 726           break;
 727         case DW_OP_not:
 728           printf ("DW_OP_not");
 729           break;
 730         case DW_OP_or:
 731           printf ("DW_OP_or");
 732           break;
 733         case DW_OP_plus:
 734           printf ("DW_OP_plus");
 735           break;
 736         case DW_OP_plus_uconst:
 737           printf ("DW_OP_plus_uconst: %lu",
 738                   read_leb128 (data, &bytes_read, 0));
 739           data += bytes_read;
 740           break;
 741         case DW_OP_shl:
 742           printf ("DW_OP_shl");
 743           break;
 744         case DW_OP_shr:
 745           printf ("DW_OP_shr");
 746           break;
 747         case DW_OP_shra:
 748           printf ("DW_OP_shra");
 749           break;
 750         case DW_OP_xor:
 751           printf ("DW_OP_xor");
 752           break;
 753         case DW_OP_bra:
 754           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
 755           data += 2;
 756           break;
 757         case DW_OP_eq:
 758           printf ("DW_OP_eq");
 759           break;
 760         case DW_OP_ge:
 761           printf ("DW_OP_ge");
 762           break;
 763         case DW_OP_gt:
 764           printf ("DW_OP_gt");
 765           break;
 766         case DW_OP_le:
 767           printf ("DW_OP_le");
 768           break;
 769         case DW_OP_lt:
 770           printf ("DW_OP_lt");
 771           break;
 772         case DW_OP_ne:
 773           printf ("DW_OP_ne");
 774           break;
 775         case DW_OP_skip:
 776           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
 777           data += 2;
 778           break;
 779
 780         case DW_OP_lit0:
 781         case DW_OP_lit1:
 782         case DW_OP_lit2:
 783         case DW_OP_lit3:
 784         case DW_OP_lit4:
 785         case DW_OP_lit5:
 786         case DW_OP_lit6:
 787         case DW_OP_lit7:
 788         case DW_OP_lit8:
 789         case DW_OP_lit9:
 790         case DW_OP_lit10:
 791         case DW_OP_lit11:
 792         case DW_OP_lit12:
 793         case DW_OP_lit13:
 794         case DW_OP_lit14:
 795         case DW_OP_lit15:
 796         case DW_OP_lit16:
 797         case DW_OP_lit17:
 798         case DW_OP_lit18:
 799         case DW_OP_lit19:
 800         case DW_OP_lit20:
 801         case DW_OP_lit21:
 802         case DW_OP_lit22:
 803         case DW_OP_lit23:
 804         case DW_OP_lit24:
 805         case DW_OP_lit25:
 806         case DW_OP_lit26:
 807         case DW_OP_lit27:
 808         case DW_OP_lit28:
 809         case DW_OP_lit29:
 810         case DW_OP_lit30:
 811         case DW_OP_lit31:
 812           printf ("DW_OP_lit%d", op - DW_OP_lit0);
 813           break;
 814
 815         case DW_OP_reg0:
 816         case DW_OP_reg1:
 817         case DW_OP_reg2:
 818         case DW_OP_reg3:
 819         case DW_OP_reg4:
 820         case DW_OP_reg5:
 821         case DW_OP_reg6:
 822         case DW_OP_reg7:
 823         case DW_OP_reg8:
 824         case DW_OP_reg9:
 825         case DW_OP_reg10:
 826         case DW_OP_reg11:
 827         case DW_OP_reg12:
 828         case DW_OP_reg13:
 829         case DW_OP_reg14:
 830         case DW_OP_reg15:
 831         case DW_OP_reg16:
 832         case DW_OP_reg17:
 833         case DW_OP_reg18:
 834         case DW_OP_reg19:
 835         case DW_OP_reg20:
 836         case DW_OP_reg21:
 837         case DW_OP_reg22:
 838         case DW_OP_reg23:
 839         case DW_OP_reg24:
 840         case DW_OP_reg25:
 841         case DW_OP_reg26:
 842         case DW_OP_reg27:
 843         case DW_OP_reg28:
 844         case DW_OP_reg29:
 845         case DW_OP_reg30:
 846         case DW_OP_reg31:
 847           printf ("DW_OP_reg%d", op - DW_OP_reg0);
 848           break;
 849
 850         case DW_OP_breg0:
 851         case DW_OP_breg1:
 852         case DW_OP_breg2:
 853         case DW_OP_breg3:
 854         case DW_OP_breg4:
 855         case DW_OP_breg5:
 856         case DW_OP_breg6:
 857         case DW_OP_breg7:
 858         case DW_OP_breg8:
 859         case DW_OP_breg9:
 860         case DW_OP_breg10:
 861         case DW_OP_breg11:
 862         case DW_OP_breg12:
 863         case DW_OP_breg13:
 864         case DW_OP_breg14:
 865         case DW_OP_breg15:
 866         case DW_OP_breg16:
 867         case DW_OP_breg17:
 868         case DW_OP_breg18:
 869         case DW_OP_breg19:
 870         case DW_OP_breg20:
 871         case DW_OP_breg21:
 872         case DW_OP_breg22:
 873         case DW_OP_breg23:
 874         case DW_OP_breg24:
 875         case DW_OP_breg25:
 876         case DW_OP_breg26:
 877         case DW_OP_breg27:
 878         case DW_OP_breg28:
 879         case DW_OP_breg29:
 880         case DW_OP_breg30:
 881         case DW_OP_breg31:
 882           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
 883                   read_leb128 (data, &bytes_read, 1));
 884           data += bytes_read;
 885           break;
 886
 887         case DW_OP_regx:
 888           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
 889           data += bytes_read;
 890           break;
 891         case DW_OP_fbreg:
 892           need_frame_base = 1;
 893           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
 894           data += bytes_read;
 895           break;
 896         case DW_OP_bregx:
 897           uvalue = read_leb128 (data, &bytes_read, 0);
 898           data += bytes_read;
 899           printf ("DW_OP_bregx: %lu %ld", uvalue,
 900                   read_leb128 (data, &bytes_read, 1));
 901           data += bytes_read;
 902           break;
 903         case DW_OP_piece:
 904           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
 905           data += bytes_read;
 906           break;
 907         case DW_OP_deref_size:
 908           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
 909           break;
 910         case DW_OP_xderef_size:
 911           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
 912           break;
 913         case DW_OP_nop:
 914           printf ("DW_OP_nop");
 915           break;
 916
 917           /* DWARF 3 extensions.  */
 918         case DW_OP_push_object_address:
 919           printf ("DW_OP_push_object_address");
 920           break;
 921         case DW_OP_call2:
 922           /* XXX: Strictly speaking for 64-bit DWARF3 files
 923              this ought to be an 8-byte wide computation.  */
 924           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
 925           data += 2;
 926           break;
 927         case DW_OP_call4:
 928           /* XXX: Strictly speaking for 64-bit DWARF3 files
 929              this ought to be an 8-byte wide computation.  */
 930           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
 931           data += 4;
 932           break;
 933         case DW_OP_call_ref:
 934           /* XXX: Strictly speaking for 64-bit DWARF3 files
 935              this ought to be an 8-byte wide computation.  */
 936           printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
 937           data += 4;
 938           break;
 939         case DW_OP_form_tls_address:
 940           printf ("DW_OP_form_tls_address");
 941           break;
 942         case DW_OP_call_frame_cfa:
 943           printf ("DW_OP_call_frame_cfa");
 944           break;
 945         case DW_OP_bit_piece:
 946           printf ("DW_OP_bit_piece: ");
 947           printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
 948           data += bytes_read;
 949           printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
 950           data += bytes_read;
 951           break;
 952
 953           /* GNU extensions.  */
 954         case DW_OP_GNU_push_tls_address:
 955           printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
 956           break;
 957         case DW_OP_GNU_uninit:
 958           printf ("DW_OP_GNU_uninit");
 959           /* FIXME: Is there data associated with this OP ?  */
 960           break;
 961
 962           /* HP extensions.  */
 963         case DW_OP_HP_is_value:
 964           printf ("DW_OP_HP_is_value");
 965           /* FIXME: Is there data associated with this OP ?  */
 966           break;
 967         case DW_OP_HP_fltconst4:
 968           printf ("DW_OP_HP_fltconst4");
 969           /* FIXME: Is there data associated with this OP ?  */
 970           break;
 971         case DW_OP_HP_fltconst8:
 972           printf ("DW_OP_HP_fltconst8");
 973           /* FIXME: Is there data associated with this OP ?  */
 974           break;
 975         case DW_OP_HP_mod_range:
 976           printf ("DW_OP_HP_mod_range");
 977           /* FIXME: Is there data associated with this OP ?  */
 978           break;
 979         case DW_OP_HP_unmod_range:
 980           printf ("DW_OP_HP_unmod_range");
 981           /* FIXME: Is there data associated with this OP ?  */
 982           break;
 983         case DW_OP_HP_tls:
 984           printf ("DW_OP_HP_tls");
 985           /* FIXME: Is there data associated with this OP ?  */
 986           break;
 987
 988         default:
 989           if (op >= DW_OP_lo_user
 990               && op <= DW_OP_hi_user)
 991             printf (_("(User defined location op)"));
 992           else
 993             printf (_("(Unknown location op)"));
 994           /* No way to tell where the next op is, so just bail.  */
 995           return need_frame_base;
 996         }
 997
 998       /* Separate the ops.  */
 999       if (data < end)
1000         printf ("; ");
1001     }
1002
1003   return need_frame_base;
1004 }
1005
1006 static unsigned char *
1007 read_and_display_attr_value (unsigned long   attribute,
1008                              unsigned long   form,
1009                              unsigned char * data,
1010                              unsigned long   cu_offset,
1011                              unsigned long   pointer_size,
1012                              unsigned long   offset_size,
1013                              int             dwarf_version,
1014                              debug_info *    debug_info_p,
1015                              int             do_loc,
1016                              unsigned char * section_start)
1017 {
1018   unsigned long uvalue = 0;
1019   unsigned char *block_start = NULL;
1020   unsigned int bytes_read;
1021
1022   switch (form)
1023     {
1024     default:
1025       break;
1026
1027     case DW_FORM_ref_addr:
1028       if (dwarf_version == 2)
1029         {
1030           uvalue = byte_get (data, pointer_size);
1031           data += pointer_size;
1032         }
1033       else if (dwarf_version == 3)
1034         {
1035           uvalue = byte_get (data, offset_size);
1036           data += offset_size;
1037         }
1038       else
1039         {
1040           error (_("Internal error: DWARF version is not 2 or 3.\n"));
1041         }
1042       break;
1043
1044     case DW_FORM_addr:
1045       uvalue = byte_get (data, pointer_size);
1046       data += pointer_size;
1047       break;
1048
1049     case DW_FORM_strp:
1050       uvalue = byte_get (data, offset_size);
1051       data += offset_size;
1052       break;
1053
1054     case DW_FORM_ref1:
1055     case DW_FORM_flag:
1056     case DW_FORM_data1:
1057       uvalue = byte_get (data++, 1);
1058       break;
1059
1060     case DW_FORM_ref2:
1061     case DW_FORM_data2:
1062       uvalue = byte_get (data, 2);
1063       data += 2;
1064       break;
1065
1066     case DW_FORM_ref4:
1067     case DW_FORM_data4:
1068       uvalue = byte_get (data, 4);
1069       data += 4;
1070       break;
1071
1072     case DW_FORM_sdata:
1073       uvalue = read_leb128 (data, & bytes_read, 1);
1074       data += bytes_read;
1075       break;
1076
1077     case DW_FORM_ref_udata:
1078     case DW_FORM_udata:
1079       uvalue = read_leb128 (data, & bytes_read, 0);
1080       data += bytes_read;
1081       break;
1082
1083     case DW_FORM_indirect:
1084       form = read_leb128 (data, & bytes_read, 0);
1085       data += bytes_read;
1086       if (!do_loc)
1087         printf (" %s", get_FORM_name (form));
1088       return read_and_display_attr_value (attribute, form, data,
1089                                           cu_offset, pointer_size,
1090                                           offset_size, dwarf_version,
1091                                           debug_info_p, do_loc,
1092                                           section_start);
1093     }
1094
1095   switch (form)
1096     {
1097     case DW_FORM_ref_addr:
1098       if (!do_loc)
1099         printf (" <0x%lx>", uvalue);
1100       break;
1101
1102     case DW_FORM_ref1:
1103     case DW_FORM_ref2:
1104     case DW_FORM_ref4:
1105     case DW_FORM_ref_udata:
1106       if (!do_loc)
1107         printf (" <0x%lx>", uvalue + cu_offset);
1108       break;
1109
1110     case DW_FORM_data4:
1111     case DW_FORM_addr:
1112       if (!do_loc)
1113         printf (" 0x%lx", uvalue);
1114       break;
1115
1116     case DW_FORM_flag:
1117     case DW_FORM_data1:
1118     case DW_FORM_data2:
1119     case DW_FORM_sdata:
1120     case DW_FORM_udata:
1121       if (!do_loc)
1122         printf (" %ld", uvalue);
1123       break;
1124
1125     case DW_FORM_ref8:
1126     case DW_FORM_data8:
1127       if (!do_loc)
1128         {
1129           uvalue = byte_get (data, 4);
1130           printf (" 0x%lx", uvalue);
1131           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1132         }
1133       if ((do_loc || do_debug_loc || do_debug_ranges)
1134           && num_debug_info_entries == 0)
1135         {
1136           if (sizeof (uvalue) == 8)
1137             uvalue = byte_get (data, 8);
1138           else
1139             error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1140         }
1141       data += 8;
1142       break;
1143
1144     case DW_FORM_string:
1145       if (!do_loc)
1146         printf (" %s", data);
1147       data += strlen ((char *) data) + 1;
1148       break;
1149
1150     case DW_FORM_block:
1151       uvalue = read_leb128 (data, & bytes_read, 0);
1152       block_start = data + bytes_read;
1153       if (do_loc)
1154         data = block_start + uvalue;
1155       else
1156         data = display_block (block_start, uvalue);
1157       break;
1158
1159     case DW_FORM_block1:
1160       uvalue = byte_get (data, 1);
1161       block_start = data + 1;
1162       if (do_loc)
1163         data = block_start + uvalue;
1164       else
1165         data = display_block (block_start, uvalue);
1166       break;
1167
1168     case DW_FORM_block2:
1169       uvalue = byte_get (data, 2);
1170       block_start = data + 2;
1171       if (do_loc)
1172         data = block_start + uvalue;
1173       else
1174         data = display_block (block_start, uvalue);
1175       break;
1176
1177     case DW_FORM_block4:
1178       uvalue = byte_get (data, 4);
1179       block_start = data + 4;
1180       if (do_loc)
1181         data = block_start + uvalue;
1182       else
1183         data = display_block (block_start, uvalue);
1184       break;
1185
1186     case DW_FORM_strp:
1187       if (!do_loc)
1188         printf (_(" (indirect string, offset: 0x%lx): %s"),
1189                 uvalue, fetch_indirect_string (uvalue));
1190       break;
1191
1192     case DW_FORM_indirect:
1193       /* Handled above.  */
1194       break;
1195
1196     default:
1197       warn (_("Unrecognized form: %lu\n"), form);
1198       break;
1199     }
1200
1201   if ((do_loc || do_debug_loc || do_debug_ranges)
1202       && num_debug_info_entries == 0)
1203     {
1204       switch (attribute)
1205         {
1206         case DW_AT_frame_base:
1207           have_frame_base = 1;
1208         case DW_AT_location:
1209         case DW_AT_string_length:
1210         case DW_AT_return_addr:
1211         case DW_AT_data_member_location:
1212         case DW_AT_vtable_elem_location:
1213         case DW_AT_segment:
1214         case DW_AT_static_link:
1215         case DW_AT_use_location:
1216           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1217             {
1218               /* Process location list.  */
1219               unsigned int max = debug_info_p->max_loc_offsets;
1220               unsigned int num = debug_info_p->num_loc_offsets;
1221
1222               if (max == 0 || num >= max)
1223                 {
1224                   max += 1024;
1225                   debug_info_p->loc_offsets
1226                     = xcrealloc (debug_info_p->loc_offsets,
1227                                  max, sizeof (*debug_info_p->loc_offsets));
1228                   debug_info_p->have_frame_base
1229                     = xcrealloc (debug_info_p->have_frame_base,
1230                                  max, sizeof (*debug_info_p->have_frame_base));
1231                   debug_info_p->max_loc_offsets = max;
1232                 }
1233               debug_info_p->loc_offsets [num] = uvalue;
1234               debug_info_p->have_frame_base [num] = have_frame_base;
1235               debug_info_p->num_loc_offsets++;
1236             }
1237           break;
1238
1239         case DW_AT_low_pc:
1240           if (need_base_address)
1241             debug_info_p->base_address = uvalue;
1242           break;
1243
1244         case DW_AT_ranges:
1245           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1246             {
1247               /* Process range list.  */
1248               unsigned int max = debug_info_p->max_range_lists;
1249               unsigned int num = debug_info_p->num_range_lists;
1250
1251               if (max == 0 || num >= max)
1252                 {
1253                   max += 1024;
1254                   debug_info_p->range_lists
1255                     = xcrealloc (debug_info_p->range_lists,
1256                                  max, sizeof (*debug_info_p->range_lists));
1257                   debug_info_p->max_range_lists = max;
1258                 }
1259               debug_info_p->range_lists [num] = uvalue;
1260               debug_info_p->num_range_lists++;
1261             }
1262           break;
1263
1264         default:
1265           break;
1266         }
1267     }
1268
1269   if (do_loc)
1270     return data;
1271
1272   /* For some attributes we can display further information.  */
1273   printf ("\t");
1274
1275   switch (attribute)
1276     {
1277     case DW_AT_inline:
1278       switch (uvalue)
1279         {
1280         case DW_INL_not_inlined:
1281           printf (_("(not inlined)"));
1282           break;
1283         case DW_INL_inlined:
1284           printf (_("(inlined)"));
1285           break;
1286         case DW_INL_declared_not_inlined:
1287           printf (_("(declared as inline but ignored)"));
1288           break;
1289         case DW_INL_declared_inlined:
1290           printf (_("(declared as inline and inlined)"));
1291           break;
1292         default:
1293           printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
1294           break;
1295         }
1296       break;
1297
1298     case DW_AT_language:
1299       switch (uvalue)
1300         {
1301           /* Ordered by the numeric value of these constants.  */
1302         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1303         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1304         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1305         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1306         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1307         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1308         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1309         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1310         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1311         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1312           /* DWARF 2.1 values.  */
1313         case DW_LANG_Java:              printf ("(Java)"); break;
1314         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1315         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1316         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1317           /* DWARF 3 values.  */
1318         case DW_LANG_PLI:               printf ("(PLI)"); break;
1319         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1320         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1321         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1322         case DW_LANG_D:                 printf ("(D)"); break;
1323           /* MIPS extension.  */
1324         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1325           /* UPC extension.  */
1326         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1327         default:
1328           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1329             printf ("(implementation defined: %lx)", uvalue);
1330           else
1331             printf ("(Unknown: %lx)", uvalue);
1332           break;
1333         }
1334       break;
1335
1336     case DW_AT_encoding:
1337       switch (uvalue)
1338         {
1339         case DW_ATE_void:               printf ("(void)"); break;
1340         case DW_ATE_address:            printf ("(machine address)"); break;
1341         case DW_ATE_boolean:            printf ("(boolean)"); break;
1342         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1343         case DW_ATE_float:              printf ("(float)"); break;
1344         case DW_ATE_signed:             printf ("(signed)"); break;
1345         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1346         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1347         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1348           /* DWARF 2.1 values:  */
1349         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1350         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1351           /* DWARF 3 values:  */
1352         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1353         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1354         case DW_ATE_edited:             printf ("(edited)"); break;
1355         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1356         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1357           /* HP extensions:  */
1358         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1359         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1360         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1361         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1362         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1363         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1364         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1365
1366         default:
1367           if (uvalue >= DW_ATE_lo_user
1368               && uvalue <= DW_ATE_hi_user)
1369             printf ("(user defined type)");
1370           else
1371             printf ("(unknown type)");
1372           break;
1373         }
1374       break;
1375
1376     case DW_AT_accessibility:
1377       switch (uvalue)
1378         {
1379         case DW_ACCESS_public:          printf ("(public)"); break;
1380         case DW_ACCESS_protected:       printf ("(protected)"); break;
1381         case DW_ACCESS_private:         printf ("(private)"); break;
1382         default:
1383           printf ("(unknown accessibility)");
1384           break;
1385         }
1386       break;
1387
1388     case DW_AT_visibility:
1389       switch (uvalue)
1390         {
1391         case DW_VIS_local:              printf ("(local)"); break;
1392         case DW_VIS_exported:           printf ("(exported)"); break;
1393         case DW_VIS_qualified:          printf ("(qualified)"); break;
1394         default:                        printf ("(unknown visibility)"); break;
1395         }
1396       break;
1397
1398     case DW_AT_virtuality:
1399       switch (uvalue)
1400         {
1401         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1402         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1403         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1404         default:                        printf ("(unknown virtuality)"); break;
1405         }
1406       break;
1407
1408     case DW_AT_identifier_case:
1409       switch (uvalue)
1410         {
1411         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1412         case DW_ID_up_case:             printf ("(up_case)"); break;
1413         case DW_ID_down_case:           printf ("(down_case)"); break;
1414         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1415         default:                        printf ("(unknown case)"); break;
1416         }
1417       break;
1418
1419     case DW_AT_calling_convention:
1420       switch (uvalue)
1421         {
1422         case DW_CC_normal:      printf ("(normal)"); break;
1423         case DW_CC_program:     printf ("(program)"); break;
1424         case DW_CC_nocall:      printf ("(nocall)"); break;
1425         default:
1426           if (uvalue >= DW_CC_lo_user
1427               && uvalue <= DW_CC_hi_user)
1428             printf ("(user defined)");
1429           else
1430             printf ("(unknown convention)");
1431         }
1432       break;
1433
1434     case DW_AT_ordering:
1435       switch (uvalue)
1436         {
1437         case -1: printf ("(undefined)"); break;
1438         case 0:  printf ("(row major)"); break;
1439         case 1:  printf ("(column major)"); break;
1440         }
1441       break;
1442
1443     case DW_AT_frame_base:
1444       have_frame_base = 1;
1445     case DW_AT_location:
1446     case DW_AT_string_length:
1447     case DW_AT_return_addr:
1448     case DW_AT_data_member_location:
1449     case DW_AT_vtable_elem_location:
1450     case DW_AT_segment:
1451     case DW_AT_static_link:
1452     case DW_AT_use_location:
1453       if (form == DW_FORM_data4 || form == DW_FORM_data8)
1454         printf (_("(location list)"));
1455       /* Fall through.  */
1456     case DW_AT_allocated:
1457     case DW_AT_associated:
1458     case DW_AT_data_location:
1459     case DW_AT_stride:
1460     case DW_AT_upper_bound:
1461     case DW_AT_lower_bound:
1462       if (block_start)
1463         {
1464           int need_frame_base;
1465
1466           printf ("(");
1467           need_frame_base = decode_location_expression (block_start,
1468                                                         pointer_size,
1469                                                         uvalue,
1470                                                         cu_offset);
1471           printf (")");
1472           if (need_frame_base && !have_frame_base)
1473             printf (_(" [without DW_AT_frame_base]"));
1474         }
1475       break;
1476
1477     case DW_AT_import:
1478       {
1479         unsigned long abbrev_number;
1480         abbrev_entry * entry;
1481
1482         if (form == DW_FORM_ref1
1483             || form == DW_FORM_ref2
1484             || form == DW_FORM_ref4)
1485           uvalue += cu_offset;
1486
1487         abbrev_number = read_leb128 (section_start + uvalue, NULL, 0);
1488
1489         printf ("[Abbrev Number: %ld", abbrev_number);
1490         for (entry = first_abbrev; entry != NULL; entry = entry->next)
1491           if (entry->entry == abbrev_number)
1492             break;
1493         if (entry != NULL)
1494           printf (" (%s)", get_TAG_name (entry->tag));
1495         printf ("]");
1496       }
1497       break;
1498
1499     default:
1500       break;
1501     }
1502
1503   return data;
1504 }
1505
1506 static char *
1507 get_AT_name (unsigned long attribute)
1508 {
1509   switch (attribute)
1510     {
1511     case DW_AT_sibling:                 return "DW_AT_sibling";
1512     case DW_AT_location:                return "DW_AT_location";
1513     case DW_AT_name:                    return "DW_AT_name";
1514     case DW_AT_ordering:                return "DW_AT_ordering";
1515     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1516     case DW_AT_byte_size:               return "DW_AT_byte_size";
1517     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1518     case DW_AT_bit_size:                return "DW_AT_bit_size";
1519     case DW_AT_element_list:            return "DW_AT_element_list";
1520     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1521     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1522     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1523     case DW_AT_language:                return "DW_AT_language";
1524     case DW_AT_member:                  return "DW_AT_member";
1525     case DW_AT_discr:                   return "DW_AT_discr";
1526     case DW_AT_discr_value:             return "DW_AT_discr_value";
1527     case DW_AT_visibility:              return "DW_AT_visibility";
1528     case DW_AT_import:                  return "DW_AT_import";
1529     case DW_AT_string_length:           return "DW_AT_string_length";
1530     case DW_AT_common_reference:        return "DW_AT_common_reference";
1531     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1532     case DW_AT_const_value:             return "DW_AT_const_value";
1533     case DW_AT_containing_type:         return "DW_AT_containing_type";
1534     case DW_AT_default_value:           return "DW_AT_default_value";
1535     case DW_AT_inline:                  return "DW_AT_inline";
1536     case DW_AT_is_optional:             return "DW_AT_is_optional";
1537     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1538     case DW_AT_producer:                return "DW_AT_producer";
1539     case DW_AT_prototyped:              return "DW_AT_prototyped";
1540     case DW_AT_return_addr:             return "DW_AT_return_addr";
1541     case DW_AT_start_scope:             return "DW_AT_start_scope";
1542     case DW_AT_stride_size:             return "DW_AT_stride_size";
1543     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1544     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1545     case DW_AT_accessibility:           return "DW_AT_accessibility";
1546     case DW_AT_address_class:           return "DW_AT_address_class";
1547     case DW_AT_artificial:              return "DW_AT_artificial";
1548     case DW_AT_base_types:              return "DW_AT_base_types";
1549     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1550     case DW_AT_count:                   return "DW_AT_count";
1551     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1552     case DW_AT_decl_column:             return "DW_AT_decl_column";
1553     case DW_AT_decl_file:               return "DW_AT_decl_file";
1554     case DW_AT_decl_line:               return "DW_AT_decl_line";
1555     case DW_AT_declaration:             return "DW_AT_declaration";
1556     case DW_AT_discr_list:              return "DW_AT_discr_list";
1557     case DW_AT_encoding:                return "DW_AT_encoding";
1558     case DW_AT_external:                return "DW_AT_external";
1559     case DW_AT_frame_base:              return "DW_AT_frame_base";
1560     case DW_AT_friend:                  return "DW_AT_friend";
1561     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1562     case DW_AT_macro_info:              return "DW_AT_macro_info";
1563     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1564     case DW_AT_priority:                return "DW_AT_priority";
1565     case DW_AT_segment:                 return "DW_AT_segment";
1566     case DW_AT_specification:           return "DW_AT_specification";
1567     case DW_AT_static_link:             return "DW_AT_static_link";
1568     case DW_AT_type:                    return "DW_AT_type";
1569     case DW_AT_use_location:            return "DW_AT_use_location";
1570     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1571     case DW_AT_virtuality:              return "DW_AT_virtuality";
1572     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1573       /* DWARF 2.1 values.  */
1574     case DW_AT_allocated:               return "DW_AT_allocated";
1575     case DW_AT_associated:              return "DW_AT_associated";
1576     case DW_AT_data_location:           return "DW_AT_data_location";
1577     case DW_AT_stride:                  return "DW_AT_stride";
1578     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1579     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1580     case DW_AT_extension:               return "DW_AT_extension";
1581     case DW_AT_ranges:                  return "DW_AT_ranges";
1582     case DW_AT_trampoline:              return "DW_AT_trampoline";
1583     case DW_AT_call_column:             return "DW_AT_call_column";
1584     case DW_AT_call_file:               return "DW_AT_call_file";
1585     case DW_AT_call_line:               return "DW_AT_call_line";
1586     case DW_AT_description:             return "DW_AT_description";
1587     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1588     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1589     case DW_AT_small:                   return "DW_AT_small";
1590     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1591     case DW_AT_digit_count:             return "DW_AT_digit_count";
1592     case DW_AT_picture_string:          return "DW_AT_picture_string";
1593     case DW_AT_mutable:                 return "DW_AT_mutable";
1594     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1595     case DW_AT_explicit:                return "DW_AT_explicit";
1596     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1597     case DW_AT_endianity:               return "DW_AT_endianity";
1598     case DW_AT_elemental:               return "DW_AT_elemental";
1599     case DW_AT_pure:                    return "DW_AT_pure";
1600     case DW_AT_recursive:               return "DW_AT_recursive";
1601
1602       /* HP and SGI/MIPS extensions.  */
1603     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1604     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1605     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1606     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1607     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1608     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1609     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1610     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1611     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1612     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1613
1614       /* HP Extensions.  */
1615     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1616     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1617     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1618     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1619     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1620     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1621     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1622     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1623     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1624     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1625     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1626     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1627     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1628
1629       /* One value is shared by the MIPS and HP extensions:  */
1630     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1631
1632       /* GNU extensions.  */
1633     case DW_AT_sf_names:                return "DW_AT_sf_names";
1634     case DW_AT_src_info:                return "DW_AT_src_info";
1635     case DW_AT_mac_info:                return "DW_AT_mac_info";
1636     case DW_AT_src_coords:              return "DW_AT_src_coords";
1637     case DW_AT_body_begin:              return "DW_AT_body_begin";
1638     case DW_AT_body_end:                return "DW_AT_body_end";
1639     case DW_AT_GNU_vector:              return "DW_AT_GNU_vector";
1640
1641       /* UPC extension.  */
1642     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1643
1644     /* PGI (STMicroelectronics) extensions.  */
1645     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1646     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1647     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1648
1649     default:
1650       {
1651         static char buffer[100];
1652
1653         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1654                   attribute);
1655         return buffer;
1656       }
1657     }
1658 }
1659
1660 static unsigned char *
1661 read_and_display_attr (unsigned long   attribute,
1662                        unsigned long   form,
1663                        unsigned char * data,
1664                        unsigned long   cu_offset,
1665                        unsigned long   pointer_size,
1666                        unsigned long   offset_size,
1667                        int             dwarf_version,
1668                        debug_info *    debug_info_p,
1669                        int             do_loc,
1670                        unsigned char * section_start)
1671 {
1672   if (!do_loc)
1673     printf ("   %-18s:", get_AT_name (attribute));
1674   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1675                                       pointer_size, offset_size,
1676                                       dwarf_version, debug_info_p,
1677                                       do_loc, section_start);
1678   if (!do_loc)
1679     printf ("\n");
1680   return data;
1681 }
1682
1683
1684 /* Process the contents of a .debug_info section.  If do_loc is non-zero
1685    then we are scanning for location lists and we do not want to display
1686    anything to the user.  */
1687
1688 static int
1689 process_debug_info (struct dwarf_section *section, void *file,
1690                     int do_loc)
1691 {
1692   unsigned char *start = section->start;
1693   unsigned char *end = start + section->size;
1694   unsigned char *section_begin;
1695   unsigned int unit;
1696   unsigned int num_units = 0;
1697
1698   if ((do_loc || do_debug_loc || do_debug_ranges)
1699       && num_debug_info_entries == 0)
1700     {
1701       unsigned long length;
1702
1703       /* First scan the section to get the number of comp units.  */
1704       for (section_begin = start, num_units = 0; section_begin < end;
1705            num_units ++)
1706         {
1707           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
1708              will be the length.  For a 64-bit DWARF section, it'll be
1709              the escape code 0xffffffff followed by an 8 byte length.  */
1710           length = byte_get (section_begin, 4);
1711
1712           if (length == 0xffffffff)
1713             {
1714               length = byte_get (section_begin + 4, 8);
1715               section_begin += length + 12;
1716             }
1717           else if (length >= 0xfffffff0 && length < 0xffffffff)
1718             {
1719               warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1720               return 0;
1721             }
1722           else
1723             section_begin += length + 4;
1724
1725           /* Negative values are illegal, they may even cause infinite
1726              looping.  This can happen if we can't accurately apply
1727              relocations to an object file.  */
1728           if ((signed long) length <= 0)
1729             {
1730               warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1731               return 0;
1732             }
1733         }
1734
1735       if (num_units == 0)
1736         {
1737           error (_("No comp units in %s section ?"), section->name);
1738           return 0;
1739         }
1740
1741       /* Then allocate an array to hold the information.  */
1742       debug_information = cmalloc (num_units,
1743                                    sizeof (* debug_information));
1744       if (debug_information == NULL)
1745         {
1746           error (_("Not enough memory for a debug info array of %u entries"),
1747                  num_units);
1748           return 0;
1749         }
1750     }
1751
1752   if (!do_loc)
1753     {
1754       printf (_("The section %s contains:\n\n"), section->name);
1755
1756       load_debug_section (str, file);
1757     }
1758
1759   load_debug_section (abbrev, file);
1760   if (debug_displays [abbrev].section.start == NULL)
1761     {
1762       warn (_("Unable to locate %s section!\n"),
1763             debug_displays [abbrev].section.name);
1764       return 0;
1765     }
1766
1767   for (section_begin = start, unit = 0; start < end; unit++)
1768     {
1769       DWARF2_Internal_CompUnit compunit;
1770       unsigned char *hdrptr;
1771       unsigned char *cu_abbrev_offset_ptr;
1772       unsigned char *tags;
1773       int level;
1774       unsigned long cu_offset;
1775       int offset_size;
1776       int initial_length_size;
1777
1778       hdrptr = start;
1779
1780       compunit.cu_length = byte_get (hdrptr, 4);
1781       hdrptr += 4;
1782
1783       if (compunit.cu_length == 0xffffffff)
1784         {
1785           compunit.cu_length = byte_get (hdrptr, 8);
1786           hdrptr += 8;
1787           offset_size = 8;
1788           initial_length_size = 12;
1789         }
1790       else
1791         {
1792           offset_size = 4;
1793           initial_length_size = 4;
1794         }
1795
1796       compunit.cu_version = byte_get (hdrptr, 2);
1797       hdrptr += 2;
1798
1799       cu_offset = start - section_begin;
1800
1801       cu_abbrev_offset_ptr = hdrptr;
1802       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1803       hdrptr += offset_size;
1804
1805       compunit.cu_pointer_size = byte_get (hdrptr, 1);
1806       hdrptr += 1;
1807       if ((do_loc || do_debug_loc || do_debug_ranges)
1808           && num_debug_info_entries == 0)
1809         {
1810           debug_information [unit].cu_offset = cu_offset;
1811           debug_information [unit].pointer_size
1812             = compunit.cu_pointer_size;
1813           debug_information [unit].base_address = 0;
1814           debug_information [unit].loc_offsets = NULL;
1815           debug_information [unit].have_frame_base = NULL;
1816           debug_information [unit].max_loc_offsets = 0;
1817           debug_information [unit].num_loc_offsets = 0;
1818           debug_information [unit].range_lists = NULL;
1819           debug_information [unit].max_range_lists= 0;
1820           debug_information [unit].num_range_lists = 0;
1821         }
1822
1823       if (!do_loc)
1824         {
1825           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1826           printf (_("   Length:        %ld\n"), compunit.cu_length);
1827           printf (_("   Version:       %d\n"), compunit.cu_version);
1828           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1829           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
1830         }
1831
1832       if (cu_offset + compunit.cu_length + initial_length_size
1833           > section->size)
1834         {
1835           warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1836                 cu_offset, compunit.cu_length);
1837           break;
1838         }
1839       tags = hdrptr;
1840       start += compunit.cu_length + initial_length_size;
1841
1842       if (compunit.cu_version != 2 && compunit.cu_version != 3)
1843         {
1844           warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1845           continue;
1846         }
1847
1848       free_abbrevs ();
1849
1850       /* Process the abbrevs used by this compilation unit. DWARF
1851          sections under Mach-O have non-zero addresses.  */
1852       if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1853         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1854               (unsigned long) compunit.cu_abbrev_offset,
1855               (unsigned long) debug_displays [abbrev].section.size);
1856       else
1857         process_abbrev_section
1858           ((unsigned char *) debug_displays [abbrev].section.start
1859            + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1860            (unsigned char *) debug_displays [abbrev].section.start
1861            + debug_displays [abbrev].section.size);
1862
1863       level = 0;
1864       while (tags < start)
1865         {
1866           unsigned int bytes_read;
1867           unsigned long abbrev_number;
1868           unsigned long die_offset;
1869           abbrev_entry *entry;
1870           abbrev_attr *attr;
1871
1872           die_offset = tags - section_begin;
1873
1874           abbrev_number = read_leb128 (tags, & bytes_read, 0);
1875           tags += bytes_read;
1876
1877           /* A null DIE marks the end of a list of siblings.  */
1878           if (abbrev_number == 0)
1879             {
1880               --level;
1881               if (level < 0)
1882                 {
1883                   static unsigned num_bogus_warns = 0;
1884
1885                   if (num_bogus_warns < 3)
1886                     {
1887                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1888                             die_offset);
1889                       num_bogus_warns ++;
1890                       if (num_bogus_warns == 3)
1891                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1892                     }
1893                 }
1894               continue;
1895             }
1896
1897           if (!do_loc)
1898             printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1899                     level, die_offset, abbrev_number);
1900
1901           /* Scan through the abbreviation list until we reach the
1902              correct entry.  */
1903           for (entry = first_abbrev;
1904                entry && entry->entry != abbrev_number;
1905                entry = entry->next)
1906             continue;
1907
1908           if (entry == NULL)
1909             {
1910               if (!do_loc)
1911                 {
1912                   printf ("\n");
1913                   fflush (stdout);
1914                 }
1915               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1916                     abbrev_number);
1917               return 0;
1918             }
1919
1920           if (!do_loc)
1921             printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1922
1923           switch (entry->tag)
1924             {
1925             default:
1926               need_base_address = 0;
1927               break;
1928             case DW_TAG_compile_unit:
1929               need_base_address = 1;
1930               break;
1931             case DW_TAG_entry_point:
1932             case DW_TAG_subprogram:
1933               need_base_address = 0;
1934               /* Assuming that there is no DW_AT_frame_base.  */
1935               have_frame_base = 0;
1936               break;
1937             }
1938
1939           for (attr = entry->first_attr; attr; attr = attr->next)
1940             {
1941               if (! do_loc)
1942                 /* Show the offset from where the tag was extracted.  */
1943                 printf ("    <%2lx>", (unsigned long)(tags - section_begin));
1944
1945               tags = read_and_display_attr (attr->attribute,
1946                                             attr->form,
1947                                             tags, cu_offset,
1948                                             compunit.cu_pointer_size,
1949                                             offset_size,
1950                                             compunit.cu_version,
1951                                             debug_information + unit,
1952                                             do_loc, section->start);
1953             }
1954
1955           if (entry->children)
1956             ++level;
1957         }
1958     }
1959
1960   /* Set num_debug_info_entries here so that it can be used to check if
1961      we need to process .debug_loc and .debug_ranges sections.  */
1962   if ((do_loc || do_debug_loc || do_debug_ranges)
1963       && num_debug_info_entries == 0)
1964     num_debug_info_entries = num_units;
1965
1966   if (!do_loc)
1967     {
1968       printf ("\n");
1969     }
1970
1971   return 1;
1972 }
1973
1974 /* Locate and scan the .debug_info section in the file and record the pointer
1975    sizes and offsets for the compilation units in it.  Usually an executable
1976    will have just one pointer size, but this is not guaranteed, and so we try
1977    not to make any assumptions.  Returns zero upon failure, or the number of
1978    compilation units upon success.  */
1979
1980 static unsigned int
1981 load_debug_info (void * file)
1982 {
1983   /* Reset the last pointer size so that we can issue correct error
1984      messages if we are displaying the contents of more than one section.  */
1985   last_pointer_size = 0;
1986   warned_about_missing_comp_units = FALSE;
1987
1988   /* If we already have the information there is nothing else to do.  */
1989   if (num_debug_info_entries > 0)
1990     return num_debug_info_entries;
1991
1992   if (load_debug_section (info, file)
1993       && process_debug_info (&debug_displays [info].section, file, 1))
1994     return num_debug_info_entries;
1995   else
1996     return 0;
1997 }
1998
1999 static int
2000 display_debug_lines (struct dwarf_section *section, void *file)
2001 {
2002   unsigned char *start = section->start;
2003   unsigned char *data = start;
2004   unsigned char *end = start + section->size;
2005
2006   printf (_("\nDump of debug contents of section %s:\n\n"),
2007           section->name);
2008
2009   load_debug_info (file);
2010
2011   while (data < end)
2012     {
2013       DWARF2_Internal_LineInfo info;
2014       unsigned char *standard_opcodes;
2015       unsigned char *end_of_sequence;
2016       unsigned char *hdrptr;
2017       unsigned long hdroff;
2018       int initial_length_size;
2019       int offset_size;
2020       int i;
2021
2022       hdrptr = data;
2023       hdroff = hdrptr - start;
2024
2025       /* Check the length of the block.  */
2026       info.li_length = byte_get (hdrptr, 4);
2027       hdrptr += 4;
2028
2029       if (info.li_length == 0xffffffff)
2030         {
2031           /* This section is 64-bit DWARF 3.  */
2032           info.li_length = byte_get (hdrptr, 8);
2033           hdrptr += 8;
2034           offset_size = 8;
2035           initial_length_size = 12;
2036         }
2037       else
2038         {
2039           offset_size = 4;
2040           initial_length_size = 4;
2041         }
2042
2043       if (info.li_length + initial_length_size > section->size)
2044         {
2045           warn
2046             (_("The line info appears to be corrupt - the section is too small\n"));
2047           return 0;
2048         }
2049
2050       /* Check its version number.  */
2051       info.li_version = byte_get (hdrptr, 2);
2052       hdrptr += 2;
2053       if (info.li_version != 2 && info.li_version != 3)
2054         {
2055           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2056           return 0;
2057         }
2058
2059       info.li_prologue_length = byte_get (hdrptr, offset_size);
2060       hdrptr += offset_size;
2061       info.li_min_insn_length = byte_get (hdrptr, 1);
2062       hdrptr++;
2063       info.li_default_is_stmt = byte_get (hdrptr, 1);
2064       hdrptr++;
2065       info.li_line_base = byte_get (hdrptr, 1);
2066       hdrptr++;
2067       info.li_line_range = byte_get (hdrptr, 1);
2068       hdrptr++;
2069       info.li_opcode_base = byte_get (hdrptr, 1);
2070       hdrptr++;
2071
2072       /* Sign extend the line base field.  */
2073       info.li_line_base <<= 24;
2074       info.li_line_base >>= 24;
2075
2076       printf (_("  Offset:                      0x%lx\n"), hdroff);
2077       printf (_("  Length:                      %ld\n"), info.li_length);
2078       printf (_("  DWARF Version:               %d\n"), info.li_version);
2079       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
2080       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
2081       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
2082       printf (_("  Line Base:                   %d\n"), info.li_line_base);
2083       printf (_("  Line Range:                  %d\n"), info.li_line_range);
2084       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
2085
2086       end_of_sequence = data + info.li_length + initial_length_size;
2087
2088       reset_state_machine (info.li_default_is_stmt);
2089
2090       /* Display the contents of the Opcodes table.  */
2091       standard_opcodes = hdrptr;
2092
2093       printf (_("\n Opcodes:\n"));
2094
2095       for (i = 1; i < info.li_opcode_base; i++)
2096         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2097
2098       /* Display the contents of the Directory table.  */
2099       data = standard_opcodes + info.li_opcode_base - 1;
2100
2101       if (*data == 0)
2102         printf (_("\n The Directory Table is empty.\n"));
2103       else
2104         {
2105           printf (_("\n The Directory Table:\n"));
2106
2107           while (*data != 0)
2108             {
2109               printf (_("  %s\n"), data);
2110
2111               data += strlen ((char *) data) + 1;
2112             }
2113         }
2114
2115       /* Skip the NUL at the end of the table.  */
2116       data++;
2117
2118       /* Display the contents of the File Name table.  */
2119       if (*data == 0)
2120         printf (_("\n The File Name Table is empty.\n"));
2121       else
2122         {
2123           printf (_("\n The File Name Table:\n"));
2124           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2125
2126           while (*data != 0)
2127             {
2128               unsigned char *name;
2129               unsigned int bytes_read;
2130
2131               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
2132               name = data;
2133
2134               data += strlen ((char *) data) + 1;
2135
2136               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2137               data += bytes_read;
2138               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2139               data += bytes_read;
2140               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2141               data += bytes_read;
2142               printf (_("%s\n"), name);
2143             }
2144         }
2145
2146       /* Skip the NUL at the end of the table.  */
2147       data++;
2148
2149       /* Now display the statements.  */
2150       printf (_("\n Line Number Statements:\n"));
2151
2152       while (data < end_of_sequence)
2153         {
2154           unsigned char op_code;
2155           int adv;
2156           unsigned long int uladv;
2157           unsigned int bytes_read;
2158
2159           op_code = *data++;
2160
2161           if (op_code >= info.li_opcode_base)
2162             {
2163               op_code -= info.li_opcode_base;
2164               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2165               state_machine_regs.address += uladv;
2166               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
2167                       op_code, uladv, state_machine_regs.address);
2168               adv = (op_code % info.li_line_range) + info.li_line_base;
2169               state_machine_regs.line += adv;
2170               printf (_(" and Line by %d to %d\n"),
2171                       adv, state_machine_regs.line);
2172             }
2173           else switch (op_code)
2174             {
2175             case DW_LNS_extended_op:
2176               data += process_extended_line_op (data, info.li_default_is_stmt);
2177               break;
2178
2179             case DW_LNS_copy:
2180               printf (_("  Copy\n"));
2181               break;
2182
2183             case DW_LNS_advance_pc:
2184               uladv = read_leb128 (data, & bytes_read, 0);
2185               uladv *= info.li_min_insn_length;
2186               data += bytes_read;
2187               state_machine_regs.address += uladv;
2188               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2189                       state_machine_regs.address);
2190               break;
2191
2192             case DW_LNS_advance_line:
2193               adv = read_leb128 (data, & bytes_read, 1);
2194               data += bytes_read;
2195               state_machine_regs.line += adv;
2196               printf (_("  Advance Line by %d to %d\n"), adv,
2197                       state_machine_regs.line);
2198               break;
2199
2200             case DW_LNS_set_file:
2201               adv = read_leb128 (data, & bytes_read, 0);
2202               data += bytes_read;
2203               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2204                       adv);
2205               state_machine_regs.file = adv;
2206               break;
2207
2208             case DW_LNS_set_column:
2209               uladv = read_leb128 (data, & bytes_read, 0);
2210               data += bytes_read;
2211               printf (_("  Set column to %lu\n"), uladv);
2212               state_machine_regs.column = uladv;
2213               break;
2214
2215             case DW_LNS_negate_stmt:
2216               adv = state_machine_regs.is_stmt;
2217               adv = ! adv;
2218               printf (_("  Set is_stmt to %d\n"), adv);
2219               state_machine_regs.is_stmt = adv;
2220               break;
2221
2222             case DW_LNS_set_basic_block:
2223               printf (_("  Set basic block\n"));
2224               state_machine_regs.basic_block = 1;
2225               break;
2226
2227             case DW_LNS_const_add_pc:
2228               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2229                       * info.li_min_insn_length);
2230               state_machine_regs.address += uladv;
2231               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2232                       state_machine_regs.address);
2233               break;
2234
2235             case DW_LNS_fixed_advance_pc:
2236               uladv = byte_get (data, 2);
2237               data += 2;
2238               state_machine_regs.address += uladv;
2239               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2240                       uladv, state_machine_regs.address);
2241               break;
2242
2243             case DW_LNS_set_prologue_end:
2244               printf (_("  Set prologue_end to true\n"));
2245               break;
2246
2247             case DW_LNS_set_epilogue_begin:
2248               printf (_("  Set epilogue_begin to true\n"));
2249               break;
2250
2251             case DW_LNS_set_isa:
2252               uladv = read_leb128 (data, & bytes_read, 0);
2253               data += bytes_read;
2254               printf (_("  Set ISA to %lu\n"), uladv);
2255               break;
2256
2257             default:
2258               printf (_("  Unknown opcode %d with operands: "), op_code);
2259
2260               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2261                 {
2262                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2263                           i == 1 ? "" : ", ");
2264                   data += bytes_read;
2265                 }
2266               putchar ('\n');
2267               break;
2268             }
2269         }
2270       putchar ('\n');
2271     }
2272
2273   return 1;
2274 }
2275
2276 static int
2277 display_debug_pubnames (struct dwarf_section *section,
2278                         void *file ATTRIBUTE_UNUSED)
2279 {
2280   DWARF2_Internal_PubNames pubnames;
2281   unsigned char *start = section->start;
2282   unsigned char *end = start + section->size;
2283
2284   printf (_("Contents of the %s section:\n\n"), section->name);
2285
2286   while (start < end)
2287     {
2288       unsigned char *data;
2289       unsigned long offset;
2290       int offset_size, initial_length_size;
2291
2292       data = start;
2293
2294       pubnames.pn_length = byte_get (data, 4);
2295       data += 4;
2296       if (pubnames.pn_length == 0xffffffff)
2297         {
2298           pubnames.pn_length = byte_get (data, 8);
2299           data += 8;
2300           offset_size = 8;
2301           initial_length_size = 12;
2302         }
2303       else
2304         {
2305           offset_size = 4;
2306           initial_length_size = 4;
2307         }
2308
2309       pubnames.pn_version = byte_get (data, 2);
2310       data += 2;
2311       pubnames.pn_offset = byte_get (data, offset_size);
2312       data += offset_size;
2313       pubnames.pn_size = byte_get (data, offset_size);
2314       data += offset_size;
2315
2316       start += pubnames.pn_length + initial_length_size;
2317
2318       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2319         {
2320           static int warned = 0;
2321
2322           if (! warned)
2323             {
2324               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2325               warned = 1;
2326             }
2327
2328           continue;
2329         }
2330
2331       printf (_("  Length:                              %ld\n"),
2332               pubnames.pn_length);
2333       printf (_("  Version:                             %d\n"),
2334               pubnames.pn_version);
2335       printf (_("  Offset into .debug_info section:     %ld\n"),
2336               pubnames.pn_offset);
2337       printf (_("  Size of area in .debug_info section: %ld\n"),
2338               pubnames.pn_size);
2339
2340       printf (_("\n    Offset\tName\n"));
2341
2342       do
2343         {
2344           offset = byte_get (data, offset_size);
2345
2346           if (offset != 0)
2347             {
2348               data += offset_size;
2349               printf ("    %-6ld\t\t%s\n", offset, data);
2350               data += strlen ((char *) data) + 1;
2351             }
2352         }
2353       while (offset != 0);
2354     }
2355
2356   printf ("\n");
2357   return 1;
2358 }
2359
2360 static int
2361 display_debug_macinfo (struct dwarf_section *section,
2362                        void *file ATTRIBUTE_UNUSED)
2363 {
2364   unsigned char *start = section->start;
2365   unsigned char *end = start + section->size;
2366   unsigned char *curr = start;
2367   unsigned int bytes_read;
2368   enum dwarf_macinfo_record_type op;
2369
2370   printf (_("Contents of the %s section:\n\n"), section->name);
2371
2372   while (curr < end)
2373     {
2374       unsigned int lineno;
2375       const char *string;
2376
2377       op = *curr;
2378       curr++;
2379
2380       switch (op)
2381         {
2382         case DW_MACINFO_start_file:
2383           {
2384             unsigned int filenum;
2385
2386             lineno = read_leb128 (curr, & bytes_read, 0);
2387             curr += bytes_read;
2388             filenum = read_leb128 (curr, & bytes_read, 0);
2389             curr += bytes_read;
2390
2391             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2392                     lineno, filenum);
2393           }
2394           break;
2395
2396         case DW_MACINFO_end_file:
2397           printf (_(" DW_MACINFO_end_file\n"));
2398           break;
2399
2400         case DW_MACINFO_define:
2401           lineno = read_leb128 (curr, & bytes_read, 0);
2402           curr += bytes_read;
2403           string = (char *) curr;
2404           curr += strlen (string) + 1;
2405           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2406                   lineno, string);
2407           break;
2408
2409         case DW_MACINFO_undef:
2410           lineno = read_leb128 (curr, & bytes_read, 0);
2411           curr += bytes_read;
2412           string = (char *) curr;
2413           curr += strlen (string) + 1;
2414           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2415                   lineno, string);
2416           break;
2417
2418         case DW_MACINFO_vendor_ext:
2419           {
2420             unsigned int constant;
2421
2422             constant = read_leb128 (curr, & bytes_read, 0);
2423             curr += bytes_read;
2424             string = (char *) curr;
2425             curr += strlen (string) + 1;
2426             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2427                     constant, string);
2428           }
2429           break;
2430         }
2431     }
2432
2433   return 1;
2434 }
2435
2436 static int
2437 display_debug_abbrev (struct dwarf_section *section,
2438                       void *file ATTRIBUTE_UNUSED)
2439 {
2440   abbrev_entry *entry;
2441   unsigned char *start = section->start;
2442   unsigned char *end = start + section->size;
2443
2444   printf (_("Contents of the %s section:\n\n"), section->name);
2445
2446   do
2447     {
2448       free_abbrevs ();
2449
2450       start = process_abbrev_section (start, end);
2451
2452       if (first_abbrev == NULL)
2453         continue;
2454
2455       printf (_("  Number TAG\n"));
2456
2457       for (entry = first_abbrev; entry; entry = entry->next)
2458         {
2459           abbrev_attr *attr;
2460
2461           printf (_("   %ld      %s    [%s]\n"),
2462                   entry->entry,
2463                   get_TAG_name (entry->tag),
2464                   entry->children ? _("has children") : _("no children"));
2465
2466           for (attr = entry->first_attr; attr; attr = attr->next)
2467             printf (_("    %-18s %s\n"),
2468                     get_AT_name (attr->attribute),
2469                     get_FORM_name (attr->form));
2470         }
2471     }
2472   while (start);
2473
2474   printf ("\n");
2475
2476   return 1;
2477 }
2478
2479 static int
2480 display_debug_loc (struct dwarf_section *section, void *file)
2481 {
2482   unsigned char *start = section->start;
2483   unsigned char *section_end;
2484   unsigned long bytes;
2485   unsigned char *section_begin = start;
2486   unsigned int num_loc_list = 0;
2487   unsigned long last_offset = 0;
2488   unsigned int first = 0;
2489   unsigned int i;
2490   unsigned int j;
2491   int seen_first_offset = 0;
2492   int use_debug_info = 1;
2493   unsigned char *next;
2494
2495   bytes = section->size;
2496   section_end = start + bytes;
2497
2498   if (bytes == 0)
2499     {
2500       printf (_("\nThe %s section is empty.\n"), section->name);
2501       return 0;
2502     }
2503
2504   load_debug_info (file);
2505
2506   /* Check the order of location list in .debug_info section. If
2507      offsets of location lists are in the ascending order, we can
2508      use `debug_information' directly.  */
2509   for (i = 0; i < num_debug_info_entries; i++)
2510     {
2511       unsigned int num;
2512
2513       num = debug_information [i].num_loc_offsets;
2514       num_loc_list += num;
2515
2516       /* Check if we can use `debug_information' directly.  */
2517       if (use_debug_info && num != 0)
2518         {
2519           if (!seen_first_offset)
2520             {
2521               /* This is the first location list.  */
2522               last_offset = debug_information [i].loc_offsets [0];
2523               first = i;
2524               seen_first_offset = 1;
2525               j = 1;
2526             }
2527           else
2528             j = 0;
2529
2530           for (; j < num; j++)
2531             {
2532               if (last_offset >
2533                   debug_information [i].loc_offsets [j])
2534                 {
2535                   use_debug_info = 0;
2536                   break;
2537                 }
2538               last_offset = debug_information [i].loc_offsets [j];
2539             }
2540         }
2541     }
2542
2543   if (!use_debug_info)
2544     /* FIXME: Should we handle this case?  */
2545     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2546
2547   if (!seen_first_offset)
2548     error (_("No location lists in .debug_info section!\n"));
2549
2550   /* DWARF sections under Mach-O have non-zero addresses.  */
2551   if (debug_information [first].num_loc_offsets > 0
2552       && debug_information [first].loc_offsets [0] != section->address)
2553     warn (_("Location lists in %s section start at 0x%lx\n"),
2554           section->name, debug_information [first].loc_offsets [0]);
2555
2556   printf (_("Contents of the %s section:\n\n"), section->name);
2557   printf (_("    Offset   Begin    End      Expression\n"));
2558
2559   seen_first_offset = 0;
2560   for (i = first; i < num_debug_info_entries; i++)
2561     {
2562       unsigned long begin;
2563       unsigned long end;
2564       unsigned short length;
2565       unsigned long offset;
2566       unsigned int pointer_size;
2567       unsigned long cu_offset;
2568       unsigned long base_address;
2569       int need_frame_base;
2570       int has_frame_base;
2571
2572       pointer_size = debug_information [i].pointer_size;
2573       cu_offset = debug_information [i].cu_offset;
2574
2575       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2576         {
2577           has_frame_base = debug_information [i].have_frame_base [j];
2578           /* DWARF sections under Mach-O have non-zero addresses.  */
2579           offset = debug_information [i].loc_offsets [j] - section->address;
2580           next = section_begin + offset;
2581           base_address = debug_information [i].base_address;
2582
2583           if (!seen_first_offset)
2584             seen_first_offset = 1;
2585           else
2586             {
2587               if (start < next)
2588                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2589                       (long)(start - section_begin), (long)(next - section_begin));
2590               else if (start > next)
2591                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2592                       (long)(start - section_begin), (long)(next - section_begin));
2593             }
2594           start = next;
2595
2596           if (offset >= bytes)
2597             {
2598               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2599                     offset);
2600               continue;
2601             }
2602
2603           while (1)
2604             {
2605               if (start + 2 * pointer_size > section_end)
2606                 {
2607                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2608                         offset);
2609                   break;
2610                 }
2611
2612               begin = byte_get (start, pointer_size);
2613               start += pointer_size;
2614               end = byte_get (start, pointer_size);
2615               start += pointer_size;
2616
2617               if (begin == 0 && end == 0)
2618                 {
2619                   printf (_("    %8.8lx <End of list>\n"), offset);
2620                   break;
2621                 }
2622
2623               /* Check base address specifiers.  */
2624               if (begin == -1UL && end != -1UL)
2625                 {
2626                   base_address = end;
2627                   printf (_("    %8.8lx %8.8lx %8.8lx (base address)\n"),
2628                           offset, begin, end);
2629                   continue;
2630                 }
2631
2632               if (start + 2 > section_end)
2633                 {
2634                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2635                         offset);
2636                   break;
2637                 }
2638
2639               length = byte_get (start, 2);
2640               start += 2;
2641
2642               if (start + length > section_end)
2643                 {
2644                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2645                         offset);
2646                   break;
2647                 }
2648
2649               printf ("    %8.8lx %8.8lx %8.8lx (",
2650                       offset, begin + base_address, end + base_address);
2651               need_frame_base = decode_location_expression (start,
2652                                                             pointer_size,
2653                                                             length,
2654                                                             cu_offset);
2655               putchar (')');
2656
2657               if (need_frame_base && !has_frame_base)
2658                 printf (_(" [without DW_AT_frame_base]"));
2659
2660               if (begin == end)
2661                 fputs (_(" (start == end)"), stdout);
2662               else if (begin > end)
2663                 fputs (_(" (start > end)"), stdout);
2664
2665               putchar ('\n');
2666
2667               start += length;
2668             }
2669         }
2670     }
2671
2672   if (start < section_end)
2673     warn (_("There are %ld unused bytes at the end of section %s\n"),
2674           (long) (section_end - start), section->name);
2675   return 1;
2676 }
2677
2678 static int
2679 display_debug_str (struct dwarf_section *section,
2680                    void *file ATTRIBUTE_UNUSED)
2681 {
2682   unsigned char *start = section->start;
2683   unsigned long bytes = section->size;
2684   dwarf_vma addr = section->address;
2685
2686   if (bytes == 0)
2687     {
2688       printf (_("\nThe %s section is empty.\n"), section->name);
2689       return 0;
2690     }
2691
2692   printf (_("Contents of the %s section:\n\n"), section->name);
2693
2694   while (bytes)
2695     {
2696       int j;
2697       int k;
2698       int lbytes;
2699
2700       lbytes = (bytes > 16 ? 16 : bytes);
2701
2702       printf ("  0x%8.8lx ", (unsigned long) addr);
2703
2704       for (j = 0; j < 16; j++)
2705         {
2706           if (j < lbytes)
2707             printf ("%2.2x", start[j]);
2708           else
2709             printf ("  ");
2710
2711           if ((j & 3) == 3)
2712             printf (" ");
2713         }
2714
2715       for (j = 0; j < lbytes; j++)
2716         {
2717           k = start[j];
2718           if (k >= ' ' && k < 0x80)
2719             printf ("%c", k);
2720           else
2721             printf (".");
2722         }
2723
2724       putchar ('\n');
2725
2726       start += lbytes;
2727       addr  += lbytes;
2728       bytes -= lbytes;
2729     }
2730
2731   putchar ('\n');
2732
2733   return 1;
2734 }
2735
2736 static int
2737 display_debug_info (struct dwarf_section *section, void *file)
2738 {
2739   return process_debug_info (section, file, 0);
2740 }
2741
2742
2743 static int
2744 display_debug_aranges (struct dwarf_section *section,
2745                        void *file ATTRIBUTE_UNUSED)
2746 {
2747   unsigned char *start = section->start;
2748   unsigned char *end = start + section->size;
2749
2750   printf (_("The section %s contains:\n\n"), section->name);
2751
2752   while (start < end)
2753     {
2754       unsigned char *hdrptr;
2755       DWARF2_Internal_ARange arange;
2756       unsigned char *ranges;
2757       unsigned long length;
2758       unsigned long address;
2759       unsigned char address_size;
2760       int excess;
2761       int offset_size;
2762       int initial_length_size;
2763
2764       hdrptr = start;
2765
2766       arange.ar_length = byte_get (hdrptr, 4);
2767       hdrptr += 4;
2768
2769       if (arange.ar_length == 0xffffffff)
2770         {
2771           arange.ar_length = byte_get (hdrptr, 8);
2772           hdrptr += 8;
2773           offset_size = 8;
2774           initial_length_size = 12;
2775         }
2776       else
2777         {
2778           offset_size = 4;
2779           initial_length_size = 4;
2780         }
2781
2782       arange.ar_version = byte_get (hdrptr, 2);
2783       hdrptr += 2;
2784
2785       arange.ar_info_offset = byte_get (hdrptr, offset_size);
2786       hdrptr += offset_size;
2787
2788       arange.ar_pointer_size = byte_get (hdrptr, 1);
2789       hdrptr += 1;
2790
2791       arange.ar_segment_size = byte_get (hdrptr, 1);
2792       hdrptr += 1;
2793
2794       if (arange.ar_version != 2 && arange.ar_version != 3)
2795         {
2796           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2797           break;
2798         }
2799
2800       printf (_("  Length:                   %ld\n"), arange.ar_length);
2801       printf (_("  Version:                  %d\n"), arange.ar_version);
2802       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
2803       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
2804       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
2805
2806       address_size = arange.ar_pointer_size + arange.ar_segment_size;
2807
2808       /* The DWARF spec does not require that the address size be a power
2809          of two, but we do.  This will have to change if we ever encounter
2810          an uneven architecture.  */
2811       if ((address_size & (address_size - 1)) != 0)
2812         {
2813           warn (_("Pointer size + Segment size is not a power of two.\n"));
2814           break;
2815         }
2816
2817       if (address_size > 4)
2818         printf (_("\n    Address            Length\n"));
2819       else
2820         printf (_("\n    Address    Length\n"));
2821
2822       ranges = hdrptr;
2823
2824       /* Must pad to an alignment boundary that is twice the address size.  */
2825       excess = (hdrptr - start) % (2 * address_size);
2826       if (excess)
2827         ranges += (2 * address_size) - excess;
2828
2829       start += arange.ar_length + initial_length_size;
2830
2831       while (ranges + 2 * address_size <= start)
2832         {
2833           address = byte_get (ranges, address_size);
2834
2835           ranges += address_size;
2836
2837           length  = byte_get (ranges, address_size);
2838
2839           ranges += address_size;
2840
2841           if (address_size > 4)
2842             printf ("    0x%16.16lx 0x%lx\n", address, length);
2843           else
2844             printf ("    0x%8.8lx 0x%lx\n", address, length);
2845         }
2846     }
2847
2848   printf ("\n");
2849
2850   return 1;
2851 }
2852
2853 static int
2854 display_debug_ranges (struct dwarf_section *section,
2855                       void *file ATTRIBUTE_UNUSED)
2856 {
2857   unsigned char *start = section->start;
2858   unsigned char *section_end;
2859   unsigned long bytes;
2860   unsigned char *section_begin = start;
2861   unsigned int num_range_list = 0;
2862   unsigned long last_offset = 0;
2863   unsigned int first = 0;
2864   unsigned int i;
2865   unsigned int j;
2866   int seen_first_offset = 0;
2867   int use_debug_info = 1;
2868   unsigned char *next;
2869
2870   bytes = section->size;
2871   section_end = start + bytes;
2872
2873   if (bytes == 0)
2874     {
2875       printf (_("\nThe %s section is empty.\n"), section->name);
2876       return 0;
2877     }
2878
2879   load_debug_info (file);
2880
2881   /* Check the order of range list in .debug_info section. If
2882      offsets of range lists are in the ascending order, we can
2883      use `debug_information' directly.  */
2884   for (i = 0; i < num_debug_info_entries; i++)
2885     {
2886       unsigned int num;
2887
2888       num = debug_information [i].num_range_lists;
2889       num_range_list += num;
2890
2891       /* Check if we can use `debug_information' directly.  */
2892       if (use_debug_info && num != 0)
2893         {
2894           if (!seen_first_offset)
2895             {
2896               /* This is the first range list.  */
2897               last_offset = debug_information [i].range_lists [0];
2898               first = i;
2899               seen_first_offset = 1;
2900               j = 1;
2901             }
2902           else
2903             j = 0;
2904
2905           for (; j < num; j++)
2906             {
2907               if (last_offset >
2908                   debug_information [i].range_lists [j])
2909                 {
2910                   use_debug_info = 0;
2911                   break;
2912                 }
2913               last_offset = debug_information [i].range_lists [j];
2914             }
2915         }
2916     }
2917
2918   if (!use_debug_info)
2919     /* FIXME: Should we handle this case?  */
2920     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2921
2922   if (!seen_first_offset)
2923     error (_("No range lists in .debug_info section!\n"));
2924
2925   /* DWARF sections under Mach-O have non-zero addresses.  */
2926   if (debug_information [first].num_range_lists > 0
2927       && debug_information [first].range_lists [0] != section->address)
2928     warn (_("Range lists in %s section start at 0x%lx\n"),
2929           section->name, debug_information [first].range_lists [0]);
2930
2931   printf (_("Contents of the %s section:\n\n"), section->name);
2932   printf (_("    Offset   Begin    End\n"));
2933
2934   seen_first_offset = 0;
2935   for (i = first; i < num_debug_info_entries; i++)
2936     {
2937       unsigned long begin;
2938       unsigned long end;
2939       unsigned long offset;
2940       unsigned int pointer_size;
2941       unsigned long base_address;
2942
2943       pointer_size = debug_information [i].pointer_size;
2944
2945       for (j = 0; j < debug_information [i].num_range_lists; j++)
2946         {
2947           /* DWARF sections under Mach-O have non-zero addresses.  */
2948           offset = debug_information [i].range_lists [j] - section->address;
2949           next = section_begin + offset;
2950           base_address = debug_information [i].base_address;
2951
2952           if (!seen_first_offset)
2953             seen_first_offset = 1;
2954           else
2955             {
2956               if (start < next)
2957                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2958                       (long)(start - section_begin),
2959                       (long)(next - section_begin), section->name);
2960               else if (start > next)
2961                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2962                       (long)(start - section_begin),
2963                       (long)(next - section_begin), section->name);
2964             }
2965           start = next;
2966
2967           while (1)
2968             {
2969               begin = byte_get (start, pointer_size);
2970               start += pointer_size;
2971               end = byte_get (start, pointer_size);
2972               start += pointer_size;
2973
2974               if (begin == 0 && end == 0)
2975                 {
2976                   printf (_("    %8.8lx <End of list>\n"), offset);
2977                   break;
2978                 }
2979
2980               /* Check base address specifiers.  */
2981               if (begin == -1UL && end != -1UL)
2982                 {
2983                   base_address = end;
2984                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
2985                           offset, begin, end);
2986                   continue;
2987                 }
2988
2989               printf ("    %8.8lx %8.8lx %8.8lx",
2990                       offset, begin + base_address, end + base_address);
2991
2992               if (begin == end)
2993                 fputs (_(" (start == end)"), stdout);
2994               else if (begin > end)
2995                 fputs (_(" (start > end)"), stdout);
2996
2997               putchar ('\n');
2998             }
2999         }
3000     }
3001   putchar ('\n');
3002   return 1;
3003 }
3004
3005 typedef struct Frame_Chunk
3006 {
3007   struct Frame_Chunk *next;
3008   unsigned char *chunk_start;
3009   int ncols;
3010   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
3011   short int *col_type;
3012   int *col_offset;
3013   char *augmentation;
3014   unsigned int code_factor;
3015   int data_factor;
3016   unsigned long pc_begin;
3017   unsigned long pc_range;
3018   int cfa_reg;
3019   int cfa_offset;
3020   int ra;
3021   unsigned char fde_encoding;
3022   unsigned char cfa_exp;
3023 }
3024 Frame_Chunk;
3025
3026 /* A marker for a col_type that means this column was never referenced
3027    in the frame info.  */
3028 #define DW_CFA_unreferenced (-1)
3029
3030 static void
3031 frame_need_space (Frame_Chunk *fc, int reg)
3032 {
3033   int prev = fc->ncols;
3034
3035   if (reg < fc->ncols)
3036     return;
3037
3038   fc->ncols = reg + 1;
3039   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3040   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3041
3042   while (prev < fc->ncols)
3043     {
3044       fc->col_type[prev] = DW_CFA_unreferenced;
3045       fc->col_offset[prev] = 0;
3046       prev++;
3047     }
3048 }
3049
3050 static void
3051 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3052 {
3053   int r;
3054   char tmp[100];
3055
3056   if (*max_regs < fc->ncols)
3057     *max_regs = fc->ncols;
3058
3059   if (*need_col_headers)
3060     {
3061       *need_col_headers = 0;
3062
3063       printf ("   LOC   CFA      ");
3064
3065       for (r = 0; r < *max_regs; r++)
3066         if (fc->col_type[r] != DW_CFA_unreferenced)
3067           {
3068             if (r == fc->ra)
3069               printf ("ra   ");
3070             else
3071               printf ("r%-4d", r);
3072           }
3073
3074       printf ("\n");
3075     }
3076
3077   printf ("%08lx ", fc->pc_begin);
3078   if (fc->cfa_exp)
3079     strcpy (tmp, "exp");
3080   else
3081     sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
3082   printf ("%-8s ", tmp);
3083
3084   for (r = 0; r < fc->ncols; r++)
3085     {
3086       if (fc->col_type[r] != DW_CFA_unreferenced)
3087         {
3088           switch (fc->col_type[r])
3089             {
3090             case DW_CFA_undefined:
3091               strcpy (tmp, "u");
3092               break;
3093             case DW_CFA_same_value:
3094               strcpy (tmp, "s");
3095               break;
3096             case DW_CFA_offset:
3097               sprintf (tmp, "c%+d", fc->col_offset[r]);
3098               break;
3099             case DW_CFA_val_offset:
3100               sprintf (tmp, "v%+d", fc->col_offset[r]);
3101               break;
3102             case DW_CFA_register:
3103               sprintf (tmp, "r%d", fc->col_offset[r]);
3104               break;
3105             case DW_CFA_expression:
3106               strcpy (tmp, "exp");
3107               break;
3108             case DW_CFA_val_expression:
3109               strcpy (tmp, "vexp");
3110               break;
3111             default:
3112               strcpy (tmp, "n/a");
3113               break;
3114             }
3115           printf ("%-5s", tmp);
3116         }
3117     }
3118   printf ("\n");
3119 }
3120
3121 static int
3122 size_of_encoded_value (int encoding)
3123 {
3124   switch (encoding & 0x7)
3125     {
3126     default:    /* ??? */
3127     case 0:     return eh_addr_size;
3128     case 2:     return 2;
3129     case 3:     return 4;
3130     case 4:     return 8;
3131     }
3132 }
3133
3134 static dwarf_vma
3135 get_encoded_value (unsigned char *data, int encoding)
3136 {
3137   int size = size_of_encoded_value (encoding);
3138
3139   if (encoding & DW_EH_PE_signed)
3140     return byte_get_signed (data, size);
3141   else
3142     return byte_get (data, size);
3143 }
3144
3145 #define GET(N)  byte_get (start, N); start += N
3146 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
3147 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
3148
3149 static int
3150 display_debug_frames (struct dwarf_section *section,
3151                       void *file ATTRIBUTE_UNUSED)
3152 {
3153   unsigned char *start = section->start;
3154   unsigned char *end = start + section->size;
3155   unsigned char *section_start = start;
3156   Frame_Chunk *chunks = 0;
3157   Frame_Chunk *remembered_state = 0;
3158   Frame_Chunk *rs;
3159   int is_eh = strcmp (section->name, ".eh_frame") == 0;
3160   unsigned int length_return;
3161   int max_regs = 0;
3162
3163   printf (_("The section %s contains:\n"), section->name);
3164
3165   while (start < end)
3166     {
3167       unsigned char *saved_start;
3168       unsigned char *block_end;
3169       unsigned long length;
3170       unsigned long cie_id;
3171       Frame_Chunk *fc;
3172       Frame_Chunk *cie;
3173       int need_col_headers = 1;
3174       unsigned char *augmentation_data = NULL;
3175       unsigned long augmentation_data_len = 0;
3176       int encoded_ptr_size = eh_addr_size;
3177       int offset_size;
3178       int initial_length_size;
3179
3180       saved_start = start;
3181       length = byte_get (start, 4); start += 4;
3182
3183       if (length == 0)
3184         {
3185           printf ("\n%08lx ZERO terminator\n\n",
3186                     (unsigned long)(saved_start - section_start));
3187           continue;
3188         }
3189
3190       if (length == 0xffffffff)
3191         {
3192           length = byte_get (start, 8);
3193           start += 8;
3194           offset_size = 8;
3195           initial_length_size = 12;
3196         }
3197       else
3198         {
3199           offset_size = 4;
3200           initial_length_size = 4;
3201         }
3202
3203       block_end = saved_start + length + initial_length_size;
3204       if (block_end > end)
3205         {
3206           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3207                 length, (unsigned long)(saved_start - section_start));
3208           block_end = end;
3209         }
3210       cie_id = byte_get (start, offset_size); start += offset_size;
3211
3212       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3213         {
3214           int version;
3215
3216           fc = xmalloc (sizeof (Frame_Chunk));
3217           memset (fc, 0, sizeof (Frame_Chunk));
3218
3219           fc->next = chunks;
3220           chunks = fc;
3221           fc->chunk_start = saved_start;
3222           fc->ncols = 0;
3223           fc->col_type = xmalloc (sizeof (short int));
3224           fc->col_offset = xmalloc (sizeof (int));
3225           frame_need_space (fc, max_regs-1);
3226
3227           version = *start++;
3228
3229           fc->augmentation = (char *) start;
3230           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3231
3232           if (fc->augmentation[0] == 'z')
3233             {
3234               fc->code_factor = LEB ();
3235               fc->data_factor = SLEB ();
3236               if (version == 1)
3237                 {
3238                   fc->ra = GET (1);
3239                 }
3240               else
3241                 {
3242                   fc->ra = LEB ();
3243                 }
3244               augmentation_data_len = LEB ();
3245               augmentation_data = start;
3246               start += augmentation_data_len;
3247             }
3248           else if (strcmp (fc->augmentation, "eh") == 0)
3249             {
3250               start += eh_addr_size;
3251               fc->code_factor = LEB ();
3252               fc->data_factor = SLEB ();
3253               if (version == 1)
3254                 {
3255                   fc->ra = GET (1);
3256                 }
3257               else
3258                 {
3259                   fc->ra = LEB ();
3260                 }
3261             }
3262           else
3263             {
3264               fc->code_factor = LEB ();
3265               fc->data_factor = SLEB ();
3266               if (version == 1)
3267                 {
3268                   fc->ra = GET (1);
3269                 }
3270               else
3271                 {
3272                   fc->ra = LEB ();
3273                 }
3274             }
3275           cie = fc;
3276
3277           if (do_debug_frames_interp)
3278             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3279                     (unsigned long)(saved_start - section_start), length, cie_id,
3280                     fc->augmentation, fc->code_factor, fc->data_factor,
3281                     fc->ra);
3282           else
3283             {
3284               printf ("\n%08lx %08lx %08lx CIE\n",
3285                       (unsigned long)(saved_start - section_start), length, cie_id);
3286               printf ("  Version:               %d\n", version);
3287               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3288               printf ("  Code alignment factor: %u\n", fc->code_factor);
3289               printf ("  Data alignment factor: %d\n", fc->data_factor);
3290               printf ("  Return address column: %d\n", fc->ra);
3291
3292               if (augmentation_data_len)
3293                 {
3294                   unsigned long i;
3295                   printf ("  Augmentation data:    ");
3296                   for (i = 0; i < augmentation_data_len; ++i)
3297                     printf (" %02x", augmentation_data[i]);
3298                   putchar ('\n');
3299                 }
3300               putchar ('\n');
3301             }
3302
3303           if (augmentation_data_len)
3304             {
3305               unsigned char *p, *q;
3306               p = (unsigned char *) fc->augmentation + 1;
3307               q = augmentation_data;
3308
3309               while (1)
3310                 {
3311                   if (*p == 'L')
3312                     q++;
3313                   else if (*p == 'P')
3314                     q += 1 + size_of_encoded_value (*q);
3315                   else if (*p == 'R')
3316                     fc->fde_encoding = *q++;
3317                   else
3318                     break;
3319                   p++;
3320                 }
3321
3322               if (fc->fde_encoding)
3323                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3324             }
3325
3326           frame_need_space (fc, fc->ra);
3327         }
3328       else
3329         {
3330           unsigned char *look_for;
3331           static Frame_Chunk fde_fc;
3332
3333           fc = & fde_fc;
3334           memset (fc, 0, sizeof (Frame_Chunk));
3335
3336           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3337
3338           for (cie = chunks; cie ; cie = cie->next)
3339             if (cie->chunk_start == look_for)
3340               break;
3341
3342           if (!cie)
3343             {
3344               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3345                     cie_id, (unsigned long)(saved_start - section_start));
3346               fc->ncols = 0;
3347               fc->col_type = xmalloc (sizeof (short int));
3348               fc->col_offset = xmalloc (sizeof (int));
3349               frame_need_space (fc, max_regs - 1);
3350               cie = fc;
3351               fc->augmentation = "";
3352               fc->fde_encoding = 0;
3353             }
3354           else
3355             {
3356               fc->ncols = cie->ncols;
3357               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3358               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3359               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3360               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3361               fc->augmentation = cie->augmentation;
3362               fc->code_factor = cie->code_factor;
3363               fc->data_factor = cie->data_factor;
3364               fc->cfa_reg = cie->cfa_reg;
3365               fc->cfa_offset = cie->cfa_offset;
3366               fc->ra = cie->ra;
3367               frame_need_space (fc, max_regs-1);
3368               fc->fde_encoding = cie->fde_encoding;
3369             }
3370
3371           if (fc->fde_encoding)
3372             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3373
3374           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3375           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3376             fc->pc_begin += section->address + (start - section_start);
3377           start += encoded_ptr_size;
3378           fc->pc_range = byte_get (start, encoded_ptr_size);
3379           start += encoded_ptr_size;
3380
3381           if (cie->augmentation[0] == 'z')
3382             {
3383               augmentation_data_len = LEB ();
3384               augmentation_data = start;
3385               start += augmentation_data_len;
3386             }
3387
3388           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3389                   (unsigned long)(saved_start - section_start), length, cie_id,
3390                   (unsigned long)(cie->chunk_start - section_start),
3391                   fc->pc_begin, fc->pc_begin + fc->pc_range);
3392           if (! do_debug_frames_interp && augmentation_data_len)
3393             {
3394               unsigned long i;
3395
3396               printf ("  Augmentation data:    ");
3397               for (i = 0; i < augmentation_data_len; ++i)
3398                 printf (" %02x", augmentation_data[i]);
3399               putchar ('\n');
3400               putchar ('\n');
3401             }
3402         }
3403
3404       /* At this point, fc is the current chunk, cie (if any) is set, and
3405          we're about to interpret instructions for the chunk.  */
3406       /* ??? At present we need to do this always, since this sizes the
3407          fc->col_type and fc->col_offset arrays, which we write into always.
3408          We should probably split the interpreted and non-interpreted bits
3409          into two different routines, since there's so much that doesn't
3410          really overlap between them.  */
3411       if (1 || do_debug_frames_interp)
3412         {
3413           /* Start by making a pass over the chunk, allocating storage
3414              and taking note of what registers are used.  */
3415           unsigned char *tmp = start;
3416
3417           while (start < block_end)
3418             {
3419               unsigned op, opa;
3420               unsigned long reg, tmp;
3421
3422               op = *start++;
3423               opa = op & 0x3f;
3424               if (op & 0xc0)
3425                 op &= 0xc0;
3426
3427               /* Warning: if you add any more cases to this switch, be
3428                  sure to add them to the corresponding switch below.  */
3429               switch (op)
3430                 {
3431                 case DW_CFA_advance_loc:
3432                   break;
3433                 case DW_CFA_offset:
3434                   LEB ();
3435                   frame_need_space (fc, opa);
3436                   fc->col_type[opa] = DW_CFA_undefined;
3437                   break;
3438                 case DW_CFA_restore:
3439                   frame_need_space (fc, opa);
3440                   fc->col_type[opa] = DW_CFA_undefined;
3441                   break;
3442                 case DW_CFA_set_loc:
3443                   start += encoded_ptr_size;
3444                   break;
3445                 case DW_CFA_advance_loc1:
3446                   start += 1;
3447                   break;
3448                 case DW_CFA_advance_loc2:
3449                   start += 2;
3450                   break;
3451                 case DW_CFA_advance_loc4:
3452                   start += 4;
3453                   break;
3454                 case DW_CFA_offset_extended:
3455                 case DW_CFA_val_offset:
3456                   reg = LEB (); LEB ();
3457                   frame_need_space (fc, reg);
3458                   fc->col_type[reg] = DW_CFA_undefined;
3459                   break;
3460                 case DW_CFA_restore_extended:
3461                   reg = LEB ();
3462                   frame_need_space (fc, reg);
3463                   fc->col_type[reg] = DW_CFA_undefined;
3464                   break;
3465                 case DW_CFA_undefined:
3466                   reg = LEB ();
3467                   frame_need_space (fc, reg);
3468                   fc->col_type[reg] = DW_CFA_undefined;
3469                   break;
3470                 case DW_CFA_same_value:
3471                   reg = LEB ();
3472                   frame_need_space (fc, reg);
3473                   fc->col_type[reg] = DW_CFA_undefined;
3474                   break;
3475                 case DW_CFA_register:
3476                   reg = LEB (); LEB ();
3477                   frame_need_space (fc, reg);
3478                   fc->col_type[reg] = DW_CFA_undefined;
3479                   break;
3480                 case DW_CFA_def_cfa:
3481                   LEB (); LEB ();
3482                   break;
3483                 case DW_CFA_def_cfa_register:
3484                   LEB ();
3485                   break;
3486                 case DW_CFA_def_cfa_offset:
3487                   LEB ();
3488                   break;
3489                 case DW_CFA_def_cfa_expression:
3490                   tmp = LEB ();
3491                   start += tmp;
3492                   break;
3493                 case DW_CFA_expression:
3494                 case DW_CFA_val_expression:
3495                   reg = LEB ();
3496                   tmp = LEB ();
3497                   start += tmp;
3498                   frame_need_space (fc, reg);
3499                   fc->col_type[reg] = DW_CFA_undefined;
3500                   break;
3501                 case DW_CFA_offset_extended_sf:
3502                 case DW_CFA_val_offset_sf:
3503                   reg = LEB (); SLEB ();
3504                   frame_need_space (fc, reg);
3505                   fc->col_type[reg] = DW_CFA_undefined;
3506                   break;
3507                 case DW_CFA_def_cfa_sf:
3508                   LEB (); SLEB ();
3509                   break;
3510                 case DW_CFA_def_cfa_offset_sf:
3511                   SLEB ();
3512                   break;
3513                 case DW_CFA_MIPS_advance_loc8:
3514                   start += 8;
3515                   break;
3516                 case DW_CFA_GNU_args_size:
3517                   LEB ();
3518                   break;
3519                 case DW_CFA_GNU_negative_offset_extended:
3520                   reg = LEB (); LEB ();
3521                   frame_need_space (fc, reg);
3522                   fc->col_type[reg] = DW_CFA_undefined;
3523
3524                 default:
3525                   break;
3526                 }
3527             }
3528           start = tmp;
3529         }
3530
3531       /* Now we know what registers are used, make a second pass over
3532          the chunk, this time actually printing out the info.  */
3533
3534       while (start < block_end)
3535         {
3536           unsigned op, opa;
3537           unsigned long ul, reg, roffs;
3538           long l, ofs;
3539           dwarf_vma vma;
3540
3541           op = *start++;
3542           opa = op & 0x3f;
3543           if (op & 0xc0)
3544             op &= 0xc0;
3545
3546           /* Warning: if you add any more cases to this switch, be
3547              sure to add them to the corresponding switch above.  */
3548           switch (op)
3549             {
3550             case DW_CFA_advance_loc:
3551               if (do_debug_frames_interp)
3552                 frame_display_row (fc, &need_col_headers, &max_regs);
3553               else
3554                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
3555                         opa * fc->code_factor,
3556                         fc->pc_begin + opa * fc->code_factor);
3557               fc->pc_begin += opa * fc->code_factor;
3558               break;
3559
3560             case DW_CFA_offset:
3561               roffs = LEB ();
3562               if (! do_debug_frames_interp)
3563                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
3564                         opa, roffs * fc->data_factor);
3565               fc->col_type[opa] = DW_CFA_offset;
3566               fc->col_offset[opa] = roffs * fc->data_factor;
3567               break;
3568
3569             case DW_CFA_restore:
3570               if (! do_debug_frames_interp)
3571                 printf ("  DW_CFA_restore: r%d\n", opa);
3572               fc->col_type[opa] = cie->col_type[opa];
3573               fc->col_offset[opa] = cie->col_offset[opa];
3574               break;
3575
3576             case DW_CFA_set_loc:
3577               vma = get_encoded_value (start, fc->fde_encoding);
3578               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3579                 vma += section->address + (start - section_start);
3580               start += encoded_ptr_size;
3581               if (do_debug_frames_interp)
3582                 frame_display_row (fc, &need_col_headers, &max_regs);
3583               else
3584                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3585               fc->pc_begin = vma;
3586               break;
3587
3588             case DW_CFA_advance_loc1:
3589               ofs = byte_get (start, 1); start += 1;
3590               if (do_debug_frames_interp)
3591                 frame_display_row (fc, &need_col_headers, &max_regs);
3592               else
3593                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
3594                         ofs * fc->code_factor,
3595                         fc->pc_begin + ofs * fc->code_factor);
3596               fc->pc_begin += ofs * fc->code_factor;
3597               break;
3598
3599             case DW_CFA_advance_loc2:
3600               ofs = byte_get (start, 2); start += 2;
3601               if (do_debug_frames_interp)
3602                 frame_display_row (fc, &need_col_headers, &max_regs);
3603               else
3604                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
3605                         ofs * fc->code_factor,
3606                         fc->pc_begin + ofs * fc->code_factor);
3607               fc->pc_begin += ofs * fc->code_factor;
3608               break;
3609
3610             case DW_CFA_advance_loc4:
3611               ofs = byte_get (start, 4); start += 4;
3612               if (do_debug_frames_interp)
3613                 frame_display_row (fc, &need_col_headers, &max_regs);
3614               else
3615                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
3616                         ofs * fc->code_factor,
3617                         fc->pc_begin + ofs * fc->code_factor);
3618               fc->pc_begin += ofs * fc->code_factor;
3619               break;
3620
3621             case DW_CFA_offset_extended:
3622               reg = LEB ();
3623               roffs = LEB ();
3624               if (! do_debug_frames_interp)
3625                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3626                         reg, roffs * fc->data_factor);
3627               fc->col_type[reg] = DW_CFA_offset;
3628               fc->col_offset[reg] = roffs * fc->data_factor;
3629               break;
3630
3631             case DW_CFA_val_offset:
3632               reg = LEB ();
3633               roffs = LEB ();
3634               if (! do_debug_frames_interp)
3635                 printf ("  DW_CFA_val_offset: r%ld at cfa%+ld\n",
3636                         reg, roffs * fc->data_factor);
3637               fc->col_type[reg] = DW_CFA_val_offset;
3638               fc->col_offset[reg] = roffs * fc->data_factor;
3639               break;
3640
3641             case DW_CFA_restore_extended:
3642               reg = LEB ();
3643               if (! do_debug_frames_interp)
3644                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
3645               fc->col_type[reg] = cie->col_type[reg];
3646               fc->col_offset[reg] = cie->col_offset[reg];
3647               break;
3648
3649             case DW_CFA_undefined:
3650               reg = LEB ();
3651               if (! do_debug_frames_interp)
3652                 printf ("  DW_CFA_undefined: r%ld\n", reg);
3653               fc->col_type[reg] = DW_CFA_undefined;
3654               fc->col_offset[reg] = 0;
3655               break;
3656
3657             case DW_CFA_same_value:
3658               reg = LEB ();
3659               if (! do_debug_frames_interp)
3660                 printf ("  DW_CFA_same_value: r%ld\n", reg);
3661               fc->col_type[reg] = DW_CFA_same_value;
3662               fc->col_offset[reg] = 0;
3663               break;
3664
3665             case DW_CFA_register:
3666               reg = LEB ();
3667               roffs = LEB ();
3668               if (! do_debug_frames_interp)
3669                 printf ("  DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3670               fc->col_type[reg] = DW_CFA_register;
3671               fc->col_offset[reg] = roffs;
3672               break;
3673
3674             case DW_CFA_remember_state:
3675               if (! do_debug_frames_interp)
3676                 printf ("  DW_CFA_remember_state\n");
3677               rs = xmalloc (sizeof (Frame_Chunk));
3678               rs->ncols = fc->ncols;
3679               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3680               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3681               memcpy (rs->col_type, fc->col_type, rs->ncols);
3682               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3683               rs->next = remembered_state;
3684               remembered_state = rs;
3685               break;
3686
3687             case DW_CFA_restore_state:
3688               if (! do_debug_frames_interp)
3689                 printf ("  DW_CFA_restore_state\n");
3690               rs = remembered_state;
3691               if (rs)
3692                 {
3693                   remembered_state = rs->next;
3694                   frame_need_space (fc, rs->ncols-1);
3695                   memcpy (fc->col_type, rs->col_type, rs->ncols);
3696                   memcpy (fc->col_offset, rs->col_offset,
3697                           rs->ncols * sizeof (int));
3698                   free (rs->col_type);
3699                   free (rs->col_offset);
3700                   free (rs);
3701                 }
3702               else if (do_debug_frames_interp)
3703                 printf ("Mismatched DW_CFA_restore_state\n");
3704               break;
3705
3706             case DW_CFA_def_cfa:
3707               fc->cfa_reg = LEB ();
3708               fc->cfa_offset = LEB ();
3709               fc->cfa_exp = 0;
3710               if (! do_debug_frames_interp)
3711                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
3712                         fc->cfa_reg, fc->cfa_offset);
3713               break;
3714
3715             case DW_CFA_def_cfa_register:
3716               fc->cfa_reg = LEB ();
3717               fc->cfa_exp = 0;
3718               if (! do_debug_frames_interp)
3719                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3720               break;
3721
3722             case DW_CFA_def_cfa_offset:
3723               fc->cfa_offset = LEB ();
3724               if (! do_debug_frames_interp)
3725                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3726               break;
3727
3728             case DW_CFA_nop:
3729               if (! do_debug_frames_interp)
3730                 printf ("  DW_CFA_nop\n");
3731               break;
3732
3733             case DW_CFA_def_cfa_expression:
3734               ul = LEB ();
3735               if (! do_debug_frames_interp)
3736                 {
3737                   printf ("  DW_CFA_def_cfa_expression (");
3738                   decode_location_expression (start, eh_addr_size, ul, 0);
3739                   printf (")\n");
3740                 }
3741               fc->cfa_exp = 1;
3742               start += ul;
3743               break;
3744
3745             case DW_CFA_expression:
3746               reg = LEB ();
3747               ul = LEB ();
3748               if (! do_debug_frames_interp)
3749                 {
3750                   printf ("  DW_CFA_expression: r%ld (", reg);
3751                   decode_location_expression (start, eh_addr_size, ul, 0);
3752                   printf (")\n");
3753                 }
3754               fc->col_type[reg] = DW_CFA_expression;
3755               start += ul;
3756               break;
3757
3758             case DW_CFA_val_expression:
3759               reg = LEB ();
3760               ul = LEB ();
3761               if (! do_debug_frames_interp)
3762                 {
3763                   printf ("  DW_CFA_val_expression: r%ld (", reg);
3764                   decode_location_expression (start, eh_addr_size, ul, 0);
3765                   printf (")\n");
3766                 }
3767               fc->col_type[reg] = DW_CFA_val_expression;
3768               start += ul;
3769               break;
3770
3771             case DW_CFA_offset_extended_sf:
3772               reg = LEB ();
3773               l = SLEB ();
3774               frame_need_space (fc, reg);
3775               if (! do_debug_frames_interp)
3776                 printf ("  DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3777                         reg, l * fc->data_factor);
3778               fc->col_type[reg] = DW_CFA_offset;
3779               fc->col_offset[reg] = l * fc->data_factor;
3780               break;
3781
3782             case DW_CFA_val_offset_sf:
3783               reg = LEB ();
3784               l = SLEB ();
3785               frame_need_space (fc, reg);
3786               if (! do_debug_frames_interp)
3787                 printf ("  DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3788                         reg, l * fc->data_factor);
3789               fc->col_type[reg] = DW_CFA_val_offset;
3790               fc->col_offset[reg] = l * fc->data_factor;
3791               break;
3792
3793             case DW_CFA_def_cfa_sf:
3794               fc->cfa_reg = LEB ();
3795               fc->cfa_offset = SLEB ();
3796               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3797               fc->cfa_exp = 0;
3798               if (! do_debug_frames_interp)
3799                 printf ("  DW_CFA_def_cfa_sf: r%d ofs %d\n",
3800                         fc->cfa_reg, fc->cfa_offset);
3801               break;
3802
3803             case DW_CFA_def_cfa_offset_sf:
3804               fc->cfa_offset = SLEB ();
3805               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3806               if (! do_debug_frames_interp)
3807                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3808               break;
3809
3810             case DW_CFA_MIPS_advance_loc8:
3811               ofs = byte_get (start, 8); start += 8;
3812               if (do_debug_frames_interp)
3813                 frame_display_row (fc, &need_col_headers, &max_regs);
3814               else
3815                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3816                         ofs * fc->code_factor,
3817                         fc->pc_begin + ofs * fc->code_factor);
3818               fc->pc_begin += ofs * fc->code_factor;
3819               break;
3820
3821             case DW_CFA_GNU_window_save:
3822               if (! do_debug_frames_interp)
3823                 printf ("  DW_CFA_GNU_window_save\n");
3824               break;
3825
3826             case DW_CFA_GNU_args_size:
3827               ul = LEB ();
3828               if (! do_debug_frames_interp)
3829                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
3830               break;
3831
3832             case DW_CFA_GNU_negative_offset_extended:
3833               reg = LEB ();
3834               l = - LEB ();
3835               frame_need_space (fc, reg);
3836               if (! do_debug_frames_interp)
3837                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3838                         reg, l * fc->data_factor);
3839               fc->col_type[reg] = DW_CFA_offset;
3840               fc->col_offset[reg] = l * fc->data_factor;
3841               break;
3842
3843             default:
3844               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3845                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3846               else
3847                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3848               start = block_end;
3849             }
3850         }
3851
3852       if (do_debug_frames_interp)
3853         frame_display_row (fc, &need_col_headers, &max_regs);
3854
3855       start = block_end;
3856     }
3857
3858   printf ("\n");
3859
3860   return 1;
3861 }
3862
3863 #undef GET
3864 #undef LEB
3865 #undef SLEB
3866
3867 static int
3868 display_debug_not_supported (struct dwarf_section *section,
3869                              void *file ATTRIBUTE_UNUSED)
3870 {
3871   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3872             section->name);
3873
3874   return 1;
3875 }
3876
3877 void *
3878 cmalloc (size_t nmemb, size_t size)
3879 {
3880   /* Check for overflow.  */
3881   if (nmemb >= ~(size_t) 0 / size)
3882     return NULL;
3883   else
3884     return malloc (nmemb * size);
3885 }
3886
3887 void *
3888 xcmalloc (size_t nmemb, size_t size)
3889 {
3890   /* Check for overflow.  */
3891   if (nmemb >= ~(size_t) 0 / size)
3892     return NULL;
3893   else
3894     return xmalloc (nmemb * size);
3895 }
3896
3897 void *
3898 xcrealloc (void *ptr, size_t nmemb, size_t size)
3899 {
3900   /* Check for overflow.  */
3901   if (nmemb >= ~(size_t) 0 / size)
3902     return NULL;
3903   else
3904     return xrealloc (ptr, nmemb * size);
3905 }
3906
3907 void
3908 error (const char *message, ...)
3909 {
3910   va_list args;
3911
3912   va_start (args, message);
3913   fprintf (stderr, _("%s: Error: "), program_name);
3914   vfprintf (stderr, message, args);
3915   va_end (args);
3916 }
3917
3918 void
3919 warn (const char *message, ...)
3920 {
3921   va_list args;
3922
3923   va_start (args, message);
3924   fprintf (stderr, _("%s: Warning: "), program_name);
3925   vfprintf (stderr, message, args);
3926   va_end (args);
3927 }
3928
3929 void
3930 free_debug_memory (void)
3931 {
3932   enum dwarf_section_display_enum i;
3933
3934   free_abbrevs ();
3935
3936   for (i = 0; i < max; i++)
3937     free_debug_section (i);
3938
3939   if (debug_information)
3940     {
3941       for (i = 0; i < num_debug_info_entries; i++)
3942         {
3943           if (!debug_information [i].max_loc_offsets)
3944             {
3945               free (debug_information [i].loc_offsets);
3946               free (debug_information [i].have_frame_base);
3947             }
3948           if (!debug_information [i].max_range_lists)
3949             free (debug_information [i].range_lists);
3950         }
3951       free (debug_information);
3952       debug_information = NULL;
3953       num_debug_info_entries = 0;
3954     }
3955
3956 }
3957
3958 struct dwarf_section_display debug_displays[] =
3959 {
3960   { { ".debug_abbrev",          NULL,   0,      0 },
3961     display_debug_abbrev,               0,      0 },
3962   { { ".debug_aranges",         NULL,   0,      0 },
3963     display_debug_aranges,              0,      0 },
3964   { { ".debug_frame",           NULL,   0,      0 },
3965     display_debug_frames,               1,      0 },
3966   { { ".debug_info",            NULL,   0,      0 },
3967     display_debug_info,                 1,      0 },
3968   { { ".debug_line",            NULL,   0,      0 },
3969     display_debug_lines,                0,      0 },
3970   { { ".debug_pubnames",        NULL,   0,      0 },
3971     display_debug_pubnames,             0,      0 },
3972   { { ".eh_frame",              NULL,   0,      0 },
3973     display_debug_frames,               1,      1 },
3974   { { ".debug_macinfo",         NULL,   0,      0 },
3975     display_debug_macinfo,              0,      0 },
3976   { { ".debug_str",             NULL,   0,      0 },
3977     display_debug_str,                  0,      0 },
3978   { { ".debug_loc",             NULL,   0,      0 },
3979     display_debug_loc,                  0,      0 },
3980   { { ".debug_pubtypes",        NULL,   0,      0 },
3981     display_debug_pubnames,             0,      0 },
3982   { { ".debug_ranges",          NULL,   0,      0 },
3983     display_debug_ranges,               0,      0 },
3984   { { ".debug_static_func",     NULL,   0,      0 },
3985     display_debug_not_supported,        0,      0 },
3986   { { ".debug_static_vars",     NULL,   0,      0 },
3987     display_debug_not_supported,        0,      0 },
3988   { { ".debug_types",           NULL,   0,      0 },
3989     display_debug_not_supported,        0,      0 },
3990   { { ".debug_weaknames",       NULL,   0,      0 },
3991     display_debug_not_supported,        0,      0 }
3992 };