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, int pointer_size)
 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, pointer_size);
 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       start += compunit.cu_length + initial_length_size;
1608
1609       cu_abbrev_offset_ptr = hdrptr;
1610       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1611       hdrptr += offset_size;
1612
1613       compunit.cu_pointer_size = byte_get (hdrptr, 1);
1614       hdrptr += 1;
1615       if ((do_loc || do_debug_loc || do_debug_ranges)
1616           && num_debug_info_entries == 0)
1617         {
1618           debug_information [unit].cu_offset = cu_offset;
1619           debug_information [unit].pointer_size
1620             = compunit.cu_pointer_size;
1621           debug_information [unit].base_address = 0;
1622           debug_information [unit].loc_offsets = NULL;
1623           debug_information [unit].have_frame_base = NULL;
1624           debug_information [unit].max_loc_offsets = 0;
1625           debug_information [unit].num_loc_offsets = 0;
1626           debug_information [unit].range_lists = NULL;
1627           debug_information [unit].max_range_lists= 0;
1628           debug_information [unit].num_range_lists = 0;
1629         }
1630
1631       tags = hdrptr;
1632
1633       if (!do_loc)
1634         {
1635           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1636           printf (_("   Length:        %ld\n"), compunit.cu_length);
1637           printf (_("   Version:       %d\n"), compunit.cu_version);
1638           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1639           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
1640         }
1641
1642       if (compunit.cu_version != 2 && compunit.cu_version != 3)
1643         {
1644           warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1645           continue;
1646         }
1647
1648       free_abbrevs ();
1649
1650       /* Process the abbrevs used by this compilation unit. DWARF
1651          sections under Mach-O have non-zero addresses.  */
1652       process_abbrev_section
1653         ((unsigned char *) debug_displays [abbrev].section.start
1654          + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1655          (unsigned char *) debug_displays [abbrev].section.start
1656          + debug_displays [abbrev].section.size);
1657
1658       level = 0;
1659       while (tags < start)
1660         {
1661           unsigned int bytes_read;
1662           unsigned long abbrev_number;
1663           abbrev_entry *entry;
1664           abbrev_attr *attr;
1665
1666           abbrev_number = read_leb128 (tags, & bytes_read, 0);
1667           tags += bytes_read;
1668
1669           /* A null DIE marks the end of a list of children.  */
1670           if (abbrev_number == 0)
1671             {
1672               --level;
1673               continue;
1674             }
1675
1676           /* Scan through the abbreviation list until we reach the
1677              correct entry.  */
1678           for (entry = first_abbrev;
1679                entry && entry->entry != abbrev_number;
1680                entry = entry->next)
1681             continue;
1682
1683           if (entry == NULL)
1684             {
1685               warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1686                     abbrev_number);
1687               return 0;
1688             }
1689
1690           if (!do_loc)
1691             printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
1692                     level,
1693                     (unsigned long) (tags - section_begin
1694                                      - bytes_read),
1695                     abbrev_number,
1696                     get_TAG_name (entry->tag));
1697
1698           switch (entry->tag)
1699             {
1700             default:
1701               need_base_address = 0;
1702               break;
1703             case DW_TAG_compile_unit:
1704               need_base_address = 1;
1705               break;
1706             case DW_TAG_entry_point:
1707             case DW_TAG_inlined_subroutine:
1708             case DW_TAG_subprogram:
1709               need_base_address = 0;
1710               /* Assuming that there is no DW_AT_frame_base.  */
1711               have_frame_base = 0;
1712               break;
1713             }
1714
1715           for (attr = entry->first_attr; attr; attr = attr->next)
1716             tags = read_and_display_attr (attr->attribute,
1717                                           attr->form,
1718                                           tags, cu_offset,
1719                                           compunit.cu_pointer_size,
1720                                           offset_size,
1721                                           compunit.cu_version,
1722                                           &debug_information [unit],
1723                                           do_loc);
1724
1725           if (entry->children)
1726             ++level;
1727         }
1728     }
1729
1730   /* Set num_debug_info_entries here so that it can be used to check if
1731      we need to process .debug_loc and .debug_ranges sections.  */
1732   if ((do_loc || do_debug_loc || do_debug_ranges)
1733       && num_debug_info_entries == 0)
1734     num_debug_info_entries = num_units;
1735
1736   if (!do_loc)
1737     {
1738       printf ("\n");
1739     }
1740
1741   return 1;
1742 }
1743
1744 /* Locate and scan the .debug_info section in the file and record the pointer
1745    sizes and offsets for the compilation units in it.  Usually an executable
1746    will have just one pointer size, but this is not guaranteed, and so we try
1747    not to make any assumptions.  Returns zero upon failure, or the number of
1748    compilation units upon success.  */
1749
1750 static unsigned int
1751 load_debug_info (void * file)
1752 {
1753   /* Reset the last pointer size so that we can issue correct error
1754      messages if we are displaying the contents of more than one section.  */
1755   last_pointer_size = 0;
1756   warned_about_missing_comp_units = FALSE;
1757
1758   /* If we already have the information there is nothing else to do.  */
1759   if (num_debug_info_entries > 0)
1760     return num_debug_info_entries;
1761
1762   if (load_debug_section (info, file)
1763       && process_debug_info (&debug_displays [info].section, file, 1))
1764     return num_debug_info_entries;
1765   else
1766     return 0;
1767 }
1768
1769 /* Retrieve the pointer size associated with the given compilation unit.
1770    Optionally the offset of this unit into the .debug_info section is
1771    also retutned.  If there is no .debug_info section then an error
1772    message is issued and 0 is returned.  If the requested comp unit has
1773    not been defined in the .debug_info section then a warning message
1774    is issued and the last know pointer size is returned.  This message
1775    is only issued once per section dumped per file dumped.  */
1776
1777 static unsigned int
1778 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit,
1779                                           const char * section_name,
1780                                           unsigned long * offset_return)
1781 {
1782   unsigned long offset = 0;
1783
1784   if (num_debug_info_entries == 0)
1785     error (_("%s section needs a populated .debug_info section\n"),
1786            section_name);
1787
1788   else if (comp_unit >= num_debug_info_entries)
1789     {
1790       if (!warned_about_missing_comp_units)
1791         {
1792           warn (_("%s section has more comp units than .debug_info section\n"),
1793                 section_name);
1794           warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
1795                 last_pointer_size);
1796           warned_about_missing_comp_units = TRUE;
1797         }
1798     }
1799   else
1800     {
1801       last_pointer_size = debug_information [comp_unit].pointer_size;
1802       offset = debug_information [comp_unit].cu_offset;
1803     }
1804
1805   if (offset_return != NULL)
1806     * offset_return = offset;
1807
1808   return last_pointer_size;
1809 }
1810
1811 static int
1812 display_debug_lines (struct dwarf_section *section, void *file)
1813 {
1814   unsigned char *start = section->start;
1815   unsigned char *data = start;
1816   unsigned char *end = start + section->size;
1817   unsigned int comp_unit = 0;
1818
1819   printf (_("\nDump of debug contents of section %s:\n\n"),
1820           section->name);
1821
1822   load_debug_info (file);
1823
1824   while (data < end)
1825     {
1826       DWARF2_Internal_LineInfo info;
1827       unsigned char *standard_opcodes;
1828       unsigned char *end_of_sequence;
1829       unsigned char *hdrptr;
1830       unsigned int pointer_size;
1831       int initial_length_size;
1832       int offset_size;
1833       int i;
1834
1835       hdrptr = data;
1836
1837       /* Check the length of the block.  */
1838       info.li_length = byte_get (hdrptr, 4);
1839       hdrptr += 4;
1840
1841       if (info.li_length == 0xffffffff)
1842         {
1843           /* This section is 64-bit DWARF 3.  */
1844           info.li_length = byte_get (hdrptr, 8);
1845           hdrptr += 8;
1846           offset_size = 8;
1847           initial_length_size = 12;
1848         }
1849       else
1850         {
1851           offset_size = 4;
1852           initial_length_size = 4;
1853         }
1854
1855       if (info.li_length + initial_length_size > section->size)
1856         {
1857           warn
1858             (_("The line info appears to be corrupt - the section is too small\n"));
1859           return 0;
1860         }
1861
1862       /* Check its version number.  */
1863       info.li_version = byte_get (hdrptr, 2);
1864       hdrptr += 2;
1865       if (info.li_version != 2 && info.li_version != 3)
1866         {
1867           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1868           return 0;
1869         }
1870
1871       info.li_prologue_length = byte_get (hdrptr, offset_size);
1872       hdrptr += offset_size;
1873       info.li_min_insn_length = byte_get (hdrptr, 1);
1874       hdrptr++;
1875       info.li_default_is_stmt = byte_get (hdrptr, 1);
1876       hdrptr++;
1877       info.li_line_base = byte_get (hdrptr, 1);
1878       hdrptr++;
1879       info.li_line_range = byte_get (hdrptr, 1);
1880       hdrptr++;
1881       info.li_opcode_base = byte_get (hdrptr, 1);
1882       hdrptr++;
1883
1884       /* Sign extend the line base field.  */
1885       info.li_line_base <<= 24;
1886       info.li_line_base >>= 24;
1887
1888       /* Get the pointer size from the comp unit associated
1889          with this block of line number information.  */
1890       pointer_size = get_pointer_size_and_offset_of_comp_unit
1891         (comp_unit, ".debug_line", NULL);
1892       comp_unit ++;
1893
1894       printf (_("  Length:                      %ld\n"), info.li_length);
1895       printf (_("  DWARF Version:               %d\n"), info.li_version);
1896       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
1897       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
1898       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
1899       printf (_("  Line Base:                   %d\n"), info.li_line_base);
1900       printf (_("  Line Range:                  %d\n"), info.li_line_range);
1901       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
1902       printf (_("  (Pointer size:               %u)%s\n"),
1903               pointer_size,
1904               warned_about_missing_comp_units ? " [assumed]" : "" );
1905
1906       end_of_sequence = data + info.li_length + initial_length_size;
1907
1908       reset_state_machine (info.li_default_is_stmt);
1909
1910       /* Display the contents of the Opcodes table.  */
1911       standard_opcodes = hdrptr;
1912
1913       printf (_("\n Opcodes:\n"));
1914
1915       for (i = 1; i < info.li_opcode_base; i++)
1916         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
1917
1918       /* Display the contents of the Directory table.  */
1919       data = standard_opcodes + info.li_opcode_base - 1;
1920
1921       if (*data == 0)
1922         printf (_("\n The Directory Table is empty.\n"));
1923       else
1924         {
1925           printf (_("\n The Directory Table:\n"));
1926
1927           while (*data != 0)
1928             {
1929               printf (_("  %s\n"), data);
1930
1931               data += strlen ((char *) data) + 1;
1932             }
1933         }
1934
1935       /* Skip the NUL at the end of the table.  */
1936       data++;
1937
1938       /* Display the contents of the File Name table.  */
1939       if (*data == 0)
1940         printf (_("\n The File Name Table is empty.\n"));
1941       else
1942         {
1943           printf (_("\n The File Name Table:\n"));
1944           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
1945
1946           while (*data != 0)
1947             {
1948               unsigned char *name;
1949               unsigned int bytes_read;
1950
1951               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
1952               name = data;
1953
1954               data += strlen ((char *) data) + 1;
1955
1956               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1957               data += bytes_read;
1958               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1959               data += bytes_read;
1960               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1961               data += bytes_read;
1962               printf (_("%s\n"), name);
1963             }
1964         }
1965
1966       /* Skip the NUL at the end of the table.  */
1967       data++;
1968
1969       /* Now display the statements.  */
1970       printf (_("\n Line Number Statements:\n"));
1971
1972       while (data < end_of_sequence)
1973         {
1974           unsigned char op_code;
1975           int adv;
1976           unsigned long int uladv;
1977           unsigned int bytes_read;
1978
1979           op_code = *data++;
1980
1981           if (op_code >= info.li_opcode_base)
1982             {
1983               op_code -= info.li_opcode_base;
1984               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
1985               state_machine_regs.address += uladv;
1986               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
1987                       op_code, uladv, state_machine_regs.address);
1988               adv = (op_code % info.li_line_range) + info.li_line_base;
1989               state_machine_regs.line += adv;
1990               printf (_(" and Line by %d to %d\n"),
1991                       adv, state_machine_regs.line);
1992             }
1993           else switch (op_code)
1994             {
1995             case DW_LNS_extended_op:
1996               if (pointer_size == 0)
1997                 {
1998                   warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
1999                   pointer_size = 4;
2000                 }
2001
2002               data += process_extended_line_op (data, info.li_default_is_stmt,
2003                                                 pointer_size);
2004               break;
2005
2006             case DW_LNS_copy:
2007               printf (_("  Copy\n"));
2008               break;
2009
2010             case DW_LNS_advance_pc:
2011               uladv = read_leb128 (data, & bytes_read, 0);
2012               uladv *= info.li_min_insn_length;
2013               data += bytes_read;
2014               state_machine_regs.address += uladv;
2015               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2016                       state_machine_regs.address);
2017               break;
2018
2019             case DW_LNS_advance_line:
2020               adv = read_leb128 (data, & bytes_read, 1);
2021               data += bytes_read;
2022               state_machine_regs.line += adv;
2023               printf (_("  Advance Line by %d to %d\n"), adv,
2024                       state_machine_regs.line);
2025               break;
2026
2027             case DW_LNS_set_file:
2028               adv = read_leb128 (data, & bytes_read, 0);
2029               data += bytes_read;
2030               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2031                       adv);
2032               state_machine_regs.file = adv;
2033               break;
2034
2035             case DW_LNS_set_column:
2036               uladv = read_leb128 (data, & bytes_read, 0);
2037               data += bytes_read;
2038               printf (_("  Set column to %lu\n"), uladv);
2039               state_machine_regs.column = uladv;
2040               break;
2041
2042             case DW_LNS_negate_stmt:
2043               adv = state_machine_regs.is_stmt;
2044               adv = ! adv;
2045               printf (_("  Set is_stmt to %d\n"), adv);
2046               state_machine_regs.is_stmt = adv;
2047               break;
2048
2049             case DW_LNS_set_basic_block:
2050               printf (_("  Set basic block\n"));
2051               state_machine_regs.basic_block = 1;
2052               break;
2053
2054             case DW_LNS_const_add_pc:
2055               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2056                       * info.li_min_insn_length);
2057               state_machine_regs.address += uladv;
2058               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2059                       state_machine_regs.address);
2060               break;
2061
2062             case DW_LNS_fixed_advance_pc:
2063               uladv = byte_get (data, 2);
2064               data += 2;
2065               state_machine_regs.address += uladv;
2066               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2067                       uladv, state_machine_regs.address);
2068               break;
2069
2070             case DW_LNS_set_prologue_end:
2071               printf (_("  Set prologue_end to true\n"));
2072               break;
2073
2074             case DW_LNS_set_epilogue_begin:
2075               printf (_("  Set epilogue_begin to true\n"));
2076               break;
2077
2078             case DW_LNS_set_isa:
2079               uladv = read_leb128 (data, & bytes_read, 0);
2080               data += bytes_read;
2081               printf (_("  Set ISA to %lu\n"), uladv);
2082               break;
2083
2084             default:
2085               printf (_("  Unknown opcode %d with operands: "), op_code);
2086
2087               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2088                 {
2089                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2090                           i == 1 ? "" : ", ");
2091                   data += bytes_read;
2092                 }
2093               putchar ('\n');
2094               break;
2095             }
2096         }
2097       putchar ('\n');
2098     }
2099
2100   return 1;
2101 }
2102
2103 static int
2104 display_debug_pubnames (struct dwarf_section *section,
2105                         void *file ATTRIBUTE_UNUSED)
2106 {
2107   DWARF2_Internal_PubNames pubnames;
2108   unsigned char *start = section->start;
2109   unsigned char *end = start + section->size;
2110
2111   printf (_("Contents of the %s section:\n\n"), section->name);
2112
2113   while (start < end)
2114     {
2115       unsigned char *data;
2116       unsigned long offset;
2117       int offset_size, initial_length_size;
2118
2119       data = start;
2120
2121       pubnames.pn_length = byte_get (data, 4);
2122       data += 4;
2123       if (pubnames.pn_length == 0xffffffff)
2124         {
2125           pubnames.pn_length = byte_get (data, 8);
2126           data += 8;
2127           offset_size = 8;
2128           initial_length_size = 12;
2129         }
2130       else
2131         {
2132           offset_size = 4;
2133           initial_length_size = 4;
2134         }
2135
2136       pubnames.pn_version = byte_get (data, 2);
2137       data += 2;
2138       pubnames.pn_offset = byte_get (data, offset_size);
2139       data += offset_size;
2140       pubnames.pn_size = byte_get (data, offset_size);
2141       data += offset_size;
2142
2143       start += pubnames.pn_length + initial_length_size;
2144
2145       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2146         {
2147           static int warned = 0;
2148
2149           if (! warned)
2150             {
2151               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2152               warned = 1;
2153             }
2154
2155           continue;
2156         }
2157
2158       printf (_("  Length:                              %ld\n"),
2159               pubnames.pn_length);
2160       printf (_("  Version:                             %d\n"),
2161               pubnames.pn_version);
2162       printf (_("  Offset into .debug_info section:     %ld\n"),
2163               pubnames.pn_offset);
2164       printf (_("  Size of area in .debug_info section: %ld\n"),
2165               pubnames.pn_size);
2166
2167       printf (_("\n    Offset\tName\n"));
2168
2169       do
2170         {
2171           offset = byte_get (data, offset_size);
2172
2173           if (offset != 0)
2174             {
2175               data += offset_size;
2176               printf ("    %-6ld\t\t%s\n", offset, data);
2177               data += strlen ((char *) data) + 1;
2178             }
2179         }
2180       while (offset != 0);
2181     }
2182
2183   printf ("\n");
2184   return 1;
2185 }
2186
2187 static int
2188 display_debug_macinfo (struct dwarf_section *section,
2189                        void *file ATTRIBUTE_UNUSED)
2190 {
2191   unsigned char *start = section->start;
2192   unsigned char *end = start + section->size;
2193   unsigned char *curr = start;
2194   unsigned int bytes_read;
2195   enum dwarf_macinfo_record_type op;
2196
2197   printf (_("Contents of the %s section:\n\n"), section->name);
2198
2199   while (curr < end)
2200     {
2201       unsigned int lineno;
2202       const char *string;
2203
2204       op = *curr;
2205       curr++;
2206
2207       switch (op)
2208         {
2209         case DW_MACINFO_start_file:
2210           {
2211             unsigned int filenum;
2212
2213             lineno = read_leb128 (curr, & bytes_read, 0);
2214             curr += bytes_read;
2215             filenum = read_leb128 (curr, & bytes_read, 0);
2216             curr += bytes_read;
2217
2218             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2219                     lineno, filenum);
2220           }
2221           break;
2222
2223         case DW_MACINFO_end_file:
2224           printf (_(" DW_MACINFO_end_file\n"));
2225           break;
2226
2227         case DW_MACINFO_define:
2228           lineno = read_leb128 (curr, & bytes_read, 0);
2229           curr += bytes_read;
2230           string = (char *) curr;
2231           curr += strlen (string) + 1;
2232           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2233                   lineno, string);
2234           break;
2235
2236         case DW_MACINFO_undef:
2237           lineno = read_leb128 (curr, & bytes_read, 0);
2238           curr += bytes_read;
2239           string = (char *) curr;
2240           curr += strlen (string) + 1;
2241           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2242                   lineno, string);
2243           break;
2244
2245         case DW_MACINFO_vendor_ext:
2246           {
2247             unsigned int constant;
2248
2249             constant = read_leb128 (curr, & bytes_read, 0);
2250             curr += bytes_read;
2251             string = (char *) curr;
2252             curr += strlen (string) + 1;
2253             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2254                     constant, string);
2255           }
2256           break;
2257         }
2258     }
2259
2260   return 1;
2261 }
2262
2263 static int
2264 display_debug_abbrev (struct dwarf_section *section,
2265                       void *file ATTRIBUTE_UNUSED)
2266 {
2267   abbrev_entry *entry;
2268   unsigned char *start = section->start;
2269   unsigned char *end = start + section->size;
2270
2271   printf (_("Contents of the %s section:\n\n"), section->name);
2272
2273   do
2274     {
2275       free_abbrevs ();
2276
2277       start = process_abbrev_section (start, end);
2278
2279       if (first_abbrev == NULL)
2280         continue;
2281
2282       printf (_("  Number TAG\n"));
2283
2284       for (entry = first_abbrev; entry; entry = entry->next)
2285         {
2286           abbrev_attr *attr;
2287
2288           printf (_("   %ld      %s    [%s]\n"),
2289                   entry->entry,
2290                   get_TAG_name (entry->tag),
2291                   entry->children ? _("has children") : _("no children"));
2292
2293           for (attr = entry->first_attr; attr; attr = attr->next)
2294             printf (_("    %-18s %s\n"),
2295                     get_AT_name (attr->attribute),
2296                     get_FORM_name (attr->form));
2297         }
2298     }
2299   while (start);
2300
2301   printf ("\n");
2302
2303   return 1;
2304 }
2305
2306 static int
2307 display_debug_loc (struct dwarf_section *section, void *file)
2308 {
2309   unsigned char *start = section->start;
2310   unsigned char *section_end;
2311   unsigned long bytes;
2312   unsigned char *section_begin = start;
2313   unsigned int num_loc_list = 0;
2314   unsigned long last_offset = 0;
2315   unsigned int first = 0;
2316   unsigned int i;
2317   unsigned int j;
2318   int seen_first_offset = 0;
2319   int use_debug_info = 1;
2320   unsigned char *next;
2321
2322   bytes = section->size;
2323   section_end = start + bytes;
2324
2325   if (bytes == 0)
2326     {
2327       printf (_("\nThe %s section is empty.\n"), section->name);
2328       return 0;
2329     }
2330
2331   load_debug_info (file);
2332
2333   /* Check the order of location list in .debug_info section. If
2334      offsets of location lists are in the ascending order, we can
2335      use `debug_information' directly.  */
2336   for (i = 0; i < num_debug_info_entries; i++)
2337     {
2338       unsigned int num;
2339
2340       num = debug_information [i].num_loc_offsets;
2341       num_loc_list += num;
2342
2343       /* Check if we can use `debug_information' directly.  */
2344       if (use_debug_info && num != 0)
2345         {
2346           if (!seen_first_offset)
2347             {
2348               /* This is the first location list.  */
2349               last_offset = debug_information [i].loc_offsets [0];
2350               first = i;
2351               seen_first_offset = 1;
2352               j = 1;
2353             }
2354           else
2355             j = 0;
2356
2357           for (; j < num; j++)
2358             {
2359               if (last_offset >
2360                   debug_information [i].loc_offsets [j])
2361                 {
2362                   use_debug_info = 0;
2363                   break;
2364                 }
2365               last_offset = debug_information [i].loc_offsets [j];
2366             }
2367         }
2368     }
2369
2370   if (!use_debug_info)
2371     /* FIXME: Should we handle this case?  */
2372     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2373
2374   if (!seen_first_offset)
2375     error (_("No location lists in .debug_info section!\n"));
2376
2377   /* DWARF sections under Mach-O have non-zero addresses.  */
2378   if (debug_information [first].loc_offsets [0] != section->address)
2379     warn (_("Location lists in %s section start at 0x%lx\n"),
2380           section->name, debug_information [first].loc_offsets [0]);
2381
2382   printf (_("Contents of the %s section:\n\n"), section->name);
2383   printf (_("    Offset   Begin    End      Expression\n"));
2384
2385   seen_first_offset = 0;
2386   for (i = first; i < num_debug_info_entries; i++)
2387     {
2388       unsigned long begin;
2389       unsigned long end;
2390       unsigned short length;
2391       unsigned long offset;
2392       unsigned int pointer_size;
2393       unsigned long cu_offset;
2394       unsigned long base_address;
2395       int need_frame_base;
2396       int has_frame_base;
2397
2398       pointer_size = debug_information [i].pointer_size;
2399       cu_offset = debug_information [i].cu_offset;
2400
2401       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2402         {
2403           has_frame_base = debug_information [i].have_frame_base [j];
2404           /* DWARF sections under Mach-O have non-zero addresses.  */
2405           offset = debug_information [i].loc_offsets [j] - section->address;
2406           next = section_begin + offset;
2407           base_address = debug_information [i].base_address;
2408
2409           if (!seen_first_offset)
2410             seen_first_offset = 1;
2411           else
2412             {
2413               if (start < next)
2414                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2415                       (long)(start - section_begin), (long)(next - section_begin));
2416               else if (start > next)
2417                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2418                       (long)(start - section_begin), (long)(next - section_begin));
2419             }
2420           start = next;
2421
2422           if (offset >= bytes)
2423             {
2424               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2425                     offset);
2426               continue;
2427             }
2428
2429           while (1)
2430             {
2431               if (start + 2 * pointer_size > section_end)
2432                 {
2433                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2434                         offset);
2435                   break;
2436                 }
2437
2438               begin = byte_get (start, pointer_size);
2439               start += pointer_size;
2440               end = byte_get (start, pointer_size);
2441               start += pointer_size;
2442
2443               if (begin == 0 && end == 0)
2444                 {
2445                   printf (_("    %8.8lx <End of list>\n"), offset);
2446                   break;
2447                 }
2448
2449               /* Check base address specifiers.  */
2450               if (begin == -1UL && end != -1UL)
2451                 {
2452                   base_address = end;
2453                   printf (_("    %8.8lx %8.8lx %8.8lx (base address)\n"),
2454                           offset, begin, end);
2455                   continue;
2456                 }
2457
2458               if (start + 2 > section_end)
2459                 {
2460                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2461                         offset);
2462                   break;
2463                 }
2464
2465               length = byte_get (start, 2);
2466               start += 2;
2467
2468               if (start + length > section_end)
2469                 {
2470                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2471                         offset);
2472                   break;
2473                 }
2474
2475               printf ("    %8.8lx %8.8lx %8.8lx (",
2476                       offset, begin + base_address, end + base_address);
2477               need_frame_base = decode_location_expression (start,
2478                                                             pointer_size,
2479                                                             length,
2480                                                             cu_offset);
2481               putchar (')');
2482
2483               if (need_frame_base && !has_frame_base)
2484                 printf (_(" [without DW_AT_frame_base]"));
2485
2486               if (begin == end)
2487                 fputs (_(" (start == end)"), stdout);
2488               else if (begin > end)
2489                 fputs (_(" (start > end)"), stdout);
2490
2491               putchar ('\n');
2492
2493               start += length;
2494             }
2495         }
2496     }
2497   return 1;
2498 }
2499
2500 static int
2501 display_debug_str (struct dwarf_section *section,
2502                    void *file ATTRIBUTE_UNUSED)
2503 {
2504   unsigned char *start = section->start;
2505   unsigned long bytes = section->size;
2506   dwarf_vma addr = section->address;
2507
2508   if (bytes == 0)
2509     {
2510       printf (_("\nThe %s section is empty.\n"), section->name);
2511       return 0;
2512     }
2513
2514   printf (_("Contents of the %s section:\n\n"), section->name);
2515
2516   while (bytes)
2517     {
2518       int j;
2519       int k;
2520       int lbytes;
2521
2522       lbytes = (bytes > 16 ? 16 : bytes);
2523
2524       printf ("  0x%8.8lx ", (unsigned long) addr);
2525
2526       for (j = 0; j < 16; j++)
2527         {
2528           if (j < lbytes)
2529             printf ("%2.2x", start[j]);
2530           else
2531             printf ("  ");
2532
2533           if ((j & 3) == 3)
2534             printf (" ");
2535         }
2536
2537       for (j = 0; j < lbytes; j++)
2538         {
2539           k = start[j];
2540           if (k >= ' ' && k < 0x80)
2541             printf ("%c", k);
2542           else
2543             printf (".");
2544         }
2545
2546       putchar ('\n');
2547
2548       start += lbytes;
2549       addr  += lbytes;
2550       bytes -= lbytes;
2551     }
2552
2553   putchar ('\n');
2554
2555   return 1;
2556 }
2557
2558
2559 static int
2560 display_debug_info (struct dwarf_section *section, void *file)
2561 {
2562   return process_debug_info (section, file, 0);
2563 }
2564
2565
2566 static int
2567 display_debug_aranges (struct dwarf_section *section,
2568                        void *file ATTRIBUTE_UNUSED)
2569 {
2570   unsigned char *start = section->start;
2571   unsigned char *end = start + section->size;
2572
2573   printf (_("The section %s contains:\n\n"), section->name);
2574
2575   while (start < end)
2576     {
2577       unsigned char *hdrptr;
2578       DWARF2_Internal_ARange arange;
2579       unsigned char *ranges;
2580       unsigned long length;
2581       unsigned long address;
2582       int excess;
2583       int offset_size;
2584       int initial_length_size;
2585
2586       hdrptr = start;
2587
2588       arange.ar_length = byte_get (hdrptr, 4);
2589       hdrptr += 4;
2590
2591       if (arange.ar_length == 0xffffffff)
2592         {
2593           arange.ar_length = byte_get (hdrptr, 8);
2594           hdrptr += 8;
2595           offset_size = 8;
2596           initial_length_size = 12;
2597         }
2598       else
2599         {
2600           offset_size = 4;
2601           initial_length_size = 4;
2602         }
2603
2604       arange.ar_version = byte_get (hdrptr, 2);
2605       hdrptr += 2;
2606
2607       arange.ar_info_offset = byte_get (hdrptr, offset_size);
2608       hdrptr += offset_size;
2609
2610       arange.ar_pointer_size = byte_get (hdrptr, 1);
2611       hdrptr += 1;
2612
2613       arange.ar_segment_size = byte_get (hdrptr, 1);
2614       hdrptr += 1;
2615
2616       if (arange.ar_version != 2 && arange.ar_version != 3)
2617         {
2618           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2619           break;
2620         }
2621
2622       printf (_("  Length:                   %ld\n"), arange.ar_length);
2623       printf (_("  Version:                  %d\n"), arange.ar_version);
2624       printf (_("  Offset into .debug_info:  %lx\n"), arange.ar_info_offset);
2625       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
2626       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
2627
2628       printf (_("\n    Address  Length\n"));
2629
2630       ranges = hdrptr;
2631
2632       /* Must pad to an alignment boundary that is twice the pointer size.  */
2633       excess = (hdrptr - start) % (2 * arange.ar_pointer_size);
2634       if (excess)
2635         ranges += (2 * arange.ar_pointer_size) - excess;
2636
2637       for (;;)
2638         {
2639           address = byte_get (ranges, arange.ar_pointer_size);
2640
2641           ranges += arange.ar_pointer_size;
2642
2643           length  = byte_get (ranges, arange.ar_pointer_size);
2644
2645           ranges += arange.ar_pointer_size;
2646
2647           /* A pair of zeros marks the end of the list.  */
2648           if (address == 0 && length == 0)
2649             break;
2650
2651           printf ("    %8.8lx %lu\n", address, length);
2652         }
2653
2654       start += arange.ar_length + initial_length_size;
2655     }
2656
2657   printf ("\n");
2658
2659   return 1;
2660 }
2661
2662 static int
2663 display_debug_ranges (struct dwarf_section *section,
2664                       void *file ATTRIBUTE_UNUSED)
2665 {
2666   unsigned char *start = section->start;
2667   unsigned char *section_end;
2668   unsigned long bytes;
2669   unsigned char *section_begin = start;
2670   unsigned int num_range_list = 0;
2671   unsigned long last_offset = 0;
2672   unsigned int first = 0;
2673   unsigned int i;
2674   unsigned int j;
2675   int seen_first_offset = 0;
2676   int use_debug_info = 1;
2677   unsigned char *next;
2678
2679   bytes = section->size;
2680   section_end = start + bytes;
2681
2682   if (bytes == 0)
2683     {
2684       printf (_("\nThe %s section is empty.\n"), section->name);
2685       return 0;
2686     }
2687
2688   load_debug_info (file);
2689
2690   /* Check the order of range list in .debug_info section. If
2691      offsets of range lists are in the ascending order, we can
2692      use `debug_information' directly.  */
2693   for (i = 0; i < num_debug_info_entries; i++)
2694     {
2695       unsigned int num;
2696
2697       num = debug_information [i].num_range_lists;
2698       num_range_list += num;
2699
2700       /* Check if we can use `debug_information' directly.  */
2701       if (use_debug_info && num != 0)
2702         {
2703           if (!seen_first_offset)
2704             {
2705               /* This is the first range list.  */
2706               last_offset = debug_information [i].range_lists [0];
2707               first = i;
2708               seen_first_offset = 1;
2709               j = 1;
2710             }
2711           else
2712             j = 0;
2713
2714           for (; j < num; j++)
2715             {
2716               if (last_offset >
2717                   debug_information [i].range_lists [j])
2718                 {
2719                   use_debug_info = 0;
2720                   break;
2721                 }
2722               last_offset = debug_information [i].range_lists [j];
2723             }
2724         }
2725     }
2726
2727   if (!use_debug_info)
2728     /* FIXME: Should we handle this case?  */
2729     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2730
2731   if (!seen_first_offset)
2732     error (_("No range lists in .debug_info section!\n"));
2733
2734   /* DWARF sections under Mach-O have non-zero addresses.  */
2735   if (debug_information [first].range_lists [0] != section->address)
2736     warn (_("Range lists in %s section start at 0x%lx\n"),
2737           section->name, debug_information [first].range_lists [0]);
2738
2739   printf (_("Contents of the %s section:\n\n"), section->name);
2740   printf (_("    Offset   Begin    End\n"));
2741
2742   seen_first_offset = 0;
2743   for (i = first; i < num_debug_info_entries; i++)
2744     {
2745       unsigned long begin;
2746       unsigned long end;
2747       unsigned long offset;
2748       unsigned int pointer_size;
2749       unsigned long base_address;
2750
2751       pointer_size = debug_information [i].pointer_size;
2752
2753       for (j = 0; j < debug_information [i].num_range_lists; j++)
2754         {
2755           /* DWARF sections under Mach-O have non-zero addresses.  */
2756           offset = debug_information [i].range_lists [j] - section->address;
2757           next = section_begin + offset;
2758           base_address = debug_information [i].base_address;
2759
2760           if (!seen_first_offset)
2761             seen_first_offset = 1;
2762           else
2763             {
2764               if (start < next)
2765                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2766                       (long)(start - section_begin),
2767                       (long)(next - section_begin), section->name);
2768               else if (start > next)
2769                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2770                       (long)(start - section_begin),
2771                       (long)(next - section_begin), section->name);
2772             }
2773           start = next;
2774
2775           while (1)
2776             {
2777               begin = byte_get (start, pointer_size);
2778               start += pointer_size;
2779               end = byte_get (start, pointer_size);
2780               start += pointer_size;
2781
2782               if (begin == 0 && end == 0)
2783                 {
2784                   printf (_("    %8.8lx <End of list>\n"), offset);
2785                   break;
2786                 }
2787
2788               /* Check base address specifiers.  */
2789               if (begin == -1UL && end != -1UL)
2790                 {
2791                   base_address = end;
2792                   printf ("    %8.8lx %8.8lx %8.8lx (base address)\n",
2793                           offset, begin, end);
2794                   continue;
2795                 }
2796
2797               printf ("    %8.8lx %8.8lx %8.8lx",
2798                       offset, begin + base_address, end + base_address);
2799
2800               if (begin == end)
2801                 fputs (_(" (start == end)"), stdout);
2802               else if (begin > end)
2803                 fputs (_(" (start > end)"), stdout);
2804
2805               putchar ('\n');
2806             }
2807         }
2808     }
2809   putchar ('\n');
2810   return 1;
2811 }
2812
2813 typedef struct Frame_Chunk
2814 {
2815   struct Frame_Chunk *next;
2816   unsigned char *chunk_start;
2817   int ncols;
2818   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
2819   short int *col_type;
2820   int *col_offset;
2821   char *augmentation;
2822   unsigned int code_factor;
2823   int data_factor;
2824   unsigned long pc_begin;
2825   unsigned long pc_range;
2826   int cfa_reg;
2827   int cfa_offset;
2828   int ra;
2829   unsigned char fde_encoding;
2830   unsigned char cfa_exp;
2831 }
2832 Frame_Chunk;
2833
2834 /* A marker for a col_type that means this column was never referenced
2835    in the frame info.  */
2836 #define DW_CFA_unreferenced (-1)
2837
2838 static void
2839 frame_need_space (Frame_Chunk *fc, int reg)
2840 {
2841   int prev = fc->ncols;
2842
2843   if (reg < fc->ncols)
2844     return;
2845
2846   fc->ncols = reg + 1;
2847   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2848   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2849
2850   while (prev < fc->ncols)
2851     {
2852       fc->col_type[prev] = DW_CFA_unreferenced;
2853       fc->col_offset[prev] = 0;
2854       prev++;
2855     }
2856 }
2857
2858 static void
2859 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
2860 {
2861   int r;
2862   char tmp[100];
2863
2864   if (*max_regs < fc->ncols)
2865     *max_regs = fc->ncols;
2866
2867   if (*need_col_headers)
2868     {
2869       *need_col_headers = 0;
2870
2871       printf ("   LOC   CFA      ");
2872
2873       for (r = 0; r < *max_regs; r++)
2874         if (fc->col_type[r] != DW_CFA_unreferenced)
2875           {
2876             if (r == fc->ra)
2877               printf ("ra   ");
2878             else
2879               printf ("r%-4d", r);
2880           }
2881
2882       printf ("\n");
2883     }
2884
2885   printf ("%08lx ", fc->pc_begin);
2886   if (fc->cfa_exp)
2887     strcpy (tmp, "exp");
2888   else
2889     sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
2890   printf ("%-8s ", tmp);
2891
2892   for (r = 0; r < fc->ncols; r++)
2893     {
2894       if (fc->col_type[r] != DW_CFA_unreferenced)
2895         {
2896           switch (fc->col_type[r])
2897             {
2898             case DW_CFA_undefined:
2899               strcpy (tmp, "u");
2900               break;
2901             case DW_CFA_same_value:
2902               strcpy (tmp, "s");
2903               break;
2904             case DW_CFA_offset:
2905               sprintf (tmp, "c%+d", fc->col_offset[r]);
2906               break;
2907             case DW_CFA_val_offset:
2908               sprintf (tmp, "v%+d", fc->col_offset[r]);
2909               break;
2910             case DW_CFA_register:
2911               sprintf (tmp, "r%d", fc->col_offset[r]);
2912               break;
2913             case DW_CFA_expression:
2914               strcpy (tmp, "exp");
2915               break;
2916             case DW_CFA_val_expression:
2917               strcpy (tmp, "vexp");
2918               break;
2919             default:
2920               strcpy (tmp, "n/a");
2921               break;
2922             }
2923           printf ("%-5s", tmp);
2924         }
2925     }
2926   printf ("\n");
2927 }
2928
2929 static int
2930 size_of_encoded_value (int encoding)
2931 {
2932   switch (encoding & 0x7)
2933     {
2934     default:    /* ??? */
2935     case 0:     return eh_addr_size;
2936     case 2:     return 2;
2937     case 3:     return 4;
2938     case 4:     return 8;
2939     }
2940 }
2941
2942 static dwarf_vma
2943 get_encoded_value (unsigned char *data, int encoding)
2944 {
2945   int size = size_of_encoded_value (encoding);
2946   if (encoding & DW_EH_PE_signed)
2947     return byte_get_signed (data, size);
2948   else
2949     return byte_get (data, size);
2950 }
2951
2952 #define GET(N)  byte_get (start, N); start += N
2953 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
2954 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
2955
2956 static int
2957 display_debug_frames (struct dwarf_section *section,
2958                       void *file ATTRIBUTE_UNUSED)
2959 {
2960   unsigned char *start = section->start;
2961   unsigned char *end = start + section->size;
2962   unsigned char *section_start = start;
2963   Frame_Chunk *chunks = 0;
2964   Frame_Chunk *remembered_state = 0;
2965   Frame_Chunk *rs;
2966   int is_eh = strcmp (section->name, ".eh_frame") == 0;
2967   unsigned int length_return;
2968   int max_regs = 0;
2969
2970   printf (_("The section %s contains:\n"), section->name);
2971
2972   while (start < end)
2973     {
2974       unsigned char *saved_start;
2975       unsigned char *block_end;
2976       unsigned long length;
2977       unsigned long cie_id;
2978       Frame_Chunk *fc;
2979       Frame_Chunk *cie;
2980       int need_col_headers = 1;
2981       unsigned char *augmentation_data = NULL;
2982       unsigned long augmentation_data_len = 0;
2983       int encoded_ptr_size = eh_addr_size;
2984       int offset_size;
2985       int initial_length_size;
2986
2987       saved_start = start;
2988       length = byte_get (start, 4); start += 4;
2989
2990       if (length == 0)
2991         {
2992           printf ("\n%08lx ZERO terminator\n\n",
2993                     (unsigned long)(saved_start - section_start));
2994           return 1;
2995         }
2996
2997       if (length == 0xffffffff)
2998         {
2999           length = byte_get (start, 8);
3000           start += 8;
3001           offset_size = 8;
3002           initial_length_size = 12;
3003         }
3004       else
3005         {
3006           offset_size = 4;
3007           initial_length_size = 4;
3008         }
3009
3010       block_end = saved_start + length + initial_length_size;
3011       cie_id = byte_get (start, offset_size); start += offset_size;
3012
3013       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3014         {
3015           int version;
3016
3017           fc = xmalloc (sizeof (Frame_Chunk));
3018           memset (fc, 0, sizeof (Frame_Chunk));
3019
3020           fc->next = chunks;
3021           chunks = fc;
3022           fc->chunk_start = saved_start;
3023           fc->ncols = 0;
3024           fc->col_type = xmalloc (sizeof (short int));
3025           fc->col_offset = xmalloc (sizeof (int));
3026           frame_need_space (fc, max_regs-1);
3027
3028           version = *start++;
3029
3030           fc->augmentation = (char *) start;
3031           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3032
3033           if (fc->augmentation[0] == 'z')
3034             {
3035               fc->code_factor = LEB ();
3036               fc->data_factor = SLEB ();
3037               if (version == 1)
3038                 {
3039                   fc->ra = GET (1);
3040                 }
3041               else
3042                 {
3043                   fc->ra = LEB ();
3044                 }
3045               augmentation_data_len = LEB ();
3046               augmentation_data = start;
3047               start += augmentation_data_len;
3048             }
3049           else if (strcmp (fc->augmentation, "eh") == 0)
3050             {
3051               start += eh_addr_size;
3052               fc->code_factor = LEB ();
3053               fc->data_factor = SLEB ();
3054               if (version == 1)
3055                 {
3056                   fc->ra = GET (1);
3057                 }
3058               else
3059                 {
3060                   fc->ra = LEB ();
3061                 }
3062             }
3063           else
3064             {
3065               fc->code_factor = LEB ();
3066               fc->data_factor = SLEB ();
3067               if (version == 1)
3068                 {
3069                   fc->ra = GET (1);
3070                 }
3071               else
3072                 {
3073                   fc->ra = LEB ();
3074                 }
3075             }
3076           cie = fc;
3077
3078           if (do_debug_frames_interp)
3079             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3080                     (unsigned long)(saved_start - section_start), length, cie_id,
3081                     fc->augmentation, fc->code_factor, fc->data_factor,
3082                     fc->ra);
3083           else
3084             {
3085               printf ("\n%08lx %08lx %08lx CIE\n",
3086                       (unsigned long)(saved_start - section_start), length, cie_id);
3087               printf ("  Version:               %d\n", version);
3088               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3089               printf ("  Code alignment factor: %u\n", fc->code_factor);
3090               printf ("  Data alignment factor: %d\n", fc->data_factor);
3091               printf ("  Return address column: %d\n", fc->ra);
3092
3093               if (augmentation_data_len)
3094                 {
3095                   unsigned long i;
3096                   printf ("  Augmentation data:    ");
3097                   for (i = 0; i < augmentation_data_len; ++i)
3098                     printf (" %02x", augmentation_data[i]);
3099                   putchar ('\n');
3100                 }
3101               putchar ('\n');
3102             }
3103
3104           if (augmentation_data_len)
3105             {
3106               unsigned char *p, *q;
3107               p = (unsigned char *) fc->augmentation + 1;
3108               q = augmentation_data;
3109
3110               while (1)
3111                 {
3112                   if (*p == 'L')
3113                     q++;
3114                   else if (*p == 'P')
3115                     q += 1 + size_of_encoded_value (*q);
3116                   else if (*p == 'R')
3117                     fc->fde_encoding = *q++;
3118                   else
3119                     break;
3120                   p++;
3121                 }
3122
3123               if (fc->fde_encoding)
3124                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3125             }
3126
3127           frame_need_space (fc, fc->ra);
3128         }
3129       else
3130         {
3131           unsigned char *look_for;
3132           static Frame_Chunk fde_fc;
3133
3134           fc = & fde_fc;
3135           memset (fc, 0, sizeof (Frame_Chunk));
3136
3137           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3138
3139           for (cie = chunks; cie ; cie = cie->next)
3140             if (cie->chunk_start == look_for)
3141               break;
3142
3143           if (!cie)
3144             {
3145               warn ("Invalid CIE pointer %08lx in FDE at %p\n",
3146                     cie_id, saved_start);
3147               start = block_end;
3148               fc->ncols = 0;
3149               fc->col_type = xmalloc (sizeof (short int));
3150               fc->col_offset = xmalloc (sizeof (int));
3151               frame_need_space (fc, max_regs - 1);
3152               cie = fc;
3153               fc->augmentation = "";
3154               fc->fde_encoding = 0;
3155             }
3156           else
3157             {
3158               fc->ncols = cie->ncols;
3159               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3160               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3161               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3162               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3163               fc->augmentation = cie->augmentation;
3164               fc->code_factor = cie->code_factor;
3165               fc->data_factor = cie->data_factor;
3166               fc->cfa_reg = cie->cfa_reg;
3167               fc->cfa_offset = cie->cfa_offset;
3168               fc->ra = cie->ra;
3169               frame_need_space (fc, max_regs-1);
3170               fc->fde_encoding = cie->fde_encoding;
3171             }
3172
3173           if (fc->fde_encoding)
3174             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3175
3176           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3177           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3178               /* Don't adjust for relocatable file since there's
3179                  invariably a pcrel reloc here, which we haven't
3180                  applied.  */
3181               && !is_relocatable)
3182             fc->pc_begin += section->address + (start - section_start);
3183           start += encoded_ptr_size;
3184           fc->pc_range = byte_get (start, encoded_ptr_size);
3185           start += encoded_ptr_size;
3186
3187           if (cie->augmentation[0] == 'z')
3188             {
3189               augmentation_data_len = LEB ();
3190               augmentation_data = start;
3191               start += augmentation_data_len;
3192             }
3193
3194           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3195                   (unsigned long)(saved_start - section_start), length, cie_id,
3196                   (unsigned long)(cie->chunk_start - section_start),
3197                   fc->pc_begin, fc->pc_begin + fc->pc_range);
3198           if (! do_debug_frames_interp && augmentation_data_len)
3199             {
3200               unsigned long i;
3201
3202               printf ("  Augmentation data:    ");
3203               for (i = 0; i < augmentation_data_len; ++i)
3204                 printf (" %02x", augmentation_data[i]);
3205               putchar ('\n');
3206               putchar ('\n');
3207             }
3208         }
3209
3210       /* At this point, fc is the current chunk, cie (if any) is set, and
3211          we're about to interpret instructions for the chunk.  */
3212       /* ??? At present we need to do this always, since this sizes the
3213          fc->col_type and fc->col_offset arrays, which we write into always.
3214          We should probably split the interpreted and non-interpreted bits
3215          into two different routines, since there's so much that doesn't
3216          really overlap between them.  */
3217       if (1 || do_debug_frames_interp)
3218         {
3219           /* Start by making a pass over the chunk, allocating storage
3220              and taking note of what registers are used.  */
3221           unsigned char *tmp = start;
3222
3223           while (start < block_end)
3224             {
3225               unsigned op, opa;
3226               unsigned long reg, tmp;
3227
3228               op = *start++;
3229               opa = op & 0x3f;
3230               if (op & 0xc0)
3231                 op &= 0xc0;
3232
3233               /* Warning: if you add any more cases to this switch, be
3234                  sure to add them to the corresponding switch below.  */
3235               switch (op)
3236                 {
3237                 case DW_CFA_advance_loc:
3238                   break;
3239                 case DW_CFA_offset:
3240                   LEB ();
3241                   frame_need_space (fc, opa);
3242                   fc->col_type[opa] = DW_CFA_undefined;
3243                   break;
3244                 case DW_CFA_restore:
3245                   frame_need_space (fc, opa);
3246                   fc->col_type[opa] = DW_CFA_undefined;
3247                   break;
3248                 case DW_CFA_set_loc:
3249                   start += encoded_ptr_size;
3250                   break;
3251                 case DW_CFA_advance_loc1:
3252                   start += 1;
3253                   break;
3254                 case DW_CFA_advance_loc2:
3255                   start += 2;
3256                   break;
3257                 case DW_CFA_advance_loc4:
3258                   start += 4;
3259                   break;
3260                 case DW_CFA_offset_extended:
3261                 case DW_CFA_val_offset:
3262                   reg = LEB (); LEB ();
3263                   frame_need_space (fc, reg);
3264                   fc->col_type[reg] = DW_CFA_undefined;
3265                   break;
3266                 case DW_CFA_restore_extended:
3267                   reg = LEB ();
3268                   frame_need_space (fc, reg);
3269                   fc->col_type[reg] = DW_CFA_undefined;
3270                   break;
3271                 case DW_CFA_undefined:
3272                   reg = LEB ();
3273                   frame_need_space (fc, reg);
3274                   fc->col_type[reg] = DW_CFA_undefined;
3275                   break;
3276                 case DW_CFA_same_value:
3277                   reg = LEB ();
3278                   frame_need_space (fc, reg);
3279                   fc->col_type[reg] = DW_CFA_undefined;
3280                   break;
3281                 case DW_CFA_register:
3282                   reg = LEB (); LEB ();
3283                   frame_need_space (fc, reg);
3284                   fc->col_type[reg] = DW_CFA_undefined;
3285                   break;
3286                 case DW_CFA_def_cfa:
3287                   LEB (); LEB ();
3288                   break;
3289                 case DW_CFA_def_cfa_register:
3290                   LEB ();
3291                   break;
3292                 case DW_CFA_def_cfa_offset:
3293                   LEB ();
3294                   break;
3295                 case DW_CFA_def_cfa_expression:
3296                   tmp = LEB ();
3297                   start += tmp;
3298                   break;
3299                 case DW_CFA_expression:
3300                 case DW_CFA_val_expression:
3301                   reg = LEB ();
3302                   tmp = LEB ();
3303                   start += tmp;
3304                   frame_need_space (fc, reg);
3305                   fc->col_type[reg] = DW_CFA_undefined;
3306                   break;
3307                 case DW_CFA_offset_extended_sf:
3308                 case DW_CFA_val_offset_sf:
3309                   reg = LEB (); SLEB ();
3310                   frame_need_space (fc, reg);
3311                   fc->col_type[reg] = DW_CFA_undefined;
3312                   break;
3313                 case DW_CFA_def_cfa_sf:
3314                   LEB (); SLEB ();
3315                   break;
3316                 case DW_CFA_def_cfa_offset_sf:
3317                   SLEB ();
3318                   break;
3319                 case DW_CFA_MIPS_advance_loc8:
3320                   start += 8;
3321                   break;
3322                 case DW_CFA_GNU_args_size:
3323                   LEB ();
3324                   break;
3325                 case DW_CFA_GNU_negative_offset_extended:
3326                   reg = LEB (); LEB ();
3327                   frame_need_space (fc, reg);
3328                   fc->col_type[reg] = DW_CFA_undefined;
3329
3330                 default:
3331                   break;
3332                 }
3333             }
3334           start = tmp;
3335         }
3336
3337       /* Now we know what registers are used, make a second pass over
3338          the chunk, this time actually printing out the info.  */
3339
3340       while (start < block_end)
3341         {
3342           unsigned op, opa;
3343           unsigned long ul, reg, roffs;
3344           long l, ofs;
3345           dwarf_vma vma;
3346
3347           op = *start++;
3348           opa = op & 0x3f;
3349           if (op & 0xc0)
3350             op &= 0xc0;
3351
3352           /* Warning: if you add any more cases to this switch, be
3353              sure to add them to the corresponding switch above.  */
3354           switch (op)
3355             {
3356             case DW_CFA_advance_loc:
3357               if (do_debug_frames_interp)
3358                 frame_display_row (fc, &need_col_headers, &max_regs);
3359               else
3360                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
3361                         opa * fc->code_factor,
3362                         fc->pc_begin + opa * fc->code_factor);
3363               fc->pc_begin += opa * fc->code_factor;
3364               break;
3365
3366             case DW_CFA_offset:
3367               roffs = LEB ();
3368               if (! do_debug_frames_interp)
3369                 printf ("  DW_CFA_offset: r%d at cfa%+ld\n",
3370                         opa, roffs * fc->data_factor);
3371               fc->col_type[opa] = DW_CFA_offset;
3372               fc->col_offset[opa] = roffs * fc->data_factor;
3373               break;
3374
3375             case DW_CFA_restore:
3376               if (! do_debug_frames_interp)
3377                 printf ("  DW_CFA_restore: r%d\n", opa);
3378               fc->col_type[opa] = cie->col_type[opa];
3379               fc->col_offset[opa] = cie->col_offset[opa];
3380               break;
3381
3382             case DW_CFA_set_loc:
3383               vma = get_encoded_value (start, fc->fde_encoding);
3384               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3385                   && !is_relocatable)
3386                 vma += section->address + (start - section_start);
3387               start += encoded_ptr_size;
3388               if (do_debug_frames_interp)
3389                 frame_display_row (fc, &need_col_headers, &max_regs);
3390               else
3391                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3392               fc->pc_begin = vma;
3393               break;
3394
3395             case DW_CFA_advance_loc1:
3396               ofs = byte_get (start, 1); start += 1;
3397               if (do_debug_frames_interp)
3398                 frame_display_row (fc, &need_col_headers, &max_regs);
3399               else
3400                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
3401                         ofs * fc->code_factor,
3402                         fc->pc_begin + ofs * fc->code_factor);
3403               fc->pc_begin += ofs * fc->code_factor;
3404               break;
3405
3406             case DW_CFA_advance_loc2:
3407               ofs = byte_get (start, 2); start += 2;
3408               if (do_debug_frames_interp)
3409                 frame_display_row (fc, &need_col_headers, &max_regs);
3410               else
3411                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
3412                         ofs * fc->code_factor,
3413                         fc->pc_begin + ofs * fc->code_factor);
3414               fc->pc_begin += ofs * fc->code_factor;
3415               break;
3416
3417             case DW_CFA_advance_loc4:
3418               ofs = byte_get (start, 4); start += 4;
3419               if (do_debug_frames_interp)
3420                 frame_display_row (fc, &need_col_headers, &max_regs);
3421               else
3422                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
3423                         ofs * fc->code_factor,
3424                         fc->pc_begin + ofs * fc->code_factor);
3425               fc->pc_begin += ofs * fc->code_factor;
3426               break;
3427
3428             case DW_CFA_offset_extended:
3429               reg = LEB ();
3430               roffs = LEB ();
3431               if (! do_debug_frames_interp)
3432                 printf ("  DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3433                         reg, roffs * fc->data_factor);
3434               fc->col_type[reg] = DW_CFA_offset;
3435               fc->col_offset[reg] = roffs * fc->data_factor;
3436               break;
3437
3438             case DW_CFA_val_offset:
3439               reg = LEB ();
3440               roffs = LEB ();
3441               if (! do_debug_frames_interp)
3442                 printf ("  DW_CFA_val_offset: r%ld at cfa%+ld\n",
3443                         reg, roffs * fc->data_factor);
3444               fc->col_type[reg] = DW_CFA_val_offset;
3445               fc->col_offset[reg] = roffs * fc->data_factor;
3446               break;
3447
3448             case DW_CFA_restore_extended:
3449               reg = LEB ();
3450               if (! do_debug_frames_interp)
3451                 printf ("  DW_CFA_restore_extended: r%ld\n", reg);
3452               fc->col_type[reg] = cie->col_type[reg];
3453               fc->col_offset[reg] = cie->col_offset[reg];
3454               break;
3455
3456             case DW_CFA_undefined:
3457               reg = LEB ();
3458               if (! do_debug_frames_interp)
3459                 printf ("  DW_CFA_undefined: r%ld\n", reg);
3460               fc->col_type[reg] = DW_CFA_undefined;
3461               fc->col_offset[reg] = 0;
3462               break;
3463
3464             case DW_CFA_same_value:
3465               reg = LEB ();
3466               if (! do_debug_frames_interp)
3467                 printf ("  DW_CFA_same_value: r%ld\n", reg);
3468               fc->col_type[reg] = DW_CFA_same_value;
3469               fc->col_offset[reg] = 0;
3470               break;
3471
3472             case DW_CFA_register:
3473               reg = LEB ();
3474               roffs = LEB ();
3475               if (! do_debug_frames_interp)
3476                 printf ("  DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3477               fc->col_type[reg] = DW_CFA_register;
3478               fc->col_offset[reg] = roffs;
3479               break;
3480
3481             case DW_CFA_remember_state:
3482               if (! do_debug_frames_interp)
3483                 printf ("  DW_CFA_remember_state\n");
3484               rs = xmalloc (sizeof (Frame_Chunk));
3485               rs->ncols = fc->ncols;
3486               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3487               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3488               memcpy (rs->col_type, fc->col_type, rs->ncols);
3489               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3490               rs->next = remembered_state;
3491               remembered_state = rs;
3492               break;
3493
3494             case DW_CFA_restore_state:
3495               if (! do_debug_frames_interp)
3496                 printf ("  DW_CFA_restore_state\n");
3497               rs = remembered_state;
3498               if (rs)
3499                 {
3500                   remembered_state = rs->next;
3501                   frame_need_space (fc, rs->ncols-1);
3502                   memcpy (fc->col_type, rs->col_type, rs->ncols);
3503                   memcpy (fc->col_offset, rs->col_offset,
3504                           rs->ncols * sizeof (int));
3505                   free (rs->col_type);
3506                   free (rs->col_offset);
3507                   free (rs);
3508                 }
3509               else if (do_debug_frames_interp)
3510                 printf ("Mismatched DW_CFA_restore_state\n");
3511               break;
3512
3513             case DW_CFA_def_cfa:
3514               fc->cfa_reg = LEB ();
3515               fc->cfa_offset = LEB ();
3516               fc->cfa_exp = 0;
3517               if (! do_debug_frames_interp)
3518                 printf ("  DW_CFA_def_cfa: r%d ofs %d\n",
3519                         fc->cfa_reg, fc->cfa_offset);
3520               break;
3521
3522             case DW_CFA_def_cfa_register:
3523               fc->cfa_reg = LEB ();
3524               fc->cfa_exp = 0;
3525               if (! do_debug_frames_interp)
3526                 printf ("  DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3527               break;
3528
3529             case DW_CFA_def_cfa_offset:
3530               fc->cfa_offset = LEB ();
3531               if (! do_debug_frames_interp)
3532                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3533               break;
3534
3535             case DW_CFA_nop:
3536               if (! do_debug_frames_interp)
3537                 printf ("  DW_CFA_nop\n");
3538               break;
3539
3540             case DW_CFA_def_cfa_expression:
3541               ul = LEB ();
3542               if (! do_debug_frames_interp)
3543                 {
3544                   printf ("  DW_CFA_def_cfa_expression (");
3545                   decode_location_expression (start, eh_addr_size, ul, 0);
3546                   printf (")\n");
3547                 }
3548               fc->cfa_exp = 1;
3549               start += ul;
3550               break;
3551
3552             case DW_CFA_expression:
3553               reg = LEB ();
3554               ul = LEB ();
3555               if (! do_debug_frames_interp)
3556                 {
3557                   printf ("  DW_CFA_expression: r%ld (", reg);
3558                   decode_location_expression (start, eh_addr_size, ul, 0);
3559                   printf (")\n");
3560                 }
3561               fc->col_type[reg] = DW_CFA_expression;
3562               start += ul;
3563               break;
3564
3565             case DW_CFA_val_expression:
3566               reg = LEB ();
3567               ul = LEB ();
3568               if (! do_debug_frames_interp)
3569                 {
3570                   printf ("  DW_CFA_val_expression: r%ld (", reg);
3571                   decode_location_expression (start, eh_addr_size, ul, 0);
3572                   printf (")\n");
3573                 }
3574               fc->col_type[reg] = DW_CFA_val_expression;
3575               start += ul;
3576               break;
3577
3578             case DW_CFA_offset_extended_sf:
3579               reg = LEB ();
3580               l = SLEB ();
3581               frame_need_space (fc, reg);
3582               if (! do_debug_frames_interp)
3583                 printf ("  DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3584                         reg, l * fc->data_factor);
3585               fc->col_type[reg] = DW_CFA_offset;
3586               fc->col_offset[reg] = l * fc->data_factor;
3587               break;
3588
3589             case DW_CFA_val_offset_sf:
3590               reg = LEB ();
3591               l = SLEB ();
3592               frame_need_space (fc, reg);
3593               if (! do_debug_frames_interp)
3594                 printf ("  DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3595                         reg, l * fc->data_factor);
3596               fc->col_type[reg] = DW_CFA_val_offset;
3597               fc->col_offset[reg] = l * fc->data_factor;
3598               break;
3599
3600             case DW_CFA_def_cfa_sf:
3601               fc->cfa_reg = LEB ();
3602               fc->cfa_offset = SLEB ();
3603               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3604               fc->cfa_exp = 0;
3605               if (! do_debug_frames_interp)
3606                 printf ("  DW_CFA_def_cfa_sf: r%d ofs %d\n",
3607                         fc->cfa_reg, fc->cfa_offset);
3608               break;
3609
3610             case DW_CFA_def_cfa_offset_sf:
3611               fc->cfa_offset = SLEB ();
3612               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3613               if (! do_debug_frames_interp)
3614                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3615               break;
3616
3617             case DW_CFA_MIPS_advance_loc8:
3618               ofs = byte_get (start, 8); start += 8;
3619               if (do_debug_frames_interp)
3620                 frame_display_row (fc, &need_col_headers, &max_regs);
3621               else
3622                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3623                         ofs * fc->code_factor,
3624                         fc->pc_begin + ofs * fc->code_factor);
3625               fc->pc_begin += ofs * fc->code_factor;
3626               break;
3627
3628             case DW_CFA_GNU_window_save:
3629               if (! do_debug_frames_interp)
3630                 printf ("  DW_CFA_GNU_window_save\n");
3631               break;
3632
3633             case DW_CFA_GNU_args_size:
3634               ul = LEB ();
3635               if (! do_debug_frames_interp)
3636                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
3637               break;
3638
3639             case DW_CFA_GNU_negative_offset_extended:
3640               reg = LEB ();
3641               l = - LEB ();
3642               frame_need_space (fc, reg);
3643               if (! do_debug_frames_interp)
3644                 printf ("  DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3645                         reg, l * fc->data_factor);
3646               fc->col_type[reg] = DW_CFA_offset;
3647               fc->col_offset[reg] = l * fc->data_factor;
3648               break;
3649
3650             default:
3651               warn (_("unsupported or unknown DW_CFA_%d\n"), op);
3652               start = block_end;
3653             }
3654         }
3655
3656       if (do_debug_frames_interp)
3657         frame_display_row (fc, &need_col_headers, &max_regs);
3658
3659       start = block_end;
3660     }
3661
3662   printf ("\n");
3663
3664   return 1;
3665 }
3666
3667 #undef GET
3668 #undef LEB
3669 #undef SLEB
3670
3671 static int
3672 display_debug_not_supported (struct dwarf_section *section,
3673                              void *file ATTRIBUTE_UNUSED)
3674 {
3675   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3676             section->name);
3677
3678   return 1;
3679 }
3680
3681 void *
3682 cmalloc (size_t nmemb, size_t size)
3683 {
3684   /* Check for overflow.  */
3685   if (nmemb >= ~(size_t) 0 / size)
3686     return NULL;
3687   else
3688     return malloc (nmemb * size);
3689 }
3690
3691 void *
3692 xcmalloc (size_t nmemb, size_t size)
3693 {
3694   /* Check for overflow.  */
3695   if (nmemb >= ~(size_t) 0 / size)
3696     return NULL;
3697   else
3698     return xmalloc (nmemb * size);
3699 }
3700
3701 void *
3702 xcrealloc (void *ptr, size_t nmemb, size_t size)
3703 {
3704   /* Check for overflow.  */
3705   if (nmemb >= ~(size_t) 0 / size)
3706     return NULL;
3707   else
3708     return xrealloc (ptr, nmemb * size);
3709 }
3710
3711 void
3712 error (const char *message, ...)
3713 {
3714   va_list args;
3715
3716   va_start (args, message);
3717   fprintf (stderr, _("%s: Error: "), program_name);
3718   vfprintf (stderr, message, args);
3719   va_end (args);
3720 }
3721
3722 void
3723 warn (const char *message, ...)
3724 {
3725   va_list args;
3726
3727   va_start (args, message);
3728   fprintf (stderr, _("%s: Warning: "), program_name);
3729   vfprintf (stderr, message, args);
3730   va_end (args);
3731 }
3732
3733 void
3734 free_debug_memory (void)
3735 {
3736   enum dwarf_section_display_enum i;
3737
3738   free_abbrevs ();
3739
3740   for (i = 0; i < max; i++)
3741     free_debug_section (i);
3742
3743   if (debug_information)
3744     {
3745       for (i = 0; i < num_debug_info_entries; i++)
3746         {
3747           if (!debug_information [i].max_loc_offsets)
3748             {
3749               free (debug_information [i].loc_offsets);
3750               free (debug_information [i].have_frame_base);
3751             }
3752           if (!debug_information [i].max_range_lists)
3753             free (debug_information [i].range_lists);
3754         }
3755       free (debug_information);
3756       debug_information = NULL;
3757       num_debug_info_entries = 0;
3758     }
3759
3760 }
3761
3762 struct dwarf_section_display debug_displays[] =
3763 {
3764   { { ".debug_abbrev",          NULL,   0,      0 },
3765     display_debug_abbrev,               0,      0 },
3766   { { ".debug_aranges",         NULL,   0,      0 },
3767     display_debug_aranges,              0,      0 },
3768   { { ".debug_frame",           NULL,   0,      0 },
3769     display_debug_frames,               1,      0 },
3770   { { ".debug_info",            NULL,   0,      0 },
3771     display_debug_info,                 1,      0 },
3772   { { ".debug_line",            NULL,   0,      0 },
3773     display_debug_lines,                0,      0 },
3774   { { ".debug_pubnames",        NULL,   0,      0 },
3775     display_debug_pubnames,             0,      0 },
3776   { { ".eh_frame",              NULL,   0,      0 },
3777     display_debug_frames,               1,      1 },
3778   { { ".debug_macinfo",         NULL,   0,      0 },
3779     display_debug_macinfo,              0,      0 },
3780   { { ".debug_str",             NULL,   0,      0 },
3781     display_debug_str,                  0,      0 },
3782   { { ".debug_loc",             NULL,   0,      0 },
3783     display_debug_loc,                  0,      0 },
3784   { { ".debug_pubtypes",        NULL,   0,      0 },
3785     display_debug_pubnames,             0,      0 },
3786   { { ".debug_ranges",          NULL,   0,      0 },
3787     display_debug_ranges,               0,      0 },
3788   { { ".debug_static_func",     NULL,   0,      0 },
3789     display_debug_not_supported,        0,      0 },
3790   { { ".debug_static_vars",     NULL,   0,      0 },
3791     display_debug_not_supported,        0,      0 },
3792   { { ".debug_types",           NULL,   0,      0 },
3793     display_debug_not_supported,        0,      0 },
3794   { { ".debug_weaknames",       NULL,   0,      0 },
3795     display_debug_not_supported,        0,      0 }
3796 };