binutils/dwarf.c

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