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