binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "libiberty.h"
  24 #include "bfd.h"
  25 #include "bucomm.h"
  26 #include "elf/dwarf2.h"
  27 #include "dwarf.h"
  28
  29 static int have_frame_base;
  30 static int need_base_address;
  31
  32 static unsigned int last_pointer_size = 0;
  33 static int warned_about_missing_comp_units = FALSE;
  34
  35 static unsigned int num_debug_info_entries = 0;
  36 static debug_info *debug_information = NULL;
  37
  38 dwarf_vma eh_addr_size;
  39 int is_relocatable;
  40
  41 int do_debug_info;
  42 int do_debug_abbrevs;
  43 int do_debug_lines;
  44 int do_debug_pubnames;
  45 int do_debug_aranges;
  46 int do_debug_ranges;
  47 int do_debug_frames;
  48 int do_debug_frames_interp;
  49 int do_debug_macinfo;
  50 int do_debug_str;
  51 int do_debug_loc;
  52
  53 dwarf_vma (*byte_get) (unsigned char *, int);
  54
  55 dwarf_vma
  56 byte_get_little_endian (unsigned char *field, int size)
  57 {
  58   switch (size)
  59     {
  60     case 1:
  61       return *field;
  62
  63     case 2:
  64       return  ((unsigned int) (field[0]))
  65         |    (((unsigned int) (field[1])) << 8);
  66
  67     case 4:
  68       return  ((unsigned long) (field[0]))
  69         |    (((unsigned long) (field[1])) << 8)
  70         |    (((unsigned long) (field[2])) << 16)
  71         |    (((unsigned long) (field[3])) << 24);
  72
  73     case 8:
  74       if (sizeof (dwarf_vma) == 8)
  75         return  ((dwarf_vma) (field[0]))
  76           |    (((dwarf_vma) (field[1])) << 8)
  77           |    (((dwarf_vma) (field[2])) << 16)
  78           |    (((dwarf_vma) (field[3])) << 24)
  79           |    (((dwarf_vma) (field[4])) << 32)
  80           |    (((dwarf_vma) (field[5])) << 40)
  81           |    (((dwarf_vma) (field[6])) << 48)
  82           |    (((dwarf_vma) (field[7])) << 56);
  83       else if (sizeof (dwarf_vma) == 4)
  84         /* We want to extract data from an 8 byte wide field and
  85            place it into a 4 byte wide field.  Since this is a little
  86            endian source we can just use the 4 byte extraction code.  */
  87         return  ((unsigned long) (field[0]))
  88           |    (((unsigned long) (field[1])) << 8)
  89           |    (((unsigned long) (field[2])) << 16)
  90           |    (((unsigned long) (field[3])) << 24);
  91
  92     default:
  93       error (_("Unhandled data length: %d\n"), size);
  94       abort ();
  95     }
  96 }
  97
  98 dwarf_vma
  99 byte_get_big_endian (unsigned char *field, int size)
 100 {
 101   switch (size)
 102     {
 103     case 1:
 104       return *field;
 105
 106     case 2:
 107       return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 108
 109     case 4:
 110       return ((unsigned long) (field[3]))
 111         |   (((unsigned long) (field[2])) << 8)
 112         |   (((unsigned long) (field[1])) << 16)
 113         |   (((unsigned long) (field[0])) << 24);
 114
 115     case 8:
 116       if (sizeof (dwarf_vma) == 8)
 117         return ((dwarf_vma) (field[7]))
 118           |   (((dwarf_vma) (field[6])) << 8)
 119           |   (((dwarf_vma) (field[5])) << 16)
 120           |   (((dwarf_vma) (field[4])) << 24)
 121           |   (((dwarf_vma) (field[3])) << 32)
 122           |   (((dwarf_vma) (field[2])) << 40)
 123           |   (((dwarf_vma) (field[1])) << 48)
 124           |   (((dwarf_vma) (field[0])) << 56);
 125       else if (sizeof (dwarf_vma) == 4)
 126         {
 127           /* Although we are extracing data from an 8 byte wide field,
 128              we are returning only 4 bytes of data.  */
 129           field += 4;
 130           return ((unsigned long) (field[3]))
 131             |   (((unsigned long) (field[2])) << 8)
 132             |   (((unsigned long) (field[1])) << 16)
 133             |   (((unsigned long) (field[0])) << 24);
 134         }
 135
 136     default:
 137       error (_("Unhandled data length: %d\n"), size);
 138       abort ();
 139     }
 140 }
 141
 142 static dwarf_vma
 143 byte_get_signed (unsigned char *field, int size)
 144 {
 145   dwarf_vma x = byte_get (field, size);
 146
 147   switch (size)
 148     {
 149     case 1:
 150       return (x ^ 0x80) - 0x80;
 151     case 2:
 152       return (x ^ 0x8000) - 0x8000;
 153     case 4:
 154       return (x ^ 0x80000000) - 0x80000000;
 155     case 8:
 156       return x;
 157     default:
 158       abort ();
 159     }
 160 }
 161
 162 static unsigned long int
 163 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
 164 {
 165   unsigned long int result = 0;
 166   unsigned int num_read = 0;
 167   unsigned int shift = 0;
 168   unsigned char byte;
 169
 170   do
 171     {
 172       byte = *data++;
 173       num_read++;
 174
 175       result |= ((unsigned long int) (byte & 0x7f)) << shift;
 176
 177       shift += 7;
 178
 179     }
 180   while (byte & 0x80);
 181
 182   if (length_return != NULL)
 183     *length_return = num_read;
 184
 185   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
 186     result |= -1L << shift;
 187
 188   return result;
 189 }
 190
 191 typedef struct State_Machine_Registers
 192 {
 193   unsigned long address;
 194   unsigned int file;
 195   unsigned int line;
 196   unsigned int column;
 197   int is_stmt;
 198   int basic_block;
 199   int end_sequence;
 200 /* This variable hold the number of the last entry seen
 201    in the File Table.  */
 202   unsigned int last_file_entry;
 203 } SMR;
 204
 205 static SMR state_machine_regs;
 206
 207 static void
 208 reset_state_machine (int is_stmt)
 209 {
 210   state_machine_regs.address = 0;
 211   state_machine_regs.file = 1;
 212   state_machine_regs.line = 1;
 213   state_machine_regs.column = 0;
 214   state_machine_regs.is_stmt = is_stmt;
 215   state_machine_regs.basic_block = 0;
 216   state_machine_regs.end_sequence = 0;
 217   state_machine_regs.last_file_entry = 0;
 218 }
 219
 220 /* Handled an extend line op.
 221    Returns the number of bytes read.  */
 222
 223 static int
 224 process_extended_line_op (unsigned char *data, int is_stmt)
 225 {
 226   unsigned char op_code;
 227   unsigned int bytes_read;
 228   unsigned int len;
 229   unsigned char *name;
 230   unsigned long adr;
 231
 232   len = read_leb128 (data, & bytes_read, 0);
 233   data += bytes_read;
 234
 235   if (len == 0)
 236     {
 237       warn (_("badly formed extended line op encountered!\n"));
 238       return bytes_read;
 239     }
 240
 241   len += bytes_read;
 242   op_code = *data++;
 243
 244   printf (_("  Extended opcode %d: "), op_code);
 245
 246   switch (op_code)
 247     {
 248     case DW_LNE_end_sequence:
 249       printf (_("End of Sequence\n\n"));
 250       reset_state_machine (is_stmt);
 251       break;
 252
 253     case DW_LNE_set_address:
 254       adr = byte_get (data, len - bytes_read - 1);
 255       printf (_("set Address to 0x%lx\n"), adr);
 256       state_machine_regs.address = adr;
 257       break;
 258
 259     case DW_LNE_define_file:
 260       printf (_("  define new File Table entry\n"));
 261       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 262
 263       printf (_("   %d\t"), ++state_machine_regs.last_file_entry);
 264       name = data;
 265       data += strlen ((char *) data) + 1;
 266       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 267       data += bytes_read;
 268       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 269       data += bytes_read;
 270       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 271       printf (_("%s\n\n"), name);
 272       break;
 273
 274     default:
 275       printf (_("UNKNOWN: length %d\n"), len - bytes_read);
 276       break;
 277     }
 278
 279   return len;
 280 }
 281
 282 static const char *
 283 fetch_indirect_string (unsigned long offset)
 284 {
 285   struct dwarf_section *section = &debug_displays [str].section;
 286
 287   if (section->start == NULL)
 288     return _("<no .debug_str section>");
 289
 290   /* DWARF sections under Mach-O have non-zero addresses.  */
 291   offset -= section->address;
 292   if (offset > section->size)
 293     {
 294       warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
 295       return _("<offset is too big>");
 296     }
 297
 298   return (const char *) section->start + offset;
 299 }
 300
 301 /* FIXME:  There are better and more efficient ways to handle
 302    these structures.  For now though, I just want something that
 303    is simple to implement.  */
 304 typedef struct abbrev_attr
 305 {
 306   unsigned long attribute;
 307   unsigned long form;
 308   struct abbrev_attr *next;
 309 }
 310 abbrev_attr;
 311
 312 typedef struct abbrev_entry
 313 {
 314   unsigned long entry;
 315   unsigned long tag;
 316   int children;
 317   struct abbrev_attr *first_attr;
 318   struct abbrev_attr *last_attr;
 319   struct abbrev_entry *next;
 320 }
 321 abbrev_entry;
 322
 323 static abbrev_entry *first_abbrev = NULL;
 324 static abbrev_entry *last_abbrev = NULL;
 325
 326 static void
 327 free_abbrevs (void)
 328 {
 329   abbrev_entry *abbrev;
 330
 331   for (abbrev = first_abbrev; abbrev;)
 332     {
 333       abbrev_entry *next = abbrev->next;
 334       abbrev_attr *attr;
 335
 336       for (attr = abbrev->first_attr; attr;)
 337         {
 338           abbrev_attr *next = attr->next;
 339
 340           free (attr);
 341           attr = next;
 342         }
 343
 344       free (abbrev);
 345       abbrev = next;
 346     }
 347
 348   last_abbrev = first_abbrev = NULL;
 349 }
 350
 351 static void
 352 add_abbrev (unsigned long number, unsigned long tag, int children)
 353 {
 354   abbrev_entry *entry;
 355
 356   entry = malloc (sizeof (*entry));
 357
 358   if (entry == NULL)
 359     /* ugg */
 360     return;
 361
 362   entry->entry      = number;
 363   entry->tag        = tag;
 364   entry->children   = children;
 365   entry->first_attr = NULL;
 366   entry->last_attr  = NULL;
 367   entry->next       = NULL;
 368
 369   if (first_abbrev == NULL)
 370     first_abbrev = entry;
 371   else
 372     last_abbrev->next = entry;
 373
 374   last_abbrev = entry;
 375 }
 376
 377 static void
 378 add_abbrev_attr (unsigned long attribute, unsigned long form)
 379 {
 380   abbrev_attr *attr;
 381
 382   attr = malloc (sizeof (*attr));
 383
 384   if (attr == NULL)
 385     /* ugg */
 386     return;
 387
 388   attr->attribute = attribute;
 389   attr->form      = form;
 390   attr->next      = NULL;
 391
 392   if (last_abbrev->first_attr == NULL)
 393     last_abbrev->first_attr = attr;
 394   else
 395     last_abbrev->last_attr->next = attr;
 396
 397   last_abbrev->last_attr = attr;
 398 }
 399
 400 /* Processes the (partial) contents of a .debug_abbrev section.
 401    Returns NULL if the end of the section was encountered.
 402    Returns the address after the last byte read if the end of
 403    an abbreviation set was found.  */
 404
 405 static unsigned char *
 406 process_abbrev_section (unsigned char *start, unsigned char *end)
 407 {
 408   if (first_abbrev != NULL)
 409     return NULL;
 410
 411   while (start < end)
 412     {
 413       unsigned int bytes_read;
 414       unsigned long entry;
 415       unsigned long tag;
 416       unsigned long attribute;
 417       int children;
 418
 419       entry = read_leb128 (start, & bytes_read, 0);
 420       start += bytes_read;
 421
 422       /* A single zero is supposed to end the section according
 423          to the standard.  If there's more, then signal that to
 424          the caller.  */
 425       if (entry == 0)
 426         return start == end ? NULL : start;
 427
 428       tag = read_leb128 (start, & bytes_read, 0);
 429       start += bytes_read;
 430
 431       children = *start++;
 432
 433       add_abbrev (entry, tag, children);
 434
 435       do
 436         {
 437           unsigned long form;
 438
 439           attribute = read_leb128 (start, & bytes_read, 0);
 440           start += bytes_read;
 441
 442           form = read_leb128 (start, & bytes_read, 0);
 443           start += bytes_read;
 444
 445           if (attribute != 0)
 446             add_abbrev_attr (attribute, form);
 447         }
 448       while (attribute != 0);
 449     }
 450
 451   return NULL;
 452 }
 453
 454 static char *
 455 get_TAG_name (unsigned long tag)
 456 {
 457   switch (tag)
 458     {
 459     case DW_TAG_padding:                return "DW_TAG_padding";
 460     case DW_TAG_array_type:             return "DW_TAG_array_type";
 461     case DW_TAG_class_type:             return "DW_TAG_class_type";
 462     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
 463     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
 464     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
 465     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
 466     case DW_TAG_label:                  return "DW_TAG_label";
 467     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
 468     case DW_TAG_member:                 return "DW_TAG_member";
 469     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
 470     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
 471     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
 472     case DW_TAG_string_type:            return "DW_TAG_string_type";
 473     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
 474     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
 475     case DW_TAG_typedef:                return "DW_TAG_typedef";
 476     case DW_TAG_union_type:             return "DW_TAG_union_type";
 477     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
 478     case DW_TAG_variant:                return "DW_TAG_variant";
 479     case DW_TAG_common_block:           return "DW_TAG_common_block";
 480     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
 481     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
 482     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
 483     case DW_TAG_module:                 return "DW_TAG_module";
 484     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
 485     case DW_TAG_set_type:               return "DW_TAG_set_type";
 486     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
 487     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
 488     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
 489     case DW_TAG_base_type:              return "DW_TAG_base_type";
 490     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
 491     case DW_TAG_const_type:             return "DW_TAG_const_type";
 492     case DW_TAG_constant:               return "DW_TAG_constant";
 493     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
 494     case DW_TAG_file_type:              return "DW_TAG_file_type";
 495     case DW_TAG_friend:                 return "DW_TAG_friend";
 496     case DW_TAG_namelist:               return "DW_TAG_namelist";
 497     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
 498     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
 499     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
 500     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
 501     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
 502     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
 503     case DW_TAG_try_block:              return "DW_TAG_try_block";
 504     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
 505     case DW_TAG_variable:               return "DW_TAG_variable";
 506     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
 507     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
 508     case DW_TAG_format_label:           return "DW_TAG_format_label";
 509     case DW_TAG_function_template:      return "DW_TAG_function_template";
 510     case DW_TAG_class_template:         return "DW_TAG_class_template";
 511       /* DWARF 2.1 values.  */
 512     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
 513     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
 514     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
 515     case DW_TAG_namespace:              return "DW_TAG_namespace";
 516     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
 517     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
 518     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
 519     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
 520       /* UPC values.  */
 521     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
 522     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
 523     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
 524     default:
 525       {
 526         static char buffer[100];
 527
 528         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
 529         return buffer;
 530       }
 531     }
 532 }
 533
 534 static char *
 535 get_FORM_name (unsigned long form)
 536 {
 537   switch (form)
 538     {
 539     case DW_FORM_addr:          return "DW_FORM_addr";
 540     case DW_FORM_block2:        return "DW_FORM_block2";
 541     case DW_FORM_block4:        return "DW_FORM_block4";
 542     case DW_FORM_data2:         return "DW_FORM_data2";
 543     case DW_FORM_data4:         return "DW_FORM_data4";
 544     case DW_FORM_data8:         return "DW_FORM_data8";
 545     case DW_FORM_string:        return "DW_FORM_string";
 546     case DW_FORM_block:         return "DW_FORM_block";
 547     case DW_FORM_block1:        return "DW_FORM_block1";
 548     case DW_FORM_data1:         return "DW_FORM_data1";
 549     case DW_FORM_flag:          return "DW_FORM_flag";
 550     case DW_FORM_sdata:         return "DW_FORM_sdata";
 551     case DW_FORM_strp:          return "DW_FORM_strp";
 552     case DW_FORM_udata:         return "DW_FORM_udata";
 553     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
 554     case DW_FORM_ref1:          return "DW_FORM_ref1";
 555     case DW_FORM_ref2:          return "DW_FORM_ref2";
 556     case DW_FORM_ref4:          return "DW_FORM_ref4";
 557     case DW_FORM_ref8:          return "DW_FORM_ref8";
 558     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
 559     case DW_FORM_indirect:      return "DW_FORM_indirect";
 560     default:
 561       {
 562         static char buffer[100];
 563
 564         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
 565         return buffer;
 566       }
 567     }
 568 }
 569
 570 static unsigned char *
 571 display_block (unsigned char *data, unsigned long length)
 572 {
 573   printf (_(" %lu byte block: "), length);
 574
 575   while (length --)
 576     printf ("%lx ", (unsigned long) byte_get (data++, 1));
 577
 578   return data;
 579 }
 580
 581 static int
 582 decode_location_expression (unsigned char * data,
 583                             unsigned int pointer_size,
 584                             unsigned long length,
 585                             unsigned long cu_offset)
 586 {
 587   unsigned op;
 588   unsigned int bytes_read;
 589   unsigned long uvalue;
 590   unsigned char *end = data + length;
 591   int need_frame_base = 0;
 592
 593   while (data < end)
 594     {
 595       op = *data++;
 596
 597       switch (op)
 598         {
 599         case DW_OP_addr:
 600           printf ("DW_OP_addr: %lx",
 601                   (unsigned long) byte_get (data, pointer_size));
 602           data += pointer_size;
 603           break;
 604         case DW_OP_deref:
 605           printf ("DW_OP_deref");
 606           break;
 607         case DW_OP_const1u:
 608           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
 609           break;
 610         case DW_OP_const1s:
 611           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
 612           break;
 613         case DW_OP_const2u:
 614           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
 615           data += 2;
 616           break;
 617         case DW_OP_const2s:
 618           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
 619           data += 2;
 620           break;
 621         case DW_OP_const4u:
 622           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
 623           data += 4;
 624           break;
 625         case DW_OP_const4s:
 626           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
 627           data += 4;
 628           break;
 629         case DW_OP_const8u:
 630           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
 631                   (unsigned long) byte_get (data + 4, 4));
 632           data += 8;
 633           break;
 634         case DW_OP_const8s:
 635           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
 636                   (long) byte_get (data + 4, 4));
 637           data += 8;
 638           break;
 639         case DW_OP_constu:
 640           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
 641           data += bytes_read;
 642           break;
 643         case DW_OP_consts:
 644           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
 645           data += bytes_read;
 646           break;
 647         case DW_OP_dup:
 648           printf ("DW_OP_dup");
 649           break;
 650         case DW_OP_drop:
 651           printf ("DW_OP_drop");
 652           break;
 653         case DW_OP_over:
 654           printf ("DW_OP_over");
 655           break;
 656         case DW_OP_pick:
 657           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
 658           break;
 659         case DW_OP_swap:
 660           printf ("DW_OP_swap");
 661           break;
 662         case DW_OP_rot:
 663           printf ("DW_OP_rot");
 664           break;
 665         case DW_OP_xderef:
 666           printf ("DW_OP_xderef");
 667           break;
 668         case DW_OP_abs:
 669           printf ("DW_OP_abs");
 670           break;
 671         case DW_OP_and:
 672           printf ("DW_OP_and");
 673           break;
 674         case DW_OP_div:
 675           printf ("DW_OP_div");
 676           break;
 677         case DW_OP_minus:
 678           printf ("DW_OP_minus");
 679           break;
 680         case DW_OP_mod:
 681           printf ("DW_OP_mod");
 682           break;
 683         case DW_OP_mul:
 684           printf ("DW_OP_mul");
 685           break;
 686         case DW_OP_neg:
 687           printf ("DW_OP_neg");
 688           break;
 689         case DW_OP_not:
 690           printf ("DW_OP_not");
 691           break;
 692         case DW_OP_or:
 693           printf ("DW_OP_or");
 694           break;
 695         case DW_OP_plus:
 696           printf ("DW_OP_plus");
 697           break;
 698         case DW_OP_plus_uconst:
 699           printf ("DW_OP_plus_uconst: %lu",
 700                   read_leb128 (data, &bytes_read, 0));
 701           data += bytes_read;
 702           break;
 703         case DW_OP_shl:
 704           printf ("DW_OP_shl");
 705           break;
 706         case DW_OP_shr:
 707           printf ("DW_OP_shr");
 708           break;
 709         case DW_OP_shra:
 710           printf ("DW_OP_shra");
 711           break;
 712         case DW_OP_xor:
 713           printf ("DW_OP_xor");
 714           break;
 715         case DW_OP_bra:
 716           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
 717           data += 2;
 718           break;
 719         case DW_OP_eq:
 720           printf ("DW_OP_eq");
 721           break;
 722         case DW_OP_ge:
 723           printf ("DW_OP_ge");
 724           break;
 725         case DW_OP_gt:
 726           printf ("DW_OP_gt");
 727           break;
 728         case DW_OP_le:
 729           printf ("DW_OP_le");
 730           break;
 731         case DW_OP_lt:
 732           printf ("DW_OP_lt");
 733           break;
 734         case DW_OP_ne:
 735           printf ("DW_OP_ne");
 736           break;
 737         case DW_OP_skip:
 738           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
 739           data += 2;
 740           break;
 741
 742         case DW_OP_lit0:
 743         case DW_OP_lit1:
 744         case DW_OP_lit2:
 745         case DW_OP_lit3:
 746         case DW_OP_lit4:
 747         case DW_OP_lit5:
 748         case DW_OP_lit6:
 749         case DW_OP_lit7:
 750         case DW_OP_lit8:
 751         case DW_OP_lit9:
 752         case DW_OP_lit10:
 753         case DW_OP_lit11:
 754         case DW_OP_lit12:
 755         case DW_OP_lit13:
 756         case DW_OP_lit14:
 757         case DW_OP_lit15:
 758         case DW_OP_lit16:
 759         case DW_OP_lit17:
 760         case DW_OP_lit18:
 761         case DW_OP_lit19:
 762         case DW_OP_lit20:
 763         case DW_OP_lit21:
 764         case DW_OP_lit22:
 765         case DW_OP_lit23:
 766         case DW_OP_lit24:
 767         case DW_OP_lit25:
 768         case DW_OP_lit26:
 769         case DW_OP_lit27:
 770         case DW_OP_lit28:
 771         case DW_OP_lit29:
 772         case DW_OP_lit30:
 773         case DW_OP_lit31:
 774           printf ("DW_OP_lit%d", op - DW_OP_lit0);
 775           break;
 776
 777         case DW_OP_reg0:
 778         case DW_OP_reg1:
 779         case DW_OP_reg2:
 780         case DW_OP_reg3:
 781         case DW_OP_reg4:
 782         case DW_OP_reg5:
 783         case DW_OP_reg6:
 784         case DW_OP_reg7:
 785         case DW_OP_reg8:
 786         case DW_OP_reg9:
 787         case DW_OP_reg10:
 788         case DW_OP_reg11:
 789         case DW_OP_reg12:
 790         case DW_OP_reg13:
 791         case DW_OP_reg14:
 792         case DW_OP_reg15:
 793         case DW_OP_reg16:
 794         case DW_OP_reg17:
 795         case DW_OP_reg18:
 796         case DW_OP_reg19:
 797         case DW_OP_reg20:
 798         case DW_OP_reg21:
 799         case DW_OP_reg22:
 800         case DW_OP_reg23:
 801         case DW_OP_reg24:
 802         case DW_OP_reg25:
 803         case DW_OP_reg26:
 804         case DW_OP_reg27:
 805         case DW_OP_reg28:
 806         case DW_OP_reg29:
 807         case DW_OP_reg30:
 808         case DW_OP_reg31:
 809           printf ("DW_OP_reg%d", op - DW_OP_reg0);
 810           break;
 811
 812         case DW_OP_breg0:
 813         case DW_OP_breg1:
 814         case DW_OP_breg2:
 815         case DW_OP_breg3:
 816         case DW_OP_breg4:
 817         case DW_OP_breg5:
 818         case DW_OP_breg6:
 819         case DW_OP_breg7:
 820         case DW_OP_breg8:
 821         case DW_OP_breg9:
 822         case DW_OP_breg10:
 823         case DW_OP_breg11:
 824         case DW_OP_breg12:
 825         case DW_OP_breg13:
 826         case DW_OP_breg14:
 827         case DW_OP_breg15:
 828         case DW_OP_breg16:
 829         case DW_OP_breg17:
 830         case DW_OP_breg18:
 831         case DW_OP_breg19:
 832         case DW_OP_breg20:
 833         case DW_OP_breg21:
 834         case DW_OP_breg22:
 835         case DW_OP_breg23:
 836         case DW_OP_breg24:
 837         case DW_OP_breg25:
 838         case DW_OP_breg26:
 839         case DW_OP_breg27:
 840         case DW_OP_breg28:
 841         case DW_OP_breg29:
 842         case DW_OP_breg30:
 843         case DW_OP_breg31:
 844           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
 845                   read_leb128 (data, &bytes_read, 1));
 846           data += bytes_read;
 847           break;
 848
 849         case DW_OP_regx:
 850           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
 851           data += bytes_read;
 852           break;
 853         case DW_OP_fbreg:
 854           need_frame_base = 1;
 855           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
 856           data += bytes_read;
 857           break;
 858         case DW_OP_bregx:
 859           uvalue = read_leb128 (data, &bytes_read, 0);
 860           data += bytes_read;
 861           printf ("DW_OP_bregx: %lu %ld", uvalue,
 862                   read_leb128 (data, &bytes_read, 1));
 863           data += bytes_read;
 864           break;
 865         case DW_OP_piece:
 866           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
 867           data += bytes_read;
 868           break;
 869         case DW_OP_deref_size:
 870           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
 871           break;
 872         case DW_OP_xderef_size:
 873           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
 874           break;
 875         case DW_OP_nop:
 876           printf ("DW_OP_nop");
 877           break;
 878
 879           /* DWARF 3 extensions.  */
 880         case DW_OP_push_object_address:
 881           printf ("DW_OP_push_object_address");
 882           break;
 883         case DW_OP_call2:
 884           /* XXX: Strictly speaking for 64-bit DWARF3 files
 885              this ought to be an 8-byte wide computation.  */
 886           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
 887           data += 2;
 888           break;
 889         case DW_OP_call4:
 890           /* XXX: Strictly speaking for 64-bit DWARF3 files
 891              this ought to be an 8-byte wide computation.  */
 892           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
 893           data += 4;
 894           break;
 895         case DW_OP_call_ref:
 896           printf ("DW_OP_call_ref");
 897           break;
 898
 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_subprogram:
1737               need_base_address = 0;
1738               /* Assuming that there is no DW_AT_frame_base.  */
1739               have_frame_base = 0;
1740               break;
1741             }
1742
1743           for (attr = entry->first_attr; attr; attr = attr->next)
1744             {
1745               if (! do_loc)
1746                 /* Show the offset from where the tag was extracted.  */
1747                 printf ("  <%2lx>", (unsigned long)(tags - section_begin));
1748
1749               tags = read_and_display_attr (attr->attribute,
1750                                             attr->form,
1751                                             tags, cu_offset,
1752                                             compunit.cu_pointer_size,
1753                                             offset_size,
1754                                             compunit.cu_version,
1755                                             &debug_information [unit],
1756                                             do_loc);
1757             }
1758
1759           if (entry->children)
1760             ++level;
1761         }
1762     }
1763
1764   /* Set num_debug_info_entries here so that it can be used to check if
1765      we need to process .debug_loc and .debug_ranges sections.  */
1766   if ((do_loc || do_debug_loc || do_debug_ranges)
1767       && num_debug_info_entries == 0)
1768     num_debug_info_entries = num_units;
1769
1770   if (!do_loc)
1771     {
1772       printf ("\n");
1773     }
1774
1775   return 1;
1776 }
1777
1778 /* Locate and scan the .debug_info section in the file and record the pointer
1779    sizes and offsets for the compilation units in it.  Usually an executable
1780    will have just one pointer size, but this is not guaranteed, and so we try
1781    not to make any assumptions.  Returns zero upon failure, or the number of
1782    compilation units upon success.  */
1783
1784 static unsigned int
1785 load_debug_info (void * file)
1786 {
1787   /* Reset the last pointer size so that we can issue correct error
1788      messages if we are displaying the contents of more than one section.  */
1789   last_pointer_size = 0;
1790   warned_about_missing_comp_units = FALSE;
1791
1792   /* If we already have the information there is nothing else to do.  */
1793   if (num_debug_info_entries > 0)
1794     return num_debug_info_entries;
1795
1796   if (load_debug_section (info, file)
1797       && process_debug_info (&debug_displays [info].section, file, 1))
1798     return num_debug_info_entries;
1799   else
1800     return 0;
1801 }
1802
1803 static int
1804 display_debug_lines (struct dwarf_section *section, void *file)
1805 {
1806   unsigned char *start = section->start;
1807   unsigned char *data = start;
1808   unsigned char *end = start + section->size;
1809
1810   printf (_("\nDump of debug contents of section %s:\n\n"),
1811           section->name);
1812
1813   load_debug_info (file);
1814
1815   while (data < end)
1816     {
1817       DWARF2_Internal_LineInfo info;
1818       unsigned char *standard_opcodes;
1819       unsigned char *end_of_sequence;
1820       unsigned char *hdrptr;
1821       int initial_length_size;
1822       int offset_size;
1823       int i;
1824
1825       hdrptr = data;
1826
1827       /* Check the length of the block.  */
1828       info.li_length = byte_get (hdrptr, 4);
1829       hdrptr += 4;
1830
1831       if (info.li_length == 0xffffffff)
1832         {
1833           /* This section is 64-bit DWARF 3.  */
1834           info.li_length = byte_get (hdrptr, 8);
1835           hdrptr += 8;
1836           offset_size = 8;
1837           initial_length_size = 12;
1838         }
1839       else
1840         {
1841           offset_size = 4;
1842           initial_length_size = 4;
1843         }
1844
1845       if (info.li_length + initial_length_size > section->size)
1846         {
1847           warn
1848             (_("The line info appears to be corrupt - the section is too small\n"));
1849           return 0;
1850         }
1851
1852       /* Check its version number.  */
1853       info.li_version = byte_get (hdrptr, 2);
1854       hdrptr += 2;
1855       if (info.li_version != 2 && info.li_version != 3)
1856         {
1857           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1858           return 0;
1859         }
1860
1861       info.li_prologue_length = byte_get (hdrptr, offset_size);
1862       hdrptr += offset_size;
1863       info.li_min_insn_length = byte_get (hdrptr, 1);
1864       hdrptr++;
1865       info.li_default_is_stmt = byte_get (hdrptr, 1);
1866       hdrptr++;
1867       info.li_line_base = byte_get (hdrptr, 1);
1868       hdrptr++;
1869       info.li_line_range = byte_get (hdrptr, 1);
1870       hdrptr++;
1871       info.li_opcode_base = byte_get (hdrptr, 1);
1872       hdrptr++;
1873
1874       /* Sign extend the line base field.  */
1875       info.li_line_base <<= 24;
1876       info.li_line_base >>= 24;
1877
1878       printf (_("  Length:                      %ld\n"), info.li_length);
1879       printf (_("  DWARF Version:               %d\n"), info.li_version);
1880       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
1881       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
1882       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
1883       printf (_("  Line Base:                   %d\n"), info.li_line_base);
1884       printf (_("  Line Range:                  %d\n"), info.li_line_range);
1885       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
1886
1887       end_of_sequence = data + info.li_length + initial_length_size;
1888
1889       reset_state_machine (info.li_default_is_stmt);
1890
1891       /* Display the contents of the Opcodes table.  */
1892       standard_opcodes = hdrptr;
1893
1894       printf (_("\n Opcodes:\n"));
1895
1896       for (i = 1; i < info.li_opcode_base; i++)
1897         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
1898
1899       /* Display the contents of the Directory table.  */
1900       data = standard_opcodes + info.li_opcode_base - 1;
1901
1902       if (*data == 0)
1903         printf (_("\n The Directory Table is empty.\n"));
1904       else
1905         {
1906           printf (_("\n The Directory Table:\n"));
1907
1908           while (*data != 0)
1909             {
1910               printf (_("  %s\n"), data);
1911
1912               data += strlen ((char *) data) + 1;
1913             }
1914         }
1915
1916       /* Skip the NUL at the end of the table.  */
1917       data++;
1918
1919       /* Display the contents of the File Name table.  */
1920       if (*data == 0)
1921         printf (_("\n The File Name Table is empty.\n"));
1922       else
1923         {
1924           printf (_("\n The File Name Table:\n"));
1925           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
1926
1927           while (*data != 0)
1928             {
1929               unsigned char *name;
1930               unsigned int bytes_read;
1931
1932               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
1933               name = data;
1934
1935               data += strlen ((char *) data) + 1;
1936
1937               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1938               data += bytes_read;
1939               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1940               data += bytes_read;
1941               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1942               data += bytes_read;
1943               printf (_("%s\n"), name);
1944             }
1945         }
1946
1947       /* Skip the NUL at the end of the table.  */
1948       data++;
1949
1950       /* Now display the statements.  */
1951       printf (_("\n Line Number Statements:\n"));
1952
1953       while (data < end_of_sequence)
1954         {
1955           unsigned char op_code;
1956           int adv;
1957           unsigned long int uladv;
1958           unsigned int bytes_read;
1959
1960           op_code = *data++;
1961
1962           if (op_code >= info.li_opcode_base)
1963             {
1964               op_code -= info.li_opcode_base;
1965               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
1966               state_machine_regs.address += uladv;
1967               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
1968                       op_code, uladv, state_machine_regs.address);
1969               adv = (op_code % info.li_line_range) + info.li_line_base;
1970               state_machine_regs.line += adv;
1971               printf (_(" and Line by %d to %d\n"),
1972                       adv, state_machine_regs.line);
1973             }
1974           else switch (op_code)
1975             {
1976             case DW_LNS_extended_op:
1977               data += process_extended_line_op (data, info.li_default_is_stmt);
1978               break;
1979
1980             case DW_LNS_copy:
1981               printf (_("  Copy\n"));
1982               break;
1983
1984             case DW_LNS_advance_pc:
1985               uladv = read_leb128 (data, & bytes_read, 0);
1986               uladv *= info.li_min_insn_length;
1987               data += bytes_read;
1988               state_machine_regs.address += uladv;
1989               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
1990                       state_machine_regs.address);
1991               break;
1992
1993             case DW_LNS_advance_line:
1994               adv = read_leb128 (data, & bytes_read, 1);
1995               data += bytes_read;
1996               state_machine_regs.line += adv;
1997               printf (_("  Advance Line by %d to %d\n"), adv,
1998                       state_machine_regs.line);
1999               break;
2000
2001             case DW_LNS_set_file:
2002               adv = read_leb128 (data, & bytes_read, 0);
2003               data += bytes_read;
2004               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2005                       adv);
2006               state_machine_regs.file = adv;
2007               break;
2008
2009             case DW_LNS_set_column:
2010               uladv = read_leb128 (data, & bytes_read, 0);
2011               data += bytes_read;
2012               printf (_("  Set column to %lu\n"), uladv);
2013               state_machine_regs.column = uladv;
2014               break;
2015
2016             case DW_LNS_negate_stmt:
2017               adv = state_machine_regs.is_stmt;
2018               adv = ! adv;
2019               printf (_("  Set is_stmt to %d\n"), adv);
2020               state_machine_regs.is_stmt = adv;
2021               break;
2022
2023             case DW_LNS_set_basic_block:
2024               printf (_("  Set basic block\n"));
2025               state_machine_regs.basic_block = 1;
2026               break;
2027
2028             case DW_LNS_const_add_pc:
2029               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2030                       * info.li_min_insn_length);
2031               state_machine_regs.address += uladv;
2032               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2033                       state_machine_regs.address);
2034               break;
2035
2036             case DW_LNS_fixed_advance_pc:
2037               uladv = byte_get (data, 2);
2038               data += 2;
2039               state_machine_regs.address += uladv;
2040               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2041                       uladv, state_machine_regs.address);
2042               break;
2043
2044             case DW_LNS_set_prologue_end:
2045               printf (_("  Set prologue_end to true\n"));
2046               break;
2047
2048             case DW_LNS_set_epilogue_begin:
2049               printf (_("  Set epilogue_begin to true\n"));
2050               break;
2051
2052             case DW_LNS_set_isa:
2053               uladv = read_leb128 (data, & bytes_read, 0);
2054               data += bytes_read;
2055               printf (_("  Set ISA to %lu\n"), uladv);
2056               break;
2057
2058             default:
2059               printf (_("  Unknown opcode %d with operands: "), op_code);
2060
2061               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2062                 {
2063                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2064                           i == 1 ? "" : ", ");
2065                   data += bytes_read;
2066                 }
2067               putchar ('\n');
2068               break;
2069             }
2070         }
2071       putchar ('\n');
2072     }
2073
2074   return 1;
2075 }
2076
2077 static int
2078 display_debug_pubnames (struct dwarf_section *section,
2079                         void *file ATTRIBUTE_UNUSED)
2080 {
2081   DWARF2_Internal_PubNames pubnames;
2082   unsigned char *start = section->start;
2083   unsigned char *end = start + section->size;
2084
2085   printf (_("Contents of the %s section:\n\n"), section->name);
2086
2087   while (start < end)
2088     {
2089       unsigned char *data;
2090       unsigned long offset;
2091       int offset_size, initial_length_size;
2092
2093       data = start;
2094
2095       pubnames.pn_length = byte_get (data, 4);
2096       data += 4;
2097       if (pubnames.pn_length == 0xffffffff)
2098         {
2099           pubnames.pn_length = byte_get (data, 8);
2100           data += 8;
2101           offset_size = 8;
2102           initial_length_size = 12;
2103         }
2104       else
2105         {
2106           offset_size = 4;
2107           initial_length_size = 4;
2108         }
2109
2110       pubnames.pn_version = byte_get (data, 2);
2111       data += 2;
2112       pubnames.pn_offset = byte_get (data, offset_size);
2113       data += offset_size;
2114       pubnames.pn_size = byte_get (data, offset_size);
2115       data += offset_size;
2116
2117       start += pubnames.pn_length + initial_length_size;
2118
2119       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2120         {
2121           static int warned = 0;
2122
2123           if (! warned)
2124             {
2125               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2126               warned = 1;
2127             }
2128
2129           continue;
2130         }
2131
2132       printf (_("  Length:                              %ld\n"),
2133               pubnames.pn_length);
2134       printf (_("  Version:                             %d\n"),
2135               pubnames.pn_version);
2136       printf (_("  Offset into .debug_info section:     %ld\n"),
2137               pubnames.pn_offset);
2138       printf (_("  Size of area in .debug_info section: %ld\n"),
2139               pubnames.pn_size);
2140
2141       printf (_("\n    Offset\tName\n"));
2142
2143       do
2144         {
2145           offset = byte_get (data, offset_size);
2146
2147           if (offset != 0)
2148             {
2149               data += offset_size;
2150               printf ("    %-6ld\t\t%s\n", offset, data);
2151               data += strlen ((char *) data) + 1;
2152             }
2153         }
2154       while (offset != 0);
2155     }
2156
2157   printf ("\n");
2158   return 1;
2159 }
2160
2161 static int
2162 display_debug_macinfo (struct dwarf_section *section,
2163                        void *file ATTRIBUTE_UNUSED)
2164 {
2165   unsigned char *start = section->start;
2166   unsigned char *end = start + section->size;
2167   unsigned char *curr = start;
2168   unsigned int bytes_read;
2169   enum dwarf_macinfo_record_type op;
2170
2171   printf (_("Contents of the %s section:\n\n"), section->name);
2172
2173   while (curr < end)
2174     {
2175       unsigned int lineno;
2176       const char *string;
2177
2178       op = *curr;
2179       curr++;
2180
2181       switch (op)
2182         {
2183         case DW_MACINFO_start_file:
2184           {
2185             unsigned int filenum;
2186
2187             lineno = read_leb128 (curr, & bytes_read, 0);
2188             curr += bytes_read;
2189             filenum = read_leb128 (curr, & bytes_read, 0);
2190             curr += bytes_read;
2191
2192             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2193                     lineno, filenum);
2194           }
2195           break;
2196
2197         case DW_MACINFO_end_file:
2198           printf (_(" DW_MACINFO_end_file\n"));
2199           break;
2200
2201         case DW_MACINFO_define:
2202           lineno = read_leb128 (curr, & bytes_read, 0);
2203           curr += bytes_read;
2204           string = (char *) curr;
2205           curr += strlen (string) + 1;
2206           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2207                   lineno, string);
2208           break;
2209
2210         case DW_MACINFO_undef:
2211           lineno = read_leb128 (curr, & bytes_read, 0);
2212           curr += bytes_read;
2213           string = (char *) curr;
2214           curr += strlen (string) + 1;
2215           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2216                   lineno, string);
2217           break;
2218
2219         case DW_MACINFO_vendor_ext:
2220           {
2221             unsigned int constant;
2222
2223             constant = read_leb128 (curr, & bytes_read, 0);
2224             curr += bytes_read;
2225             string = (char *) curr;
2226             curr += strlen (string) + 1;
2227             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2228                     constant, string);
2229           }
2230           break;
2231         }
2232     }
2233
2234   return 1;
2235 }
2236
2237 static int
2238 display_debug_abbrev (struct dwarf_section *section,
2239                       void *file ATTRIBUTE_UNUSED)
2240 {
2241   abbrev_entry *entry;
2242   unsigned char *start = section->start;
2243   unsigned char *end = start + section->size;
2244
2245   printf (_("Contents of the %s section:\n\n"), section->name);
2246
2247   do
2248     {
2249       free_abbrevs ();
2250
2251       start = process_abbrev_section (start, end);
2252
2253       if (first_abbrev == NULL)
2254         continue;
2255
2256       printf (_("  Number TAG\n"));
2257
2258       for (entry = first_abbrev; entry; entry = entry->next)
2259         {
2260           abbrev_attr *attr;
2261
2262           printf (_("   %ld      %s    [%s]\n"),
2263                   entry->entry,
2264                   get_TAG_name (entry->tag),
2265                   entry->children ? _("has children") : _("no children"));
2266
2267           for (attr = entry->first_attr; attr; attr = attr->next)
2268             printf (_("    %-18s %s\n"),
2269                     get_AT_name (attr->attribute),
2270                     get_FORM_name (attr->form));
2271         }
2272     }
2273   while (start);
2274
2275   printf ("\n");
2276
2277   return 1;
2278 }
2279
2280 static int
2281 display_debug_loc (struct dwarf_section *section, void *file)
2282 {
2283   unsigned char *start = section->start;
2284   unsigned char *section_end;
2285   unsigned long bytes;
2286   unsigned char *section_begin = start;
2287   unsigned int num_loc_list = 0;
2288   unsigned long last_offset = 0;
2289   unsigned int first = 0;
2290   unsigned int i;
2291   unsigned int j;
2292   int seen_first_offset = 0;
2293   int use_debug_info = 1;
2294   unsigned char *next;
2295
2296   bytes = section->size;
2297   section_end = start + bytes;
2298
2299   if (bytes == 0)
2300     {
2301       printf (_("\nThe %s section is empty.\n"), section->name);
2302       return 0;
2303     }
2304
2305   load_debug_info (file);
2306
2307   /* Check the order of location list in .debug_info section. If
2308      offsets of location lists are in the ascending order, we can
2309      use `debug_information' directly.  */
2310   for (i = 0; i < num_debug_info_entries; i++)
2311     {
2312       unsigned int num;
2313
2314       num = debug_information [i].num_loc_offsets;
2315       num_loc_list += num;
2316
2317       /* Check if we can use `debug_information' directly.  */
2318       if (use_debug_info && num != 0)
2319         {
2320           if (!seen_first_offset)
2321             {
2322               /* This is the first location list.  */
2323               last_offset = debug_information [i].loc_offsets [0];
2324               first = i;
2325               seen_first_offset = 1;
2326               j = 1;
2327             }
2328           else
2329             j = 0;
2330
2331           for (; j < num; j++)
2332             {
2333               if (last_offset >
2334                   debug_information [i].loc_offsets [j])
2335                 {
2336                   use_debug_info = 0;
2337                   break;
2338                 }
2339               last_offset = debug_information [i].loc_offsets [j];
2340             }
2341         }
2342     }
2343
2344   if (!use_debug_info)
2345     /* FIXME: Should we handle this case?  */
2346     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2347
2348   if (!seen_first_offset)
2349     error (_("No location lists in .debug_info section!\n"));
2350
2351   /* DWARF sections under Mach-O have non-zero addresses.  */
2352   if (debug_information [first].num_loc_offsets > 0
2353       && debug_information [first].loc_offsets [0] != section->address)
2354     warn (_("Location lists in %s section start at 0x%lx\n"),
2355           section->name, debug_information [first].loc_offsets [0]);
2356
2357   printf (_("Contents of the %s section:\n\n"), section->name);
2358   printf (_("    Offset   Begin    End      Expression\n"));
2359
2360   seen_first_offset = 0;
2361   for (i = first; i < num_debug_info_entries; i++)
2362     {
2363       unsigned long begin;
2364       unsigned long end;
2365       unsigned short length;
2366       unsigned long offset;
2367       unsigned int pointer_size;
2368       unsigned long cu_offset;
2369       unsigned long base_address;
2370       int need_frame_base;
2371       int has_frame_base;
2372
2373       pointer_size = debug_information [i].pointer_size;
2374       cu_offset = debug_information [i].cu_offset;
2375
2376       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2377         {
2378           has_frame_base = debug_information [i].have_frame_base [j];
2379           /* DWARF sections under Mach-O have non-zero addresses.  */
2380           offset = debug_information [i].loc_offsets [j] - section->address;
2381           next = section_begin + offset;
2382           base_address = debug_information [i].base_address;
2383
2384           if (!seen_first_offset)
2385             seen_first_offset = 1;
2386           else
2387             {
2388               if (start < next)
2389                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2390                       (long)(start - section_begin), (long)(next - section_begin));
2391               else if (start > next)
2392                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2393                       (long)(start - section_begin), (long)(next - section_begin));
2394             }
2395           start = next;
2396
2397           if (offset >= bytes)
2398             {
2399               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2400                     offset);
2401               continue;
2402             }
2403
2404           while (1)
2405             {
2406               if (start + 2 * pointer_size > section_end)
2407                 {
2408                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2409                         offset);
2410                   break;
2411                 }
2412
2413               begin = byte_get (start, pointer_size);
2414               start += pointer_size;
2415               end = byte_get (start, pointer_size);
2416               start += pointer_size;
2417
2418               if (begin == 0 && end == 0)
2419                 {
2420                   printf (_("    %8.8lx <End of list>\n"), offset);
2421                   break;
2422                 }
2423
2424               /* Check base address specifiers.  */
2425               if (begin == -1UL && end != -1UL)
2426                 {
2427                   base_address = end;
2428                   printf (_("    %8.8lx %8.8lx %8.8lx (base address)\n"),
2429                           offset, begin, end);
2430                   continue;
2431                 }
2432
2433               if (start + 2 > section_end)
2434                 {
2435                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2436                         offset);
2437                   break;
2438                 }
2439
2440               length = byte_get (start, 2);
2441               start += 2;
2442
2443               if (start + length > section_end)
2444                 {
2445                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2446                         offset);
2447                   break;
2448                 }
2449
2450               printf ("    %8.8lx %8.8lx %8.8lx (",
2451                       offset, begin + base_address, end + base_address);
2452               need_frame_base = decode_location_expression (start,
2453                                                             pointer_size,
2454                                                             length,
2455                                                             cu_offset);
2456               putchar (')');
2457
2458               if (need_frame_base && !has_frame_base)
2459                 printf (_(" [without DW_AT_frame_base]"));
2460
2461               if (begin == end)
2462                 fputs (_(" (start == end)"), stdout);
2463               else if (begin > end)
2464                 fputs (_(" (start > end)"), stdout);
2465
2466               putchar ('\n');
2467
2468               start += length;
2469             }
2470         }
2471     }
2472   return 1;
2473 }
2474
2475 static int
2476 display_debug_str (struct dwarf_section *section,
2477                    void *file ATTRIBUTE_UNUSED)
2478 {
2479   unsigned char *start = section->start;
2480   unsigned long bytes = section->size;
2481   dwarf_vma addr = section->address;
2482
2483   if (bytes == 0)
2484     {
2485       printf (_("\nThe %s section is empty.\n"), section->name);
2486       return 0;
2487     }
2488
2489   printf (_("Contents of the %s section:\n\n"), section->name);
2490
2491   while (bytes)
2492     {
2493       int j;
2494       int k;
2495       int lbytes;
2496
2497       lbytes = (bytes > 16 ? 16 : bytes);
2498
2499       printf ("  0x%8.8lx ", (unsigned long) addr);
2500
2501       for (j = 0; j < 16; j++)
2502         {
2503           if (j < lbytes)
2504             printf ("%2.2x", start[j]);
2505           else
2506             printf ("  ");
2507
2508           if ((j & 3) == 3)
2509             printf (" ");
2510         }
2511
2512       for (j = 0; j < lbytes; j++)
2513         {
2514           k = start[j];
2515           if (k >= ' ' && k < 0x80)
2516             printf ("%c", k);
2517           else
2518             printf (".");
2519         }
2520
2521       putchar ('\n');
2522
2523       start += lbytes;
2524       addr  += lbytes;
2525       bytes -= lbytes;
2526     }
2527
2528   putchar ('\n');
2529
2530   return 1;
2531 }
2532
2533 static int
2534 display_debug_info (struct dwarf_section *section, void *file)
2535 {
2536   return process_debug_info (section, file, 0);
2537 }
2538
2539
2540 static int
2541 display_debug_aranges (struct dwarf_section *section,
2542                        void *file ATTRIBUTE_UNUSED)
2543 {
2544   unsigned char *start = section->start;
2545   unsigned char *end = start + section->size;
2546
2547   printf (_("The section %s contains:\n\n"), section->name);
2548
2549   while (start < end)
2550     {
2551       unsigned char *hdrptr;
2552       DWARF2_Internal_ARange arange;
2553       unsigned char *ranges;
2554       unsigned long length;
2555       unsigned long address;
2556       unsigned char address_size;
2557       int excess;
2558       int offset_size;
2559       int initial_length_size;
2560
2561       hdrptr = start;
2562
2563       arange.ar_length = byte_get (hdrptr, 4);
2564       hdrptr += 4;
2565
2566       if (arange.ar_length == 0xffffffff)
2567         {
2568           arange.ar_length = byte_get (hdrptr, 8);
2569           hdrptr += 8;
2570           offset_size = 8;
2571           initial_length_size = 12;
2572         }
2573       else
2574         {
2575           offset_size = 4;
2576           initial_length_size = 4;
2577         }
2578
2579       arange.ar_version = byte_get (hdrptr, 2);
2580       hdrptr += 2;
2581
2582       arange.ar_info_offset = byte_get (hdrptr, offset_size);
2583       hdrptr += offset_size;
2584
2585       arange.ar_pointer_size = byte_get (hdrptr, 1);
2586       hdrptr += 1;
2587
2588       arange.ar_segment_size = byte_get (hdrptr, 1);
2589       hdrptr += 1;
2590
2591       if (arange.ar_version != 2 && arange.ar_version != 3)
2592         {
2593           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2594           break;
2595         }
2596
2597       printf (_("  Length:                   %ld\n"), arange.ar_length);
2598       printf (_("  Version:                  %d\n"), arange.ar_version);
2599       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
2600       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
2601       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
2602
2603       address_size = arange.ar_pointer_size + arange.ar_segment_size;
2604
2605       /* The DWARF spec does not require that the address size be a power
2606          of two, but we do.  This will have to change if we ever encounter
2607          an uneven architecture.  */
2608       if ((address_size & (address_size - 1)) != 0)
2609         {
2610           warn (_("Pointer size + Segment size is not a power of two.\n"));
2611           break;
2612         }
2613
2614       if (address_size > 4)
2615         printf (_("\n    Address            Length\n"));
2616       else
2617         printf (_("\n    Address    Length\n"));
2618
2619       ranges = hdrptr;
2620
2621       /* Must pad to an alignment boundary that is twice the address size.  */
2622       excess = (hdrptr - start) % (2 * address_size);
2623       if (excess)
2624         ranges += (2 * address_size) - excess;
2625
2626       start += arange.ar_length + initial_length_size;
2627
2628       while (ranges + 2 * address_size <= start)
2629         {
2630           address = byte_get (ranges, address_size);
2631
2632           ranges += address_size;
2633
2634           length  = byte_get (ranges, address_size);
2635
2636           ranges += address_size;
2637
2638           if (address_size > 4)
2639             printf ("    0x%16.16lx 0x%lx\n", address, length);
2640           else
2641             printf ("    0x%8.8lx 0x%lx\n", address, length);
2642         }
2643     }
2644
2645   printf ("\n");
2646
2647   return 1;
2648 }
2649
2650 static int
2651 display_debug_ranges (struct dwarf_section *section,
2652                       void *file ATTRIBUTE_UNUSED)
2653 {
2654   unsigned char *start = section->start;
2655   unsigned char *section_end;
2656   unsigned long bytes;
2657   unsigned char *section_begin = start;
2658   unsigned int num_range_list = 0;
2659   unsigned long last_offset = 0;
2660   unsigned int first = 0;
2661   unsigned int i;
2662   unsigned int j;
2663   int seen_first_offset = 0;
2664   int use_debug_info = 1;
2665   unsigned char *next;
2666
2667   bytes = section->size;
2668   section_end = start + bytes;
2669
2670   if (bytes == 0)
2671     {
2672       printf (_("\nThe %s section is empty.\n"), section->name);
2673       return 0;
2674     }
2675
2676   load_debug_info (file);
2677
2678   /* Check the order of range list in .debug_info section. If
2679      offsets of range lists are in the ascending order, we can
2680      use `debug_information' directly.  */
2681   for (i = 0; i < num_debug_info_entries; i++)
2682     {
2683       unsigned int num;
2684
2685       num = debug_information [i].num_range_lists;
2686       num_range_list += num;
2687
2688       /* Check if we can use `debug_information' directly.  */
2689       if (use_debug_info && num != 0)
2690         {
2691           if (!seen_first_offset)
2692             {
2693               /* This is the first range list.  */
2694               last_offset = debug_information [i].range_lists [0];
2695               first = i;
2696               seen_first_offset = 1;
2697               j = 1;
2698             }
2699           else
2700             j = 0;
2701
2702           for (; j < num; j++)
2703             {
2704               if (last_offset >
2705                   debug_information [i].range_lists [j])
2706                 {
2707                   use_debug_info = 0;
2708                   break;
2709                 }
2710               last_offset = debug_information [i].range_lists [j];
2711             }
2712         }
2713     }
2714
2715   if (!use_debug_info)
2716     /* FIXME: Should we handle this case?  */
2717     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2718
2719   if (!seen_first_offset)
2720     error (_("No range lists in .debug_info section!\n"));
2721
2722   /* DWARF sections under Mach-O have non-zero addresses.  */
2723   if (debug_information [first].num_range_lists > 0
2724       && debug_information [first].range_lists [0] != section->address)
2725     warn (_("Range lists in %s section start at 0x%lx\n"),
2726           section->name, debug_information [first].range_lists [0]);
2727
2728   printf (_("Contents of the %s section:\n\n"), section->name);
2729   printf (_("    Offset   Begin    End\n"));
2730
2731   seen_first_offset = 0;
2732   for (i = first; i < num_debug_info_entries; i++)
2733     {
2734       unsigned long begin;
2735       unsigned long end;
2736       unsigned long offset;
2737       unsigned int pointer_size;
2738       unsigned long base_address;
2739
2740       pointer_size = debug_information [i].pointer_size;
2741
2742       for (j = 0; j < debug_information [i].num_range_lists; j++)
2743         {
2744           /* DWARF sections under Mach-O have non-zero addresses.  */
2745           offset = debug_information [i].range_lists [j] - section->address;
2746           next = section_begin + offset;
2747           base_address = debug_information [i].base_address;
2748
2749           if (!seen_first_offset)
2750             seen_first_offset = 1;
2751           else
2752             {
2753               if (start < next)
2754                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2755                       (long)(start - section_begin),
2756                       (long)(next - section_begin), section->name);
2757               else if (start > next)
2758                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2759                       (long)(start - section_begin),
2760                       (long)(next - section_begin), section->name);
2761             }
2762           start = next;
2763
2764           while (1)
2765             {
2766               begin = byte_get (start, pointer_size);
2767               start += pointer_size;
2768               end = byte_get (start, pointer_size);
2769               start += pointer_size;
2770
2771               if (begin == 0 && end == 0)
2772                 {
2773                   printf (_("    %8.8lx <End of list>\n"), offset);
2774                   break;
2775                 }
2776
2777               /* Check base address specifiers.  */
2778               if (begin == -1UL && end != -1UL)
2779                 {
2780                   base_address = end;
2781                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
2782                           offset, begin, end);
2783                   continue;
2784                 }
2785
2786               printf ("    %8.8lx %8.8lx %8.8lx",
2787                       offset, begin + base_address, end + base_address);
2788
2789               if (begin == end)
2790                 fputs (_(" (start == end)"), stdout);
2791               else if (begin > end)
2792                 fputs (_(" (start > end)"), stdout);
2793
2794               putchar ('\n');
2795             }
2796         }
2797     }
2798   putchar ('\n');
2799   return 1;
2800 }
2801
2802 typedef struct Frame_Chunk
2803 {
2804   struct Frame_Chunk *next;
2805   unsigned char *chunk_start;
2806   int ncols;
2807   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
2808   short int *col_type;
2809   int *col_offset;
2810   char *augmentation;
2811   unsigned int code_factor;
2812   int data_factor;
2813   unsigned long pc_begin;
2814   unsigned long pc_range;
2815   int cfa_reg;
2816   int cfa_offset;
2817   int ra;
2818   unsigned char fde_encoding;
2819   unsigned char cfa_exp;
2820 }
2821 Frame_Chunk;
2822
2823 /* A marker for a col_type that means this column was never referenced
2824    in the frame info.  */
2825 #define DW_CFA_unreferenced (-1)
2826
2827 static void
2828 frame_need_space (Frame_Chunk *fc, int reg)
2829 {
2830   int prev = fc->ncols;
2831
2832   if (reg < fc->ncols)
2833     return;
2834
2835   fc->ncols = reg + 1;
2836   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2837   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2838
2839   while (prev < fc->ncols)
2840     {
2841       fc->col_type[prev] = DW_CFA_unreferenced;
2842       fc->col_offset[prev] = 0;
2843       prev++;
2844     }
2845 }
2846
2847 static void
2848 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
2849 {
2850   int r;
2851   char tmp[100];
2852
2853   if (*max_regs < fc->ncols)
2854     *max_regs = fc->ncols;
2855
2856   if (*need_col_headers)
2857     {
2858       *need_col_headers = 0;
2859
2860       printf ("   LOC   CFA      ");
2861
2862       for (r = 0; r < *max_regs; r++)
2863         if (fc->col_type[r] != DW_CFA_unreferenced)
2864           {
2865             if (r == fc->ra)
2866               printf ("ra   ");
2867             else
2868               printf ("r%-4d", r);
2869           }
2870
2871       printf ("\n");
2872     }
2873
2874   printf ("%08lx ", fc->pc_begin);
2875   if (fc->cfa_exp)
2876     strcpy (tmp, "exp");
2877   else
2878     sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
2879   printf ("%-8s ", tmp);
2880
2881   for (r = 0; r < fc->ncols; r++)
2882     {
2883       if (fc->col_type[r] != DW_CFA_unreferenced)
2884         {
2885           switch (fc->col_type[r])
2886             {
2887             case DW_CFA_undefined:
2888               strcpy (tmp, "u");
2889               break;
2890             case DW_CFA_same_value:
2891               strcpy (tmp, "s");
2892               break;
2893             case DW_CFA_offset:
2894               sprintf (tmp, "c%+d", fc->col_offset[r]);
2895               break;
2896             case DW_CFA_val_offset:
2897               sprintf (tmp, "v%+d", fc->col_offset[r]);
2898               break;
2899             case DW_CFA_register:
2900               sprintf (tmp, "r%d", fc->col_offset[r]);
2901               break;
2902             case DW_CFA_expression:
2903               strcpy (tmp, "exp");
2904               break;
2905             case DW_CFA_val_expression:
2906               strcpy (tmp, "vexp");
2907               break;
2908             default:
2909               strcpy (tmp, "n/a");
2910               break;
2911             }
2912           printf ("%-5s", tmp);
2913         }
2914     }
2915   printf ("\n");
2916 }
2917
2918 static int
2919 size_of_encoded_value (int encoding)
2920 {
2921   switch (encoding & 0x7)
2922     {
2923     default:    /* ??? */
2924     case 0:     return eh_addr_size;
2925     case 2:     return 2;
2926     case 3:     return 4;
2927     case 4:     return 8;
2928     }
2929 }
2930
2931 static dwarf_vma
2932 get_encoded_value (unsigned char *data, int encoding)
2933 {
2934   int size = size_of_encoded_value (encoding);
2935
2936   if (encoding & DW_EH_PE_signed)
2937     return byte_get_signed (data, size);
2938   else
2939     return byte_get (data, size);
2940 }
2941
2942 #define GET(N)  byte_get (start, N); start += N
2943 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
2944 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
2945
2946 static int
2947 display_debug_frames (struct dwarf_section *section,
2948                       void *file ATTRIBUTE_UNUSED)
2949 {
2950   unsigned char *start = section->start;
2951   unsigned char *end = start + section->size;
2952   unsigned char *section_start = start;
2953   Frame_Chunk *chunks = 0;
2954   Frame_Chunk *remembered_state = 0;
2955   Frame_Chunk *rs;
2956   int is_eh = strcmp (section->name, ".eh_frame") == 0;
2957   unsigned int length_return;
2958   int max_regs = 0;
2959
2960   printf (_("The section %s contains:\n"), section->name);
2961
2962   while (start < end)
2963     {
2964       unsigned char *saved_start;
2965       unsigned char *block_end;
2966       unsigned long length;
2967       unsigned long cie_id;
2968       Frame_Chunk *fc;
2969       Frame_Chunk *cie;
2970       int need_col_headers = 1;
2971       unsigned char *augmentation_data = NULL;
2972       unsigned long augmentation_data_len = 0;
2973       int encoded_ptr_size = eh_addr_size;
2974       int offset_size;
2975       int initial_length_size;
2976
2977       saved_start = start;
2978       length = byte_get (start, 4); start += 4;
2979
2980       if (length == 0)
2981         {
2982           printf ("\n%08lx ZERO terminator\n\n",
2983                     (unsigned long)(saved_start - section_start));
2984           continue;
2985         }
2986
2987       if (length == 0xffffffff)
2988         {
2989           length = byte_get (start, 8);
2990           start += 8;
2991           offset_size = 8;
2992           initial_length_size = 12;
2993         }
2994       else
2995         {
2996           offset_size = 4;
2997           initial_length_size = 4;
2998         }
2999
3000       block_end = saved_start + length + initial_length_size;
3001       if (block_end > end)
3002         {
3003           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3004                 length, (unsigned long)(saved_start - section_start));
3005           block_end = end;
3006         }
3007       cie_id = byte_get (start, offset_size); start += offset_size;
3008
3009       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3010         {
3011           int version;
3012
3013           fc = xmalloc (sizeof (Frame_Chunk));
3014           memset (fc, 0, sizeof (Frame_Chunk));
3015
3016           fc->next = chunks;
3017           chunks = fc;
3018           fc->chunk_start = saved_start;
3019           fc->ncols = 0;
3020           fc->col_type = xmalloc (sizeof (short int));
3021           fc->col_offset = xmalloc (sizeof (int));
3022           frame_need_space (fc, max_regs-1);
3023
3024           version = *start++;
3025
3026           fc->augmentation = (char *) start;
3027           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3028
3029           if (fc->augmentation[0] == 'z')
3030             {
3031               fc->code_factor = LEB ();
3032               fc->data_factor = SLEB ();
3033               if (version == 1)
3034                 {
3035                   fc->ra = GET (1);
3036                 }
3037               else
3038                 {
3039                   fc->ra = LEB ();
3040                 }
3041               augmentation_data_len = LEB ();
3042               augmentation_data = start;
3043               start += augmentation_data_len;
3044             }
3045           else if (strcmp (fc->augmentation, "eh") == 0)
3046             {
3047               start += eh_addr_size;
3048               fc->code_factor = LEB ();
3049               fc->data_factor = SLEB ();
3050               if (version == 1)
3051                 {
3052                   fc->ra = GET (1);
3053                 }
3054               else
3055                 {
3056                   fc->ra = LEB ();
3057                 }
3058             }
3059           else
3060             {
3061               fc->code_factor = LEB ();
3062               fc->data_factor = SLEB ();
3063               if (version == 1)
3064                 {
3065                   fc->ra = GET (1);
3066                 }
3067               else
3068                 {
3069                   fc->ra = LEB ();
3070                 }
3071             }
3072           cie = fc;
3073
3074           if (do_debug_frames_interp)
3075             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3076                     (unsigned long)(saved_start - section_start), length, cie_id,
3077                     fc->augmentation, fc->code_factor, fc->data_factor,
3078                     fc->ra);
3079           else
3080             {
3081               printf ("\n%08lx %08lx %08lx CIE\n",
3082                       (unsigned long)(saved_start - section_start), length, cie_id);
3083               printf ("  Version:               %d\n", version);
3084               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3085               printf ("  Code alignment factor: %u\n", fc->code_factor);
3086               printf ("  Data alignment factor: %d\n", fc->data_factor);
3087               printf ("  Return address column: %d\n", fc->ra);
3088
3089               if (augmentation_data_len)
3090                 {
3091                   unsigned long i;
3092                   printf ("  Augmentation data:    ");
3093                   for (i = 0; i < augmentation_data_len; ++i)
3094                     printf (" %02x", augmentation_data[i]);
3095                   putchar ('\n');
3096                 }
3097               putchar ('\n');
3098             }
3099
3100           if (augmentation_data_len)
3101             {
3102               unsigned char *p, *q;
3103               p = (unsigned char *) fc->augmentation + 1;
3104               q = augmentation_data;
3105
3106               while (1)
3107                 {
3108                   if (*p == 'L')
3109                     q++;
3110                   else if (*p == 'P')
3111                     q += 1 + size_of_encoded_value (*q);
3112                   else if (*p == 'R')
3113                     fc->fde_encoding = *q++;
3114                   else
3115                     break;
3116                   p++;
3117                 }
3118
3119               if (fc->fde_encoding)
3120                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3121             }
3122
3123           frame_need_space (fc, fc->ra);
3124         }
3125       else
3126         {
3127           unsigned char *look_for;
3128           static Frame_Chunk fde_fc;
3129
3130           fc = & fde_fc;
3131           memset (fc, 0, sizeof (Frame_Chunk));
3132
3133           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3134
3135           for (cie = chunks; cie ; cie = cie->next)
3136             if (cie->chunk_start == look_for)
3137               break;
3138
3139           if (!cie)
3140             {
3141               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3142                     cie_id, (unsigned long)(saved_start - section_start));
3143               fc->ncols = 0;
3144               fc->col_type = xmalloc (sizeof (short int));
3145               fc->col_offset = xmalloc (sizeof (int));
3146               frame_need_space (fc, max_regs - 1);
3147               cie = fc;
3148               fc->augmentation = "";
3149               fc->fde_encoding = 0;
3150             }
3151           else
3152             {
3153               fc->ncols = cie->ncols;
3154               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3155               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3156               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3157               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3158               fc->augmentation = cie->augmentation;
3159               fc->code_factor = cie->code_factor;
3160               fc->data_factor = cie->data_factor;
3161               fc->cfa_reg = cie->cfa_reg;
3162               fc->cfa_offset = cie->cfa_offset;
3163               fc->ra = cie->ra;
3164               frame_need_space (fc, max_regs-1);
3165               fc->fde_encoding = cie->fde_encoding;
3166             }
3167
3168           if (fc->fde_encoding)
3169             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3170
3171           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3172           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3173               /* Don't adjust for relocatable file since there's
3174                  invariably a pcrel reloc here, which we haven't
3175                  applied.  */
3176               && !is_relocatable)
3177             fc->pc_begin += section->address + (start - section_start);
3178           start += encoded_ptr_size;
3179           fc->pc_range = byte_get (start, encoded_ptr_size);
3180           start += encoded_ptr_size;
3181
3182           if (cie->augmentation[0] == 'z')
3183             {
3184               augmentation_data_len = LEB ();
3185               augmentation_data = start;
3186               start += augmentation_data_len;
3187             }
3188
3189           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3190                   (unsigned long)(saved_start - section_start), length, cie_id,
3191                   (unsigned long)(cie->chunk_start - section_start),
3192                   fc->pc_begin, fc->pc_begin + fc->pc_range);
3193           if (! do_debug_frames_interp && augmentation_data_len)
3194             {
3195               unsigned long i;
3196
3197               printf ("  Augmentation data:    ");
3198               for (i = 0; i < augmentation_data_len; ++i)
3199                 printf (" %02x", augmentation_data[i]);
3200               putchar ('\n');
3201               putchar ('\n');
3202             }
3203         }
3204
3205       /* At this point, fc is the current chunk, cie (if any) is set, and
3206          we're about to interpret instructions for the chunk.  */
3207       /* ??? At present we need to do this always, since this sizes the
3208          fc->col_type and fc->col_offset arrays, which we write into always.
3209          We should probably split the interpreted and non-interpreted bits
3210          into two different routines, since there's so much that doesn't
3211          really overlap between them.  */
3212       if (1 || do_debug_frames_interp)
3213         {
3214           /* Start by making a pass over the chunk, allocating storage
3215              and taking note of what registers are used.  */
3216           unsigned char *tmp = start;
3217
3218           while (start < block_end)
3219             {
3220               unsigned op, opa;
3221               unsigned long reg, tmp;
3222
3223               op = *start++;
3224               opa = op & 0x3f;
3225               if (op & 0xc0)
3226                 op &= 0xc0;
3227
3228               /* Warning: if you add any more cases to this switch, be
3229                  sure to add them to the corresponding switch below.  */
3230               switch (op)
3231                 {
3232                 case DW_CFA_advance_loc:
3233                   break;
3234                 case DW_CFA_offset:
3235                   LEB ();
3236                   frame_need_space (fc, opa);
3237                   fc->col_type[opa] = DW_CFA_undefined;
3238                   break;
3239                 case DW_CFA_restore:
3240                   frame_need_space (fc, opa);
3241                   fc->col_type[opa] = DW_CFA_undefined;
3242                   break;
3243                 case DW_CFA_set_loc:
3244                   start += encoded_ptr_size;
3245                   break;
3246                 case DW_CFA_advance_loc1:
3247                   start += 1;
3248                   break;
3249                 case DW_CFA_advance_loc2:
3250                   start += 2;
3251                   break;
3252                 case DW_CFA_advance_loc4:
3253                   start += 4;
3254                   break;
3255                 case DW_CFA_offset_extended:
3256                 case DW_CFA_val_offset:
3257                   reg = LEB (); LEB ();
3258                   frame_need_space (fc, reg);
3259                   fc->col_type[reg] = DW_CFA_undefined;
3260                   break;
3261                 case DW_CFA_restore_extended:
3262                   reg = LEB ();
3263                   frame_need_space (fc, reg);
3264                   fc->col_type[reg] = DW_CFA_undefined;
3265                   break;
3266                 case DW_CFA_undefined:
3267                   reg = LEB ();
3268                   frame_need_space (fc, reg);
3269                   fc->col_type[reg] = DW_CFA_undefined;
3270                   break;
3271                 case DW_CFA_same_value:
3272                   reg = LEB ();
3273                   frame_need_space (fc, reg);
3274                   fc->col_type[reg] = DW_CFA_undefined;
3275                   break;
3276                 case DW_CFA_register:
3277                   reg = LEB (); LEB ();
3278                   frame_need_space (fc, reg);
3279                   fc->col_type[reg] = DW_CFA_undefined;
3280                   break;
3281                 case DW_CFA_def_cfa:
3282                   LEB (); LEB ();
3283                   break;
3284                 case DW_CFA_def_cfa_register:
3285                   LEB ();
3286                   break;
3287                 case DW_CFA_def_cfa_offset:
3288                   LEB ();
3289                   break;
3290                 case DW_CFA_def_cfa_expression:
3291                   tmp = LEB ();
3292                   start += tmp;
3293                   break;
3294                 case DW_CFA_expression:
3295                 case DW_CFA_val_expression:
3296                   reg = LEB ();
3297                   tmp = LEB ();
3298                   start += tmp;
3299                   frame_need_space (fc, reg);
3300                   fc->col_type[reg] = DW_CFA_undefined;
3301                   break;
3302                 case DW_CFA_offset_extended_sf:
3303                 case DW_CFA_val_offset_sf:
3304                   reg = LEB (); SLEB ();
3305                   frame_need_space (fc, reg);
3306                   fc->col_type[reg] = DW_CFA_undefined;
3307                   break;
3308                 case DW_CFA_def_cfa_sf:
3309                   LEB (); SLEB ();
3310                   break;
3311                 case DW_CFA_def_cfa_offset_sf:
3312                   SLEB ();
3313                   break;
3314                 case DW_CFA_MIPS_advance_loc8:
3315                   start += 8;
3316                   break;
3317                 case DW_CFA_GNU_args_size:
3318                   LEB ();
3319                   break;
3320                 case DW_CFA_GNU_negative_offset_extended:
3321                   reg = LEB (); LEB ();
3322                   frame_need_space (fc, reg);
3323                   fc->col_type[reg] = DW_CFA_undefined;
3324
3325                 default:
3326                   break;
3327                 }
3328             }
3329           start = tmp;
3330         }
3331
3332       /* Now we know what registers are used, make a second pass over
3333          the chunk, this time actually printing out the info.  */
3334
3335       while (start < block_end)
3336         {
3337           unsigned op, opa;
3338           unsigned long ul, reg, roffs;
3339           long l, ofs;
3340           dwarf_vma vma;
3341
3342           op = *start++;
3343           opa = op & 0x3f;
3344           if (op & 0xc0)
3345             op &= 0xc0;
3346
3347           /* Warning: if you add any more cases to this switch, be
3348              sure to add them to the corresponding switch above.  */
3349           switch (op)
3350             {
3351             case DW_CFA_advance_loc:
3352               if (do_debug_frames_interp)
3353                 frame_display_row (fc, &need_col_headers, &max_regs);
3354               else
3355                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
3356                         opa * fc->code_factor,
3357                         fc->pc_begin + opa * fc->code_factor);
3358               fc->pc_begin += opa * fc->code_factor;
3359               break;
3360
3361             case DW_CFA_offset:
3362               roffs = LEB ();
3363               if (! do_debug_frames_interp)
3364                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
3365                         opa, roffs * fc->data_factor);
3366               fc->col_type[opa] = DW_CFA_offset;
3367               fc->col_offset[opa] = roffs * fc->data_factor;
3368               break;
3369
3370             case DW_CFA_restore:
3371               if (! do_debug_frames_interp)
3372                 printf ("  DW_CFA_restore: r%d\n", opa);
3373               fc->col_type[opa] = cie->col_type[opa];
3374               fc->col_offset[opa] = cie->col_offset[opa];
3375               break;
3376
3377             case DW_CFA_set_loc:
3378               vma = get_encoded_value (start, fc->fde_encoding);
3379               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3380                   && !is_relocatable)
3381                 vma += section->address + (start - section_start);
3382               start += encoded_ptr_size;
3383               if (do_debug_frames_interp)
3384                 frame_display_row (fc, &need_col_headers, &max_regs);
3385               else
3386                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3387               fc->pc_begin = vma;
3388               break;
3389
3390             case DW_CFA_advance_loc1:
3391               ofs = byte_get (start, 1); start += 1;
3392               if (do_debug_frames_interp)
3393                 frame_display_row (fc, &need_col_headers, &max_regs);
3394               else
3395                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
3396                         ofs * fc->code_factor,
3397                         fc->pc_begin + ofs * fc->code_factor);
3398               fc->pc_begin += ofs * fc->code_factor;
3399               break;
3400
3401             case DW_CFA_advance_loc2:
3402               ofs = byte_get (start, 2); start += 2;
3403               if (do_debug_frames_interp)
3404                 frame_display_row (fc, &need_col_headers, &max_regs);
3405               else
3406                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
3407                         ofs * fc->code_factor,
3408                         fc->pc_begin + ofs * fc->code_factor);
3409               fc->pc_begin += ofs * fc->code_factor;
3410               break;
3411
3412             case DW_CFA_advance_loc4:
3413               ofs = byte_get (start, 4); start += 4;
3414               if (do_debug_frames_interp)
3415                 frame_display_row (fc, &need_col_headers, &max_regs);
3416               else
3417                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
3418                         ofs * fc->code_factor,
3419                         fc->pc_begin + ofs * fc->code_factor);
3420               fc->pc_begin += ofs * fc->code_factor;
3421               break;
3422
3423             case DW_CFA_offset_extended:
3424               reg = LEB ();
3425               roffs = LEB ();
3426               if (! do_debug_frames_interp)
3427                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3428                         reg, roffs * fc->data_factor);
3429               fc->col_type[reg] = DW_CFA_offset;
3430               fc->col_offset[reg] = roffs * fc->data_factor;
3431               break;
3432
3433             case DW_CFA_val_offset:
3434               reg = LEB ();
3435               roffs = LEB ();
3436               if (! do_debug_frames_interp)
3437                 printf ("  DW_CFA_val_offset: r%ld at cfa%+ld\n",
3438                         reg, roffs * fc->data_factor);
3439               fc->col_type[reg] = DW_CFA_val_offset;
3440               fc->col_offset[reg] = roffs * fc->data_factor;
3441               break;
3442
3443             case DW_CFA_restore_extended:
3444               reg = LEB ();
3445               if (! do_debug_frames_interp)
3446                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
3447               fc->col_type[reg] = cie->col_type[reg];
3448               fc->col_offset[reg] = cie->col_offset[reg];
3449               break;
3450
3451             case DW_CFA_undefined:
3452               reg = LEB ();
3453               if (! do_debug_frames_interp)
3454                 printf ("  DW_CFA_undefined: r%ld\n", reg);
3455               fc->col_type[reg] = DW_CFA_undefined;
3456               fc->col_offset[reg] = 0;
3457               break;
3458
3459             case DW_CFA_same_value:
3460               reg = LEB ();
3461               if (! do_debug_frames_interp)
3462                 printf ("  DW_CFA_same_value: r%ld\n", reg);
3463               fc->col_type[reg] = DW_CFA_same_value;
3464               fc->col_offset[reg] = 0;
3465               break;
3466
3467             case DW_CFA_register:
3468               reg = LEB ();
3469               roffs = LEB ();
3470               if (! do_debug_frames_interp)
3471                 printf ("  DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3472               fc->col_type[reg] = DW_CFA_register;
3473               fc->col_offset[reg] = roffs;
3474               break;
3475
3476             case DW_CFA_remember_state:
3477               if (! do_debug_frames_interp)
3478                 printf ("  DW_CFA_remember_state\n");
3479               rs = xmalloc (sizeof (Frame_Chunk));
3480               rs->ncols = fc->ncols;
3481               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3482               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3483               memcpy (rs->col_type, fc->col_type, rs->ncols);
3484               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3485               rs->next = remembered_state;
3486               remembered_state = rs;
3487               break;
3488
3489             case DW_CFA_restore_state:
3490               if (! do_debug_frames_interp)
3491                 printf ("  DW_CFA_restore_state\n");
3492               rs = remembered_state;
3493               if (rs)
3494                 {
3495                   remembered_state = rs->next;
3496                   frame_need_space (fc, rs->ncols-1);
3497                   memcpy (fc->col_type, rs->col_type, rs->ncols);
3498                   memcpy (fc->col_offset, rs->col_offset,
3499                           rs->ncols * sizeof (int));
3500                   free (rs->col_type);
3501                   free (rs->col_offset);
3502                   free (rs);
3503                 }
3504               else if (do_debug_frames_interp)
3505                 printf ("Mismatched DW_CFA_restore_state\n");
3506               break;
3507
3508             case DW_CFA_def_cfa:
3509               fc->cfa_reg = LEB ();
3510               fc->cfa_offset = LEB ();
3511               fc->cfa_exp = 0;
3512               if (! do_debug_frames_interp)
3513                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
3514                         fc->cfa_reg, fc->cfa_offset);
3515               break;
3516
3517             case DW_CFA_def_cfa_register:
3518               fc->cfa_reg = LEB ();
3519               fc->cfa_exp = 0;
3520               if (! do_debug_frames_interp)
3521                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3522               break;
3523
3524             case DW_CFA_def_cfa_offset:
3525               fc->cfa_offset = LEB ();
3526               if (! do_debug_frames_interp)
3527                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3528               break;
3529
3530             case DW_CFA_nop:
3531               if (! do_debug_frames_interp)
3532                 printf ("  DW_CFA_nop\n");
3533               break;
3534
3535             case DW_CFA_def_cfa_expression:
3536               ul = LEB ();
3537               if (! do_debug_frames_interp)
3538                 {
3539                   printf ("  DW_CFA_def_cfa_expression (");
3540                   decode_location_expression (start, eh_addr_size, ul, 0);
3541                   printf (")\n");
3542                 }
3543               fc->cfa_exp = 1;
3544               start += ul;
3545               break;
3546
3547             case DW_CFA_expression:
3548               reg = LEB ();
3549               ul = LEB ();
3550               if (! do_debug_frames_interp)
3551                 {
3552                   printf ("  DW_CFA_expression: r%ld (", reg);
3553                   decode_location_expression (start, eh_addr_size, ul, 0);
3554                   printf (")\n");
3555                 }
3556               fc->col_type[reg] = DW_CFA_expression;
3557               start += ul;
3558               break;
3559
3560             case DW_CFA_val_expression:
3561               reg = LEB ();
3562               ul = LEB ();
3563               if (! do_debug_frames_interp)
3564                 {
3565                   printf ("  DW_CFA_val_expression: r%ld (", reg);
3566                   decode_location_expression (start, eh_addr_size, ul, 0);
3567                   printf (")\n");
3568                 }
3569               fc->col_type[reg] = DW_CFA_val_expression;
3570               start += ul;
3571               break;
3572
3573             case DW_CFA_offset_extended_sf:
3574               reg = LEB ();
3575               l = SLEB ();
3576               frame_need_space (fc, reg);
3577               if (! do_debug_frames_interp)
3578                 printf ("  DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3579                         reg, l * fc->data_factor);
3580               fc->col_type[reg] = DW_CFA_offset;
3581               fc->col_offset[reg] = l * fc->data_factor;
3582               break;
3583
3584             case DW_CFA_val_offset_sf:
3585               reg = LEB ();
3586               l = SLEB ();
3587               frame_need_space (fc, reg);
3588               if (! do_debug_frames_interp)
3589                 printf ("  DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3590                         reg, l * fc->data_factor);
3591               fc->col_type[reg] = DW_CFA_val_offset;
3592               fc->col_offset[reg] = l * fc->data_factor;
3593               break;
3594
3595             case DW_CFA_def_cfa_sf:
3596               fc->cfa_reg = LEB ();
3597               fc->cfa_offset = SLEB ();
3598               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3599               fc->cfa_exp = 0;
3600               if (! do_debug_frames_interp)
3601                 printf ("  DW_CFA_def_cfa_sf: r%d ofs %d\n",
3602                         fc->cfa_reg, fc->cfa_offset);
3603               break;
3604
3605             case DW_CFA_def_cfa_offset_sf:
3606               fc->cfa_offset = SLEB ();
3607               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3608               if (! do_debug_frames_interp)
3609                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3610               break;
3611
3612             case DW_CFA_MIPS_advance_loc8:
3613               ofs = byte_get (start, 8); start += 8;
3614               if (do_debug_frames_interp)
3615                 frame_display_row (fc, &need_col_headers, &max_regs);
3616               else
3617                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3618                         ofs * fc->code_factor,
3619                         fc->pc_begin + ofs * fc->code_factor);
3620               fc->pc_begin += ofs * fc->code_factor;
3621               break;
3622
3623             case DW_CFA_GNU_window_save:
3624               if (! do_debug_frames_interp)
3625                 printf ("  DW_CFA_GNU_window_save\n");
3626               break;
3627
3628             case DW_CFA_GNU_args_size:
3629               ul = LEB ();
3630               if (! do_debug_frames_interp)
3631                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
3632               break;
3633
3634             case DW_CFA_GNU_negative_offset_extended:
3635               reg = LEB ();
3636               l = - LEB ();
3637               frame_need_space (fc, reg);
3638               if (! do_debug_frames_interp)
3639                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3640                         reg, l * fc->data_factor);
3641               fc->col_type[reg] = DW_CFA_offset;
3642               fc->col_offset[reg] = l * fc->data_factor;
3643               break;
3644
3645             default:
3646               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3647                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3648               else
3649                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3650               start = block_end;
3651             }
3652         }
3653
3654       if (do_debug_frames_interp)
3655         frame_display_row (fc, &need_col_headers, &max_regs);
3656
3657       start = block_end;
3658     }
3659
3660   printf ("\n");
3661
3662   return 1;
3663 }
3664
3665 #undef GET
3666 #undef LEB
3667 #undef SLEB
3668
3669 static int
3670 display_debug_not_supported (struct dwarf_section *section,
3671                              void *file ATTRIBUTE_UNUSED)
3672 {
3673   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3674             section->name);
3675
3676   return 1;
3677 }
3678
3679 void *
3680 cmalloc (size_t nmemb, size_t size)
3681 {
3682   /* Check for overflow.  */
3683   if (nmemb >= ~(size_t) 0 / size)
3684     return NULL;
3685   else
3686     return malloc (nmemb * size);
3687 }
3688
3689 void *
3690 xcmalloc (size_t nmemb, size_t size)
3691 {
3692   /* Check for overflow.  */
3693   if (nmemb >= ~(size_t) 0 / size)
3694     return NULL;
3695   else
3696     return xmalloc (nmemb * size);
3697 }
3698
3699 void *
3700 xcrealloc (void *ptr, size_t nmemb, size_t size)
3701 {
3702   /* Check for overflow.  */
3703   if (nmemb >= ~(size_t) 0 / size)
3704     return NULL;
3705   else
3706     return xrealloc (ptr, nmemb * size);
3707 }
3708
3709 void
3710 error (const char *message, ...)
3711 {
3712   va_list args;
3713
3714   va_start (args, message);
3715   fprintf (stderr, _("%s: Error: "), program_name);
3716   vfprintf (stderr, message, args);
3717   va_end (args);
3718 }
3719
3720 void
3721 warn (const char *message, ...)
3722 {
3723   va_list args;
3724
3725   va_start (args, message);
3726   fprintf (stderr, _("%s: Warning: "), program_name);
3727   vfprintf (stderr, message, args);
3728   va_end (args);
3729 }
3730
3731 void
3732 free_debug_memory (void)
3733 {
3734   enum dwarf_section_display_enum i;
3735
3736   free_abbrevs ();
3737
3738   for (i = 0; i < max; i++)
3739     free_debug_section (i);
3740
3741   if (debug_information)
3742     {
3743       for (i = 0; i < num_debug_info_entries; i++)
3744         {
3745           if (!debug_information [i].max_loc_offsets)
3746             {
3747               free (debug_information [i].loc_offsets);
3748               free (debug_information [i].have_frame_base);
3749             }
3750           if (!debug_information [i].max_range_lists)
3751             free (debug_information [i].range_lists);
3752         }
3753       free (debug_information);
3754       debug_information = NULL;
3755       num_debug_info_entries = 0;
3756     }
3757
3758 }
3759
3760 struct dwarf_section_display debug_displays[] =
3761 {
3762   { { ".debug_abbrev",          NULL,   0,      0 },
3763     display_debug_abbrev,               0,      0 },
3764   { { ".debug_aranges",         NULL,   0,      0 },
3765     display_debug_aranges,              0,      0 },
3766   { { ".debug_frame",           NULL,   0,      0 },
3767     display_debug_frames,               1,      0 },
3768   { { ".debug_info",            NULL,   0,      0 },
3769     display_debug_info,                 1,      0 },
3770   { { ".debug_line",            NULL,   0,      0 },
3771     display_debug_lines,                0,      0 },
3772   { { ".debug_pubnames",        NULL,   0,      0 },
3773     display_debug_pubnames,             0,      0 },
3774   { { ".eh_frame",              NULL,   0,      0 },
3775     display_debug_frames,               1,      1 },
3776   { { ".debug_macinfo",         NULL,   0,      0 },
3777     display_debug_macinfo,              0,      0 },
3778   { { ".debug_str",             NULL,   0,      0 },
3779     display_debug_str,                  0,      0 },
3780   { { ".debug_loc",             NULL,   0,      0 },
3781     display_debug_loc,                  0,      0 },
3782   { { ".debug_pubtypes",        NULL,   0,      0 },
3783     display_debug_pubnames,             0,      0 },
3784   { { ".debug_ranges",          NULL,   0,      0 },
3785     display_debug_ranges,               0,      0 },
3786   { { ".debug_static_func",     NULL,   0,      0 },
3787     display_debug_not_supported,        0,      0 },
3788   { { ".debug_static_vars",     NULL,   0,      0 },
3789     display_debug_not_supported,        0,      0 },
3790   { { ".debug_types",           NULL,   0,      0 },
3791     display_debug_not_supported,        0,      0 },
3792   { { ".debug_weaknames",       NULL,   0,      0 },
3793     display_debug_not_supported,        0,      0 }
3794 };