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 {
1017   unsigned long uvalue = 0;
1018   unsigned char *block_start = NULL;
1019   unsigned int bytes_read;
1020
1021   switch (form)
1022     {
1023     default:
1024       break;
1025
1026     case DW_FORM_ref_addr:
1027       if (dwarf_version == 2)
1028         {
1029           uvalue = byte_get (data, pointer_size);
1030           data += pointer_size;
1031         }
1032       else if (dwarf_version == 3)
1033         {
1034           uvalue = byte_get (data, offset_size);
1035           data += offset_size;
1036         }
1037       else
1038         {
1039           error (_("Internal error: DWARF version is not 2 or 3.\n"));
1040         }
1041       break;
1042
1043     case DW_FORM_addr:
1044       uvalue = byte_get (data, pointer_size);
1045       data += pointer_size;
1046       break;
1047
1048     case DW_FORM_strp:
1049       uvalue = byte_get (data, offset_size);
1050       data += offset_size;
1051       break;
1052
1053     case DW_FORM_ref1:
1054     case DW_FORM_flag:
1055     case DW_FORM_data1:
1056       uvalue = byte_get (data++, 1);
1057       break;
1058
1059     case DW_FORM_ref2:
1060     case DW_FORM_data2:
1061       uvalue = byte_get (data, 2);
1062       data += 2;
1063       break;
1064
1065     case DW_FORM_ref4:
1066     case DW_FORM_data4:
1067       uvalue = byte_get (data, 4);
1068       data += 4;
1069       break;
1070
1071     case DW_FORM_sdata:
1072       uvalue = read_leb128 (data, & bytes_read, 1);
1073       data += bytes_read;
1074       break;
1075
1076     case DW_FORM_ref_udata:
1077     case DW_FORM_udata:
1078       uvalue = read_leb128 (data, & bytes_read, 0);
1079       data += bytes_read;
1080       break;
1081
1082     case DW_FORM_indirect:
1083       form = read_leb128 (data, & bytes_read, 0);
1084       data += bytes_read;
1085       if (!do_loc)
1086         printf (" %s", get_FORM_name (form));
1087       return read_and_display_attr_value (attribute, form, data,
1088                                           cu_offset, pointer_size,
1089                                           offset_size, dwarf_version,
1090                                           debug_info_p, do_loc);
1091     }
1092
1093   switch (form)
1094     {
1095     case DW_FORM_ref_addr:
1096       if (!do_loc)
1097         printf (" <#%lx>", uvalue);
1098       break;
1099
1100     case DW_FORM_ref1:
1101     case DW_FORM_ref2:
1102     case DW_FORM_ref4:
1103     case DW_FORM_ref_udata:
1104       if (!do_loc)
1105         printf (" <%lx>", uvalue + cu_offset);
1106       break;
1107
1108     case DW_FORM_data4:
1109     case DW_FORM_addr:
1110       if (!do_loc)
1111         printf (" %#lx", uvalue);
1112       break;
1113
1114     case DW_FORM_flag:
1115     case DW_FORM_data1:
1116     case DW_FORM_data2:
1117     case DW_FORM_sdata:
1118     case DW_FORM_udata:
1119       if (!do_loc)
1120         printf (" %ld", uvalue);
1121       break;
1122
1123     case DW_FORM_ref8:
1124     case DW_FORM_data8:
1125       if (!do_loc)
1126         {
1127           uvalue = byte_get (data, 4);
1128           printf (" %lx", uvalue);
1129           printf (" %lx", (unsigned long) byte_get (data + 4, 4));
1130         }
1131       if ((do_loc || do_debug_loc || do_debug_ranges)
1132           && num_debug_info_entries == 0)
1133         {
1134           if (sizeof (uvalue) == 8)
1135             uvalue = byte_get (data, 8);
1136           else
1137             error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1138         }
1139       data += 8;
1140       break;
1141
1142     case DW_FORM_string:
1143       if (!do_loc)
1144         printf (" %s", data);
1145       data += strlen ((char *) data) + 1;
1146       break;
1147
1148     case DW_FORM_block:
1149       uvalue = read_leb128 (data, & bytes_read, 0);
1150       block_start = data + bytes_read;
1151       if (do_loc)
1152         data = block_start + uvalue;
1153       else
1154         data = display_block (block_start, uvalue);
1155       break;
1156
1157     case DW_FORM_block1:
1158       uvalue = byte_get (data, 1);
1159       block_start = data + 1;
1160       if (do_loc)
1161         data = block_start + uvalue;
1162       else
1163         data = display_block (block_start, uvalue);
1164       break;
1165
1166     case DW_FORM_block2:
1167       uvalue = byte_get (data, 2);
1168       block_start = data + 2;
1169       if (do_loc)
1170         data = block_start + uvalue;
1171       else
1172         data = display_block (block_start, uvalue);
1173       break;
1174
1175     case DW_FORM_block4:
1176       uvalue = byte_get (data, 4);
1177       block_start = data + 4;
1178       if (do_loc)
1179         data = block_start + uvalue;
1180       else
1181         data = display_block (block_start, uvalue);
1182       break;
1183
1184     case DW_FORM_strp:
1185       if (!do_loc)
1186         printf (_(" (indirect string, offset: 0x%lx): %s"),
1187                 uvalue, fetch_indirect_string (uvalue));
1188       break;
1189
1190     case DW_FORM_indirect:
1191       /* Handled above.  */
1192       break;
1193
1194     default:
1195       warn (_("Unrecognized form: %lu\n"), form);
1196       break;
1197     }
1198
1199   /* For some attributes we can display further information.  */
1200   if ((do_loc || do_debug_loc || do_debug_ranges)
1201       && num_debug_info_entries == 0)
1202     {
1203       switch (attribute)
1204         {
1205         case DW_AT_frame_base:
1206           have_frame_base = 1;
1207         case DW_AT_location:
1208         case DW_AT_string_length:
1209         case DW_AT_return_addr:
1210         case DW_AT_data_member_location:
1211         case DW_AT_vtable_elem_location:
1212         case DW_AT_segment:
1213         case DW_AT_static_link:
1214         case DW_AT_use_location:
1215           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1216             {
1217               /* Process location list.  */
1218               unsigned int max = debug_info_p->max_loc_offsets;
1219               unsigned int num = debug_info_p->num_loc_offsets;
1220
1221               if (max == 0 || num >= max)
1222                 {
1223                   max += 1024;
1224                   debug_info_p->loc_offsets
1225                     = xcrealloc (debug_info_p->loc_offsets,
1226                                  max, sizeof (*debug_info_p->loc_offsets));
1227                   debug_info_p->have_frame_base
1228                     = xcrealloc (debug_info_p->have_frame_base,
1229                                  max, sizeof (*debug_info_p->have_frame_base));
1230                   debug_info_p->max_loc_offsets = max;
1231                 }
1232               debug_info_p->loc_offsets [num] = uvalue;
1233               debug_info_p->have_frame_base [num] = have_frame_base;
1234               debug_info_p->num_loc_offsets++;
1235             }
1236           break;
1237
1238         case DW_AT_low_pc:
1239           if (need_base_address)
1240             debug_info_p->base_address = uvalue;
1241           break;
1242
1243         case DW_AT_ranges:
1244           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1245             {
1246               /* Process range list.  */
1247               unsigned int max = debug_info_p->max_range_lists;
1248               unsigned int num = debug_info_p->num_range_lists;
1249
1250               if (max == 0 || num >= max)
1251                 {
1252                   max += 1024;
1253                   debug_info_p->range_lists
1254                     = xcrealloc (debug_info_p->range_lists,
1255                                  max, sizeof (*debug_info_p->range_lists));
1256                   debug_info_p->max_range_lists = max;
1257                 }
1258               debug_info_p->range_lists [num] = uvalue;
1259               debug_info_p->num_range_lists++;
1260             }
1261           break;
1262
1263         default:
1264           break;
1265         }
1266     }
1267
1268   if (do_loc)
1269     return data;
1270
1271   printf ("\t");
1272
1273   switch (attribute)
1274     {
1275     case DW_AT_inline:
1276       switch (uvalue)
1277         {
1278         case DW_INL_not_inlined:
1279           printf (_("(not inlined)"));
1280           break;
1281         case DW_INL_inlined:
1282           printf (_("(inlined)"));
1283           break;
1284         case DW_INL_declared_not_inlined:
1285           printf (_("(declared as inline but ignored)"));
1286           break;
1287         case DW_INL_declared_inlined:
1288           printf (_("(declared as inline and inlined)"));
1289           break;
1290         default:
1291           printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
1292           break;
1293         }
1294       break;
1295
1296     case DW_AT_language:
1297       switch (uvalue)
1298         {
1299           /* Ordered by the numeric value of these constants.  */
1300         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1301         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1302         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1303         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1304         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1305         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1306         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1307         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1308         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1309         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1310           /* DWARF 2.1 values.  */
1311         case DW_LANG_Java:              printf ("(Java)"); break;
1312         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1313         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1314         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1315           /* DWARF 3 values.  */
1316         case DW_LANG_PLI:               printf ("(PLI)"); break;
1317         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1318         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1319         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1320         case DW_LANG_D:                 printf ("(D)"); break;
1321           /* MIPS extension.  */
1322         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1323           /* UPC extension.  */
1324         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1325         default:
1326           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1327             printf ("(implementation defined: %lx)", uvalue);
1328           else
1329             printf ("(Unknown: %lx)", uvalue);
1330           break;
1331         }
1332       break;
1333
1334     case DW_AT_encoding:
1335       switch (uvalue)
1336         {
1337         case DW_ATE_void:               printf ("(void)"); break;
1338         case DW_ATE_address:            printf ("(machine address)"); break;
1339         case DW_ATE_boolean:            printf ("(boolean)"); break;
1340         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1341         case DW_ATE_float:              printf ("(float)"); break;
1342         case DW_ATE_signed:             printf ("(signed)"); break;
1343         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1344         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1345         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1346           /* DWARF 2.1 values:  */
1347         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1348         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1349           /* DWARF 3 values:  */
1350         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1351         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1352         case DW_ATE_edited:             printf ("(edited)"); break;
1353         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1354         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1355           /* HP extensions:  */
1356         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1357         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1358         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1359         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1360         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1361         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1362         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1363
1364         default:
1365           if (uvalue >= DW_ATE_lo_user
1366               && uvalue <= DW_ATE_hi_user)
1367             printf ("(user defined type)");
1368           else
1369             printf ("(unknown type)");
1370           break;
1371         }
1372       break;
1373
1374     case DW_AT_accessibility:
1375       switch (uvalue)
1376         {
1377         case DW_ACCESS_public:          printf ("(public)"); break;
1378         case DW_ACCESS_protected:       printf ("(protected)"); break;
1379         case DW_ACCESS_private:         printf ("(private)"); break;
1380         default:
1381           printf ("(unknown accessibility)");
1382           break;
1383         }
1384       break;
1385
1386     case DW_AT_visibility:
1387       switch (uvalue)
1388         {
1389         case DW_VIS_local:              printf ("(local)"); break;
1390         case DW_VIS_exported:           printf ("(exported)"); break;
1391         case DW_VIS_qualified:          printf ("(qualified)"); break;
1392         default:                        printf ("(unknown visibility)"); break;
1393         }
1394       break;
1395
1396     case DW_AT_virtuality:
1397       switch (uvalue)
1398         {
1399         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1400         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1401         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1402         default:                        printf ("(unknown virtuality)"); break;
1403         }
1404       break;
1405
1406     case DW_AT_identifier_case:
1407       switch (uvalue)
1408         {
1409         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1410         case DW_ID_up_case:             printf ("(up_case)"); break;
1411         case DW_ID_down_case:           printf ("(down_case)"); break;
1412         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1413         default:                        printf ("(unknown case)"); break;
1414         }
1415       break;
1416
1417     case DW_AT_calling_convention:
1418       switch (uvalue)
1419         {
1420         case DW_CC_normal:      printf ("(normal)"); break;
1421         case DW_CC_program:     printf ("(program)"); break;
1422         case DW_CC_nocall:      printf ("(nocall)"); break;
1423         default:
1424           if (uvalue >= DW_CC_lo_user
1425               && uvalue <= DW_CC_hi_user)
1426             printf ("(user defined)");
1427           else
1428             printf ("(unknown convention)");
1429         }
1430       break;
1431
1432     case DW_AT_ordering:
1433       switch (uvalue)
1434         {
1435         case -1: printf ("(undefined)"); break;
1436         case 0:  printf ("(row major)"); break;
1437         case 1:  printf ("(column major)"); break;
1438         }
1439       break;
1440
1441     case DW_AT_frame_base:
1442       have_frame_base = 1;
1443     case DW_AT_location:
1444     case DW_AT_string_length:
1445     case DW_AT_return_addr:
1446     case DW_AT_data_member_location:
1447     case DW_AT_vtable_elem_location:
1448     case DW_AT_segment:
1449     case DW_AT_static_link:
1450     case DW_AT_use_location:
1451       if (form == DW_FORM_data4 || form == DW_FORM_data8)
1452         printf (_("(location list)"));
1453       /* Fall through.  */
1454     case DW_AT_allocated:
1455     case DW_AT_associated:
1456     case DW_AT_data_location:
1457     case DW_AT_stride:
1458     case DW_AT_upper_bound:
1459     case DW_AT_lower_bound:
1460       if (block_start)
1461         {
1462           int need_frame_base;
1463
1464           printf ("(");
1465           need_frame_base = decode_location_expression (block_start,
1466                                                         pointer_size,
1467                                                         uvalue,
1468                                                         cu_offset);
1469           printf (")");
1470           if (need_frame_base && !have_frame_base)
1471             printf (_(" [without DW_AT_frame_base]"));
1472         }
1473       break;
1474
1475     default:
1476       break;
1477     }
1478
1479   return data;
1480 }
1481
1482 static char *
1483 get_AT_name (unsigned long attribute)
1484 {
1485   switch (attribute)
1486     {
1487     case DW_AT_sibling:                 return "DW_AT_sibling";
1488     case DW_AT_location:                return "DW_AT_location";
1489     case DW_AT_name:                    return "DW_AT_name";
1490     case DW_AT_ordering:                return "DW_AT_ordering";
1491     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1492     case DW_AT_byte_size:               return "DW_AT_byte_size";
1493     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1494     case DW_AT_bit_size:                return "DW_AT_bit_size";
1495     case DW_AT_element_list:            return "DW_AT_element_list";
1496     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1497     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1498     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1499     case DW_AT_language:                return "DW_AT_language";
1500     case DW_AT_member:                  return "DW_AT_member";
1501     case DW_AT_discr:                   return "DW_AT_discr";
1502     case DW_AT_discr_value:             return "DW_AT_discr_value";
1503     case DW_AT_visibility:              return "DW_AT_visibility";
1504     case DW_AT_import:                  return "DW_AT_import";
1505     case DW_AT_string_length:           return "DW_AT_string_length";
1506     case DW_AT_common_reference:        return "DW_AT_common_reference";
1507     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1508     case DW_AT_const_value:             return "DW_AT_const_value";
1509     case DW_AT_containing_type:         return "DW_AT_containing_type";
1510     case DW_AT_default_value:           return "DW_AT_default_value";
1511     case DW_AT_inline:                  return "DW_AT_inline";
1512     case DW_AT_is_optional:             return "DW_AT_is_optional";
1513     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1514     case DW_AT_producer:                return "DW_AT_producer";
1515     case DW_AT_prototyped:              return "DW_AT_prototyped";
1516     case DW_AT_return_addr:             return "DW_AT_return_addr";
1517     case DW_AT_start_scope:             return "DW_AT_start_scope";
1518     case DW_AT_stride_size:             return "DW_AT_stride_size";
1519     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1520     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1521     case DW_AT_accessibility:           return "DW_AT_accessibility";
1522     case DW_AT_address_class:           return "DW_AT_address_class";
1523     case DW_AT_artificial:              return "DW_AT_artificial";
1524     case DW_AT_base_types:              return "DW_AT_base_types";
1525     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1526     case DW_AT_count:                   return "DW_AT_count";
1527     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1528     case DW_AT_decl_column:             return "DW_AT_decl_column";
1529     case DW_AT_decl_file:               return "DW_AT_decl_file";
1530     case DW_AT_decl_line:               return "DW_AT_decl_line";
1531     case DW_AT_declaration:             return "DW_AT_declaration";
1532     case DW_AT_discr_list:              return "DW_AT_discr_list";
1533     case DW_AT_encoding:                return "DW_AT_encoding";
1534     case DW_AT_external:                return "DW_AT_external";
1535     case DW_AT_frame_base:              return "DW_AT_frame_base";
1536     case DW_AT_friend:                  return "DW_AT_friend";
1537     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1538     case DW_AT_macro_info:              return "DW_AT_macro_info";
1539     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1540     case DW_AT_priority:                return "DW_AT_priority";
1541     case DW_AT_segment:                 return "DW_AT_segment";
1542     case DW_AT_specification:           return "DW_AT_specification";
1543     case DW_AT_static_link:             return "DW_AT_static_link";
1544     case DW_AT_type:                    return "DW_AT_type";
1545     case DW_AT_use_location:            return "DW_AT_use_location";
1546     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1547     case DW_AT_virtuality:              return "DW_AT_virtuality";
1548     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1549       /* DWARF 2.1 values.  */
1550     case DW_AT_allocated:               return "DW_AT_allocated";
1551     case DW_AT_associated:              return "DW_AT_associated";
1552     case DW_AT_data_location:           return "DW_AT_data_location";
1553     case DW_AT_stride:                  return "DW_AT_stride";
1554     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1555     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1556     case DW_AT_extension:               return "DW_AT_extension";
1557     case DW_AT_ranges:                  return "DW_AT_ranges";
1558     case DW_AT_trampoline:              return "DW_AT_trampoline";
1559     case DW_AT_call_column:             return "DW_AT_call_column";
1560     case DW_AT_call_file:               return "DW_AT_call_file";
1561     case DW_AT_call_line:               return "DW_AT_call_line";
1562     case DW_AT_description:             return "DW_AT_description";
1563     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1564     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1565     case DW_AT_small:                   return "DW_AT_small";
1566     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1567     case DW_AT_digit_count:             return "DW_AT_digit_count";
1568     case DW_AT_picture_string:          return "DW_AT_picture_string";
1569     case DW_AT_mutable:                 return "DW_AT_mutable";
1570     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1571     case DW_AT_explicit:                return "DW_AT_explicit";
1572     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1573     case DW_AT_endianity:               return "DW_AT_endianity";
1574     case DW_AT_elemental:               return "DW_AT_elemental";
1575     case DW_AT_pure:                    return "DW_AT_pure";
1576     case DW_AT_recursive:               return "DW_AT_recursive";
1577
1578       /* HP and SGI/MIPS extensions.  */
1579     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1580     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1581     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1582     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1583     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1584     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1585     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1586     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1587     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1588     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1589
1590       /* HP Extensions.  */
1591     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1592     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1593     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1594     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1595     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1596     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1597     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1598     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1599     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1600     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1601     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1602     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1603     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1604
1605       /* One value is shared by the MIPS and HP extensions:  */
1606     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1607
1608       /* GNU extensions.  */
1609     case DW_AT_sf_names:                return "DW_AT_sf_names";
1610     case DW_AT_src_info:                return "DW_AT_src_info";
1611     case DW_AT_mac_info:                return "DW_AT_mac_info";
1612     case DW_AT_src_coords:              return "DW_AT_src_coords";
1613     case DW_AT_body_begin:              return "DW_AT_body_begin";
1614     case DW_AT_body_end:                return "DW_AT_body_end";
1615     case DW_AT_GNU_vector:              return "DW_AT_GNU_vector";
1616
1617       /* UPC extension.  */
1618     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1619
1620     /* PGI (STMicroelectronics) extensions.  */
1621     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1622     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1623     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1624
1625     default:
1626       {
1627         static char buffer[100];
1628
1629         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1630                   attribute);
1631         return buffer;
1632       }
1633     }
1634 }
1635
1636 static unsigned char *
1637 read_and_display_attr (unsigned long attribute,
1638                        unsigned long form,
1639                        unsigned char *data,
1640                        unsigned long cu_offset,
1641                        unsigned long pointer_size,
1642                        unsigned long offset_size,
1643                        int dwarf_version,
1644                        debug_info *debug_info_p,
1645                        int do_loc)
1646 {
1647   if (!do_loc)
1648     printf ("   %-18s:", get_AT_name (attribute));
1649   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1650                                       pointer_size, offset_size,
1651                                       dwarf_version, debug_info_p,
1652                                       do_loc);
1653   if (!do_loc)
1654     printf ("\n");
1655   return data;
1656 }
1657
1658
1659 /* Process the contents of a .debug_info section.  If do_loc is non-zero
1660    then we are scanning for location lists and we do not want to display
1661    anything to the user.  */
1662
1663 static int
1664 process_debug_info (struct dwarf_section *section, void *file,
1665                     int do_loc)
1666 {
1667   unsigned char *start = section->start;
1668   unsigned char *end = start + section->size;
1669   unsigned char *section_begin;
1670   unsigned int unit;
1671   unsigned int num_units = 0;
1672
1673   if ((do_loc || do_debug_loc || do_debug_ranges)
1674       && num_debug_info_entries == 0)
1675     {
1676       unsigned long length;
1677
1678       /* First scan the section to get the number of comp units.  */
1679       for (section_begin = start, num_units = 0; section_begin < end;
1680            num_units ++)
1681         {
1682           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
1683              will be the length.  For a 64-bit DWARF section, it'll be
1684              the escape code 0xffffffff followed by an 8 byte length.  */
1685           length = byte_get (section_begin, 4);
1686
1687           if (length == 0xffffffff)
1688             {
1689               length = byte_get (section_begin + 4, 8);
1690               section_begin += length + 12;
1691             }
1692           else
1693             section_begin += length + 4;
1694
1695           /* Negative values are illegal, they may even cause infinite
1696              looping.  This can happen if we can't accurately apply
1697              relocations to an object file.  */
1698           if ((signed long) length <= 0)
1699             {
1700               warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1701               return 0;
1702             }
1703         }
1704
1705       if (num_units == 0)
1706         {
1707           error (_("No comp units in %s section ?"), section->name);
1708           return 0;
1709         }
1710
1711       /* Then allocate an array to hold the information.  */
1712       debug_information = cmalloc (num_units,
1713                                    sizeof (* debug_information));
1714       if (debug_information == NULL)
1715         {
1716           error (_("Not enough memory for a debug info array of %u entries"),
1717                  num_units);
1718           return 0;
1719         }
1720     }
1721
1722   if (!do_loc)
1723     {
1724       printf (_("The section %s contains:\n\n"), section->name);
1725
1726       load_debug_section (str, file);
1727     }
1728
1729   load_debug_section (abbrev, file);
1730   if (debug_displays [abbrev].section.start == NULL)
1731     {
1732       warn (_("Unable to locate %s section!\n"),
1733             debug_displays [abbrev].section.name);
1734       return 0;
1735     }
1736
1737   for (section_begin = start, unit = 0; start < end; unit++)
1738     {
1739       DWARF2_Internal_CompUnit compunit;
1740       unsigned char *hdrptr;
1741       unsigned char *cu_abbrev_offset_ptr;
1742       unsigned char *tags;
1743       int level;
1744       unsigned long cu_offset;
1745       int offset_size;
1746       int initial_length_size;
1747
1748       hdrptr = start;
1749
1750       compunit.cu_length = byte_get (hdrptr, 4);
1751       hdrptr += 4;
1752
1753       if (compunit.cu_length == 0xffffffff)
1754         {
1755           compunit.cu_length = byte_get (hdrptr, 8);
1756           hdrptr += 8;
1757           offset_size = 8;
1758           initial_length_size = 12;
1759         }
1760       else
1761         {
1762           offset_size = 4;
1763           initial_length_size = 4;
1764         }
1765
1766       compunit.cu_version = byte_get (hdrptr, 2);
1767       hdrptr += 2;
1768
1769       cu_offset = start - section_begin;
1770
1771       cu_abbrev_offset_ptr = hdrptr;
1772       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1773       hdrptr += offset_size;
1774
1775       compunit.cu_pointer_size = byte_get (hdrptr, 1);
1776       hdrptr += 1;
1777       if ((do_loc || do_debug_loc || do_debug_ranges)
1778           && num_debug_info_entries == 0)
1779         {
1780           debug_information [unit].cu_offset = cu_offset;
1781           debug_information [unit].pointer_size
1782             = compunit.cu_pointer_size;
1783           debug_information [unit].base_address = 0;
1784           debug_information [unit].loc_offsets = NULL;
1785           debug_information [unit].have_frame_base = NULL;
1786           debug_information [unit].max_loc_offsets = 0;
1787           debug_information [unit].num_loc_offsets = 0;
1788           debug_information [unit].range_lists = NULL;
1789           debug_information [unit].max_range_lists= 0;
1790           debug_information [unit].num_range_lists = 0;
1791         }
1792
1793       if (!do_loc)
1794         {
1795           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1796           printf (_("   Length:        %ld\n"), compunit.cu_length);
1797           printf (_("   Version:       %d\n"), compunit.cu_version);
1798           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1799           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
1800         }
1801
1802       if (cu_offset + compunit.cu_length + initial_length_size
1803           > section->size)
1804         {
1805           warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"),
1806                 (unsigned long)section->size);
1807           break;
1808         }
1809       tags = hdrptr;
1810       start += compunit.cu_length + initial_length_size;
1811
1812       if (compunit.cu_version != 2 && compunit.cu_version != 3)
1813         {
1814           warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1815           continue;
1816         }
1817
1818       free_abbrevs ();
1819
1820       /* Process the abbrevs used by this compilation unit. DWARF
1821          sections under Mach-O have non-zero addresses.  */
1822       if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1823         warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"),
1824               (unsigned long)debug_displays [abbrev].section.size);
1825       else
1826         process_abbrev_section
1827           ((unsigned char *) debug_displays [abbrev].section.start
1828            + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1829            (unsigned char *) debug_displays [abbrev].section.start
1830            + debug_displays [abbrev].section.size);
1831
1832       level = 0;
1833       while (tags < start)
1834         {
1835           unsigned int bytes_read;
1836           unsigned long abbrev_number;
1837           abbrev_entry *entry;
1838           abbrev_attr *attr;
1839
1840           abbrev_number = read_leb128 (tags, & bytes_read, 0);
1841           tags += bytes_read;
1842
1843           /* A null DIE marks the end of a list of children.  */
1844           if (abbrev_number == 0)
1845             {
1846               --level;
1847               continue;
1848             }
1849
1850           if (!do_loc)
1851             printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1852                     level,
1853                     (unsigned long) (tags - section_begin
1854                                      - bytes_read),
1855                     abbrev_number);
1856
1857           /* Scan through the abbreviation list until we reach the
1858              correct entry.  */
1859           for (entry = first_abbrev;
1860                entry && entry->entry != abbrev_number;
1861                entry = entry->next)
1862             continue;
1863
1864           if (entry == NULL)
1865             {
1866               if (!do_loc)
1867                 {
1868                   printf ("\n");
1869                   fflush (stdout);
1870                 }
1871               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1872                     abbrev_number);
1873               return 0;
1874             }
1875
1876           if (!do_loc)
1877             printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1878
1879           switch (entry->tag)
1880             {
1881             default:
1882               need_base_address = 0;
1883               break;
1884             case DW_TAG_compile_unit:
1885               need_base_address = 1;
1886               break;
1887             case DW_TAG_entry_point:
1888             case DW_TAG_subprogram:
1889               need_base_address = 0;
1890               /* Assuming that there is no DW_AT_frame_base.  */
1891               have_frame_base = 0;
1892               break;
1893             }
1894
1895           for (attr = entry->first_attr; attr; attr = attr->next)
1896             {
1897               if (! do_loc)
1898                 /* Show the offset from where the tag was extracted.  */
1899                 printf ("    <%2lx>", (unsigned long)(tags - section_begin));
1900
1901               tags = read_and_display_attr (attr->attribute,
1902                                             attr->form,
1903                                             tags, cu_offset,
1904                                             compunit.cu_pointer_size,
1905                                             offset_size,
1906                                             compunit.cu_version,
1907                                             &debug_information [unit],
1908                                             do_loc);
1909             }
1910
1911           if (entry->children)
1912             ++level;
1913         }
1914     }
1915
1916   /* Set num_debug_info_entries here so that it can be used to check if
1917      we need to process .debug_loc and .debug_ranges sections.  */
1918   if ((do_loc || do_debug_loc || do_debug_ranges)
1919       && num_debug_info_entries == 0)
1920     num_debug_info_entries = num_units;
1921
1922   if (!do_loc)
1923     {
1924       printf ("\n");
1925     }
1926
1927   return 1;
1928 }
1929
1930 /* Locate and scan the .debug_info section in the file and record the pointer
1931    sizes and offsets for the compilation units in it.  Usually an executable
1932    will have just one pointer size, but this is not guaranteed, and so we try
1933    not to make any assumptions.  Returns zero upon failure, or the number of
1934    compilation units upon success.  */
1935
1936 static unsigned int
1937 load_debug_info (void * file)
1938 {
1939   /* Reset the last pointer size so that we can issue correct error
1940      messages if we are displaying the contents of more than one section.  */
1941   last_pointer_size = 0;
1942   warned_about_missing_comp_units = FALSE;
1943
1944   /* If we already have the information there is nothing else to do.  */
1945   if (num_debug_info_entries > 0)
1946     return num_debug_info_entries;
1947
1948   if (load_debug_section (info, file)
1949       && process_debug_info (&debug_displays [info].section, file, 1))
1950     return num_debug_info_entries;
1951   else
1952     return 0;
1953 }
1954
1955 static int
1956 display_debug_lines (struct dwarf_section *section, void *file)
1957 {
1958   unsigned char *start = section->start;
1959   unsigned char *data = start;
1960   unsigned char *end = start + section->size;
1961
1962   printf (_("\nDump of debug contents of section %s:\n\n"),
1963           section->name);
1964
1965   load_debug_info (file);
1966
1967   while (data < end)
1968     {
1969       DWARF2_Internal_LineInfo info;
1970       unsigned char *standard_opcodes;
1971       unsigned char *end_of_sequence;
1972       unsigned char *hdrptr;
1973       unsigned long hdroff;
1974       int initial_length_size;
1975       int offset_size;
1976       int i;
1977
1978       hdrptr = data;
1979       hdroff = hdrptr - start;
1980
1981       /* Check the length of the block.  */
1982       info.li_length = byte_get (hdrptr, 4);
1983       hdrptr += 4;
1984
1985       if (info.li_length == 0xffffffff)
1986         {
1987           /* This section is 64-bit DWARF 3.  */
1988           info.li_length = byte_get (hdrptr, 8);
1989           hdrptr += 8;
1990           offset_size = 8;
1991           initial_length_size = 12;
1992         }
1993       else
1994         {
1995           offset_size = 4;
1996           initial_length_size = 4;
1997         }
1998
1999       if (info.li_length + initial_length_size > section->size)
2000         {
2001           warn
2002             (_("The line info appears to be corrupt - the section is too small\n"));
2003           return 0;
2004         }
2005
2006       /* Check its version number.  */
2007       info.li_version = byte_get (hdrptr, 2);
2008       hdrptr += 2;
2009       if (info.li_version != 2 && info.li_version != 3)
2010         {
2011           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2012           return 0;
2013         }
2014
2015       info.li_prologue_length = byte_get (hdrptr, offset_size);
2016       hdrptr += offset_size;
2017       info.li_min_insn_length = byte_get (hdrptr, 1);
2018       hdrptr++;
2019       info.li_default_is_stmt = byte_get (hdrptr, 1);
2020       hdrptr++;
2021       info.li_line_base = byte_get (hdrptr, 1);
2022       hdrptr++;
2023       info.li_line_range = byte_get (hdrptr, 1);
2024       hdrptr++;
2025       info.li_opcode_base = byte_get (hdrptr, 1);
2026       hdrptr++;
2027
2028       /* Sign extend the line base field.  */
2029       info.li_line_base <<= 24;
2030       info.li_line_base >>= 24;
2031
2032       printf (_("  Offset:                      0x%lx\n"), hdroff);
2033       printf (_("  Length:                      %ld\n"), info.li_length);
2034       printf (_("  DWARF Version:               %d\n"), info.li_version);
2035       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
2036       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
2037       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
2038       printf (_("  Line Base:                   %d\n"), info.li_line_base);
2039       printf (_("  Line Range:                  %d\n"), info.li_line_range);
2040       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
2041
2042       end_of_sequence = data + info.li_length + initial_length_size;
2043
2044       reset_state_machine (info.li_default_is_stmt);
2045
2046       /* Display the contents of the Opcodes table.  */
2047       standard_opcodes = hdrptr;
2048
2049       printf (_("\n Opcodes:\n"));
2050
2051       for (i = 1; i < info.li_opcode_base; i++)
2052         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2053
2054       /* Display the contents of the Directory table.  */
2055       data = standard_opcodes + info.li_opcode_base - 1;
2056
2057       if (*data == 0)
2058         printf (_("\n The Directory Table is empty.\n"));
2059       else
2060         {
2061           printf (_("\n The Directory Table:\n"));
2062
2063           while (*data != 0)
2064             {
2065               printf (_("  %s\n"), data);
2066
2067               data += strlen ((char *) data) + 1;
2068             }
2069         }
2070
2071       /* Skip the NUL at the end of the table.  */
2072       data++;
2073
2074       /* Display the contents of the File Name table.  */
2075       if (*data == 0)
2076         printf (_("\n The File Name Table is empty.\n"));
2077       else
2078         {
2079           printf (_("\n The File Name Table:\n"));
2080           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2081
2082           while (*data != 0)
2083             {
2084               unsigned char *name;
2085               unsigned int bytes_read;
2086
2087               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
2088               name = data;
2089
2090               data += strlen ((char *) data) + 1;
2091
2092               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2093               data += bytes_read;
2094               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2095               data += bytes_read;
2096               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2097               data += bytes_read;
2098               printf (_("%s\n"), name);
2099             }
2100         }
2101
2102       /* Skip the NUL at the end of the table.  */
2103       data++;
2104
2105       /* Now display the statements.  */
2106       printf (_("\n Line Number Statements:\n"));
2107
2108       while (data < end_of_sequence)
2109         {
2110           unsigned char op_code;
2111           int adv;
2112           unsigned long int uladv;
2113           unsigned int bytes_read;
2114
2115           op_code = *data++;
2116
2117           if (op_code >= info.li_opcode_base)
2118             {
2119               op_code -= info.li_opcode_base;
2120               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2121               state_machine_regs.address += uladv;
2122               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
2123                       op_code, uladv, state_machine_regs.address);
2124               adv = (op_code % info.li_line_range) + info.li_line_base;
2125               state_machine_regs.line += adv;
2126               printf (_(" and Line by %d to %d\n"),
2127                       adv, state_machine_regs.line);
2128             }
2129           else switch (op_code)
2130             {
2131             case DW_LNS_extended_op:
2132               data += process_extended_line_op (data, info.li_default_is_stmt);
2133               break;
2134
2135             case DW_LNS_copy:
2136               printf (_("  Copy\n"));
2137               break;
2138
2139             case DW_LNS_advance_pc:
2140               uladv = read_leb128 (data, & bytes_read, 0);
2141               uladv *= info.li_min_insn_length;
2142               data += bytes_read;
2143               state_machine_regs.address += uladv;
2144               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2145                       state_machine_regs.address);
2146               break;
2147
2148             case DW_LNS_advance_line:
2149               adv = read_leb128 (data, & bytes_read, 1);
2150               data += bytes_read;
2151               state_machine_regs.line += adv;
2152               printf (_("  Advance Line by %d to %d\n"), adv,
2153                       state_machine_regs.line);
2154               break;
2155
2156             case DW_LNS_set_file:
2157               adv = read_leb128 (data, & bytes_read, 0);
2158               data += bytes_read;
2159               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2160                       adv);
2161               state_machine_regs.file = adv;
2162               break;
2163
2164             case DW_LNS_set_column:
2165               uladv = read_leb128 (data, & bytes_read, 0);
2166               data += bytes_read;
2167               printf (_("  Set column to %lu\n"), uladv);
2168               state_machine_regs.column = uladv;
2169               break;
2170
2171             case DW_LNS_negate_stmt:
2172               adv = state_machine_regs.is_stmt;
2173               adv = ! adv;
2174               printf (_("  Set is_stmt to %d\n"), adv);
2175               state_machine_regs.is_stmt = adv;
2176               break;
2177
2178             case DW_LNS_set_basic_block:
2179               printf (_("  Set basic block\n"));
2180               state_machine_regs.basic_block = 1;
2181               break;
2182
2183             case DW_LNS_const_add_pc:
2184               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2185                       * info.li_min_insn_length);
2186               state_machine_regs.address += uladv;
2187               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2188                       state_machine_regs.address);
2189               break;
2190
2191             case DW_LNS_fixed_advance_pc:
2192               uladv = byte_get (data, 2);
2193               data += 2;
2194               state_machine_regs.address += uladv;
2195               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2196                       uladv, state_machine_regs.address);
2197               break;
2198
2199             case DW_LNS_set_prologue_end:
2200               printf (_("  Set prologue_end to true\n"));
2201               break;
2202
2203             case DW_LNS_set_epilogue_begin:
2204               printf (_("  Set epilogue_begin to true\n"));
2205               break;
2206
2207             case DW_LNS_set_isa:
2208               uladv = read_leb128 (data, & bytes_read, 0);
2209               data += bytes_read;
2210               printf (_("  Set ISA to %lu\n"), uladv);
2211               break;
2212
2213             default:
2214               printf (_("  Unknown opcode %d with operands: "), op_code);
2215
2216               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2217                 {
2218                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2219                           i == 1 ? "" : ", ");
2220                   data += bytes_read;
2221                 }
2222               putchar ('\n');
2223               break;
2224             }
2225         }
2226       putchar ('\n');
2227     }
2228
2229   return 1;
2230 }
2231
2232 static int
2233 display_debug_pubnames (struct dwarf_section *section,
2234                         void *file ATTRIBUTE_UNUSED)
2235 {
2236   DWARF2_Internal_PubNames pubnames;
2237   unsigned char *start = section->start;
2238   unsigned char *end = start + section->size;
2239
2240   printf (_("Contents of the %s section:\n\n"), section->name);
2241
2242   while (start < end)
2243     {
2244       unsigned char *data;
2245       unsigned long offset;
2246       int offset_size, initial_length_size;
2247
2248       data = start;
2249
2250       pubnames.pn_length = byte_get (data, 4);
2251       data += 4;
2252       if (pubnames.pn_length == 0xffffffff)
2253         {
2254           pubnames.pn_length = byte_get (data, 8);
2255           data += 8;
2256           offset_size = 8;
2257           initial_length_size = 12;
2258         }
2259       else
2260         {
2261           offset_size = 4;
2262           initial_length_size = 4;
2263         }
2264
2265       pubnames.pn_version = byte_get (data, 2);
2266       data += 2;
2267       pubnames.pn_offset = byte_get (data, offset_size);
2268       data += offset_size;
2269       pubnames.pn_size = byte_get (data, offset_size);
2270       data += offset_size;
2271
2272       start += pubnames.pn_length + initial_length_size;
2273
2274       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2275         {
2276           static int warned = 0;
2277
2278           if (! warned)
2279             {
2280               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2281               warned = 1;
2282             }
2283
2284           continue;
2285         }
2286
2287       printf (_("  Length:                              %ld\n"),
2288               pubnames.pn_length);
2289       printf (_("  Version:                             %d\n"),
2290               pubnames.pn_version);
2291       printf (_("  Offset into .debug_info section:     %ld\n"),
2292               pubnames.pn_offset);
2293       printf (_("  Size of area in .debug_info section: %ld\n"),
2294               pubnames.pn_size);
2295
2296       printf (_("\n    Offset\tName\n"));
2297
2298       do
2299         {
2300           offset = byte_get (data, offset_size);
2301
2302           if (offset != 0)
2303             {
2304               data += offset_size;
2305               printf ("    %-6ld\t\t%s\n", offset, data);
2306               data += strlen ((char *) data) + 1;
2307             }
2308         }
2309       while (offset != 0);
2310     }
2311
2312   printf ("\n");
2313   return 1;
2314 }
2315
2316 static int
2317 display_debug_macinfo (struct dwarf_section *section,
2318                        void *file ATTRIBUTE_UNUSED)
2319 {
2320   unsigned char *start = section->start;
2321   unsigned char *end = start + section->size;
2322   unsigned char *curr = start;
2323   unsigned int bytes_read;
2324   enum dwarf_macinfo_record_type op;
2325
2326   printf (_("Contents of the %s section:\n\n"), section->name);
2327
2328   while (curr < end)
2329     {
2330       unsigned int lineno;
2331       const char *string;
2332
2333       op = *curr;
2334       curr++;
2335
2336       switch (op)
2337         {
2338         case DW_MACINFO_start_file:
2339           {
2340             unsigned int filenum;
2341
2342             lineno = read_leb128 (curr, & bytes_read, 0);
2343             curr += bytes_read;
2344             filenum = read_leb128 (curr, & bytes_read, 0);
2345             curr += bytes_read;
2346
2347             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2348                     lineno, filenum);
2349           }
2350           break;
2351
2352         case DW_MACINFO_end_file:
2353           printf (_(" DW_MACINFO_end_file\n"));
2354           break;
2355
2356         case DW_MACINFO_define:
2357           lineno = read_leb128 (curr, & bytes_read, 0);
2358           curr += bytes_read;
2359           string = (char *) curr;
2360           curr += strlen (string) + 1;
2361           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2362                   lineno, string);
2363           break;
2364
2365         case DW_MACINFO_undef:
2366           lineno = read_leb128 (curr, & bytes_read, 0);
2367           curr += bytes_read;
2368           string = (char *) curr;
2369           curr += strlen (string) + 1;
2370           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2371                   lineno, string);
2372           break;
2373
2374         case DW_MACINFO_vendor_ext:
2375           {
2376             unsigned int constant;
2377
2378             constant = read_leb128 (curr, & bytes_read, 0);
2379             curr += bytes_read;
2380             string = (char *) curr;
2381             curr += strlen (string) + 1;
2382             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2383                     constant, string);
2384           }
2385           break;
2386         }
2387     }
2388
2389   return 1;
2390 }
2391
2392 static int
2393 display_debug_abbrev (struct dwarf_section *section,
2394                       void *file ATTRIBUTE_UNUSED)
2395 {
2396   abbrev_entry *entry;
2397   unsigned char *start = section->start;
2398   unsigned char *end = start + section->size;
2399
2400   printf (_("Contents of the %s section:\n\n"), section->name);
2401
2402   do
2403     {
2404       free_abbrevs ();
2405
2406       start = process_abbrev_section (start, end);
2407
2408       if (first_abbrev == NULL)
2409         continue;
2410
2411       printf (_("  Number TAG\n"));
2412
2413       for (entry = first_abbrev; entry; entry = entry->next)
2414         {
2415           abbrev_attr *attr;
2416
2417           printf (_("   %ld      %s    [%s]\n"),
2418                   entry->entry,
2419                   get_TAG_name (entry->tag),
2420                   entry->children ? _("has children") : _("no children"));
2421
2422           for (attr = entry->first_attr; attr; attr = attr->next)
2423             printf (_("    %-18s %s\n"),
2424                     get_AT_name (attr->attribute),
2425                     get_FORM_name (attr->form));
2426         }
2427     }
2428   while (start);
2429
2430   printf ("\n");
2431
2432   return 1;
2433 }
2434
2435 static int
2436 display_debug_loc (struct dwarf_section *section, void *file)
2437 {
2438   unsigned char *start = section->start;
2439   unsigned char *section_end;
2440   unsigned long bytes;
2441   unsigned char *section_begin = start;
2442   unsigned int num_loc_list = 0;
2443   unsigned long last_offset = 0;
2444   unsigned int first = 0;
2445   unsigned int i;
2446   unsigned int j;
2447   int seen_first_offset = 0;
2448   int use_debug_info = 1;
2449   unsigned char *next;
2450
2451   bytes = section->size;
2452   section_end = start + bytes;
2453
2454   if (bytes == 0)
2455     {
2456       printf (_("\nThe %s section is empty.\n"), section->name);
2457       return 0;
2458     }
2459
2460   load_debug_info (file);
2461
2462   /* Check the order of location list in .debug_info section. If
2463      offsets of location lists are in the ascending order, we can
2464      use `debug_information' directly.  */
2465   for (i = 0; i < num_debug_info_entries; i++)
2466     {
2467       unsigned int num;
2468
2469       num = debug_information [i].num_loc_offsets;
2470       num_loc_list += num;
2471
2472       /* Check if we can use `debug_information' directly.  */
2473       if (use_debug_info && num != 0)
2474         {
2475           if (!seen_first_offset)
2476             {
2477               /* This is the first location list.  */
2478               last_offset = debug_information [i].loc_offsets [0];
2479               first = i;
2480               seen_first_offset = 1;
2481               j = 1;
2482             }
2483           else
2484             j = 0;
2485
2486           for (; j < num; j++)
2487             {
2488               if (last_offset >
2489                   debug_information [i].loc_offsets [j])
2490                 {
2491                   use_debug_info = 0;
2492                   break;
2493                 }
2494               last_offset = debug_information [i].loc_offsets [j];
2495             }
2496         }
2497     }
2498
2499   if (!use_debug_info)
2500     /* FIXME: Should we handle this case?  */
2501     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2502
2503   if (!seen_first_offset)
2504     error (_("No location lists in .debug_info section!\n"));
2505
2506   /* DWARF sections under Mach-O have non-zero addresses.  */
2507   if (debug_information [first].num_loc_offsets > 0
2508       && debug_information [first].loc_offsets [0] != section->address)
2509     warn (_("Location lists in %s section start at 0x%lx\n"),
2510           section->name, debug_information [first].loc_offsets [0]);
2511
2512   printf (_("Contents of the %s section:\n\n"), section->name);
2513   printf (_("    Offset   Begin    End      Expression\n"));
2514
2515   seen_first_offset = 0;
2516   for (i = first; i < num_debug_info_entries; i++)
2517     {
2518       unsigned long begin;
2519       unsigned long end;
2520       unsigned short length;
2521       unsigned long offset;
2522       unsigned int pointer_size;
2523       unsigned long cu_offset;
2524       unsigned long base_address;
2525       int need_frame_base;
2526       int has_frame_base;
2527
2528       pointer_size = debug_information [i].pointer_size;
2529       cu_offset = debug_information [i].cu_offset;
2530
2531       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2532         {
2533           has_frame_base = debug_information [i].have_frame_base [j];
2534           /* DWARF sections under Mach-O have non-zero addresses.  */
2535           offset = debug_information [i].loc_offsets [j] - section->address;
2536           next = section_begin + offset;
2537           base_address = debug_information [i].base_address;
2538
2539           if (!seen_first_offset)
2540             seen_first_offset = 1;
2541           else
2542             {
2543               if (start < next)
2544                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2545                       (long)(start - section_begin), (long)(next - section_begin));
2546               else if (start > next)
2547                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2548                       (long)(start - section_begin), (long)(next - section_begin));
2549             }
2550           start = next;
2551
2552           if (offset >= bytes)
2553             {
2554               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2555                     offset);
2556               continue;
2557             }
2558
2559           while (1)
2560             {
2561               if (start + 2 * pointer_size > section_end)
2562                 {
2563                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2564                         offset);
2565                   break;
2566                 }
2567
2568               begin = byte_get (start, pointer_size);
2569               start += pointer_size;
2570               end = byte_get (start, pointer_size);
2571               start += pointer_size;
2572
2573               if (begin == 0 && end == 0)
2574                 {
2575                   printf (_("    %8.8lx <End of list>\n"), offset);
2576                   break;
2577                 }
2578
2579               /* Check base address specifiers.  */
2580               if (begin == -1UL && end != -1UL)
2581                 {
2582                   base_address = end;
2583                   printf (_("    %8.8lx %8.8lx %8.8lx (base address)\n"),
2584                           offset, begin, end);
2585                   continue;
2586                 }
2587
2588               if (start + 2 > section_end)
2589                 {
2590                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2591                         offset);
2592                   break;
2593                 }
2594
2595               length = byte_get (start, 2);
2596               start += 2;
2597
2598               if (start + length > section_end)
2599                 {
2600                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2601                         offset);
2602                   break;
2603                 }
2604
2605               printf ("    %8.8lx %8.8lx %8.8lx (",
2606                       offset, begin + base_address, end + base_address);
2607               need_frame_base = decode_location_expression (start,
2608                                                             pointer_size,
2609                                                             length,
2610                                                             cu_offset);
2611               putchar (')');
2612
2613               if (need_frame_base && !has_frame_base)
2614                 printf (_(" [without DW_AT_frame_base]"));
2615
2616               if (begin == end)
2617                 fputs (_(" (start == end)"), stdout);
2618               else if (begin > end)
2619                 fputs (_(" (start > end)"), stdout);
2620
2621               putchar ('\n');
2622
2623               start += length;
2624             }
2625         }
2626     }
2627
2628   if (start < section_end)
2629     warn (_("There are %ld unused bytes at the end of section %s\n"),
2630           (long) (section_end - start), section->name);
2631   return 1;
2632 }
2633
2634 static int
2635 display_debug_str (struct dwarf_section *section,
2636                    void *file ATTRIBUTE_UNUSED)
2637 {
2638   unsigned char *start = section->start;
2639   unsigned long bytes = section->size;
2640   dwarf_vma addr = section->address;
2641
2642   if (bytes == 0)
2643     {
2644       printf (_("\nThe %s section is empty.\n"), section->name);
2645       return 0;
2646     }
2647
2648   printf (_("Contents of the %s section:\n\n"), section->name);
2649
2650   while (bytes)
2651     {
2652       int j;
2653       int k;
2654       int lbytes;
2655
2656       lbytes = (bytes > 16 ? 16 : bytes);
2657
2658       printf ("  0x%8.8lx ", (unsigned long) addr);
2659
2660       for (j = 0; j < 16; j++)
2661         {
2662           if (j < lbytes)
2663             printf ("%2.2x", start[j]);
2664           else
2665             printf ("  ");
2666
2667           if ((j & 3) == 3)
2668             printf (" ");
2669         }
2670
2671       for (j = 0; j < lbytes; j++)
2672         {
2673           k = start[j];
2674           if (k >= ' ' && k < 0x80)
2675             printf ("%c", k);
2676           else
2677             printf (".");
2678         }
2679
2680       putchar ('\n');
2681
2682       start += lbytes;
2683       addr  += lbytes;
2684       bytes -= lbytes;
2685     }
2686
2687   putchar ('\n');
2688
2689   return 1;
2690 }
2691
2692 static int
2693 display_debug_info (struct dwarf_section *section, void *file)
2694 {
2695   return process_debug_info (section, file, 0);
2696 }
2697
2698
2699 static int
2700 display_debug_aranges (struct dwarf_section *section,
2701                        void *file ATTRIBUTE_UNUSED)
2702 {
2703   unsigned char *start = section->start;
2704   unsigned char *end = start + section->size;
2705
2706   printf (_("The section %s contains:\n\n"), section->name);
2707
2708   while (start < end)
2709     {
2710       unsigned char *hdrptr;
2711       DWARF2_Internal_ARange arange;
2712       unsigned char *ranges;
2713       unsigned long length;
2714       unsigned long address;
2715       unsigned char address_size;
2716       int excess;
2717       int offset_size;
2718       int initial_length_size;
2719
2720       hdrptr = start;
2721
2722       arange.ar_length = byte_get (hdrptr, 4);
2723       hdrptr += 4;
2724
2725       if (arange.ar_length == 0xffffffff)
2726         {
2727           arange.ar_length = byte_get (hdrptr, 8);
2728           hdrptr += 8;
2729           offset_size = 8;
2730           initial_length_size = 12;
2731         }
2732       else
2733         {
2734           offset_size = 4;
2735           initial_length_size = 4;
2736         }
2737
2738       arange.ar_version = byte_get (hdrptr, 2);
2739       hdrptr += 2;
2740
2741       arange.ar_info_offset = byte_get (hdrptr, offset_size);
2742       hdrptr += offset_size;
2743
2744       arange.ar_pointer_size = byte_get (hdrptr, 1);
2745       hdrptr += 1;
2746
2747       arange.ar_segment_size = byte_get (hdrptr, 1);
2748       hdrptr += 1;
2749
2750       if (arange.ar_version != 2 && arange.ar_version != 3)
2751         {
2752           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2753           break;
2754         }
2755
2756       printf (_("  Length:                   %ld\n"), arange.ar_length);
2757       printf (_("  Version:                  %d\n"), arange.ar_version);
2758       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
2759       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
2760       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
2761
2762       address_size = arange.ar_pointer_size + arange.ar_segment_size;
2763
2764       /* The DWARF spec does not require that the address size be a power
2765          of two, but we do.  This will have to change if we ever encounter
2766          an uneven architecture.  */
2767       if ((address_size & (address_size - 1)) != 0)
2768         {
2769           warn (_("Pointer size + Segment size is not a power of two.\n"));
2770           break;
2771         }
2772
2773       if (address_size > 4)
2774         printf (_("\n    Address            Length\n"));
2775       else
2776         printf (_("\n    Address    Length\n"));
2777
2778       ranges = hdrptr;
2779
2780       /* Must pad to an alignment boundary that is twice the address size.  */
2781       excess = (hdrptr - start) % (2 * address_size);
2782       if (excess)
2783         ranges += (2 * address_size) - excess;
2784
2785       start += arange.ar_length + initial_length_size;
2786
2787       while (ranges + 2 * address_size <= start)
2788         {
2789           address = byte_get (ranges, address_size);
2790
2791           ranges += address_size;
2792
2793           length  = byte_get (ranges, address_size);
2794
2795           ranges += address_size;
2796
2797           if (address_size > 4)
2798             printf ("    0x%16.16lx 0x%lx\n", address, length);
2799           else
2800             printf ("    0x%8.8lx 0x%lx\n", address, length);
2801         }
2802     }
2803
2804   printf ("\n");
2805
2806   return 1;
2807 }
2808
2809 static int
2810 display_debug_ranges (struct dwarf_section *section,
2811                       void *file ATTRIBUTE_UNUSED)
2812 {
2813   unsigned char *start = section->start;
2814   unsigned char *section_end;
2815   unsigned long bytes;
2816   unsigned char *section_begin = start;
2817   unsigned int num_range_list = 0;
2818   unsigned long last_offset = 0;
2819   unsigned int first = 0;
2820   unsigned int i;
2821   unsigned int j;
2822   int seen_first_offset = 0;
2823   int use_debug_info = 1;
2824   unsigned char *next;
2825
2826   bytes = section->size;
2827   section_end = start + bytes;
2828
2829   if (bytes == 0)
2830     {
2831       printf (_("\nThe %s section is empty.\n"), section->name);
2832       return 0;
2833     }
2834
2835   load_debug_info (file);
2836
2837   /* Check the order of range list in .debug_info section. If
2838      offsets of range lists are in the ascending order, we can
2839      use `debug_information' directly.  */
2840   for (i = 0; i < num_debug_info_entries; i++)
2841     {
2842       unsigned int num;
2843
2844       num = debug_information [i].num_range_lists;
2845       num_range_list += num;
2846
2847       /* Check if we can use `debug_information' directly.  */
2848       if (use_debug_info && num != 0)
2849         {
2850           if (!seen_first_offset)
2851             {
2852               /* This is the first range list.  */
2853               last_offset = debug_information [i].range_lists [0];
2854               first = i;
2855               seen_first_offset = 1;
2856               j = 1;
2857             }
2858           else
2859             j = 0;
2860
2861           for (; j < num; j++)
2862             {
2863               if (last_offset >
2864                   debug_information [i].range_lists [j])
2865                 {
2866                   use_debug_info = 0;
2867                   break;
2868                 }
2869               last_offset = debug_information [i].range_lists [j];
2870             }
2871         }
2872     }
2873
2874   if (!use_debug_info)
2875     /* FIXME: Should we handle this case?  */
2876     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2877
2878   if (!seen_first_offset)
2879     error (_("No range lists in .debug_info section!\n"));
2880
2881   /* DWARF sections under Mach-O have non-zero addresses.  */
2882   if (debug_information [first].num_range_lists > 0
2883       && debug_information [first].range_lists [0] != section->address)
2884     warn (_("Range lists in %s section start at 0x%lx\n"),
2885           section->name, debug_information [first].range_lists [0]);
2886
2887   printf (_("Contents of the %s section:\n\n"), section->name);
2888   printf (_("    Offset   Begin    End\n"));
2889
2890   seen_first_offset = 0;
2891   for (i = first; i < num_debug_info_entries; i++)
2892     {
2893       unsigned long begin;
2894       unsigned long end;
2895       unsigned long offset;
2896       unsigned int pointer_size;
2897       unsigned long base_address;
2898
2899       pointer_size = debug_information [i].pointer_size;
2900
2901       for (j = 0; j < debug_information [i].num_range_lists; j++)
2902         {
2903           /* DWARF sections under Mach-O have non-zero addresses.  */
2904           offset = debug_information [i].range_lists [j] - section->address;
2905           next = section_begin + offset;
2906           base_address = debug_information [i].base_address;
2907
2908           if (!seen_first_offset)
2909             seen_first_offset = 1;
2910           else
2911             {
2912               if (start < next)
2913                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2914                       (long)(start - section_begin),
2915                       (long)(next - section_begin), section->name);
2916               else if (start > next)
2917                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2918                       (long)(start - section_begin),
2919                       (long)(next - section_begin), section->name);
2920             }
2921           start = next;
2922
2923           while (1)
2924             {
2925               begin = byte_get (start, pointer_size);
2926               start += pointer_size;
2927               end = byte_get (start, pointer_size);
2928               start += pointer_size;
2929
2930               if (begin == 0 && end == 0)
2931                 {
2932                   printf (_("    %8.8lx <End of list>\n"), offset);
2933                   break;
2934                 }
2935
2936               /* Check base address specifiers.  */
2937               if (begin == -1UL && end != -1UL)
2938                 {
2939                   base_address = end;
2940                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
2941                           offset, begin, end);
2942                   continue;
2943                 }
2944
2945               printf ("    %8.8lx %8.8lx %8.8lx",
2946                       offset, begin + base_address, end + base_address);
2947
2948               if (begin == end)
2949                 fputs (_(" (start == end)"), stdout);
2950               else if (begin > end)
2951                 fputs (_(" (start > end)"), stdout);
2952
2953               putchar ('\n');
2954             }
2955         }
2956     }
2957   putchar ('\n');
2958   return 1;
2959 }
2960
2961 typedef struct Frame_Chunk
2962 {
2963   struct Frame_Chunk *next;
2964   unsigned char *chunk_start;
2965   int ncols;
2966   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
2967   short int *col_type;
2968   int *col_offset;
2969   char *augmentation;
2970   unsigned int code_factor;
2971   int data_factor;
2972   unsigned long pc_begin;
2973   unsigned long pc_range;
2974   int cfa_reg;
2975   int cfa_offset;
2976   int ra;
2977   unsigned char fde_encoding;
2978   unsigned char cfa_exp;
2979 }
2980 Frame_Chunk;
2981
2982 /* A marker for a col_type that means this column was never referenced
2983    in the frame info.  */
2984 #define DW_CFA_unreferenced (-1)
2985
2986 static void
2987 frame_need_space (Frame_Chunk *fc, int reg)
2988 {
2989   int prev = fc->ncols;
2990
2991   if (reg < fc->ncols)
2992     return;
2993
2994   fc->ncols = reg + 1;
2995   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2996   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2997
2998   while (prev < fc->ncols)
2999     {
3000       fc->col_type[prev] = DW_CFA_unreferenced;
3001       fc->col_offset[prev] = 0;
3002       prev++;
3003     }
3004 }
3005
3006 static void
3007 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3008 {
3009   int r;
3010   char tmp[100];
3011
3012   if (*max_regs < fc->ncols)
3013     *max_regs = fc->ncols;
3014
3015   if (*need_col_headers)
3016     {
3017       *need_col_headers = 0;
3018
3019       printf ("   LOC   CFA      ");
3020
3021       for (r = 0; r < *max_regs; r++)
3022         if (fc->col_type[r] != DW_CFA_unreferenced)
3023           {
3024             if (r == fc->ra)
3025               printf ("ra   ");
3026             else
3027               printf ("r%-4d", r);
3028           }
3029
3030       printf ("\n");
3031     }
3032
3033   printf ("%08lx ", fc->pc_begin);
3034   if (fc->cfa_exp)
3035     strcpy (tmp, "exp");
3036   else
3037     sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
3038   printf ("%-8s ", tmp);
3039
3040   for (r = 0; r < fc->ncols; r++)
3041     {
3042       if (fc->col_type[r] != DW_CFA_unreferenced)
3043         {
3044           switch (fc->col_type[r])
3045             {
3046             case DW_CFA_undefined:
3047               strcpy (tmp, "u");
3048               break;
3049             case DW_CFA_same_value:
3050               strcpy (tmp, "s");
3051               break;
3052             case DW_CFA_offset:
3053               sprintf (tmp, "c%+d", fc->col_offset[r]);
3054               break;
3055             case DW_CFA_val_offset:
3056               sprintf (tmp, "v%+d", fc->col_offset[r]);
3057               break;
3058             case DW_CFA_register:
3059               sprintf (tmp, "r%d", fc->col_offset[r]);
3060               break;
3061             case DW_CFA_expression:
3062               strcpy (tmp, "exp");
3063               break;
3064             case DW_CFA_val_expression:
3065               strcpy (tmp, "vexp");
3066               break;
3067             default:
3068               strcpy (tmp, "n/a");
3069               break;
3070             }
3071           printf ("%-5s", tmp);
3072         }
3073     }
3074   printf ("\n");
3075 }
3076
3077 static int
3078 size_of_encoded_value (int encoding)
3079 {
3080   switch (encoding & 0x7)
3081     {
3082     default:    /* ??? */
3083     case 0:     return eh_addr_size;
3084     case 2:     return 2;
3085     case 3:     return 4;
3086     case 4:     return 8;
3087     }
3088 }
3089
3090 static dwarf_vma
3091 get_encoded_value (unsigned char *data, int encoding)
3092 {
3093   int size = size_of_encoded_value (encoding);
3094
3095   if (encoding & DW_EH_PE_signed)
3096     return byte_get_signed (data, size);
3097   else
3098     return byte_get (data, size);
3099 }
3100
3101 #define GET(N)  byte_get (start, N); start += N
3102 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
3103 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
3104
3105 static int
3106 display_debug_frames (struct dwarf_section *section,
3107                       void *file ATTRIBUTE_UNUSED)
3108 {
3109   unsigned char *start = section->start;
3110   unsigned char *end = start + section->size;
3111   unsigned char *section_start = start;
3112   Frame_Chunk *chunks = 0;
3113   Frame_Chunk *remembered_state = 0;
3114   Frame_Chunk *rs;
3115   int is_eh = strcmp (section->name, ".eh_frame") == 0;
3116   unsigned int length_return;
3117   int max_regs = 0;
3118
3119   printf (_("The section %s contains:\n"), section->name);
3120
3121   while (start < end)
3122     {
3123       unsigned char *saved_start;
3124       unsigned char *block_end;
3125       unsigned long length;
3126       unsigned long cie_id;
3127       Frame_Chunk *fc;
3128       Frame_Chunk *cie;
3129       int need_col_headers = 1;
3130       unsigned char *augmentation_data = NULL;
3131       unsigned long augmentation_data_len = 0;
3132       int encoded_ptr_size = eh_addr_size;
3133       int offset_size;
3134       int initial_length_size;
3135
3136       saved_start = start;
3137       length = byte_get (start, 4); start += 4;
3138
3139       if (length == 0)
3140         {
3141           printf ("\n%08lx ZERO terminator\n\n",
3142                     (unsigned long)(saved_start - section_start));
3143           continue;
3144         }
3145
3146       if (length == 0xffffffff)
3147         {
3148           length = byte_get (start, 8);
3149           start += 8;
3150           offset_size = 8;
3151           initial_length_size = 12;
3152         }
3153       else
3154         {
3155           offset_size = 4;
3156           initial_length_size = 4;
3157         }
3158
3159       block_end = saved_start + length + initial_length_size;
3160       if (block_end > end)
3161         {
3162           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3163                 length, (unsigned long)(saved_start - section_start));
3164           block_end = end;
3165         }
3166       cie_id = byte_get (start, offset_size); start += offset_size;
3167
3168       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3169         {
3170           int version;
3171
3172           fc = xmalloc (sizeof (Frame_Chunk));
3173           memset (fc, 0, sizeof (Frame_Chunk));
3174
3175           fc->next = chunks;
3176           chunks = fc;
3177           fc->chunk_start = saved_start;
3178           fc->ncols = 0;
3179           fc->col_type = xmalloc (sizeof (short int));
3180           fc->col_offset = xmalloc (sizeof (int));
3181           frame_need_space (fc, max_regs-1);
3182
3183           version = *start++;
3184
3185           fc->augmentation = (char *) start;
3186           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3187
3188           if (fc->augmentation[0] == 'z')
3189             {
3190               fc->code_factor = LEB ();
3191               fc->data_factor = SLEB ();
3192               if (version == 1)
3193                 {
3194                   fc->ra = GET (1);
3195                 }
3196               else
3197                 {
3198                   fc->ra = LEB ();
3199                 }
3200               augmentation_data_len = LEB ();
3201               augmentation_data = start;
3202               start += augmentation_data_len;
3203             }
3204           else if (strcmp (fc->augmentation, "eh") == 0)
3205             {
3206               start += eh_addr_size;
3207               fc->code_factor = LEB ();
3208               fc->data_factor = SLEB ();
3209               if (version == 1)
3210                 {
3211                   fc->ra = GET (1);
3212                 }
3213               else
3214                 {
3215                   fc->ra = LEB ();
3216                 }
3217             }
3218           else
3219             {
3220               fc->code_factor = LEB ();
3221               fc->data_factor = SLEB ();
3222               if (version == 1)
3223                 {
3224                   fc->ra = GET (1);
3225                 }
3226               else
3227                 {
3228                   fc->ra = LEB ();
3229                 }
3230             }
3231           cie = fc;
3232
3233           if (do_debug_frames_interp)
3234             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3235                     (unsigned long)(saved_start - section_start), length, cie_id,
3236                     fc->augmentation, fc->code_factor, fc->data_factor,
3237                     fc->ra);
3238           else
3239             {
3240               printf ("\n%08lx %08lx %08lx CIE\n",
3241                       (unsigned long)(saved_start - section_start), length, cie_id);
3242               printf ("  Version:               %d\n", version);
3243               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3244               printf ("  Code alignment factor: %u\n", fc->code_factor);
3245               printf ("  Data alignment factor: %d\n", fc->data_factor);
3246               printf ("  Return address column: %d\n", fc->ra);
3247
3248               if (augmentation_data_len)
3249                 {
3250                   unsigned long i;
3251                   printf ("  Augmentation data:    ");
3252                   for (i = 0; i < augmentation_data_len; ++i)
3253                     printf (" %02x", augmentation_data[i]);
3254                   putchar ('\n');
3255                 }
3256               putchar ('\n');
3257             }
3258
3259           if (augmentation_data_len)
3260             {
3261               unsigned char *p, *q;
3262               p = (unsigned char *) fc->augmentation + 1;
3263               q = augmentation_data;
3264
3265               while (1)
3266                 {
3267                   if (*p == 'L')
3268                     q++;
3269                   else if (*p == 'P')
3270                     q += 1 + size_of_encoded_value (*q);
3271                   else if (*p == 'R')
3272                     fc->fde_encoding = *q++;
3273                   else
3274                     break;
3275                   p++;
3276                 }
3277
3278               if (fc->fde_encoding)
3279                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3280             }
3281
3282           frame_need_space (fc, fc->ra);
3283         }
3284       else
3285         {
3286           unsigned char *look_for;
3287           static Frame_Chunk fde_fc;
3288
3289           fc = & fde_fc;
3290           memset (fc, 0, sizeof (Frame_Chunk));
3291
3292           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3293
3294           for (cie = chunks; cie ; cie = cie->next)
3295             if (cie->chunk_start == look_for)
3296               break;
3297
3298           if (!cie)
3299             {
3300               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3301                     cie_id, (unsigned long)(saved_start - section_start));
3302               fc->ncols = 0;
3303               fc->col_type = xmalloc (sizeof (short int));
3304               fc->col_offset = xmalloc (sizeof (int));
3305               frame_need_space (fc, max_regs - 1);
3306               cie = fc;
3307               fc->augmentation = "";
3308               fc->fde_encoding = 0;
3309             }
3310           else
3311             {
3312               fc->ncols = cie->ncols;
3313               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3314               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3315               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3316               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3317               fc->augmentation = cie->augmentation;
3318               fc->code_factor = cie->code_factor;
3319               fc->data_factor = cie->data_factor;
3320               fc->cfa_reg = cie->cfa_reg;
3321               fc->cfa_offset = cie->cfa_offset;
3322               fc->ra = cie->ra;
3323               frame_need_space (fc, max_regs-1);
3324               fc->fde_encoding = cie->fde_encoding;
3325             }
3326
3327           if (fc->fde_encoding)
3328             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3329
3330           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3331           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3332             fc->pc_begin += section->address + (start - section_start);
3333           start += encoded_ptr_size;
3334           fc->pc_range = byte_get (start, encoded_ptr_size);
3335           start += encoded_ptr_size;
3336
3337           if (cie->augmentation[0] == 'z')
3338             {
3339               augmentation_data_len = LEB ();
3340               augmentation_data = start;
3341               start += augmentation_data_len;
3342             }
3343
3344           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3345                   (unsigned long)(saved_start - section_start), length, cie_id,
3346                   (unsigned long)(cie->chunk_start - section_start),
3347                   fc->pc_begin, fc->pc_begin + fc->pc_range);
3348           if (! do_debug_frames_interp && augmentation_data_len)
3349             {
3350               unsigned long i;
3351
3352               printf ("  Augmentation data:    ");
3353               for (i = 0; i < augmentation_data_len; ++i)
3354                 printf (" %02x", augmentation_data[i]);
3355               putchar ('\n');
3356               putchar ('\n');
3357             }
3358         }
3359
3360       /* At this point, fc is the current chunk, cie (if any) is set, and
3361          we're about to interpret instructions for the chunk.  */
3362       /* ??? At present we need to do this always, since this sizes the
3363          fc->col_type and fc->col_offset arrays, which we write into always.
3364          We should probably split the interpreted and non-interpreted bits
3365          into two different routines, since there's so much that doesn't
3366          really overlap between them.  */
3367       if (1 || do_debug_frames_interp)
3368         {
3369           /* Start by making a pass over the chunk, allocating storage
3370              and taking note of what registers are used.  */
3371           unsigned char *tmp = start;
3372
3373           while (start < block_end)
3374             {
3375               unsigned op, opa;
3376               unsigned long reg, tmp;
3377
3378               op = *start++;
3379               opa = op & 0x3f;
3380               if (op & 0xc0)
3381                 op &= 0xc0;
3382
3383               /* Warning: if you add any more cases to this switch, be
3384                  sure to add them to the corresponding switch below.  */
3385               switch (op)
3386                 {
3387                 case DW_CFA_advance_loc:
3388                   break;
3389                 case DW_CFA_offset:
3390                   LEB ();
3391                   frame_need_space (fc, opa);
3392                   fc->col_type[opa] = DW_CFA_undefined;
3393                   break;
3394                 case DW_CFA_restore:
3395                   frame_need_space (fc, opa);
3396                   fc->col_type[opa] = DW_CFA_undefined;
3397                   break;
3398                 case DW_CFA_set_loc:
3399                   start += encoded_ptr_size;
3400                   break;
3401                 case DW_CFA_advance_loc1:
3402                   start += 1;
3403                   break;
3404                 case DW_CFA_advance_loc2:
3405                   start += 2;
3406                   break;
3407                 case DW_CFA_advance_loc4:
3408                   start += 4;
3409                   break;
3410                 case DW_CFA_offset_extended:
3411                 case DW_CFA_val_offset:
3412                   reg = LEB (); LEB ();
3413                   frame_need_space (fc, reg);
3414                   fc->col_type[reg] = DW_CFA_undefined;
3415                   break;
3416                 case DW_CFA_restore_extended:
3417                   reg = LEB ();
3418                   frame_need_space (fc, reg);
3419                   fc->col_type[reg] = DW_CFA_undefined;
3420                   break;
3421                 case DW_CFA_undefined:
3422                   reg = LEB ();
3423                   frame_need_space (fc, reg);
3424                   fc->col_type[reg] = DW_CFA_undefined;
3425                   break;
3426                 case DW_CFA_same_value:
3427                   reg = LEB ();
3428                   frame_need_space (fc, reg);
3429                   fc->col_type[reg] = DW_CFA_undefined;
3430                   break;
3431                 case DW_CFA_register:
3432                   reg = LEB (); LEB ();
3433                   frame_need_space (fc, reg);
3434                   fc->col_type[reg] = DW_CFA_undefined;
3435                   break;
3436                 case DW_CFA_def_cfa:
3437                   LEB (); LEB ();
3438                   break;
3439                 case DW_CFA_def_cfa_register:
3440                   LEB ();
3441                   break;
3442                 case DW_CFA_def_cfa_offset:
3443                   LEB ();
3444                   break;
3445                 case DW_CFA_def_cfa_expression:
3446                   tmp = LEB ();
3447                   start += tmp;
3448                   break;
3449                 case DW_CFA_expression:
3450                 case DW_CFA_val_expression:
3451                   reg = LEB ();
3452                   tmp = LEB ();
3453                   start += tmp;
3454                   frame_need_space (fc, reg);
3455                   fc->col_type[reg] = DW_CFA_undefined;
3456                   break;
3457                 case DW_CFA_offset_extended_sf:
3458                 case DW_CFA_val_offset_sf:
3459                   reg = LEB (); SLEB ();
3460                   frame_need_space (fc, reg);
3461                   fc->col_type[reg] = DW_CFA_undefined;
3462                   break;
3463                 case DW_CFA_def_cfa_sf:
3464                   LEB (); SLEB ();
3465                   break;
3466                 case DW_CFA_def_cfa_offset_sf:
3467                   SLEB ();
3468                   break;
3469                 case DW_CFA_MIPS_advance_loc8:
3470                   start += 8;
3471                   break;
3472                 case DW_CFA_GNU_args_size:
3473                   LEB ();
3474                   break;
3475                 case DW_CFA_GNU_negative_offset_extended:
3476                   reg = LEB (); LEB ();
3477                   frame_need_space (fc, reg);
3478                   fc->col_type[reg] = DW_CFA_undefined;
3479
3480                 default:
3481                   break;
3482                 }
3483             }
3484           start = tmp;
3485         }
3486
3487       /* Now we know what registers are used, make a second pass over
3488          the chunk, this time actually printing out the info.  */
3489
3490       while (start < block_end)
3491         {
3492           unsigned op, opa;
3493           unsigned long ul, reg, roffs;
3494           long l, ofs;
3495           dwarf_vma vma;
3496
3497           op = *start++;
3498           opa = op & 0x3f;
3499           if (op & 0xc0)
3500             op &= 0xc0;
3501
3502           /* Warning: if you add any more cases to this switch, be
3503              sure to add them to the corresponding switch above.  */
3504           switch (op)
3505             {
3506             case DW_CFA_advance_loc:
3507               if (do_debug_frames_interp)
3508                 frame_display_row (fc, &need_col_headers, &max_regs);
3509               else
3510                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
3511                         opa * fc->code_factor,
3512                         fc->pc_begin + opa * fc->code_factor);
3513               fc->pc_begin += opa * fc->code_factor;
3514               break;
3515
3516             case DW_CFA_offset:
3517               roffs = LEB ();
3518               if (! do_debug_frames_interp)
3519                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
3520                         opa, roffs * fc->data_factor);
3521               fc->col_type[opa] = DW_CFA_offset;
3522               fc->col_offset[opa] = roffs * fc->data_factor;
3523               break;
3524
3525             case DW_CFA_restore:
3526               if (! do_debug_frames_interp)
3527                 printf ("  DW_CFA_restore: r%d\n", opa);
3528               fc->col_type[opa] = cie->col_type[opa];
3529               fc->col_offset[opa] = cie->col_offset[opa];
3530               break;
3531
3532             case DW_CFA_set_loc:
3533               vma = get_encoded_value (start, fc->fde_encoding);
3534               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
3535                 vma += section->address + (start - section_start);
3536               start += encoded_ptr_size;
3537               if (do_debug_frames_interp)
3538                 frame_display_row (fc, &need_col_headers, &max_regs);
3539               else
3540                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3541               fc->pc_begin = vma;
3542               break;
3543
3544             case DW_CFA_advance_loc1:
3545               ofs = byte_get (start, 1); start += 1;
3546               if (do_debug_frames_interp)
3547                 frame_display_row (fc, &need_col_headers, &max_regs);
3548               else
3549                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
3550                         ofs * fc->code_factor,
3551                         fc->pc_begin + ofs * fc->code_factor);
3552               fc->pc_begin += ofs * fc->code_factor;
3553               break;
3554
3555             case DW_CFA_advance_loc2:
3556               ofs = byte_get (start, 2); start += 2;
3557               if (do_debug_frames_interp)
3558                 frame_display_row (fc, &need_col_headers, &max_regs);
3559               else
3560                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
3561                         ofs * fc->code_factor,
3562                         fc->pc_begin + ofs * fc->code_factor);
3563               fc->pc_begin += ofs * fc->code_factor;
3564               break;
3565
3566             case DW_CFA_advance_loc4:
3567               ofs = byte_get (start, 4); start += 4;
3568               if (do_debug_frames_interp)
3569                 frame_display_row (fc, &need_col_headers, &max_regs);
3570               else
3571                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
3572                         ofs * fc->code_factor,
3573                         fc->pc_begin + ofs * fc->code_factor);
3574               fc->pc_begin += ofs * fc->code_factor;
3575               break;
3576
3577             case DW_CFA_offset_extended:
3578               reg = LEB ();
3579               roffs = LEB ();
3580               if (! do_debug_frames_interp)
3581                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3582                         reg, roffs * fc->data_factor);
3583               fc->col_type[reg] = DW_CFA_offset;
3584               fc->col_offset[reg] = roffs * fc->data_factor;
3585               break;
3586
3587             case DW_CFA_val_offset:
3588               reg = LEB ();
3589               roffs = LEB ();
3590               if (! do_debug_frames_interp)
3591                 printf ("  DW_CFA_val_offset: r%ld at cfa%+ld\n",
3592                         reg, roffs * fc->data_factor);
3593               fc->col_type[reg] = DW_CFA_val_offset;
3594               fc->col_offset[reg] = roffs * fc->data_factor;
3595               break;
3596
3597             case DW_CFA_restore_extended:
3598               reg = LEB ();
3599               if (! do_debug_frames_interp)
3600                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
3601               fc->col_type[reg] = cie->col_type[reg];
3602               fc->col_offset[reg] = cie->col_offset[reg];
3603               break;
3604
3605             case DW_CFA_undefined:
3606               reg = LEB ();
3607               if (! do_debug_frames_interp)
3608                 printf ("  DW_CFA_undefined: r%ld\n", reg);
3609               fc->col_type[reg] = DW_CFA_undefined;
3610               fc->col_offset[reg] = 0;
3611               break;
3612
3613             case DW_CFA_same_value:
3614               reg = LEB ();
3615               if (! do_debug_frames_interp)
3616                 printf ("  DW_CFA_same_value: r%ld\n", reg);
3617               fc->col_type[reg] = DW_CFA_same_value;
3618               fc->col_offset[reg] = 0;
3619               break;
3620
3621             case DW_CFA_register:
3622               reg = LEB ();
3623               roffs = LEB ();
3624               if (! do_debug_frames_interp)
3625                 printf ("  DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3626               fc->col_type[reg] = DW_CFA_register;
3627               fc->col_offset[reg] = roffs;
3628               break;
3629
3630             case DW_CFA_remember_state:
3631               if (! do_debug_frames_interp)
3632                 printf ("  DW_CFA_remember_state\n");
3633               rs = xmalloc (sizeof (Frame_Chunk));
3634               rs->ncols = fc->ncols;
3635               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3636               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3637               memcpy (rs->col_type, fc->col_type, rs->ncols);
3638               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3639               rs->next = remembered_state;
3640               remembered_state = rs;
3641               break;
3642
3643             case DW_CFA_restore_state:
3644               if (! do_debug_frames_interp)
3645                 printf ("  DW_CFA_restore_state\n");
3646               rs = remembered_state;
3647               if (rs)
3648                 {
3649                   remembered_state = rs->next;
3650                   frame_need_space (fc, rs->ncols-1);
3651                   memcpy (fc->col_type, rs->col_type, rs->ncols);
3652                   memcpy (fc->col_offset, rs->col_offset,
3653                           rs->ncols * sizeof (int));
3654                   free (rs->col_type);
3655                   free (rs->col_offset);
3656                   free (rs);
3657                 }
3658               else if (do_debug_frames_interp)
3659                 printf ("Mismatched DW_CFA_restore_state\n");
3660               break;
3661
3662             case DW_CFA_def_cfa:
3663               fc->cfa_reg = LEB ();
3664               fc->cfa_offset = LEB ();
3665               fc->cfa_exp = 0;
3666               if (! do_debug_frames_interp)
3667                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
3668                         fc->cfa_reg, fc->cfa_offset);
3669               break;
3670
3671             case DW_CFA_def_cfa_register:
3672               fc->cfa_reg = LEB ();
3673               fc->cfa_exp = 0;
3674               if (! do_debug_frames_interp)
3675                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3676               break;
3677
3678             case DW_CFA_def_cfa_offset:
3679               fc->cfa_offset = LEB ();
3680               if (! do_debug_frames_interp)
3681                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3682               break;
3683
3684             case DW_CFA_nop:
3685               if (! do_debug_frames_interp)
3686                 printf ("  DW_CFA_nop\n");
3687               break;
3688
3689             case DW_CFA_def_cfa_expression:
3690               ul = LEB ();
3691               if (! do_debug_frames_interp)
3692                 {
3693                   printf ("  DW_CFA_def_cfa_expression (");
3694                   decode_location_expression (start, eh_addr_size, ul, 0);
3695                   printf (")\n");
3696                 }
3697               fc->cfa_exp = 1;
3698               start += ul;
3699               break;
3700
3701             case DW_CFA_expression:
3702               reg = LEB ();
3703               ul = LEB ();
3704               if (! do_debug_frames_interp)
3705                 {
3706                   printf ("  DW_CFA_expression: r%ld (", reg);
3707                   decode_location_expression (start, eh_addr_size, ul, 0);
3708                   printf (")\n");
3709                 }
3710               fc->col_type[reg] = DW_CFA_expression;
3711               start += ul;
3712               break;
3713
3714             case DW_CFA_val_expression:
3715               reg = LEB ();
3716               ul = LEB ();
3717               if (! do_debug_frames_interp)
3718                 {
3719                   printf ("  DW_CFA_val_expression: r%ld (", reg);
3720                   decode_location_expression (start, eh_addr_size, ul, 0);
3721                   printf (")\n");
3722                 }
3723               fc->col_type[reg] = DW_CFA_val_expression;
3724               start += ul;
3725               break;
3726
3727             case DW_CFA_offset_extended_sf:
3728               reg = LEB ();
3729               l = SLEB ();
3730               frame_need_space (fc, reg);
3731               if (! do_debug_frames_interp)
3732                 printf ("  DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3733                         reg, l * fc->data_factor);
3734               fc->col_type[reg] = DW_CFA_offset;
3735               fc->col_offset[reg] = l * fc->data_factor;
3736               break;
3737
3738             case DW_CFA_val_offset_sf:
3739               reg = LEB ();
3740               l = SLEB ();
3741               frame_need_space (fc, reg);
3742               if (! do_debug_frames_interp)
3743                 printf ("  DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3744                         reg, l * fc->data_factor);
3745               fc->col_type[reg] = DW_CFA_val_offset;
3746               fc->col_offset[reg] = l * fc->data_factor;
3747               break;
3748
3749             case DW_CFA_def_cfa_sf:
3750               fc->cfa_reg = LEB ();
3751               fc->cfa_offset = SLEB ();
3752               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3753               fc->cfa_exp = 0;
3754               if (! do_debug_frames_interp)
3755                 printf ("  DW_CFA_def_cfa_sf: r%d ofs %d\n",
3756                         fc->cfa_reg, fc->cfa_offset);
3757               break;
3758
3759             case DW_CFA_def_cfa_offset_sf:
3760               fc->cfa_offset = SLEB ();
3761               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3762               if (! do_debug_frames_interp)
3763                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3764               break;
3765
3766             case DW_CFA_MIPS_advance_loc8:
3767               ofs = byte_get (start, 8); start += 8;
3768               if (do_debug_frames_interp)
3769                 frame_display_row (fc, &need_col_headers, &max_regs);
3770               else
3771                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3772                         ofs * fc->code_factor,
3773                         fc->pc_begin + ofs * fc->code_factor);
3774               fc->pc_begin += ofs * fc->code_factor;
3775               break;
3776
3777             case DW_CFA_GNU_window_save:
3778               if (! do_debug_frames_interp)
3779                 printf ("  DW_CFA_GNU_window_save\n");
3780               break;
3781
3782             case DW_CFA_GNU_args_size:
3783               ul = LEB ();
3784               if (! do_debug_frames_interp)
3785                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
3786               break;
3787
3788             case DW_CFA_GNU_negative_offset_extended:
3789               reg = LEB ();
3790               l = - LEB ();
3791               frame_need_space (fc, reg);
3792               if (! do_debug_frames_interp)
3793                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3794                         reg, l * fc->data_factor);
3795               fc->col_type[reg] = DW_CFA_offset;
3796               fc->col_offset[reg] = l * fc->data_factor;
3797               break;
3798
3799             default:
3800               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3801                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3802               else
3803                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3804               start = block_end;
3805             }
3806         }
3807
3808       if (do_debug_frames_interp)
3809         frame_display_row (fc, &need_col_headers, &max_regs);
3810
3811       start = block_end;
3812     }
3813
3814   printf ("\n");
3815
3816   return 1;
3817 }
3818
3819 #undef GET
3820 #undef LEB
3821 #undef SLEB
3822
3823 static int
3824 display_debug_not_supported (struct dwarf_section *section,
3825                              void *file ATTRIBUTE_UNUSED)
3826 {
3827   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3828             section->name);
3829
3830   return 1;
3831 }
3832
3833 void *
3834 cmalloc (size_t nmemb, size_t size)
3835 {
3836   /* Check for overflow.  */
3837   if (nmemb >= ~(size_t) 0 / size)
3838     return NULL;
3839   else
3840     return malloc (nmemb * size);
3841 }
3842
3843 void *
3844 xcmalloc (size_t nmemb, size_t size)
3845 {
3846   /* Check for overflow.  */
3847   if (nmemb >= ~(size_t) 0 / size)
3848     return NULL;
3849   else
3850     return xmalloc (nmemb * size);
3851 }
3852
3853 void *
3854 xcrealloc (void *ptr, size_t nmemb, size_t size)
3855 {
3856   /* Check for overflow.  */
3857   if (nmemb >= ~(size_t) 0 / size)
3858     return NULL;
3859   else
3860     return xrealloc (ptr, nmemb * size);
3861 }
3862
3863 void
3864 error (const char *message, ...)
3865 {
3866   va_list args;
3867
3868   va_start (args, message);
3869   fprintf (stderr, _("%s: Error: "), program_name);
3870   vfprintf (stderr, message, args);
3871   va_end (args);
3872 }
3873
3874 void
3875 warn (const char *message, ...)
3876 {
3877   va_list args;
3878
3879   va_start (args, message);
3880   fprintf (stderr, _("%s: Warning: "), program_name);
3881   vfprintf (stderr, message, args);
3882   va_end (args);
3883 }
3884
3885 void
3886 free_debug_memory (void)
3887 {
3888   enum dwarf_section_display_enum i;
3889
3890   free_abbrevs ();
3891
3892   for (i = 0; i < max; i++)
3893     free_debug_section (i);
3894
3895   if (debug_information)
3896     {
3897       for (i = 0; i < num_debug_info_entries; i++)
3898         {
3899           if (!debug_information [i].max_loc_offsets)
3900             {
3901               free (debug_information [i].loc_offsets);
3902               free (debug_information [i].have_frame_base);
3903             }
3904           if (!debug_information [i].max_range_lists)
3905             free (debug_information [i].range_lists);
3906         }
3907       free (debug_information);
3908       debug_information = NULL;
3909       num_debug_info_entries = 0;
3910     }
3911
3912 }
3913
3914 struct dwarf_section_display debug_displays[] =
3915 {
3916   { { ".debug_abbrev",          NULL,   0,      0 },
3917     display_debug_abbrev,               0,      0 },
3918   { { ".debug_aranges",         NULL,   0,      0 },
3919     display_debug_aranges,              0,      0 },
3920   { { ".debug_frame",           NULL,   0,      0 },
3921     display_debug_frames,               1,      0 },
3922   { { ".debug_info",            NULL,   0,      0 },
3923     display_debug_info,                 1,      0 },
3924   { { ".debug_line",            NULL,   0,      0 },
3925     display_debug_lines,                0,      0 },
3926   { { ".debug_pubnames",        NULL,   0,      0 },
3927     display_debug_pubnames,             0,      0 },
3928   { { ".eh_frame",              NULL,   0,      0 },
3929     display_debug_frames,               1,      1 },
3930   { { ".debug_macinfo",         NULL,   0,      0 },
3931     display_debug_macinfo,              0,      0 },
3932   { { ".debug_str",             NULL,   0,      0 },
3933     display_debug_str,                  0,      0 },
3934   { { ".debug_loc",             NULL,   0,      0 },
3935     display_debug_loc,                  0,      0 },
3936   { { ".debug_pubtypes",        NULL,   0,      0 },
3937     display_debug_pubnames,             0,      0 },
3938   { { ".debug_ranges",          NULL,   0,      0 },
3939     display_debug_ranges,               0,      0 },
3940   { { ".debug_static_func",     NULL,   0,      0 },
3941     display_debug_not_supported,        0,      0 },
3942   { { ".debug_static_vars",     NULL,   0,      0 },
3943     display_debug_not_supported,        0,      0 },
3944   { { ".debug_types",           NULL,   0,      0 },
3945     display_debug_not_supported,        0,      0 },
3946   { { ".debug_weaknames",       NULL,   0,      0 },
3947     display_debug_not_supported,        0,      0 }
3948 };