binutils/dwarf.c

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