contrib/binutils/binutils/dwarf.c

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