binutils/dwarf.c

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