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