binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright 2005, 2006, 2007, 2008
   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/common.h"
  27 #include "dwarf2.h"
  28 #include "dwarf.h"
  29
  30 static int have_frame_base;
  31 static int need_base_address;
  32
  33 static unsigned int last_pointer_size = 0;
  34 static int warned_about_missing_comp_units = FALSE;
  35
  36 static unsigned int num_debug_info_entries = 0;
  37 static debug_info *debug_information = NULL;
  38 /* Special value for num_debug_info_entries to indicate
  39    that the .debug_info section could not be loaded/parsed.  */
  40 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
  41
  42 int eh_addr_size;
  43
  44 int do_debug_info;
  45 int do_debug_abbrevs;
  46 int do_debug_lines;
  47 int do_debug_pubnames;
  48 int do_debug_aranges;
  49 int do_debug_ranges;
  50 int do_debug_frames;
  51 int do_debug_frames_interp;
  52 int do_debug_macinfo;
  53 int do_debug_str;
  54 int do_debug_loc;
  55 int do_wide;
  56
  57 /* Values for do_debug_lines.  */
  58 #define FLAG_DEBUG_LINES_RAW     1
  59 #define FLAG_DEBUG_LINES_DECODED 2
  60
  61 dwarf_vma (*byte_get) (unsigned char *, int);
  62
  63 dwarf_vma
  64 byte_get_little_endian (unsigned char *field, int size)
  65 {
  66   switch (size)
  67     {
  68     case 1:
  69       return *field;
  70
  71     case 2:
  72       return  ((unsigned int) (field[0]))
  73         |    (((unsigned int) (field[1])) << 8);
  74
  75     case 4:
  76       return  ((unsigned long) (field[0]))
  77         |    (((unsigned long) (field[1])) << 8)
  78         |    (((unsigned long) (field[2])) << 16)
  79         |    (((unsigned long) (field[3])) << 24);
  80
  81     case 8:
  82       if (sizeof (dwarf_vma) == 8)
  83         return  ((dwarf_vma) (field[0]))
  84           |    (((dwarf_vma) (field[1])) << 8)
  85           |    (((dwarf_vma) (field[2])) << 16)
  86           |    (((dwarf_vma) (field[3])) << 24)
  87           |    (((dwarf_vma) (field[4])) << 32)
  88           |    (((dwarf_vma) (field[5])) << 40)
  89           |    (((dwarf_vma) (field[6])) << 48)
  90           |    (((dwarf_vma) (field[7])) << 56);
  91       else if (sizeof (dwarf_vma) == 4)
  92         /* We want to extract data from an 8 byte wide field and
  93            place it into a 4 byte wide field.  Since this is a little
  94            endian source we can just use the 4 byte extraction code.  */
  95         return  ((unsigned long) (field[0]))
  96           |    (((unsigned long) (field[1])) << 8)
  97           |    (((unsigned long) (field[2])) << 16)
  98           |    (((unsigned long) (field[3])) << 24);
  99
 100     default:
 101       error (_("Unhandled data length: %d\n"), size);
 102       abort ();
 103     }
 104 }
 105
 106 dwarf_vma
 107 byte_get_big_endian (unsigned char *field, int size)
 108 {
 109   switch (size)
 110     {
 111     case 1:
 112       return *field;
 113
 114     case 2:
 115       return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 116
 117     case 4:
 118       return ((unsigned long) (field[3]))
 119         |   (((unsigned long) (field[2])) << 8)
 120         |   (((unsigned long) (field[1])) << 16)
 121         |   (((unsigned long) (field[0])) << 24);
 122
 123     case 8:
 124       if (sizeof (dwarf_vma) == 8)
 125         return ((dwarf_vma) (field[7]))
 126           |   (((dwarf_vma) (field[6])) << 8)
 127           |   (((dwarf_vma) (field[5])) << 16)
 128           |   (((dwarf_vma) (field[4])) << 24)
 129           |   (((dwarf_vma) (field[3])) << 32)
 130           |   (((dwarf_vma) (field[2])) << 40)
 131           |   (((dwarf_vma) (field[1])) << 48)
 132           |   (((dwarf_vma) (field[0])) << 56);
 133       else if (sizeof (dwarf_vma) == 4)
 134         {
 135           /* Although we are extracing data from an 8 byte wide field,
 136              we are returning only 4 bytes of data.  */
 137           field += 4;
 138           return ((unsigned long) (field[3]))
 139             |   (((unsigned long) (field[2])) << 8)
 140             |   (((unsigned long) (field[1])) << 16)
 141             |   (((unsigned long) (field[0])) << 24);
 142         }
 143
 144     default:
 145       error (_("Unhandled data length: %d\n"), size);
 146       abort ();
 147     }
 148 }
 149
 150 static dwarf_vma
 151 byte_get_signed (unsigned char *field, int size)
 152 {
 153   dwarf_vma x = byte_get (field, size);
 154
 155   switch (size)
 156     {
 157     case 1:
 158       return (x ^ 0x80) - 0x80;
 159     case 2:
 160       return (x ^ 0x8000) - 0x8000;
 161     case 4:
 162       return (x ^ 0x80000000) - 0x80000000;
 163     case 8:
 164       return x;
 165     default:
 166       abort ();
 167     }
 168 }
 169
 170 static int
 171 size_of_encoded_value (int encoding)
 172 {
 173   switch (encoding & 0x7)
 174     {
 175     default:    /* ??? */
 176     case 0:     return eh_addr_size;
 177     case 2:     return 2;
 178     case 3:     return 4;
 179     case 4:     return 8;
 180     }
 181 }
 182
 183 static dwarf_vma
 184 get_encoded_value (unsigned char *data, int encoding)
 185 {
 186   int size = size_of_encoded_value (encoding);
 187
 188   if (encoding & DW_EH_PE_signed)
 189     return byte_get_signed (data, size);
 190   else
 191     return byte_get (data, size);
 192 }
 193
 194 /* Print a dwarf_vma value (typically an address, offset or length) in
 195    hexadecimal format, followed by a space.  The length of the value (and
 196    hence the precision displayed) is determined by the byte_size parameter.  */
 197
 198 static void
 199 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
 200 {
 201   static char buff[18];
 202
 203   /* Printf does not have a way of specifiying a maximum field width for an
 204      integer value, so we print the full value into a buffer and then select
 205      the precision we need.  */
 206 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
 207 #ifndef __MSVCRT__
 208   snprintf (buff, sizeof (buff), "%16.16llx ", val);
 209 #else
 210   snprintf (buff, sizeof (buff), "%016I64x ", val);
 211 #endif
 212 #else
 213   snprintf (buff, sizeof (buff), "%16.16lx ", val);
 214 #endif
 215
 216   fputs (buff + (byte_size == 4 ? 8 : 0), stdout);
 217 }
 218
 219 static unsigned long int
 220 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
 221 {
 222   unsigned long int result = 0;
 223   unsigned int num_read = 0;
 224   unsigned int shift = 0;
 225   unsigned char byte;
 226
 227   do
 228     {
 229       byte = *data++;
 230       num_read++;
 231
 232       result |= ((unsigned long int) (byte & 0x7f)) << shift;
 233
 234       shift += 7;
 235
 236     }
 237   while (byte & 0x80);
 238
 239   if (length_return != NULL)
 240     *length_return = num_read;
 241
 242   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
 243     result |= -1L << shift;
 244
 245   return result;
 246 }
 247
 248 typedef struct State_Machine_Registers
 249 {
 250   unsigned long address;
 251   unsigned int file;
 252   unsigned int line;
 253   unsigned int column;
 254   int is_stmt;
 255   int basic_block;
 256   int end_sequence;
 257 /* This variable hold the number of the last entry seen
 258    in the File Table.  */
 259   unsigned int last_file_entry;
 260 } SMR;
 261
 262 static SMR state_machine_regs;
 263
 264 static void
 265 reset_state_machine (int is_stmt)
 266 {
 267   state_machine_regs.address = 0;
 268   state_machine_regs.file = 1;
 269   state_machine_regs.line = 1;
 270   state_machine_regs.column = 0;
 271   state_machine_regs.is_stmt = is_stmt;
 272   state_machine_regs.basic_block = 0;
 273   state_machine_regs.end_sequence = 0;
 274   state_machine_regs.last_file_entry = 0;
 275 }
 276
 277 /* Handled an extend line op.
 278    Returns the number of bytes read.  */
 279
 280 static int
 281 process_extended_line_op (unsigned char *data, int is_stmt)
 282 {
 283   unsigned char op_code;
 284   unsigned int bytes_read;
 285   unsigned int len;
 286   unsigned char *name;
 287   unsigned long adr;
 288
 289   len = read_leb128 (data, & bytes_read, 0);
 290   data += bytes_read;
 291
 292   if (len == 0)
 293     {
 294       warn (_("badly formed extended line op encountered!\n"));
 295       return bytes_read;
 296     }
 297
 298   len += bytes_read;
 299   op_code = *data++;
 300
 301   printf (_("  Extended opcode %d: "), op_code);
 302
 303   switch (op_code)
 304     {
 305     case DW_LNE_end_sequence:
 306       printf (_("End of Sequence\n\n"));
 307       reset_state_machine (is_stmt);
 308       break;
 309
 310     case DW_LNE_set_address:
 311       adr = byte_get (data, len - bytes_read - 1);
 312       printf (_("set Address to 0x%lx\n"), adr);
 313       state_machine_regs.address = adr;
 314       break;
 315
 316     case DW_LNE_define_file:
 317       printf (_("  define new File Table entry\n"));
 318       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
 319
 320       printf (_("   %d\t"), ++state_machine_regs.last_file_entry);
 321       name = data;
 322       data += strlen ((char *) data) + 1;
 323       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 324       data += bytes_read;
 325       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 326       data += bytes_read;
 327       printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
 328       printf (_("%s\n\n"), name);
 329       break;
 330
 331     case DW_LNE_set_discriminator:
 332       printf (_("set Discriminator to %lu\n"),
 333               read_leb128 (data, & bytes_read, 0));
 334       break;
 335
 336     /* HP extensions.  */
 337     case DW_LNE_HP_negate_is_UV_update:
 338       printf ("DW_LNE_HP_negate_is_UV_update\n");
 339       break;
 340     case DW_LNE_HP_push_context:
 341       printf ("DW_LNE_HP_push_context\n");
 342       break;
 343     case DW_LNE_HP_pop_context:
 344       printf ("DW_LNE_HP_pop_context\n");
 345       break;
 346     case DW_LNE_HP_set_file_line_column:
 347       printf ("DW_LNE_HP_set_file_line_column\n");
 348       break;
 349     case DW_LNE_HP_set_routine_name:
 350       printf ("DW_LNE_HP_set_routine_name\n");
 351       break;
 352     case DW_LNE_HP_set_sequence:
 353       printf ("DW_LNE_HP_set_sequence\n");
 354       break;
 355     case DW_LNE_HP_negate_post_semantics:
 356       printf ("DW_LNE_HP_negate_post_semantics\n");
 357       break;
 358     case DW_LNE_HP_negate_function_exit:
 359       printf ("DW_LNE_HP_negate_function_exit\n");
 360       break;
 361     case DW_LNE_HP_negate_front_end_logical:
 362       printf ("DW_LNE_HP_negate_front_end_logical\n");
 363       break;
 364     case DW_LNE_HP_define_proc:
 365       printf ("DW_LNE_HP_define_proc\n");
 366       break;
 367
 368     default:
 369       if (op_code >= DW_LNE_lo_user
 370           /* The test against DW_LNW_hi_user is redundant due to
 371              the limited range of the unsigned char data type used
 372              for op_code.  */
 373           /*&& op_code <= DW_LNE_hi_user*/)
 374         printf (_("user defined: length %d\n"), len - bytes_read);
 375       else
 376         printf (_("UNKNOWN: length %d\n"), len - bytes_read);
 377       break;
 378     }
 379
 380   return len;
 381 }
 382
 383 static const char *
 384 fetch_indirect_string (unsigned long offset)
 385 {
 386   struct dwarf_section *section = &debug_displays [str].section;
 387
 388   if (section->start == NULL)
 389     return _("<no .debug_str section>");
 390
 391   /* DWARF sections under Mach-O have non-zero addresses.  */
 392   offset -= section->address;
 393   if (offset > section->size)
 394     {
 395       warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
 396       return _("<offset is too big>");
 397     }
 398
 399   return (const char *) section->start + offset;
 400 }
 401
 402 /* FIXME:  There are better and more efficient ways to handle
 403    these structures.  For now though, I just want something that
 404    is simple to implement.  */
 405 typedef struct abbrev_attr
 406 {
 407   unsigned long attribute;
 408   unsigned long form;
 409   struct abbrev_attr *next;
 410 }
 411 abbrev_attr;
 412
 413 typedef struct abbrev_entry
 414 {
 415   unsigned long entry;
 416   unsigned long tag;
 417   int children;
 418   struct abbrev_attr *first_attr;
 419   struct abbrev_attr *last_attr;
 420   struct abbrev_entry *next;
 421 }
 422 abbrev_entry;
 423
 424 static abbrev_entry *first_abbrev = NULL;
 425 static abbrev_entry *last_abbrev = NULL;
 426
 427 static void
 428 free_abbrevs (void)
 429 {
 430   abbrev_entry *abbrev;
 431
 432   for (abbrev = first_abbrev; abbrev;)
 433     {
 434       abbrev_entry *next = abbrev->next;
 435       abbrev_attr *attr;
 436
 437       for (attr = abbrev->first_attr; attr;)
 438         {
 439           abbrev_attr *next = attr->next;
 440
 441           free (attr);
 442           attr = next;
 443         }
 444
 445       free (abbrev);
 446       abbrev = next;
 447     }
 448
 449   last_abbrev = first_abbrev = NULL;
 450 }
 451
 452 static void
 453 add_abbrev (unsigned long number, unsigned long tag, int children)
 454 {
 455   abbrev_entry *entry;
 456
 457   entry = malloc (sizeof (*entry));
 458
 459   if (entry == NULL)
 460     /* ugg */
 461     return;
 462
 463   entry->entry      = number;
 464   entry->tag        = tag;
 465   entry->children   = children;
 466   entry->first_attr = NULL;
 467   entry->last_attr  = NULL;
 468   entry->next       = NULL;
 469
 470   if (first_abbrev == NULL)
 471     first_abbrev = entry;
 472   else
 473     last_abbrev->next = entry;
 474
 475   last_abbrev = entry;
 476 }
 477
 478 static void
 479 add_abbrev_attr (unsigned long attribute, unsigned long form)
 480 {
 481   abbrev_attr *attr;
 482
 483   attr = malloc (sizeof (*attr));
 484
 485   if (attr == NULL)
 486     /* ugg */
 487     return;
 488
 489   attr->attribute = attribute;
 490   attr->form      = form;
 491   attr->next      = NULL;
 492
 493   if (last_abbrev->first_attr == NULL)
 494     last_abbrev->first_attr = attr;
 495   else
 496     last_abbrev->last_attr->next = attr;
 497
 498   last_abbrev->last_attr = attr;
 499 }
 500
 501 /* Processes the (partial) contents of a .debug_abbrev section.
 502    Returns NULL if the end of the section was encountered.
 503    Returns the address after the last byte read if the end of
 504    an abbreviation set was found.  */
 505
 506 static unsigned char *
 507 process_abbrev_section (unsigned char *start, unsigned char *end)
 508 {
 509   if (first_abbrev != NULL)
 510     return NULL;
 511
 512   while (start < end)
 513     {
 514       unsigned int bytes_read;
 515       unsigned long entry;
 516       unsigned long tag;
 517       unsigned long attribute;
 518       int children;
 519
 520       entry = read_leb128 (start, & bytes_read, 0);
 521       start += bytes_read;
 522
 523       /* A single zero is supposed to end the section according
 524          to the standard.  If there's more, then signal that to
 525          the caller.  */
 526       if (entry == 0)
 527         return start == end ? NULL : start;
 528
 529       tag = read_leb128 (start, & bytes_read, 0);
 530       start += bytes_read;
 531
 532       children = *start++;
 533
 534       add_abbrev (entry, tag, children);
 535
 536       do
 537         {
 538           unsigned long form;
 539
 540           attribute = read_leb128 (start, & bytes_read, 0);
 541           start += bytes_read;
 542
 543           form = read_leb128 (start, & bytes_read, 0);
 544           start += bytes_read;
 545
 546           if (attribute != 0)
 547             add_abbrev_attr (attribute, form);
 548         }
 549       while (attribute != 0);
 550     }
 551
 552   return NULL;
 553 }
 554
 555 static char *
 556 get_TAG_name (unsigned long tag)
 557 {
 558   switch (tag)
 559     {
 560     case DW_TAG_padding:                return "DW_TAG_padding";
 561     case DW_TAG_array_type:             return "DW_TAG_array_type";
 562     case DW_TAG_class_type:             return "DW_TAG_class_type";
 563     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
 564     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
 565     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
 566     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
 567     case DW_TAG_label:                  return "DW_TAG_label";
 568     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
 569     case DW_TAG_member:                 return "DW_TAG_member";
 570     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
 571     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
 572     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
 573     case DW_TAG_string_type:            return "DW_TAG_string_type";
 574     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
 575     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
 576     case DW_TAG_typedef:                return "DW_TAG_typedef";
 577     case DW_TAG_union_type:             return "DW_TAG_union_type";
 578     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
 579     case DW_TAG_variant:                return "DW_TAG_variant";
 580     case DW_TAG_common_block:           return "DW_TAG_common_block";
 581     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
 582     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
 583     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
 584     case DW_TAG_module:                 return "DW_TAG_module";
 585     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
 586     case DW_TAG_set_type:               return "DW_TAG_set_type";
 587     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
 588     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
 589     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
 590     case DW_TAG_base_type:              return "DW_TAG_base_type";
 591     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
 592     case DW_TAG_const_type:             return "DW_TAG_const_type";
 593     case DW_TAG_constant:               return "DW_TAG_constant";
 594     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
 595     case DW_TAG_file_type:              return "DW_TAG_file_type";
 596     case DW_TAG_friend:                 return "DW_TAG_friend";
 597     case DW_TAG_namelist:               return "DW_TAG_namelist";
 598     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
 599     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
 600     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
 601     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
 602     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
 603     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
 604     case DW_TAG_try_block:              return "DW_TAG_try_block";
 605     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
 606     case DW_TAG_variable:               return "DW_TAG_variable";
 607     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
 608     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
 609     case DW_TAG_format_label:           return "DW_TAG_format_label";
 610     case DW_TAG_function_template:      return "DW_TAG_function_template";
 611     case DW_TAG_class_template:         return "DW_TAG_class_template";
 612       /* DWARF 2.1 values.  */
 613     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
 614     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
 615     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
 616     case DW_TAG_namespace:              return "DW_TAG_namespace";
 617     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
 618     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
 619     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
 620     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
 621       /* UPC values.  */
 622     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
 623     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
 624     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
 625     default:
 626       {
 627         static char buffer[100];
 628
 629         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
 630         return buffer;
 631       }
 632     }
 633 }
 634
 635 static char *
 636 get_FORM_name (unsigned long form)
 637 {
 638   switch (form)
 639     {
 640     case DW_FORM_addr:          return "DW_FORM_addr";
 641     case DW_FORM_block2:        return "DW_FORM_block2";
 642     case DW_FORM_block4:        return "DW_FORM_block4";
 643     case DW_FORM_data2:         return "DW_FORM_data2";
 644     case DW_FORM_data4:         return "DW_FORM_data4";
 645     case DW_FORM_data8:         return "DW_FORM_data8";
 646     case DW_FORM_string:        return "DW_FORM_string";
 647     case DW_FORM_block:         return "DW_FORM_block";
 648     case DW_FORM_block1:        return "DW_FORM_block1";
 649     case DW_FORM_data1:         return "DW_FORM_data1";
 650     case DW_FORM_flag:          return "DW_FORM_flag";
 651     case DW_FORM_sdata:         return "DW_FORM_sdata";
 652     case DW_FORM_strp:          return "DW_FORM_strp";
 653     case DW_FORM_udata:         return "DW_FORM_udata";
 654     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
 655     case DW_FORM_ref1:          return "DW_FORM_ref1";
 656     case DW_FORM_ref2:          return "DW_FORM_ref2";
 657     case DW_FORM_ref4:          return "DW_FORM_ref4";
 658     case DW_FORM_ref8:          return "DW_FORM_ref8";
 659     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
 660     case DW_FORM_indirect:      return "DW_FORM_indirect";
 661     default:
 662       {
 663         static char buffer[100];
 664
 665         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
 666         return buffer;
 667       }
 668     }
 669 }
 670
 671 static unsigned char *
 672 display_block (unsigned char *data, unsigned long length)
 673 {
 674   printf (_(" %lu byte block: "), length);
 675
 676   while (length --)
 677     printf ("%lx ", (unsigned long) byte_get (data++, 1));
 678
 679   return data;
 680 }
 681
 682 static int
 683 decode_location_expression (unsigned char * data,
 684                             unsigned int pointer_size,
 685                             unsigned long length,
 686                             unsigned long cu_offset,
 687                             struct dwarf_section * section)
 688 {
 689   unsigned op;
 690   unsigned int bytes_read;
 691   unsigned long uvalue;
 692   unsigned char *end = data + length;
 693   int need_frame_base = 0;
 694
 695   while (data < end)
 696     {
 697       op = *data++;
 698
 699       switch (op)
 700         {
 701         case DW_OP_addr:
 702           printf ("DW_OP_addr: %lx",
 703                   (unsigned long) byte_get (data, pointer_size));
 704           data += pointer_size;
 705           break;
 706         case DW_OP_deref:
 707           printf ("DW_OP_deref");
 708           break;
 709         case DW_OP_const1u:
 710           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
 711           break;
 712         case DW_OP_const1s:
 713           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
 714           break;
 715         case DW_OP_const2u:
 716           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
 717           data += 2;
 718           break;
 719         case DW_OP_const2s:
 720           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
 721           data += 2;
 722           break;
 723         case DW_OP_const4u:
 724           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
 725           data += 4;
 726           break;
 727         case DW_OP_const4s:
 728           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
 729           data += 4;
 730           break;
 731         case DW_OP_const8u:
 732           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
 733                   (unsigned long) byte_get (data + 4, 4));
 734           data += 8;
 735           break;
 736         case DW_OP_const8s:
 737           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
 738                   (long) byte_get (data + 4, 4));
 739           data += 8;
 740           break;
 741         case DW_OP_constu:
 742           printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
 743           data += bytes_read;
 744           break;
 745         case DW_OP_consts:
 746           printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
 747           data += bytes_read;
 748           break;
 749         case DW_OP_dup:
 750           printf ("DW_OP_dup");
 751           break;
 752         case DW_OP_drop:
 753           printf ("DW_OP_drop");
 754           break;
 755         case DW_OP_over:
 756           printf ("DW_OP_over");
 757           break;
 758         case DW_OP_pick:
 759           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
 760           break;
 761         case DW_OP_swap:
 762           printf ("DW_OP_swap");
 763           break;
 764         case DW_OP_rot:
 765           printf ("DW_OP_rot");
 766           break;
 767         case DW_OP_xderef:
 768           printf ("DW_OP_xderef");
 769           break;
 770         case DW_OP_abs:
 771           printf ("DW_OP_abs");
 772           break;
 773         case DW_OP_and:
 774           printf ("DW_OP_and");
 775           break;
 776         case DW_OP_div:
 777           printf ("DW_OP_div");
 778           break;
 779         case DW_OP_minus:
 780           printf ("DW_OP_minus");
 781           break;
 782         case DW_OP_mod:
 783           printf ("DW_OP_mod");
 784           break;
 785         case DW_OP_mul:
 786           printf ("DW_OP_mul");
 787           break;
 788         case DW_OP_neg:
 789           printf ("DW_OP_neg");
 790           break;
 791         case DW_OP_not:
 792           printf ("DW_OP_not");
 793           break;
 794         case DW_OP_or:
 795           printf ("DW_OP_or");
 796           break;
 797         case DW_OP_plus:
 798           printf ("DW_OP_plus");
 799           break;
 800         case DW_OP_plus_uconst:
 801           printf ("DW_OP_plus_uconst: %lu",
 802                   read_leb128 (data, &bytes_read, 0));
 803           data += bytes_read;
 804           break;
 805         case DW_OP_shl:
 806           printf ("DW_OP_shl");
 807           break;
 808         case DW_OP_shr:
 809           printf ("DW_OP_shr");
 810           break;
 811         case DW_OP_shra:
 812           printf ("DW_OP_shra");
 813           break;
 814         case DW_OP_xor:
 815           printf ("DW_OP_xor");
 816           break;
 817         case DW_OP_bra:
 818           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
 819           data += 2;
 820           break;
 821         case DW_OP_eq:
 822           printf ("DW_OP_eq");
 823           break;
 824         case DW_OP_ge:
 825           printf ("DW_OP_ge");
 826           break;
 827         case DW_OP_gt:
 828           printf ("DW_OP_gt");
 829           break;
 830         case DW_OP_le:
 831           printf ("DW_OP_le");
 832           break;
 833         case DW_OP_lt:
 834           printf ("DW_OP_lt");
 835           break;
 836         case DW_OP_ne:
 837           printf ("DW_OP_ne");
 838           break;
 839         case DW_OP_skip:
 840           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
 841           data += 2;
 842           break;
 843
 844         case DW_OP_lit0:
 845         case DW_OP_lit1:
 846         case DW_OP_lit2:
 847         case DW_OP_lit3:
 848         case DW_OP_lit4:
 849         case DW_OP_lit5:
 850         case DW_OP_lit6:
 851         case DW_OP_lit7:
 852         case DW_OP_lit8:
 853         case DW_OP_lit9:
 854         case DW_OP_lit10:
 855         case DW_OP_lit11:
 856         case DW_OP_lit12:
 857         case DW_OP_lit13:
 858         case DW_OP_lit14:
 859         case DW_OP_lit15:
 860         case DW_OP_lit16:
 861         case DW_OP_lit17:
 862         case DW_OP_lit18:
 863         case DW_OP_lit19:
 864         case DW_OP_lit20:
 865         case DW_OP_lit21:
 866         case DW_OP_lit22:
 867         case DW_OP_lit23:
 868         case DW_OP_lit24:
 869         case DW_OP_lit25:
 870         case DW_OP_lit26:
 871         case DW_OP_lit27:
 872         case DW_OP_lit28:
 873         case DW_OP_lit29:
 874         case DW_OP_lit30:
 875         case DW_OP_lit31:
 876           printf ("DW_OP_lit%d", op - DW_OP_lit0);
 877           break;
 878
 879         case DW_OP_reg0:
 880         case DW_OP_reg1:
 881         case DW_OP_reg2:
 882         case DW_OP_reg3:
 883         case DW_OP_reg4:
 884         case DW_OP_reg5:
 885         case DW_OP_reg6:
 886         case DW_OP_reg7:
 887         case DW_OP_reg8:
 888         case DW_OP_reg9:
 889         case DW_OP_reg10:
 890         case DW_OP_reg11:
 891         case DW_OP_reg12:
 892         case DW_OP_reg13:
 893         case DW_OP_reg14:
 894         case DW_OP_reg15:
 895         case DW_OP_reg16:
 896         case DW_OP_reg17:
 897         case DW_OP_reg18:
 898         case DW_OP_reg19:
 899         case DW_OP_reg20:
 900         case DW_OP_reg21:
 901         case DW_OP_reg22:
 902         case DW_OP_reg23:
 903         case DW_OP_reg24:
 904         case DW_OP_reg25:
 905         case DW_OP_reg26:
 906         case DW_OP_reg27:
 907         case DW_OP_reg28:
 908         case DW_OP_reg29:
 909         case DW_OP_reg30:
 910         case DW_OP_reg31:
 911           printf ("DW_OP_reg%d", op - DW_OP_reg0);
 912           break;
 913
 914         case DW_OP_breg0:
 915         case DW_OP_breg1:
 916         case DW_OP_breg2:
 917         case DW_OP_breg3:
 918         case DW_OP_breg4:
 919         case DW_OP_breg5:
 920         case DW_OP_breg6:
 921         case DW_OP_breg7:
 922         case DW_OP_breg8:
 923         case DW_OP_breg9:
 924         case DW_OP_breg10:
 925         case DW_OP_breg11:
 926         case DW_OP_breg12:
 927         case DW_OP_breg13:
 928         case DW_OP_breg14:
 929         case DW_OP_breg15:
 930         case DW_OP_breg16:
 931         case DW_OP_breg17:
 932         case DW_OP_breg18:
 933         case DW_OP_breg19:
 934         case DW_OP_breg20:
 935         case DW_OP_breg21:
 936         case DW_OP_breg22:
 937         case DW_OP_breg23:
 938         case DW_OP_breg24:
 939         case DW_OP_breg25:
 940         case DW_OP_breg26:
 941         case DW_OP_breg27:
 942         case DW_OP_breg28:
 943         case DW_OP_breg29:
 944         case DW_OP_breg30:
 945         case DW_OP_breg31:
 946           printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
 947                   read_leb128 (data, &bytes_read, 1));
 948           data += bytes_read;
 949           break;
 950
 951         case DW_OP_regx:
 952           printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
 953           data += bytes_read;
 954           break;
 955         case DW_OP_fbreg:
 956           need_frame_base = 1;
 957           printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
 958           data += bytes_read;
 959           break;
 960         case DW_OP_bregx:
 961           uvalue = read_leb128 (data, &bytes_read, 0);
 962           data += bytes_read;
 963           printf ("DW_OP_bregx: %lu %ld", uvalue,
 964                   read_leb128 (data, &bytes_read, 1));
 965           data += bytes_read;
 966           break;
 967         case DW_OP_piece:
 968           printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
 969           data += bytes_read;
 970           break;
 971         case DW_OP_deref_size:
 972           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
 973           break;
 974         case DW_OP_xderef_size:
 975           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
 976           break;
 977         case DW_OP_nop:
 978           printf ("DW_OP_nop");
 979           break;
 980
 981           /* DWARF 3 extensions.  */
 982         case DW_OP_push_object_address:
 983           printf ("DW_OP_push_object_address");
 984           break;
 985         case DW_OP_call2:
 986           /* XXX: Strictly speaking for 64-bit DWARF3 files
 987              this ought to be an 8-byte wide computation.  */
 988           printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
 989           data += 2;
 990           break;
 991         case DW_OP_call4:
 992           /* XXX: Strictly speaking for 64-bit DWARF3 files
 993              this ought to be an 8-byte wide computation.  */
 994           printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
 995           data += 4;
 996           break;
 997         case DW_OP_call_ref:
 998           /* XXX: Strictly speaking for 64-bit DWARF3 files
 999              this ought to be an 8-byte wide computation.  */
1000           printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
1001           data += 4;
1002           break;
1003         case DW_OP_form_tls_address:
1004           printf ("DW_OP_form_tls_address");
1005           break;
1006         case DW_OP_call_frame_cfa:
1007           printf ("DW_OP_call_frame_cfa");
1008           break;
1009         case DW_OP_bit_piece:
1010           printf ("DW_OP_bit_piece: ");
1011           printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
1012           data += bytes_read;
1013           printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
1014           data += bytes_read;
1015           break;
1016
1017           /* DWARF 4 extensions.  */
1018         case DW_OP_stack_value:
1019           printf ("DW_OP_stack_value");
1020           break;
1021
1022         case DW_OP_implicit_value:
1023           printf ("DW_OP_implicit_value");
1024           uvalue = read_leb128 (data, &bytes_read, 0);
1025           data += bytes_read;
1026           display_block (data, uvalue);
1027           data += uvalue;
1028           break;
1029
1030           /* GNU extensions.  */
1031         case DW_OP_GNU_push_tls_address:
1032           printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1033           break;
1034         case DW_OP_GNU_uninit:
1035           printf ("DW_OP_GNU_uninit");
1036           /* FIXME: Is there data associated with this OP ?  */
1037           break;
1038         case DW_OP_GNU_encoded_addr:
1039           {
1040             int encoding;
1041             dwarf_vma addr;
1042
1043             encoding = *data++;
1044             addr = get_encoded_value (data, encoding);
1045             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1046               addr += section->address + (data - section->start);
1047             data += size_of_encoded_value (encoding);
1048
1049             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1050             print_dwarf_vma (addr, pointer_size);
1051           }
1052           break;
1053
1054           /* HP extensions.  */
1055         case DW_OP_HP_is_value:
1056           printf ("DW_OP_HP_is_value");
1057           /* FIXME: Is there data associated with this OP ?  */
1058           break;
1059         case DW_OP_HP_fltconst4:
1060           printf ("DW_OP_HP_fltconst4");
1061           /* FIXME: Is there data associated with this OP ?  */
1062           break;
1063         case DW_OP_HP_fltconst8:
1064           printf ("DW_OP_HP_fltconst8");
1065           /* FIXME: Is there data associated with this OP ?  */
1066           break;
1067         case DW_OP_HP_mod_range:
1068           printf ("DW_OP_HP_mod_range");
1069           /* FIXME: Is there data associated with this OP ?  */
1070           break;
1071         case DW_OP_HP_unmod_range:
1072           printf ("DW_OP_HP_unmod_range");
1073           /* FIXME: Is there data associated with this OP ?  */
1074           break;
1075         case DW_OP_HP_tls:
1076           printf ("DW_OP_HP_tls");
1077           /* FIXME: Is there data associated with this OP ?  */
1078           break;
1079
1080           /* PGI (STMicroelectronics) extensions.  */
1081         case DW_OP_PGI_omp_thread_num:
1082           /* Pushes the thread number for the current thread as it would be
1083              returned by the standard OpenMP library function:
1084              omp_get_thread_num().  The "current thread" is the thread for
1085              which the expression is being evaluated.  */
1086           printf ("DW_OP_PGI_omp_thread_num");
1087           break;
1088
1089         default:
1090           if (op >= DW_OP_lo_user
1091               && op <= DW_OP_hi_user)
1092             printf (_("(User defined location op)"));
1093           else
1094             printf (_("(Unknown location op)"));
1095           /* No way to tell where the next op is, so just bail.  */
1096           return need_frame_base;
1097         }
1098
1099       /* Separate the ops.  */
1100       if (data < end)
1101         printf ("; ");
1102     }
1103
1104   return need_frame_base;
1105 }
1106
1107 static unsigned char *
1108 read_and_display_attr_value (unsigned long attribute,
1109                              unsigned long form,
1110                              unsigned char * data,
1111                              unsigned long cu_offset,
1112                              unsigned long pointer_size,
1113                              unsigned long offset_size,
1114                              int dwarf_version,
1115                              debug_info * debug_info_p,
1116                              int do_loc,
1117                              struct dwarf_section * section)
1118 {
1119   unsigned long uvalue = 0;
1120   unsigned char *block_start = NULL;
1121   unsigned char * orig_data = data;
1122   unsigned int bytes_read;
1123
1124   switch (form)
1125     {
1126     default:
1127       break;
1128
1129     case DW_FORM_ref_addr:
1130       if (dwarf_version == 2)
1131         {
1132           uvalue = byte_get (data, pointer_size);
1133           data += pointer_size;
1134         }
1135       else if (dwarf_version == 3)
1136         {
1137           uvalue = byte_get (data, offset_size);
1138           data += offset_size;
1139         }
1140       else
1141         {
1142           error (_("Internal error: DWARF version is not 2 or 3.\n"));
1143         }
1144       break;
1145
1146     case DW_FORM_addr:
1147       uvalue = byte_get (data, pointer_size);
1148       data += pointer_size;
1149       break;
1150
1151     case DW_FORM_strp:
1152       uvalue = byte_get (data, offset_size);
1153       data += offset_size;
1154       break;
1155
1156     case DW_FORM_ref1:
1157     case DW_FORM_flag:
1158     case DW_FORM_data1:
1159       uvalue = byte_get (data++, 1);
1160       break;
1161
1162     case DW_FORM_ref2:
1163     case DW_FORM_data2:
1164       uvalue = byte_get (data, 2);
1165       data += 2;
1166       break;
1167
1168     case DW_FORM_ref4:
1169     case DW_FORM_data4:
1170       uvalue = byte_get (data, 4);
1171       data += 4;
1172       break;
1173
1174     case DW_FORM_sdata:
1175       uvalue = read_leb128 (data, & bytes_read, 1);
1176       data += bytes_read;
1177       break;
1178
1179     case DW_FORM_ref_udata:
1180     case DW_FORM_udata:
1181       uvalue = read_leb128 (data, & bytes_read, 0);
1182       data += bytes_read;
1183       break;
1184
1185     case DW_FORM_indirect:
1186       form = read_leb128 (data, & bytes_read, 0);
1187       data += bytes_read;
1188       if (!do_loc)
1189         printf (" %s", get_FORM_name (form));
1190       return read_and_display_attr_value (attribute, form, data,
1191                                           cu_offset, pointer_size,
1192                                           offset_size, dwarf_version,
1193                                           debug_info_p, do_loc,
1194                                           section);
1195     }
1196
1197   switch (form)
1198     {
1199     case DW_FORM_ref_addr:
1200       if (!do_loc)
1201         printf (" <0x%lx>", uvalue);
1202       break;
1203
1204     case DW_FORM_ref1:
1205     case DW_FORM_ref2:
1206     case DW_FORM_ref4:
1207     case DW_FORM_ref_udata:
1208       if (!do_loc)
1209         printf (" <0x%lx>", uvalue + cu_offset);
1210       break;
1211
1212     case DW_FORM_data4:
1213     case DW_FORM_addr:
1214       if (!do_loc)
1215         printf (" 0x%lx", uvalue);
1216       break;
1217
1218     case DW_FORM_flag:
1219     case DW_FORM_data1:
1220     case DW_FORM_data2:
1221     case DW_FORM_sdata:
1222     case DW_FORM_udata:
1223       if (!do_loc)
1224         printf (" %ld", uvalue);
1225       break;
1226
1227     case DW_FORM_ref8:
1228     case DW_FORM_data8:
1229       if (!do_loc)
1230         {
1231           uvalue = byte_get (data, 4);
1232           printf (" 0x%lx", uvalue);
1233           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1234         }
1235       if ((do_loc || do_debug_loc || do_debug_ranges)
1236           && num_debug_info_entries == 0)
1237         {
1238           if (sizeof (uvalue) == 8)
1239             uvalue = byte_get (data, 8);
1240           else
1241             error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1242         }
1243       data += 8;
1244       break;
1245
1246     case DW_FORM_string:
1247       if (!do_loc)
1248         printf (" %s", data);
1249       data += strlen ((char *) data) + 1;
1250       break;
1251
1252     case DW_FORM_block:
1253       uvalue = read_leb128 (data, & bytes_read, 0);
1254       block_start = data + bytes_read;
1255       if (do_loc)
1256         data = block_start + uvalue;
1257       else
1258         data = display_block (block_start, uvalue);
1259       break;
1260
1261     case DW_FORM_block1:
1262       uvalue = byte_get (data, 1);
1263       block_start = data + 1;
1264       if (do_loc)
1265         data = block_start + uvalue;
1266       else
1267         data = display_block (block_start, uvalue);
1268       break;
1269
1270     case DW_FORM_block2:
1271       uvalue = byte_get (data, 2);
1272       block_start = data + 2;
1273       if (do_loc)
1274         data = block_start + uvalue;
1275       else
1276         data = display_block (block_start, uvalue);
1277       break;
1278
1279     case DW_FORM_block4:
1280       uvalue = byte_get (data, 4);
1281       block_start = data + 4;
1282       if (do_loc)
1283         data = block_start + uvalue;
1284       else
1285         data = display_block (block_start, uvalue);
1286       break;
1287
1288     case DW_FORM_strp:
1289       if (!do_loc)
1290         printf (_(" (indirect string, offset: 0x%lx): %s"),
1291                 uvalue, fetch_indirect_string (uvalue));
1292       break;
1293
1294     case DW_FORM_indirect:
1295       /* Handled above.  */
1296       break;
1297
1298     default:
1299       warn (_("Unrecognized form: %lu\n"), form);
1300       break;
1301     }
1302
1303   if ((do_loc || do_debug_loc || do_debug_ranges)
1304       && num_debug_info_entries == 0)
1305     {
1306       switch (attribute)
1307         {
1308         case DW_AT_frame_base:
1309           have_frame_base = 1;
1310         case DW_AT_location:
1311         case DW_AT_string_length:
1312         case DW_AT_return_addr:
1313         case DW_AT_data_member_location:
1314         case DW_AT_vtable_elem_location:
1315         case DW_AT_segment:
1316         case DW_AT_static_link:
1317         case DW_AT_use_location:
1318           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1319             {
1320               /* Process location list.  */
1321               unsigned int max = debug_info_p->max_loc_offsets;
1322               unsigned int num = debug_info_p->num_loc_offsets;
1323
1324               if (max == 0 || num >= max)
1325                 {
1326                   max += 1024;
1327                   debug_info_p->loc_offsets
1328                     = xcrealloc (debug_info_p->loc_offsets,
1329                                  max, sizeof (*debug_info_p->loc_offsets));
1330                   debug_info_p->have_frame_base
1331                     = xcrealloc (debug_info_p->have_frame_base,
1332                                  max, sizeof (*debug_info_p->have_frame_base));
1333                   debug_info_p->max_loc_offsets = max;
1334                 }
1335               debug_info_p->loc_offsets [num] = uvalue;
1336               debug_info_p->have_frame_base [num] = have_frame_base;
1337               debug_info_p->num_loc_offsets++;
1338             }
1339           break;
1340
1341         case DW_AT_low_pc:
1342           if (need_base_address)
1343             debug_info_p->base_address = uvalue;
1344           break;
1345
1346         case DW_AT_ranges:
1347           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1348             {
1349               /* Process range list.  */
1350               unsigned int max = debug_info_p->max_range_lists;
1351               unsigned int num = debug_info_p->num_range_lists;
1352
1353               if (max == 0 || num >= max)
1354                 {
1355                   max += 1024;
1356                   debug_info_p->range_lists
1357                     = xcrealloc (debug_info_p->range_lists,
1358                                  max, sizeof (*debug_info_p->range_lists));
1359                   debug_info_p->max_range_lists = max;
1360                 }
1361               debug_info_p->range_lists [num] = uvalue;
1362               debug_info_p->num_range_lists++;
1363             }
1364           break;
1365
1366         default:
1367           break;
1368         }
1369     }
1370
1371   if (do_loc)
1372     return data;
1373
1374   /* For some attributes we can display further information.  */
1375   printf ("\t");
1376
1377   switch (attribute)
1378     {
1379     case DW_AT_inline:
1380       switch (uvalue)
1381         {
1382         case DW_INL_not_inlined:
1383           printf (_("(not inlined)"));
1384           break;
1385         case DW_INL_inlined:
1386           printf (_("(inlined)"));
1387           break;
1388         case DW_INL_declared_not_inlined:
1389           printf (_("(declared as inline but ignored)"));
1390           break;
1391         case DW_INL_declared_inlined:
1392           printf (_("(declared as inline and inlined)"));
1393           break;
1394         default:
1395           printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
1396           break;
1397         }
1398       break;
1399
1400     case DW_AT_language:
1401       switch (uvalue)
1402         {
1403           /* Ordered by the numeric value of these constants.  */
1404         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1405         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1406         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1407         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1408         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1409         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1410         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1411         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1412         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1413         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1414           /* DWARF 2.1 values.  */
1415         case DW_LANG_Java:              printf ("(Java)"); break;
1416         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1417         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1418         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1419           /* DWARF 3 values.  */
1420         case DW_LANG_PLI:               printf ("(PLI)"); break;
1421         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1422         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1423         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1424         case DW_LANG_D:                 printf ("(D)"); break;
1425           /* MIPS extension.  */
1426         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1427           /* UPC extension.  */
1428         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1429         default:
1430           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1431             printf ("(implementation defined: %lx)", uvalue);
1432           else
1433             printf ("(Unknown: %lx)", uvalue);
1434           break;
1435         }
1436       break;
1437
1438     case DW_AT_encoding:
1439       switch (uvalue)
1440         {
1441         case DW_ATE_void:               printf ("(void)"); break;
1442         case DW_ATE_address:            printf ("(machine address)"); break;
1443         case DW_ATE_boolean:            printf ("(boolean)"); break;
1444         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1445         case DW_ATE_float:              printf ("(float)"); break;
1446         case DW_ATE_signed:             printf ("(signed)"); break;
1447         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1448         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1449         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1450           /* DWARF 2.1 values:  */
1451         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1452         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1453           /* DWARF 3 values:  */
1454         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1455         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1456         case DW_ATE_edited:             printf ("(edited)"); break;
1457         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1458         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1459           /* HP extensions:  */
1460         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1461         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1462         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1463         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1464         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1465         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1466         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1467
1468         default:
1469           if (uvalue >= DW_ATE_lo_user
1470               && uvalue <= DW_ATE_hi_user)
1471             printf ("(user defined type)");
1472           else
1473             printf ("(unknown type)");
1474           break;
1475         }
1476       break;
1477
1478     case DW_AT_accessibility:
1479       switch (uvalue)
1480         {
1481         case DW_ACCESS_public:          printf ("(public)"); break;
1482         case DW_ACCESS_protected:       printf ("(protected)"); break;
1483         case DW_ACCESS_private:         printf ("(private)"); break;
1484         default:
1485           printf ("(unknown accessibility)");
1486           break;
1487         }
1488       break;
1489
1490     case DW_AT_visibility:
1491       switch (uvalue)
1492         {
1493         case DW_VIS_local:              printf ("(local)"); break;
1494         case DW_VIS_exported:           printf ("(exported)"); break;
1495         case DW_VIS_qualified:          printf ("(qualified)"); break;
1496         default:                        printf ("(unknown visibility)"); break;
1497         }
1498       break;
1499
1500     case DW_AT_virtuality:
1501       switch (uvalue)
1502         {
1503         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1504         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1505         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1506         default:                        printf ("(unknown virtuality)"); break;
1507         }
1508       break;
1509
1510     case DW_AT_identifier_case:
1511       switch (uvalue)
1512         {
1513         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1514         case DW_ID_up_case:             printf ("(up_case)"); break;
1515         case DW_ID_down_case:           printf ("(down_case)"); break;
1516         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1517         default:                        printf ("(unknown case)"); break;
1518         }
1519       break;
1520
1521     case DW_AT_calling_convention:
1522       switch (uvalue)
1523         {
1524         case DW_CC_normal:      printf ("(normal)"); break;
1525         case DW_CC_program:     printf ("(program)"); break;
1526         case DW_CC_nocall:      printf ("(nocall)"); break;
1527         default:
1528           if (uvalue >= DW_CC_lo_user
1529               && uvalue <= DW_CC_hi_user)
1530             printf ("(user defined)");
1531           else
1532             printf ("(unknown convention)");
1533         }
1534       break;
1535
1536     case DW_AT_ordering:
1537       switch (uvalue)
1538         {
1539         case -1: printf ("(undefined)"); break;
1540         case 0:  printf ("(row major)"); break;
1541         case 1:  printf ("(column major)"); break;
1542         }
1543       break;
1544
1545     case DW_AT_frame_base:
1546       have_frame_base = 1;
1547     case DW_AT_location:
1548     case DW_AT_string_length:
1549     case DW_AT_return_addr:
1550     case DW_AT_data_member_location:
1551     case DW_AT_vtable_elem_location:
1552     case DW_AT_segment:
1553     case DW_AT_static_link:
1554     case DW_AT_use_location:
1555       if (form == DW_FORM_data4 || form == DW_FORM_data8)
1556         printf (_("(location list)"));
1557       /* Fall through.  */
1558     case DW_AT_allocated:
1559     case DW_AT_associated:
1560     case DW_AT_data_location:
1561     case DW_AT_stride:
1562     case DW_AT_upper_bound:
1563     case DW_AT_lower_bound:
1564       if (block_start)
1565         {
1566           int need_frame_base;
1567
1568           printf ("(");
1569           need_frame_base = decode_location_expression (block_start,
1570                                                         pointer_size,
1571                                                         uvalue,
1572                                                         cu_offset, section);
1573           printf (")");
1574           if (need_frame_base && !have_frame_base)
1575             printf (_(" [without DW_AT_frame_base]"));
1576         }
1577       break;
1578
1579     case DW_AT_import:
1580       {
1581         if (form == DW_FORM_ref1
1582             || form == DW_FORM_ref2
1583             || form == DW_FORM_ref4)
1584           uvalue += cu_offset;
1585
1586         if (uvalue >= section->size)
1587           warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1588                 uvalue, (unsigned long) (orig_data - section->start));
1589         else
1590           {
1591             unsigned long abbrev_number;
1592             abbrev_entry * entry;
1593
1594             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1595
1596             printf ("[Abbrev Number: %ld", abbrev_number);
1597             for (entry = first_abbrev; entry != NULL; entry = entry->next)
1598               if (entry->entry == abbrev_number)
1599                 break;
1600             if (entry != NULL)
1601               printf (" (%s)", get_TAG_name (entry->tag));
1602             printf ("]");
1603           }
1604       }
1605       break;
1606
1607     default:
1608       break;
1609     }
1610
1611   return data;
1612 }
1613
1614 static char *
1615 get_AT_name (unsigned long attribute)
1616 {
1617   switch (attribute)
1618     {
1619     case DW_AT_sibling:                 return "DW_AT_sibling";
1620     case DW_AT_location:                return "DW_AT_location";
1621     case DW_AT_name:                    return "DW_AT_name";
1622     case DW_AT_ordering:                return "DW_AT_ordering";
1623     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1624     case DW_AT_byte_size:               return "DW_AT_byte_size";
1625     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1626     case DW_AT_bit_size:                return "DW_AT_bit_size";
1627     case DW_AT_element_list:            return "DW_AT_element_list";
1628     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1629     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1630     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1631     case DW_AT_language:                return "DW_AT_language";
1632     case DW_AT_member:                  return "DW_AT_member";
1633     case DW_AT_discr:                   return "DW_AT_discr";
1634     case DW_AT_discr_value:             return "DW_AT_discr_value";
1635     case DW_AT_visibility:              return "DW_AT_visibility";
1636     case DW_AT_import:                  return "DW_AT_import";
1637     case DW_AT_string_length:           return "DW_AT_string_length";
1638     case DW_AT_common_reference:        return "DW_AT_common_reference";
1639     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1640     case DW_AT_const_value:             return "DW_AT_const_value";
1641     case DW_AT_containing_type:         return "DW_AT_containing_type";
1642     case DW_AT_default_value:           return "DW_AT_default_value";
1643     case DW_AT_inline:                  return "DW_AT_inline";
1644     case DW_AT_is_optional:             return "DW_AT_is_optional";
1645     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1646     case DW_AT_producer:                return "DW_AT_producer";
1647     case DW_AT_prototyped:              return "DW_AT_prototyped";
1648     case DW_AT_return_addr:             return "DW_AT_return_addr";
1649     case DW_AT_start_scope:             return "DW_AT_start_scope";
1650     case DW_AT_stride_size:             return "DW_AT_stride_size";
1651     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1652     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1653     case DW_AT_accessibility:           return "DW_AT_accessibility";
1654     case DW_AT_address_class:           return "DW_AT_address_class";
1655     case DW_AT_artificial:              return "DW_AT_artificial";
1656     case DW_AT_base_types:              return "DW_AT_base_types";
1657     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1658     case DW_AT_count:                   return "DW_AT_count";
1659     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1660     case DW_AT_decl_column:             return "DW_AT_decl_column";
1661     case DW_AT_decl_file:               return "DW_AT_decl_file";
1662     case DW_AT_decl_line:               return "DW_AT_decl_line";
1663     case DW_AT_declaration:             return "DW_AT_declaration";
1664     case DW_AT_discr_list:              return "DW_AT_discr_list";
1665     case DW_AT_encoding:                return "DW_AT_encoding";
1666     case DW_AT_external:                return "DW_AT_external";
1667     case DW_AT_frame_base:              return "DW_AT_frame_base";
1668     case DW_AT_friend:                  return "DW_AT_friend";
1669     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1670     case DW_AT_macro_info:              return "DW_AT_macro_info";
1671     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1672     case DW_AT_priority:                return "DW_AT_priority";
1673     case DW_AT_segment:                 return "DW_AT_segment";
1674     case DW_AT_specification:           return "DW_AT_specification";
1675     case DW_AT_static_link:             return "DW_AT_static_link";
1676     case DW_AT_type:                    return "DW_AT_type";
1677     case DW_AT_use_location:            return "DW_AT_use_location";
1678     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1679     case DW_AT_virtuality:              return "DW_AT_virtuality";
1680     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1681       /* DWARF 2.1 values.  */
1682     case DW_AT_allocated:               return "DW_AT_allocated";
1683     case DW_AT_associated:              return "DW_AT_associated";
1684     case DW_AT_data_location:           return "DW_AT_data_location";
1685     case DW_AT_stride:                  return "DW_AT_stride";
1686     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1687     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1688     case DW_AT_extension:               return "DW_AT_extension";
1689     case DW_AT_ranges:                  return "DW_AT_ranges";
1690     case DW_AT_trampoline:              return "DW_AT_trampoline";
1691     case DW_AT_call_column:             return "DW_AT_call_column";
1692     case DW_AT_call_file:               return "DW_AT_call_file";
1693     case DW_AT_call_line:               return "DW_AT_call_line";
1694     case DW_AT_description:             return "DW_AT_description";
1695     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1696     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1697     case DW_AT_small:                   return "DW_AT_small";
1698     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1699     case DW_AT_digit_count:             return "DW_AT_digit_count";
1700     case DW_AT_picture_string:          return "DW_AT_picture_string";
1701     case DW_AT_mutable:                 return "DW_AT_mutable";
1702     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1703     case DW_AT_explicit:                return "DW_AT_explicit";
1704     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1705     case DW_AT_endianity:               return "DW_AT_endianity";
1706     case DW_AT_elemental:               return "DW_AT_elemental";
1707     case DW_AT_pure:                    return "DW_AT_pure";
1708     case DW_AT_recursive:               return "DW_AT_recursive";
1709
1710       /* HP and SGI/MIPS extensions.  */
1711     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1712     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1713     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1714     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1715     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1716     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1717     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1718     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1719     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1720     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1721
1722       /* HP Extensions.  */
1723     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1724     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1725     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1726     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1727     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1728     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1729     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1730     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1731     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1732     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1733     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1734     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1735     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1736
1737       /* One value is shared by the MIPS and HP extensions:  */
1738     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1739
1740       /* GNU extensions.  */
1741     case DW_AT_sf_names:                return "DW_AT_sf_names";
1742     case DW_AT_src_info:                return "DW_AT_src_info";
1743     case DW_AT_mac_info:                return "DW_AT_mac_info";
1744     case DW_AT_src_coords:              return "DW_AT_src_coords";
1745     case DW_AT_body_begin:              return "DW_AT_body_begin";
1746     case DW_AT_body_end:                return "DW_AT_body_end";
1747     case DW_AT_GNU_vector:              return "DW_AT_GNU_vector";
1748
1749       /* UPC extension.  */
1750     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1751
1752     /* PGI (STMicroelectronics) extensions.  */
1753     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1754     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1755     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1756
1757     default:
1758       {
1759         static char buffer[100];
1760
1761         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1762                   attribute);
1763         return buffer;
1764       }
1765     }
1766 }
1767
1768 static unsigned char *
1769 read_and_display_attr (unsigned long attribute,
1770                        unsigned long form,
1771                        unsigned char * data,
1772                        unsigned long cu_offset,
1773                        unsigned long pointer_size,
1774                        unsigned long offset_size,
1775                        int dwarf_version,
1776                        debug_info * debug_info_p,
1777                        int do_loc,
1778                        struct dwarf_section * section)
1779 {
1780   if (!do_loc)
1781     printf ("   %-18s:", get_AT_name (attribute));
1782   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1783                                       pointer_size, offset_size,
1784                                       dwarf_version, debug_info_p,
1785                                       do_loc, section);
1786   if (!do_loc)
1787     printf ("\n");
1788   return data;
1789 }
1790
1791
1792 /* Process the contents of a .debug_info section.  If do_loc is non-zero
1793    then we are scanning for location lists and we do not want to display
1794    anything to the user.  */
1795
1796 static int
1797 process_debug_info (struct dwarf_section *section,
1798                     void *file,
1799                     int do_loc)
1800 {
1801   unsigned char *start = section->start;
1802   unsigned char *end = start + section->size;
1803   unsigned char *section_begin;
1804   unsigned int unit;
1805   unsigned int num_units = 0;
1806
1807   if ((do_loc || do_debug_loc || do_debug_ranges)
1808       && num_debug_info_entries == 0)
1809     {
1810       unsigned long length;
1811
1812       /* First scan the section to get the number of comp units.  */
1813       for (section_begin = start, num_units = 0; section_begin < end;
1814            num_units ++)
1815         {
1816           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
1817              will be the length.  For a 64-bit DWARF section, it'll be
1818              the escape code 0xffffffff followed by an 8 byte length.  */
1819           length = byte_get (section_begin, 4);
1820
1821           if (length == 0xffffffff)
1822             {
1823               length = byte_get (section_begin + 4, 8);
1824               section_begin += length + 12;
1825             }
1826           else if (length >= 0xfffffff0 && length < 0xffffffff)
1827             {
1828               warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1829               return 0;
1830             }
1831           else
1832             section_begin += length + 4;
1833
1834           /* Negative values are illegal, they may even cause infinite
1835              looping.  This can happen if we can't accurately apply
1836              relocations to an object file.  */
1837           if ((signed long) length <= 0)
1838             {
1839               warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1840               return 0;
1841             }
1842         }
1843
1844       if (num_units == 0)
1845         {
1846           error (_("No comp units in %s section ?"), section->name);
1847           return 0;
1848         }
1849
1850       /* Then allocate an array to hold the information.  */
1851       debug_information = cmalloc (num_units,
1852                                    sizeof (* debug_information));
1853       if (debug_information == NULL)
1854         {
1855           error (_("Not enough memory for a debug info array of %u entries"),
1856                  num_units);
1857           return 0;
1858         }
1859     }
1860
1861   if (!do_loc)
1862     {
1863       printf (_("Contents of the %s section:\n\n"), section->name);
1864
1865       load_debug_section (str, file);
1866     }
1867
1868   load_debug_section (abbrev, file);
1869   if (debug_displays [abbrev].section.start == NULL)
1870     {
1871       warn (_("Unable to locate %s section!\n"),
1872             debug_displays [abbrev].section.name);
1873       return 0;
1874     }
1875
1876   for (section_begin = start, unit = 0; start < end; unit++)
1877     {
1878       DWARF2_Internal_CompUnit compunit;
1879       unsigned char *hdrptr;
1880       unsigned char *cu_abbrev_offset_ptr;
1881       unsigned char *tags;
1882       int level;
1883       unsigned long cu_offset;
1884       int offset_size;
1885       int initial_length_size;
1886
1887       hdrptr = start;
1888
1889       compunit.cu_length = byte_get (hdrptr, 4);
1890       hdrptr += 4;
1891
1892       if (compunit.cu_length == 0xffffffff)
1893         {
1894           compunit.cu_length = byte_get (hdrptr, 8);
1895           hdrptr += 8;
1896           offset_size = 8;
1897           initial_length_size = 12;
1898         }
1899       else
1900         {
1901           offset_size = 4;
1902           initial_length_size = 4;
1903         }
1904
1905       compunit.cu_version = byte_get (hdrptr, 2);
1906       hdrptr += 2;
1907
1908       cu_offset = start - section_begin;
1909
1910       cu_abbrev_offset_ptr = hdrptr;
1911       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1912       hdrptr += offset_size;
1913
1914       compunit.cu_pointer_size = byte_get (hdrptr, 1);
1915       hdrptr += 1;
1916       if ((do_loc || do_debug_loc || do_debug_ranges)
1917           && num_debug_info_entries == 0)
1918         {
1919           debug_information [unit].cu_offset = cu_offset;
1920           debug_information [unit].pointer_size
1921             = compunit.cu_pointer_size;
1922           debug_information [unit].base_address = 0;
1923           debug_information [unit].loc_offsets = NULL;
1924           debug_information [unit].have_frame_base = NULL;
1925           debug_information [unit].max_loc_offsets = 0;
1926           debug_information [unit].num_loc_offsets = 0;
1927           debug_information [unit].range_lists = NULL;
1928           debug_information [unit].max_range_lists= 0;
1929           debug_information [unit].num_range_lists = 0;
1930         }
1931
1932       if (!do_loc)
1933         {
1934           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1935           printf (_("   Length:        0x%lx (%s)\n"), compunit.cu_length,
1936                   initial_length_size == 8 ? "64-bit" : "32-bit");
1937           printf (_("   Version:       %d\n"), compunit.cu_version);
1938           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1939           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
1940         }
1941
1942       if (cu_offset + compunit.cu_length + initial_length_size
1943           > section->size)
1944         {
1945           warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1946                 cu_offset, compunit.cu_length);
1947           break;
1948         }
1949       tags = hdrptr;
1950       start += compunit.cu_length + initial_length_size;
1951
1952       if (compunit.cu_version != 2 && compunit.cu_version != 3)
1953         {
1954           warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1955                 cu_offset, compunit.cu_version);
1956           continue;
1957         }
1958
1959       free_abbrevs ();
1960
1961       /* Process the abbrevs used by this compilation unit. DWARF
1962          sections under Mach-O have non-zero addresses.  */
1963       if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1964         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1965               (unsigned long) compunit.cu_abbrev_offset,
1966               (unsigned long) debug_displays [abbrev].section.size);
1967       else
1968         process_abbrev_section
1969           ((unsigned char *) debug_displays [abbrev].section.start
1970            + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1971            (unsigned char *) debug_displays [abbrev].section.start
1972            + debug_displays [abbrev].section.size);
1973
1974       level = 0;
1975       while (tags < start)
1976         {
1977           unsigned int bytes_read;
1978           unsigned long abbrev_number;
1979           unsigned long die_offset;
1980           abbrev_entry *entry;
1981           abbrev_attr *attr;
1982
1983           die_offset = tags - section_begin;
1984
1985           abbrev_number = read_leb128 (tags, & bytes_read, 0);
1986           tags += bytes_read;
1987
1988           /* A null DIE marks the end of a list of siblings.  */
1989           if (abbrev_number == 0)
1990             {
1991               --level;
1992               if (level < 0)
1993                 {
1994                   static unsigned num_bogus_warns = 0;
1995
1996                   if (num_bogus_warns < 3)
1997                     {
1998                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1999                             die_offset);
2000                       num_bogus_warns ++;
2001                       if (num_bogus_warns == 3)
2002                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2003                     }
2004                 }
2005               continue;
2006             }
2007
2008           if (!do_loc)
2009             printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2010                     level, die_offset, abbrev_number);
2011
2012           /* Scan through the abbreviation list until we reach the
2013              correct entry.  */
2014           for (entry = first_abbrev;
2015                entry && entry->entry != abbrev_number;
2016                entry = entry->next)
2017             continue;
2018
2019           if (entry == NULL)
2020             {
2021               if (!do_loc)
2022                 {
2023                   printf ("\n");
2024                   fflush (stdout);
2025                 }
2026               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2027                     die_offset, abbrev_number);
2028               return 0;
2029             }
2030
2031           if (!do_loc)
2032             printf (_(" (%s)\n"), get_TAG_name (entry->tag));
2033
2034           switch (entry->tag)
2035             {
2036             default:
2037               need_base_address = 0;
2038               break;
2039             case DW_TAG_compile_unit:
2040               need_base_address = 1;
2041               break;
2042             case DW_TAG_entry_point:
2043             case DW_TAG_subprogram:
2044               need_base_address = 0;
2045               /* Assuming that there is no DW_AT_frame_base.  */
2046               have_frame_base = 0;
2047               break;
2048             }
2049
2050           for (attr = entry->first_attr; attr; attr = attr->next)
2051             {
2052               if (! do_loc)
2053                 /* Show the offset from where the tag was extracted.  */
2054                 printf ("    <%2lx>", (unsigned long)(tags - section_begin));
2055
2056               tags = read_and_display_attr (attr->attribute,
2057                                             attr->form,
2058                                             tags, cu_offset,
2059                                             compunit.cu_pointer_size,
2060                                             offset_size,
2061                                             compunit.cu_version,
2062                                             debug_information + unit,
2063                                             do_loc, section);
2064             }
2065
2066           if (entry->children)
2067             ++level;
2068         }
2069     }
2070
2071   /* Set num_debug_info_entries here so that it can be used to check if
2072      we need to process .debug_loc and .debug_ranges sections.  */
2073   if ((do_loc || do_debug_loc || do_debug_ranges)
2074       && num_debug_info_entries == 0)
2075     num_debug_info_entries = num_units;
2076
2077   if (!do_loc)
2078     {
2079       printf ("\n");
2080     }
2081
2082   return 1;
2083 }
2084
2085 /* Locate and scan the .debug_info section in the file and record the pointer
2086    sizes and offsets for the compilation units in it.  Usually an executable
2087    will have just one pointer size, but this is not guaranteed, and so we try
2088    not to make any assumptions.  Returns zero upon failure, or the number of
2089    compilation units upon success.  */
2090
2091 static unsigned int
2092 load_debug_info (void * file)
2093 {
2094   /* Reset the last pointer size so that we can issue correct error
2095      messages if we are displaying the contents of more than one section.  */
2096   last_pointer_size = 0;
2097   warned_about_missing_comp_units = FALSE;
2098
2099   /* If we have already tried and failed to load the .debug_info
2100      section then do not bother to repear the task.  */
2101   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2102     return 0;
2103
2104   /* If we already have the information there is nothing else to do.  */
2105   if (num_debug_info_entries > 0)
2106     return num_debug_info_entries;
2107
2108   if (load_debug_section (info, file)
2109       && process_debug_info (&debug_displays [info].section, file, 1))
2110     return num_debug_info_entries;
2111
2112   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2113   return 0;
2114 }
2115
2116 static int
2117 display_debug_lines_raw (struct dwarf_section *section,
2118                          unsigned char *data,
2119                          unsigned char *end)
2120 {
2121   unsigned char *start = section->start;
2122
2123   printf (_("Raw dump of debug contents of section %s:\n\n"),
2124           section->name);
2125
2126   while (data < end)
2127     {
2128       DWARF2_Internal_LineInfo info;
2129       unsigned char *standard_opcodes;
2130       unsigned char *end_of_sequence;
2131       unsigned char *hdrptr;
2132       unsigned long hdroff;
2133       int initial_length_size;
2134       int offset_size;
2135       int i;
2136
2137       hdrptr = data;
2138       hdroff = hdrptr - start;
2139
2140       /* Check the length of the block.  */
2141       info.li_length = byte_get (hdrptr, 4);
2142       hdrptr += 4;
2143
2144       if (info.li_length == 0xffffffff)
2145         {
2146           /* This section is 64-bit DWARF 3.  */
2147           info.li_length = byte_get (hdrptr, 8);
2148           hdrptr += 8;
2149           offset_size = 8;
2150           initial_length_size = 12;
2151         }
2152       else
2153         {
2154           offset_size = 4;
2155           initial_length_size = 4;
2156         }
2157
2158       if (info.li_length + initial_length_size > section->size)
2159         {
2160           warn
2161             (_("The information in section %s appears to be corrupt - the section is too small\n"),
2162              section->name);
2163           return 0;
2164         }
2165
2166       /* Check its version number.  */
2167       info.li_version = byte_get (hdrptr, 2);
2168       hdrptr += 2;
2169       if (info.li_version != 2 && info.li_version != 3)
2170         {
2171           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2172           return 0;
2173         }
2174
2175       info.li_prologue_length = byte_get (hdrptr, offset_size);
2176       hdrptr += offset_size;
2177       info.li_min_insn_length = byte_get (hdrptr, 1);
2178       hdrptr++;
2179       info.li_default_is_stmt = byte_get (hdrptr, 1);
2180       hdrptr++;
2181       info.li_line_base = byte_get (hdrptr, 1);
2182       hdrptr++;
2183       info.li_line_range = byte_get (hdrptr, 1);
2184       hdrptr++;
2185       info.li_opcode_base = byte_get (hdrptr, 1);
2186       hdrptr++;
2187
2188       /* Sign extend the line base field.  */
2189       info.li_line_base <<= 24;
2190       info.li_line_base >>= 24;
2191
2192       printf (_("  Offset:                      0x%lx\n"), hdroff);
2193       printf (_("  Length:                      %ld\n"), info.li_length);
2194       printf (_("  DWARF Version:               %d\n"), info.li_version);
2195       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
2196       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
2197       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
2198       printf (_("  Line Base:                   %d\n"), info.li_line_base);
2199       printf (_("  Line Range:                  %d\n"), info.li_line_range);
2200       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
2201
2202       end_of_sequence = data + info.li_length + initial_length_size;
2203
2204       reset_state_machine (info.li_default_is_stmt);
2205
2206       /* Display the contents of the Opcodes table.  */
2207       standard_opcodes = hdrptr;
2208
2209       printf (_("\n Opcodes:\n"));
2210
2211       for (i = 1; i < info.li_opcode_base; i++)
2212         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2213
2214       /* Display the contents of the Directory table.  */
2215       data = standard_opcodes + info.li_opcode_base - 1;
2216
2217       if (*data == 0)
2218         printf (_("\n The Directory Table is empty.\n"));
2219       else
2220         {
2221           printf (_("\n The Directory Table:\n"));
2222
2223           while (*data != 0)
2224             {
2225               printf (_("  %s\n"), data);
2226
2227               data += strlen ((char *) data) + 1;
2228             }
2229         }
2230
2231       /* Skip the NUL at the end of the table.  */
2232       data++;
2233
2234       /* Display the contents of the File Name table.  */
2235       if (*data == 0)
2236         printf (_("\n The File Name Table is empty.\n"));
2237       else
2238         {
2239           printf (_("\n The File Name Table:\n"));
2240           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2241
2242           while (*data != 0)
2243             {
2244               unsigned char *name;
2245               unsigned int bytes_read;
2246
2247               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
2248               name = data;
2249
2250               data += strlen ((char *) data) + 1;
2251
2252               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2253               data += bytes_read;
2254               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2255               data += bytes_read;
2256               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2257               data += bytes_read;
2258               printf (_("%s\n"), name);
2259             }
2260         }
2261
2262       /* Skip the NUL at the end of the table.  */
2263       data++;
2264
2265       /* Now display the statements.  */
2266       printf (_("\n Line Number Statements:\n"));
2267
2268       while (data < end_of_sequence)
2269         {
2270           unsigned char op_code;
2271           int adv;
2272           unsigned long int uladv;
2273           unsigned int bytes_read;
2274
2275           op_code = *data++;
2276
2277           if (op_code >= info.li_opcode_base)
2278             {
2279               op_code -= info.li_opcode_base;
2280               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2281               state_machine_regs.address += uladv;
2282               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
2283                       op_code, uladv, state_machine_regs.address);
2284               adv = (op_code % info.li_line_range) + info.li_line_base;
2285               state_machine_regs.line += adv;
2286               printf (_(" and Line by %d to %d\n"),
2287                       adv, state_machine_regs.line);
2288             }
2289           else switch (op_code)
2290             {
2291             case DW_LNS_extended_op:
2292               data += process_extended_line_op (data, info.li_default_is_stmt);
2293               break;
2294
2295             case DW_LNS_copy:
2296               printf (_("  Copy\n"));
2297               break;
2298
2299             case DW_LNS_advance_pc:
2300               uladv = read_leb128 (data, & bytes_read, 0);
2301               uladv *= info.li_min_insn_length;
2302               data += bytes_read;
2303               state_machine_regs.address += uladv;
2304               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2305                       state_machine_regs.address);
2306               break;
2307
2308             case DW_LNS_advance_line:
2309               adv = read_leb128 (data, & bytes_read, 1);
2310               data += bytes_read;
2311               state_machine_regs.line += adv;
2312               printf (_("  Advance Line by %d to %d\n"), adv,
2313                       state_machine_regs.line);
2314               break;
2315
2316             case DW_LNS_set_file:
2317               adv = read_leb128 (data, & bytes_read, 0);
2318               data += bytes_read;
2319               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2320                       adv);
2321               state_machine_regs.file = adv;
2322               break;
2323
2324             case DW_LNS_set_column:
2325               uladv = read_leb128 (data, & bytes_read, 0);
2326               data += bytes_read;
2327               printf (_("  Set column to %lu\n"), uladv);
2328               state_machine_regs.column = uladv;
2329               break;
2330
2331             case DW_LNS_negate_stmt:
2332               adv = state_machine_regs.is_stmt;
2333               adv = ! adv;
2334               printf (_("  Set is_stmt to %d\n"), adv);
2335               state_machine_regs.is_stmt = adv;
2336               break;
2337
2338             case DW_LNS_set_basic_block:
2339               printf (_("  Set basic block\n"));
2340               state_machine_regs.basic_block = 1;
2341               break;
2342
2343             case DW_LNS_const_add_pc:
2344               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2345                       * info.li_min_insn_length);
2346               state_machine_regs.address += uladv;
2347               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2348                       state_machine_regs.address);
2349               break;
2350
2351             case DW_LNS_fixed_advance_pc:
2352               uladv = byte_get (data, 2);
2353               data += 2;
2354               state_machine_regs.address += uladv;
2355               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2356                       uladv, state_machine_regs.address);
2357               break;
2358
2359             case DW_LNS_set_prologue_end:
2360               printf (_("  Set prologue_end to true\n"));
2361               break;
2362
2363             case DW_LNS_set_epilogue_begin:
2364               printf (_("  Set epilogue_begin to true\n"));
2365               break;
2366
2367             case DW_LNS_set_isa:
2368               uladv = read_leb128 (data, & bytes_read, 0);
2369               data += bytes_read;
2370               printf (_("  Set ISA to %lu\n"), uladv);
2371               break;
2372
2373             default:
2374               printf (_("  Unknown opcode %d with operands: "), op_code);
2375
2376               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2377                 {
2378                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2379                           i == 1 ? "" : ", ");
2380                   data += bytes_read;
2381                 }
2382               putchar ('\n');
2383               break;
2384             }
2385         }
2386       putchar ('\n');
2387     }
2388
2389   return 1;
2390 }
2391
2392 typedef struct
2393 {
2394     unsigned char *name;
2395     unsigned int directory_index;
2396     unsigned int modification_date;
2397     unsigned int length;
2398 } File_Entry;
2399
2400 /* Output a decoded representation of the .debug_line section.  */
2401
2402 static int
2403 display_debug_lines_decoded (struct dwarf_section *section,
2404                              unsigned char *data,
2405                              unsigned char *end)
2406 {
2407   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2408           section->name);
2409
2410   while (data < end)
2411     {
2412       /* This loop amounts to one iteration per compilation unit.  */
2413       DWARF2_Internal_LineInfo info;
2414       unsigned char *standard_opcodes;
2415       unsigned char *end_of_sequence;
2416       unsigned char *hdrptr;
2417       int initial_length_size;
2418       int offset_size;
2419       int i;
2420       File_Entry *file_table = NULL;
2421       unsigned char **directory_table = NULL;
2422       unsigned int prev_line = 0;
2423
2424       hdrptr = data;
2425
2426       /* Extract information from the Line Number Program Header.
2427         (section 6.2.4 in the Dwarf3 doc).  */
2428
2429       /* Get the length of this CU's line number information block.  */
2430       info.li_length = byte_get (hdrptr, 4);
2431       hdrptr += 4;
2432
2433       if (info.li_length == 0xffffffff)
2434         {
2435           /* This section is 64-bit DWARF 3.  */
2436           info.li_length = byte_get (hdrptr, 8);
2437           hdrptr += 8;
2438           offset_size = 8;
2439           initial_length_size = 12;
2440         }
2441       else
2442         {
2443           offset_size = 4;
2444           initial_length_size = 4;
2445         }
2446
2447       if (info.li_length + initial_length_size > section->size)
2448         {
2449           warn (_("The line info appears to be corrupt - "
2450                   "the section is too small\n"));
2451           return 0;
2452         }
2453
2454       /* Get this CU's Line Number Block version number.  */
2455       info.li_version = byte_get (hdrptr, 2);
2456       hdrptr += 2;
2457       if (info.li_version != 2 && info.li_version != 3)
2458         {
2459           warn (_("Only DWARF version 2 and 3 line info is currently "
2460                 "supported.\n"));
2461           return 0;
2462         }
2463
2464       info.li_prologue_length = byte_get (hdrptr, offset_size);
2465       hdrptr += offset_size;
2466       info.li_min_insn_length = byte_get (hdrptr, 1);
2467       hdrptr++;
2468       info.li_default_is_stmt = byte_get (hdrptr, 1);
2469       hdrptr++;
2470       info.li_line_base = byte_get (hdrptr, 1);
2471       hdrptr++;
2472       info.li_line_range = byte_get (hdrptr, 1);
2473       hdrptr++;
2474       info.li_opcode_base = byte_get (hdrptr, 1);
2475       hdrptr++;
2476
2477       /* Sign extend the line base field.  */
2478       info.li_line_base <<= 24;
2479       info.li_line_base >>= 24;
2480
2481       /* Find the end of this CU's Line Number Information Block.  */
2482       end_of_sequence = data + info.li_length + initial_length_size;
2483
2484       reset_state_machine (info.li_default_is_stmt);
2485
2486       /* Save a pointer to the contents of the Opcodes table.  */
2487       standard_opcodes = hdrptr;
2488
2489       /* Traverse the Directory table just to count entries.  */
2490       data = standard_opcodes + info.li_opcode_base - 1;
2491       if (*data != 0)
2492         {
2493           unsigned int n_directories = 0;
2494           unsigned char *ptr_directory_table = data;
2495           int i;
2496
2497           while (*data != 0)
2498             {
2499               data += strlen ((char *) data) + 1;
2500               n_directories++;
2501             }
2502
2503           /* Go through the directory table again to save the directories.  */
2504           directory_table = xmalloc (n_directories * sizeof (unsigned char *));
2505
2506           i = 0;
2507           while (*ptr_directory_table != 0)
2508             {
2509               directory_table[i] = ptr_directory_table;
2510               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2511               i++;
2512             }
2513         }
2514       /* Skip the NUL at the end of the table.  */
2515       data++;
2516
2517       /* Traverse the File Name table just to count the entries.  */
2518       if (*data != 0)
2519         {
2520           unsigned int n_files = 0;
2521           unsigned char *ptr_file_name_table = data;
2522           int i;
2523
2524           while (*data != 0)
2525             {
2526               unsigned int bytes_read;
2527
2528               /* Skip Name, directory index, last modification time and length
2529                  of file.  */
2530               data += strlen ((char *) data) + 1;
2531               read_leb128 (data, & bytes_read, 0);
2532               data += bytes_read;
2533               read_leb128 (data, & bytes_read, 0);
2534               data += bytes_read;
2535               read_leb128 (data, & bytes_read, 0);
2536               data += bytes_read;
2537
2538               n_files++;
2539             }
2540
2541           /* Go through the file table again to save the strings.  */
2542           file_table = xmalloc (n_files * sizeof (File_Entry));
2543
2544           i = 0;
2545           while (*ptr_file_name_table != 0)
2546             {
2547               unsigned int bytes_read;
2548
2549               file_table[i].name = ptr_file_name_table;
2550               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2551
2552               /* We are not interested in directory, time or size.  */
2553               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2554                                                            & bytes_read, 0);
2555               ptr_file_name_table += bytes_read;
2556               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2557                                                              & bytes_read, 0);
2558               ptr_file_name_table += bytes_read;
2559               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2560               ptr_file_name_table += bytes_read;
2561               i++;
2562             }
2563           i = 0;
2564
2565           /* Print the Compilation Unit's name and a header.  */
2566           if (directory_table == NULL)
2567             {
2568               printf (_("CU: %s:\n"), file_table[0].name);
2569               printf (_("File name                            Line number    Starting address\n"));
2570             }
2571           else
2572             {
2573               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2574                 {
2575                   printf (_("CU: %s/%s:\n"), directory_table[0],
2576                           file_table[0].name);
2577                 }
2578               else
2579                 {
2580                   printf (_("%s:\n"), file_table[0].name);
2581                 }
2582               printf (_("File name                            Line number    Starting address\n"));
2583             }
2584         }
2585
2586       /* Skip the NUL at the end of the table.  */
2587       data++;
2588
2589       /* This loop iterates through the Dwarf Line Number Program.  */
2590       while (data < end_of_sequence)
2591         {
2592           unsigned char op_code;
2593           int adv;
2594           unsigned long int uladv;
2595           unsigned int bytes_read;
2596           int is_special_opcode = 0;
2597
2598           op_code = *data++;
2599           prev_line = state_machine_regs.line;
2600
2601           if (op_code >= info.li_opcode_base)
2602             {
2603               op_code -= info.li_opcode_base;
2604               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2605               state_machine_regs.address += uladv;
2606
2607               adv = (op_code % info.li_line_range) + info.li_line_base;
2608               state_machine_regs.line += adv;
2609               is_special_opcode = 1;
2610             }
2611           else switch (op_code)
2612             {
2613             case DW_LNS_extended_op:
2614               {
2615                 unsigned int ext_op_code_len;
2616                 unsigned int bytes_read;
2617                 unsigned char ext_op_code;
2618                 unsigned char *op_code_data = data;
2619
2620                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
2621                 op_code_data += bytes_read;
2622
2623                 if (ext_op_code_len == 0)
2624                   {
2625                     warn (_("badly formed extended line op encountered!\n"));
2626                     break;
2627                   }
2628                 ext_op_code_len += bytes_read;
2629                 ext_op_code = *op_code_data++;
2630
2631                 switch (ext_op_code)
2632                   {
2633                   case DW_LNE_end_sequence:
2634                     reset_state_machine (info.li_default_is_stmt);
2635                     break;
2636                   case DW_LNE_set_address:
2637                     state_machine_regs.address =
2638                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
2639                     break;
2640                   case DW_LNE_define_file:
2641                     {
2642                       unsigned int dir_index = 0;
2643
2644                       ++state_machine_regs.last_file_entry;
2645                       op_code_data += strlen ((char *) op_code_data) + 1;
2646                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
2647                       op_code_data += bytes_read;
2648                       read_leb128 (op_code_data, & bytes_read, 0);
2649                       op_code_data += bytes_read;
2650                       read_leb128 (op_code_data, & bytes_read, 0);
2651
2652                       printf (_("%s:\n"), directory_table[dir_index]);
2653                       break;
2654                     }
2655                   default:
2656                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
2657                     break;
2658                   }
2659                 data += ext_op_code_len;
2660                 break;
2661               }
2662             case DW_LNS_copy:
2663               break;
2664
2665             case DW_LNS_advance_pc:
2666               uladv = read_leb128 (data, & bytes_read, 0);
2667               uladv *= info.li_min_insn_length;
2668               data += bytes_read;
2669               state_machine_regs.address += uladv;
2670               break;
2671
2672             case DW_LNS_advance_line:
2673               adv = read_leb128 (data, & bytes_read, 1);
2674               data += bytes_read;
2675               state_machine_regs.line += adv;
2676               break;
2677
2678             case DW_LNS_set_file:
2679               adv = read_leb128 (data, & bytes_read, 0);
2680               data += bytes_read;
2681               state_machine_regs.file = adv;
2682               if (file_table[state_machine_regs.file - 1].directory_index == 0)
2683                 {
2684                   /* If directory index is 0, that means current directory.  */
2685                   printf (_("\n./%s:[++]\n"),
2686                           file_table[state_machine_regs.file - 1].name);
2687                 }
2688               else
2689                 {
2690                   /* The directory index starts counting at 1.  */
2691                   printf (_("\n%s/%s:\n"),
2692                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
2693                           file_table[state_machine_regs.file - 1].name);
2694                 }
2695               break;
2696
2697             case DW_LNS_set_column:
2698               uladv = read_leb128 (data, & bytes_read, 0);
2699               data += bytes_read;
2700               state_machine_regs.column = uladv;
2701               break;
2702
2703             case DW_LNS_negate_stmt:
2704               adv = state_machine_regs.is_stmt;
2705               adv = ! adv;
2706               state_machine_regs.is_stmt = adv;
2707               break;
2708
2709             case DW_LNS_set_basic_block:
2710               state_machine_regs.basic_block = 1;
2711               break;
2712
2713             case DW_LNS_const_add_pc:
2714               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2715                        * info.li_min_insn_length);
2716               state_machine_regs.address += uladv;
2717               break;
2718
2719             case DW_LNS_fixed_advance_pc:
2720               uladv = byte_get (data, 2);
2721               data += 2;
2722               state_machine_regs.address += uladv;
2723               break;
2724
2725             case DW_LNS_set_prologue_end:
2726               break;
2727
2728             case DW_LNS_set_epilogue_begin:
2729               break;
2730
2731             case DW_LNS_set_isa:
2732               uladv = read_leb128 (data, & bytes_read, 0);
2733               data += bytes_read;
2734               printf (_("  Set ISA to %lu\n"), uladv);
2735               break;
2736
2737             default:
2738               printf (_("  Unknown opcode %d with operands: "), op_code);
2739
2740               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2741                 {
2742                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2743                           i == 1 ? "" : ", ");
2744                   data += bytes_read;
2745                 }
2746               putchar ('\n');
2747               break;
2748             }
2749
2750           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2751              to the DWARF address/line matrix.  */
2752           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
2753               || (op_code == DW_LNS_copy))
2754             {
2755               const unsigned int MAX_FILENAME_LENGTH = 35;
2756               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
2757               char *newFileName = NULL;
2758               size_t fileNameLength = strlen (fileName);
2759
2760               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
2761                 {
2762                   newFileName = xmalloc (MAX_FILENAME_LENGTH + 1);
2763                   /* Truncate file name */
2764                   strncpy (newFileName,
2765                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
2766                            MAX_FILENAME_LENGTH + 1);
2767                 }
2768               else
2769                 {
2770                   newFileName = xmalloc (fileNameLength + 1);
2771                   strncpy (newFileName, fileName, fileNameLength + 1);
2772                 }
2773
2774               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
2775                 {
2776                   printf (_("%-35s  %11d  %#18lx\n"), newFileName,
2777                           state_machine_regs.line, state_machine_regs.address);
2778                 }
2779               else
2780                 {
2781                   printf (_("%s  %11d  %#18lx\n"), newFileName,
2782                           state_machine_regs.line, state_machine_regs.address);
2783                 }
2784
2785               if (op_code == DW_LNE_end_sequence)
2786                 printf ("\n");
2787
2788               free (newFileName);
2789             }
2790         }
2791       free (file_table);
2792       file_table = NULL;
2793       free (directory_table);
2794       directory_table = NULL;
2795       putchar ('\n');
2796     }
2797
2798   return 1;
2799 }
2800
2801 static int
2802 display_debug_lines (struct dwarf_section *section, void *file)
2803 {
2804   unsigned char *data = section->start;
2805   unsigned char *end = data + section->size;
2806   int retValRaw = 1;
2807   int retValDecoded = 1;
2808
2809   if (load_debug_info (file) == 0)
2810     {
2811       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2812             section->name);
2813       return 0;
2814     }
2815
2816   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
2817     retValRaw = display_debug_lines_raw (section, data, end);
2818
2819   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
2820     retValDecoded = display_debug_lines_decoded (section, data, end);
2821
2822   if (!retValRaw || !retValDecoded)
2823     return 0;
2824
2825   return 1;
2826 }
2827
2828 static debug_info *
2829 find_debug_info_for_offset (unsigned long offset)
2830 {
2831   unsigned int i;
2832
2833   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2834     return NULL;
2835
2836   for (i = 0; i < num_debug_info_entries; i++)
2837     if (debug_information[i].cu_offset == offset)
2838       return debug_information + i;
2839
2840   return NULL;
2841 }
2842
2843 static int
2844 display_debug_pubnames (struct dwarf_section *section,
2845                         void *file ATTRIBUTE_UNUSED)
2846 {
2847   DWARF2_Internal_PubNames pubnames;
2848   unsigned char *start = section->start;
2849   unsigned char *end = start + section->size;
2850
2851   /* It does not matter if this load fails,
2852      we test for that later on.  */
2853   load_debug_info (file);
2854
2855   printf (_("Contents of the %s section:\n\n"), section->name);
2856
2857   while (start < end)
2858     {
2859       unsigned char *data;
2860       unsigned long offset;
2861       int offset_size, initial_length_size;
2862
2863       data = start;
2864
2865       pubnames.pn_length = byte_get (data, 4);
2866       data += 4;
2867       if (pubnames.pn_length == 0xffffffff)
2868         {
2869           pubnames.pn_length = byte_get (data, 8);
2870           data += 8;
2871           offset_size = 8;
2872           initial_length_size = 12;
2873         }
2874       else
2875         {
2876           offset_size = 4;
2877           initial_length_size = 4;
2878         }
2879
2880       pubnames.pn_version = byte_get (data, 2);
2881       data += 2;
2882
2883       pubnames.pn_offset = byte_get (data, offset_size);
2884       data += offset_size;
2885
2886       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2887           && num_debug_info_entries > 0
2888           && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2889         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2890               pubnames.pn_offset, section->name);
2891
2892       pubnames.pn_size = byte_get (data, offset_size);
2893       data += offset_size;
2894
2895       start += pubnames.pn_length + initial_length_size;
2896
2897       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2898         {
2899           static int warned = 0;
2900
2901           if (! warned)
2902             {
2903               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2904               warned = 1;
2905             }
2906
2907           continue;
2908         }
2909
2910       printf (_("  Length:                              %ld\n"),
2911               pubnames.pn_length);
2912       printf (_("  Version:                             %d\n"),
2913               pubnames.pn_version);
2914       printf (_("  Offset into .debug_info section:     0x%lx\n"),
2915               pubnames.pn_offset);
2916       printf (_("  Size of area in .debug_info section: %ld\n"),
2917               pubnames.pn_size);
2918
2919       printf (_("\n    Offset\tName\n"));
2920
2921       do
2922         {
2923           offset = byte_get (data, offset_size);
2924
2925           if (offset != 0)
2926             {
2927               data += offset_size;
2928               printf ("    %-6lx\t%s\n", offset, data);
2929               data += strlen ((char *) data) + 1;
2930             }
2931         }
2932       while (offset != 0);
2933     }
2934
2935   printf ("\n");
2936   return 1;
2937 }
2938
2939 static int
2940 display_debug_macinfo (struct dwarf_section *section,
2941                        void *file ATTRIBUTE_UNUSED)
2942 {
2943   unsigned char *start = section->start;
2944   unsigned char *end = start + section->size;
2945   unsigned char *curr = start;
2946   unsigned int bytes_read;
2947   enum dwarf_macinfo_record_type op;
2948
2949   printf (_("Contents of the %s section:\n\n"), section->name);
2950
2951   while (curr < end)
2952     {
2953       unsigned int lineno;
2954       const char *string;
2955
2956       op = *curr;
2957       curr++;
2958
2959       switch (op)
2960         {
2961         case DW_MACINFO_start_file:
2962           {
2963             unsigned int filenum;
2964
2965             lineno = read_leb128 (curr, & bytes_read, 0);
2966             curr += bytes_read;
2967             filenum = read_leb128 (curr, & bytes_read, 0);
2968             curr += bytes_read;
2969
2970             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2971                     lineno, filenum);
2972           }
2973           break;
2974
2975         case DW_MACINFO_end_file:
2976           printf (_(" DW_MACINFO_end_file\n"));
2977           break;
2978
2979         case DW_MACINFO_define:
2980           lineno = read_leb128 (curr, & bytes_read, 0);
2981           curr += bytes_read;
2982           string = (char *) curr;
2983           curr += strlen (string) + 1;
2984           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2985                   lineno, string);
2986           break;
2987
2988         case DW_MACINFO_undef:
2989           lineno = read_leb128 (curr, & bytes_read, 0);
2990           curr += bytes_read;
2991           string = (char *) curr;
2992           curr += strlen (string) + 1;
2993           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2994                   lineno, string);
2995           break;
2996
2997         case DW_MACINFO_vendor_ext:
2998           {
2999             unsigned int constant;
3000
3001             constant = read_leb128 (curr, & bytes_read, 0);
3002             curr += bytes_read;
3003             string = (char *) curr;
3004             curr += strlen (string) + 1;
3005             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3006                     constant, string);
3007           }
3008           break;
3009         }
3010     }
3011
3012   return 1;
3013 }
3014
3015 static int
3016 display_debug_abbrev (struct dwarf_section *section,
3017                       void *file ATTRIBUTE_UNUSED)
3018 {
3019   abbrev_entry *entry;
3020   unsigned char *start = section->start;
3021   unsigned char *end = start + section->size;
3022
3023   printf (_("Contents of the %s section:\n\n"), section->name);
3024
3025   do
3026     {
3027       free_abbrevs ();
3028
3029       start = process_abbrev_section (start, end);
3030
3031       if (first_abbrev == NULL)
3032         continue;
3033
3034       printf (_("  Number TAG\n"));
3035
3036       for (entry = first_abbrev; entry; entry = entry->next)
3037         {
3038           abbrev_attr *attr;
3039
3040           printf (_("   %ld      %s    [%s]\n"),
3041                   entry->entry,
3042                   get_TAG_name (entry->tag),
3043                   entry->children ? _("has children") : _("no children"));
3044
3045           for (attr = entry->first_attr; attr; attr = attr->next)
3046             printf (_("    %-18s %s\n"),
3047                     get_AT_name (attr->attribute),
3048                     get_FORM_name (attr->form));
3049         }
3050     }
3051   while (start);
3052
3053   printf ("\n");
3054
3055   return 1;
3056 }
3057
3058 static int
3059 display_debug_loc (struct dwarf_section *section, void *file)
3060 {
3061   unsigned char *start = section->start;
3062   unsigned char *section_end;
3063   unsigned long bytes;
3064   unsigned char *section_begin = start;
3065   unsigned int num_loc_list = 0;
3066   unsigned long last_offset = 0;
3067   unsigned int first = 0;
3068   unsigned int i;
3069   unsigned int j;
3070   int seen_first_offset = 0;
3071   int use_debug_info = 1;
3072   unsigned char *next;
3073
3074   bytes = section->size;
3075   section_end = start + bytes;
3076
3077   if (bytes == 0)
3078     {
3079       printf (_("\nThe %s section is empty.\n"), section->name);
3080       return 0;
3081     }
3082
3083   if (load_debug_info (file) == 0)
3084     {
3085       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3086             section->name);
3087       return 0;
3088     }
3089
3090   /* Check the order of location list in .debug_info section. If
3091      offsets of location lists are in the ascending order, we can
3092      use `debug_information' directly.  */
3093   for (i = 0; i < num_debug_info_entries; i++)
3094     {
3095       unsigned int num;
3096
3097       num = debug_information [i].num_loc_offsets;
3098       num_loc_list += num;
3099
3100       /* Check if we can use `debug_information' directly.  */
3101       if (use_debug_info && num != 0)
3102         {
3103           if (!seen_first_offset)
3104             {
3105               /* This is the first location list.  */
3106               last_offset = debug_information [i].loc_offsets [0];
3107               first = i;
3108               seen_first_offset = 1;
3109               j = 1;
3110             }
3111           else
3112             j = 0;
3113
3114           for (; j < num; j++)
3115             {
3116               if (last_offset >
3117                   debug_information [i].loc_offsets [j])
3118                 {
3119                   use_debug_info = 0;
3120                   break;
3121                 }
3122               last_offset = debug_information [i].loc_offsets [j];
3123             }
3124         }
3125     }
3126
3127   if (!use_debug_info)
3128     /* FIXME: Should we handle this case?  */
3129     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3130
3131   if (!seen_first_offset)
3132     error (_("No location lists in .debug_info section!\n"));
3133
3134   /* DWARF sections under Mach-O have non-zero addresses.  */
3135   if (debug_information [first].num_loc_offsets > 0
3136       && debug_information [first].loc_offsets [0] != section->address)
3137     warn (_("Location lists in %s section start at 0x%lx\n"),
3138           section->name, debug_information [first].loc_offsets [0]);
3139
3140   printf (_("Contents of the %s section:\n\n"), section->name);
3141   printf (_("    Offset   Begin    End      Expression\n"));
3142
3143   seen_first_offset = 0;
3144   for (i = first; i < num_debug_info_entries; i++)
3145     {
3146       dwarf_vma begin;
3147       dwarf_vma end;
3148       unsigned short length;
3149       unsigned long offset;
3150       unsigned int pointer_size;
3151       unsigned long cu_offset;
3152       unsigned long base_address;
3153       int need_frame_base;
3154       int has_frame_base;
3155
3156       pointer_size = debug_information [i].pointer_size;
3157       cu_offset = debug_information [i].cu_offset;
3158
3159       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3160         {
3161           has_frame_base = debug_information [i].have_frame_base [j];
3162           /* DWARF sections under Mach-O have non-zero addresses.  */
3163           offset = debug_information [i].loc_offsets [j] - section->address;
3164           next = section_begin + offset;
3165           base_address = debug_information [i].base_address;
3166
3167           if (!seen_first_offset)
3168             seen_first_offset = 1;
3169           else
3170             {
3171               if (start < next)
3172                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3173                       (unsigned long) (start - section_begin),
3174                       (unsigned long) (next - section_begin));
3175               else if (start > next)
3176                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3177                       (unsigned long) (start - section_begin),
3178                       (unsigned long) (next - section_begin));
3179             }
3180           start = next;
3181
3182           if (offset >= bytes)
3183             {
3184               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3185                     offset);
3186               continue;
3187             }
3188
3189           while (1)
3190             {
3191               if (start + 2 * pointer_size > section_end)
3192                 {
3193                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3194                         offset);
3195                   break;
3196                 }
3197
3198               /* Note: we use sign extension here in order to be sure that
3199                  we can detect the -1 escape value.  Sign extension into the
3200                  top 32 bits of a 32-bit address will not affect the values
3201                  that we display since we always show hex values, and always
3202                  the bottom 32-bits.  */
3203               begin = byte_get_signed (start, pointer_size);
3204               start += pointer_size;
3205               end = byte_get_signed (start, pointer_size);
3206               start += pointer_size;
3207
3208               printf ("    %8.8lx ", offset);
3209
3210               if (begin == 0 && end == 0)
3211                 {
3212                   printf (_("<End of list>\n"));
3213                   break;
3214                 }
3215
3216               /* Check base address specifiers.  */
3217               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3218                 {
3219                   base_address = end;
3220                   print_dwarf_vma (begin, pointer_size);
3221                   print_dwarf_vma (end, pointer_size);
3222                   printf (_("(base address)\n"));
3223                   continue;
3224                 }
3225
3226               if (start + 2 > section_end)
3227                 {
3228                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3229                         offset);
3230                   break;
3231                 }
3232
3233               length = byte_get (start, 2);
3234               start += 2;
3235
3236               if (start + length > section_end)
3237                 {
3238                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3239                         offset);
3240                   break;
3241                 }
3242
3243               print_dwarf_vma (begin + base_address, pointer_size);
3244               print_dwarf_vma (end + base_address, pointer_size);
3245
3246               putchar ('(');
3247               need_frame_base = decode_location_expression (start,
3248                                                             pointer_size,
3249                                                             length,
3250                                                             cu_offset, section);
3251               putchar (')');
3252
3253               if (need_frame_base && !has_frame_base)
3254                 printf (_(" [without DW_AT_frame_base]"));
3255
3256               if (begin == end)
3257                 fputs (_(" (start == end)"), stdout);
3258               else if (begin > end)
3259                 fputs (_(" (start > end)"), stdout);
3260
3261               putchar ('\n');
3262
3263               start += length;
3264             }
3265         }
3266     }
3267
3268   if (start < section_end)
3269     warn (_("There are %ld unused bytes at the end of section %s\n"),
3270           (long) (section_end - start), section->name);
3271   putchar ('\n');
3272   return 1;
3273 }
3274
3275 static int
3276 display_debug_str (struct dwarf_section *section,
3277                    void *file ATTRIBUTE_UNUSED)
3278 {
3279   unsigned char *start = section->start;
3280   unsigned long bytes = section->size;
3281   dwarf_vma addr = section->address;
3282
3283   if (bytes == 0)
3284     {
3285       printf (_("\nThe %s section is empty.\n"), section->name);
3286       return 0;
3287     }
3288
3289   printf (_("Contents of the %s section:\n\n"), section->name);
3290
3291   while (bytes)
3292     {
3293       int j;
3294       int k;
3295       int lbytes;
3296
3297       lbytes = (bytes > 16 ? 16 : bytes);
3298
3299       printf ("  0x%8.8lx ", (unsigned long) addr);
3300
3301       for (j = 0; j < 16; j++)
3302         {
3303           if (j < lbytes)
3304             printf ("%2.2x", start[j]);
3305           else
3306             printf ("  ");
3307
3308           if ((j & 3) == 3)
3309             printf (" ");
3310         }
3311
3312       for (j = 0; j < lbytes; j++)
3313         {
3314           k = start[j];
3315           if (k >= ' ' && k < 0x80)
3316             printf ("%c", k);
3317           else
3318             printf (".");
3319         }
3320
3321       putchar ('\n');
3322
3323       start += lbytes;
3324       addr  += lbytes;
3325       bytes -= lbytes;
3326     }
3327
3328   putchar ('\n');
3329
3330   return 1;
3331 }
3332
3333 static int
3334 display_debug_info (struct dwarf_section *section, void *file)
3335 {
3336   return process_debug_info (section, file, 0);
3337 }
3338
3339
3340 static int
3341 display_debug_aranges (struct dwarf_section *section,
3342                        void *file ATTRIBUTE_UNUSED)
3343 {
3344   unsigned char *start = section->start;
3345   unsigned char *end = start + section->size;
3346
3347   printf (_("Contents of the %s section:\n\n"), section->name);
3348
3349   /* It does not matter if this load fails,
3350      we test for that later on.  */
3351   load_debug_info (file);
3352
3353   while (start < end)
3354     {
3355       unsigned char *hdrptr;
3356       DWARF2_Internal_ARange arange;
3357       unsigned char *ranges;
3358       dwarf_vma length;
3359       dwarf_vma address;
3360       unsigned char address_size;
3361       int excess;
3362       int offset_size;
3363       int initial_length_size;
3364
3365       hdrptr = start;
3366
3367       arange.ar_length = byte_get (hdrptr, 4);
3368       hdrptr += 4;
3369
3370       if (arange.ar_length == 0xffffffff)
3371         {
3372           arange.ar_length = byte_get (hdrptr, 8);
3373           hdrptr += 8;
3374           offset_size = 8;
3375           initial_length_size = 12;
3376         }
3377       else
3378         {
3379           offset_size = 4;
3380           initial_length_size = 4;
3381         }
3382
3383       arange.ar_version = byte_get (hdrptr, 2);
3384       hdrptr += 2;
3385
3386       arange.ar_info_offset = byte_get (hdrptr, offset_size);
3387       hdrptr += offset_size;
3388
3389       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3390           && num_debug_info_entries > 0
3391           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3392         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3393               arange.ar_info_offset, section->name);
3394
3395       arange.ar_pointer_size = byte_get (hdrptr, 1);
3396       hdrptr += 1;
3397
3398       arange.ar_segment_size = byte_get (hdrptr, 1);
3399       hdrptr += 1;
3400
3401       if (arange.ar_version != 2 && arange.ar_version != 3)
3402         {
3403           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3404           break;
3405         }
3406
3407       printf (_("  Length:                   %ld\n"), arange.ar_length);
3408       printf (_("  Version:                  %d\n"), arange.ar_version);
3409       printf (_("  Offset into .debug_info:  0x%lx\n"), arange.ar_info_offset);
3410       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
3411       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
3412
3413       address_size = arange.ar_pointer_size + arange.ar_segment_size;
3414
3415       /* The DWARF spec does not require that the address size be a power
3416          of two, but we do.  This will have to change if we ever encounter
3417          an uneven architecture.  */
3418       if ((address_size & (address_size - 1)) != 0)
3419         {
3420           warn (_("Pointer size + Segment size is not a power of two.\n"));
3421           break;
3422         }
3423
3424       if (address_size > 4)
3425         printf (_("\n    Address            Length\n"));
3426       else
3427         printf (_("\n    Address    Length\n"));
3428
3429       ranges = hdrptr;
3430
3431       /* Must pad to an alignment boundary that is twice the address size.  */
3432       excess = (hdrptr - start) % (2 * address_size);
3433       if (excess)
3434         ranges += (2 * address_size) - excess;
3435
3436       start += arange.ar_length + initial_length_size;
3437
3438       while (ranges + 2 * address_size <= start)
3439         {
3440           address = byte_get (ranges, address_size);
3441
3442           ranges += address_size;
3443
3444           length  = byte_get (ranges, address_size);
3445
3446           ranges += address_size;
3447
3448           printf ("    ");
3449           print_dwarf_vma (address, address_size);
3450           print_dwarf_vma (length, address_size);
3451           putchar ('\n');
3452         }
3453     }
3454
3455   printf ("\n");
3456
3457   return 1;
3458 }
3459
3460 static int
3461 display_debug_ranges (struct dwarf_section *section,
3462                       void *file ATTRIBUTE_UNUSED)
3463 {
3464   unsigned char *start = section->start;
3465   unsigned char *section_end;
3466   unsigned long bytes;
3467   unsigned char *section_begin = start;
3468   unsigned int num_range_list = 0;
3469   unsigned long last_offset = 0;
3470   unsigned int first = 0;
3471   unsigned int i;
3472   unsigned int j;
3473   int seen_first_offset = 0;
3474   int use_debug_info = 1;
3475   unsigned char *next;
3476
3477   bytes = section->size;
3478   section_end = start + bytes;
3479
3480   if (bytes == 0)
3481     {
3482       printf (_("\nThe %s section is empty.\n"), section->name);
3483       return 0;
3484     }
3485
3486   if (load_debug_info (file) == 0)
3487     {
3488       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3489             section->name);
3490       return 0;
3491     }
3492
3493   /* Check the order of range list in .debug_info section. If
3494      offsets of range lists are in the ascending order, we can
3495      use `debug_information' directly.  */
3496   for (i = 0; i < num_debug_info_entries; i++)
3497     {
3498       unsigned int num;
3499
3500       num = debug_information [i].num_range_lists;
3501       num_range_list += num;
3502
3503       /* Check if we can use `debug_information' directly.  */
3504       if (use_debug_info && num != 0)
3505         {
3506           if (!seen_first_offset)
3507             {
3508               /* This is the first range list.  */
3509               last_offset = debug_information [i].range_lists [0];
3510               first = i;
3511               seen_first_offset = 1;
3512               j = 1;
3513             }
3514           else
3515             j = 0;
3516
3517           for (; j < num; j++)
3518             {
3519               if (last_offset >
3520                   debug_information [i].range_lists [j])
3521                 {
3522                   use_debug_info = 0;
3523                   break;
3524                 }
3525               last_offset = debug_information [i].range_lists [j];
3526             }
3527         }
3528     }
3529
3530   if (!use_debug_info)
3531     /* FIXME: Should we handle this case?  */
3532     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
3533
3534   if (!seen_first_offset)
3535     error (_("No range lists in .debug_info section!\n"));
3536
3537   /* DWARF sections under Mach-O have non-zero addresses.  */
3538   if (debug_information [first].num_range_lists > 0
3539       && debug_information [first].range_lists [0] != section->address)
3540     warn (_("Range lists in %s section start at 0x%lx\n"),
3541           section->name, debug_information [first].range_lists [0]);
3542
3543   printf (_("Contents of the %s section:\n\n"), section->name);
3544   printf (_("    Offset   Begin    End\n"));
3545
3546   seen_first_offset = 0;
3547   for (i = first; i < num_debug_info_entries; i++)
3548     {
3549       dwarf_vma begin;
3550       dwarf_vma end;
3551       unsigned long offset;
3552       unsigned int pointer_size;
3553       unsigned long base_address;
3554
3555       pointer_size = debug_information [i].pointer_size;
3556
3557       for (j = 0; j < debug_information [i].num_range_lists; j++)
3558         {
3559           /* DWARF sections under Mach-O have non-zero addresses.  */
3560           offset = debug_information [i].range_lists [j] - section->address;
3561           next = section_begin + offset;
3562           base_address = debug_information [i].base_address;
3563
3564           if (!seen_first_offset)
3565             seen_first_offset = 1;
3566           else
3567             {
3568               if (start < next)
3569                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3570                       (unsigned long) (start - section_begin),
3571                       (unsigned long) (next - section_begin), section->name);
3572               else if (start > next)
3573                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3574                       (unsigned long) (start - section_begin),
3575                       (unsigned long) (next - section_begin), section->name);
3576             }
3577           start = next;
3578
3579           while (1)
3580             {
3581               /* Note: we use sign extension here in order to be sure that
3582                  we can detect the -1 escape value.  Sign extension into the
3583                  top 32 bits of a 32-bit address will not affect the values
3584                  that we display since we always show hex values, and always
3585                  the bottom 32-bits.  */
3586               begin = byte_get_signed (start, pointer_size);
3587               start += pointer_size;
3588               end = byte_get_signed (start, pointer_size);
3589               start += pointer_size;
3590
3591               printf ("    %8.8lx ", offset);
3592
3593               if (begin == 0 && end == 0)
3594                 {
3595                   printf (_("<End of list>\n"));
3596                   break;
3597                 }
3598
3599               /* Check base address specifiers.  */
3600               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3601                 {
3602                   base_address = end;
3603                   print_dwarf_vma (begin, pointer_size);
3604                   print_dwarf_vma (end, pointer_size);
3605                   printf ("(base address)\n");
3606                   continue;
3607                 }
3608
3609               print_dwarf_vma (begin + base_address, pointer_size);
3610               print_dwarf_vma (end + base_address, pointer_size);
3611
3612               if (begin == end)
3613                 fputs (_("(start == end)"), stdout);
3614               else if (begin > end)
3615                 fputs (_("(start > end)"), stdout);
3616
3617               putchar ('\n');
3618             }
3619         }
3620     }
3621   putchar ('\n');
3622   return 1;
3623 }
3624
3625 typedef struct Frame_Chunk
3626 {
3627   struct Frame_Chunk *next;
3628   unsigned char *chunk_start;
3629   int ncols;
3630   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
3631   short int *col_type;
3632   int *col_offset;
3633   char *augmentation;
3634   unsigned int code_factor;
3635   int data_factor;
3636   unsigned long pc_begin;
3637   unsigned long pc_range;
3638   int cfa_reg;
3639   int cfa_offset;
3640   int ra;
3641   unsigned char fde_encoding;
3642   unsigned char cfa_exp;
3643 }
3644 Frame_Chunk;
3645
3646 static const char *const *dwarf_regnames;
3647 static unsigned int dwarf_regnames_count;
3648
3649 /* A marker for a col_type that means this column was never referenced
3650    in the frame info.  */
3651 #define DW_CFA_unreferenced (-1)
3652
3653 /* Return 0 if not more space is needed, 1 if more space is needed,
3654    -1 for invalid reg.  */
3655
3656 static int
3657 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3658 {
3659   int prev = fc->ncols;
3660
3661   if (reg < (unsigned int) fc->ncols)
3662     return 0;
3663
3664   if (dwarf_regnames_count
3665       && reg > dwarf_regnames_count)
3666     return -1;
3667
3668   fc->ncols = reg + 1;
3669   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3670   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3671
3672   while (prev < fc->ncols)
3673     {
3674       fc->col_type[prev] = DW_CFA_unreferenced;
3675       fc->col_offset[prev] = 0;
3676       prev++;
3677     }
3678   return 1;
3679 }
3680
3681 static const char *const dwarf_regnames_i386[] =
3682 {
3683   "eax", "ecx", "edx", "ebx",
3684   "esp", "ebp", "esi", "edi",
3685   "eip", "eflags", NULL,
3686   "st0", "st1", "st2", "st3",
3687   "st4", "st5", "st6", "st7",
3688   NULL, NULL,
3689   "xmm0", "xmm1", "xmm2", "xmm3",
3690   "xmm4", "xmm5", "xmm6", "xmm7",
3691   "mm0", "mm1", "mm2", "mm3",
3692   "mm4", "mm5", "mm6", "mm7",
3693   "fcw", "fsw", "mxcsr",
3694   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3695   "tr", "ldtr"
3696 };
3697
3698 static const char *const dwarf_regnames_x86_64[] =
3699 {
3700   "rax", "rdx", "rcx", "rbx",
3701   "rsi", "rdi", "rbp", "rsp",
3702   "r8",  "r9",  "r10", "r11",
3703   "r12", "r13", "r14", "r15",
3704   "rip",
3705   "xmm0",  "xmm1",  "xmm2",  "xmm3",
3706   "xmm4",  "xmm5",  "xmm6",  "xmm7",
3707   "xmm8",  "xmm9",  "xmm10", "xmm11",
3708   "xmm12", "xmm13", "xmm14", "xmm15",
3709   "st0", "st1", "st2", "st3",
3710   "st4", "st5", "st6", "st7",
3711   "mm0", "mm1", "mm2", "mm3",
3712   "mm4", "mm5", "mm6", "mm7",
3713   "rflags",
3714   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3715   "fs.base", "gs.base", NULL, NULL,
3716   "tr", "ldtr",
3717   "mxcsr", "fcw", "fsw"
3718 };
3719
3720 void
3721 init_dwarf_regnames (unsigned int e_machine)
3722 {
3723   switch (e_machine)
3724     {
3725     case EM_386:
3726     case EM_486:
3727       dwarf_regnames = dwarf_regnames_i386;
3728       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3729       break;
3730
3731     case EM_X86_64:
3732       dwarf_regnames = dwarf_regnames_x86_64;
3733       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
3734       break;
3735
3736     default:
3737       break;
3738     }
3739 }
3740
3741 static const char *
3742 regname (unsigned int regno, int row)
3743 {
3744   static char reg[64];
3745   if (dwarf_regnames
3746       && regno < dwarf_regnames_count
3747       && dwarf_regnames [regno] != NULL)
3748     {
3749       if (row)
3750         return dwarf_regnames [regno];
3751       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
3752                 dwarf_regnames [regno]);
3753     }
3754   else
3755     snprintf (reg, sizeof (reg), "r%d", regno);
3756   return reg;
3757 }
3758
3759 static void
3760 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3761 {
3762   int r;
3763   char tmp[100];
3764
3765   if (*max_regs < fc->ncols)
3766     *max_regs = fc->ncols;
3767
3768   if (*need_col_headers)
3769     {
3770       static const char *loc = "   LOC";
3771
3772       *need_col_headers = 0;
3773
3774       printf ("%-*s CFA      ", eh_addr_size * 2, loc);
3775
3776       for (r = 0; r < *max_regs; r++)
3777         if (fc->col_type[r] != DW_CFA_unreferenced)
3778           {
3779             if (r == fc->ra)
3780               printf ("ra      ");
3781             else
3782               printf ("%-5s ", regname (r, 1));
3783           }
3784
3785       printf ("\n");
3786     }
3787
3788   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
3789   if (fc->cfa_exp)
3790     strcpy (tmp, "exp");
3791   else
3792     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
3793   printf ("%-8s ", tmp);
3794
3795   for (r = 0; r < fc->ncols; r++)
3796     {
3797       if (fc->col_type[r] != DW_CFA_unreferenced)
3798         {
3799           switch (fc->col_type[r])
3800             {
3801             case DW_CFA_undefined:
3802               strcpy (tmp, "u");
3803               break;
3804             case DW_CFA_same_value:
3805               strcpy (tmp, "s");
3806               break;
3807             case DW_CFA_offset:
3808               sprintf (tmp, "c%+d", fc->col_offset[r]);
3809               break;
3810             case DW_CFA_val_offset:
3811               sprintf (tmp, "v%+d", fc->col_offset[r]);
3812               break;
3813             case DW_CFA_register:
3814               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
3815               break;
3816             case DW_CFA_expression:
3817               strcpy (tmp, "exp");
3818               break;
3819             case DW_CFA_val_expression:
3820               strcpy (tmp, "vexp");
3821               break;
3822             default:
3823               strcpy (tmp, "n/a");
3824               break;
3825             }
3826           printf ("%-5s ", tmp);
3827         }
3828     }
3829   printf ("\n");
3830 }
3831
3832 #define GET(N)  byte_get (start, N); start += N
3833 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
3834 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
3835
3836 static int
3837 display_debug_frames (struct dwarf_section *section,
3838                       void *file ATTRIBUTE_UNUSED)
3839 {
3840   unsigned char *start = section->start;
3841   unsigned char *end = start + section->size;
3842   unsigned char *section_start = start;
3843   Frame_Chunk *chunks = 0;
3844   Frame_Chunk *remembered_state = 0;
3845   Frame_Chunk *rs;
3846   int is_eh = strcmp (section->name, ".eh_frame") == 0;
3847   unsigned int length_return;
3848   int max_regs = 0;
3849   const char *bad_reg = _("bad register: ");
3850
3851   printf (_("Contents of the %s section:\n"), section->name);
3852
3853   while (start < end)
3854     {
3855       unsigned char *saved_start;
3856       unsigned char *block_end;
3857       unsigned long length;
3858       unsigned long cie_id;
3859       Frame_Chunk *fc;
3860       Frame_Chunk *cie;
3861       int need_col_headers = 1;
3862       unsigned char *augmentation_data = NULL;
3863       unsigned long augmentation_data_len = 0;
3864       int encoded_ptr_size = eh_addr_size;
3865       int offset_size;
3866       int initial_length_size;
3867
3868       saved_start = start;
3869       length = byte_get (start, 4); start += 4;
3870
3871       if (length == 0)
3872         {
3873           printf ("\n%08lx ZERO terminator\n\n",
3874                     (unsigned long)(saved_start - section_start));
3875           continue;
3876         }
3877
3878       if (length == 0xffffffff)
3879         {
3880           length = byte_get (start, 8);
3881           start += 8;
3882           offset_size = 8;
3883           initial_length_size = 12;
3884         }
3885       else
3886         {
3887           offset_size = 4;
3888           initial_length_size = 4;
3889         }
3890
3891       block_end = saved_start + length + initial_length_size;
3892       if (block_end > end)
3893         {
3894           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3895                 length, (unsigned long)(saved_start - section_start));
3896           block_end = end;
3897         }
3898       cie_id = byte_get (start, offset_size); start += offset_size;
3899
3900       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3901         {
3902           int version;
3903
3904           fc = xmalloc (sizeof (Frame_Chunk));
3905           memset (fc, 0, sizeof (Frame_Chunk));
3906
3907           fc->next = chunks;
3908           chunks = fc;
3909           fc->chunk_start = saved_start;
3910           fc->ncols = 0;
3911           fc->col_type = xmalloc (sizeof (short int));
3912           fc->col_offset = xmalloc (sizeof (int));
3913           frame_need_space (fc, max_regs - 1);
3914
3915           version = *start++;
3916
3917           fc->augmentation = (char *) start;
3918           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3919
3920           if (fc->augmentation[0] == 'z')
3921             {
3922               fc->code_factor = LEB ();
3923               fc->data_factor = SLEB ();
3924               if (version == 1)
3925                 {
3926                   fc->ra = GET (1);
3927                 }
3928               else
3929                 {
3930                   fc->ra = LEB ();
3931                 }
3932               augmentation_data_len = LEB ();
3933               augmentation_data = start;
3934               start += augmentation_data_len;
3935             }
3936           else if (strcmp (fc->augmentation, "eh") == 0)
3937             {
3938               start += eh_addr_size;
3939               fc->code_factor = LEB ();
3940               fc->data_factor = SLEB ();
3941               if (version == 1)
3942                 {
3943                   fc->ra = GET (1);
3944                 }
3945               else
3946                 {
3947                   fc->ra = LEB ();
3948                 }
3949             }
3950           else
3951             {
3952               fc->code_factor = LEB ();
3953               fc->data_factor = SLEB ();
3954               if (version == 1)
3955                 {
3956                   fc->ra = GET (1);
3957                 }
3958               else
3959                 {
3960                   fc->ra = LEB ();
3961                 }
3962             }
3963           cie = fc;
3964
3965           if (do_debug_frames_interp)
3966             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3967                     (unsigned long)(saved_start - section_start), length, cie_id,
3968                     fc->augmentation, fc->code_factor, fc->data_factor,
3969                     fc->ra);
3970           else
3971             {
3972               printf ("\n%08lx %08lx %08lx CIE\n",
3973                       (unsigned long)(saved_start - section_start), length, cie_id);
3974               printf ("  Version:               %d\n", version);
3975               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3976               printf ("  Code alignment factor: %u\n", fc->code_factor);
3977               printf ("  Data alignment factor: %d\n", fc->data_factor);
3978               printf ("  Return address column: %d\n", fc->ra);
3979
3980               if (augmentation_data_len)
3981                 {
3982                   unsigned long i;
3983                   printf ("  Augmentation data:    ");
3984                   for (i = 0; i < augmentation_data_len; ++i)
3985                     printf (" %02x", augmentation_data[i]);
3986                   putchar ('\n');
3987                 }
3988               putchar ('\n');
3989             }
3990
3991           if (augmentation_data_len)
3992             {
3993               unsigned char *p, *q;
3994               p = (unsigned char *) fc->augmentation + 1;
3995               q = augmentation_data;
3996
3997               while (1)
3998                 {
3999                   if (*p == 'L')
4000                     q++;
4001                   else if (*p == 'P')
4002                     q += 1 + size_of_encoded_value (*q);
4003                   else if (*p == 'R')
4004                     fc->fde_encoding = *q++;
4005                   else
4006                     break;
4007                   p++;
4008                 }
4009
4010               if (fc->fde_encoding)
4011                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4012             }
4013
4014           frame_need_space (fc, fc->ra);
4015         }
4016       else
4017         {
4018           unsigned char *look_for;
4019           static Frame_Chunk fde_fc;
4020
4021           fc = & fde_fc;
4022           memset (fc, 0, sizeof (Frame_Chunk));
4023
4024           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4025
4026           for (cie = chunks; cie ; cie = cie->next)
4027             if (cie->chunk_start == look_for)
4028               break;
4029
4030           if (!cie)
4031             {
4032               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4033                     cie_id, (unsigned long)(saved_start - section_start));
4034               fc->ncols = 0;
4035               fc->col_type = xmalloc (sizeof (short int));
4036               fc->col_offset = xmalloc (sizeof (int));
4037               frame_need_space (fc, max_regs - 1);
4038               cie = fc;
4039               fc->augmentation = "";
4040               fc->fde_encoding = 0;
4041             }
4042           else
4043             {
4044               fc->ncols = cie->ncols;
4045               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
4046               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
4047               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4048               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4049               fc->augmentation = cie->augmentation;
4050               fc->code_factor = cie->code_factor;
4051               fc->data_factor = cie->data_factor;
4052               fc->cfa_reg = cie->cfa_reg;
4053               fc->cfa_offset = cie->cfa_offset;
4054               fc->ra = cie->ra;
4055               frame_need_space (fc, max_regs - 1);
4056               fc->fde_encoding = cie->fde_encoding;
4057             }
4058
4059           if (fc->fde_encoding)
4060             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4061
4062           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4063           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4064             fc->pc_begin += section->address + (start - section_start);
4065           start += encoded_ptr_size;
4066           fc->pc_range = byte_get (start, encoded_ptr_size);
4067           start += encoded_ptr_size;
4068
4069           if (cie->augmentation[0] == 'z')
4070             {
4071               augmentation_data_len = LEB ();
4072               augmentation_data = start;
4073               start += augmentation_data_len;
4074             }
4075
4076           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4077                   (unsigned long)(saved_start - section_start), length, cie_id,
4078                   (unsigned long)(cie->chunk_start - section_start),
4079                   fc->pc_begin, fc->pc_begin + fc->pc_range);
4080           if (! do_debug_frames_interp && augmentation_data_len)
4081             {
4082               unsigned long i;
4083
4084               printf ("  Augmentation data:    ");
4085               for (i = 0; i < augmentation_data_len; ++i)
4086                 printf (" %02x", augmentation_data[i]);
4087               putchar ('\n');
4088               putchar ('\n');
4089             }
4090         }
4091
4092       /* At this point, fc is the current chunk, cie (if any) is set, and
4093          we're about to interpret instructions for the chunk.  */
4094       /* ??? At present we need to do this always, since this sizes the
4095          fc->col_type and fc->col_offset arrays, which we write into always.
4096          We should probably split the interpreted and non-interpreted bits
4097          into two different routines, since there's so much that doesn't
4098          really overlap between them.  */
4099       if (1 || do_debug_frames_interp)
4100         {
4101           /* Start by making a pass over the chunk, allocating storage
4102              and taking note of what registers are used.  */
4103           unsigned char *tmp = start;
4104
4105           while (start < block_end)
4106             {
4107               unsigned op, opa;
4108               unsigned long reg, tmp;
4109
4110               op = *start++;
4111               opa = op & 0x3f;
4112               if (op & 0xc0)
4113                 op &= 0xc0;
4114
4115               /* Warning: if you add any more cases to this switch, be
4116                  sure to add them to the corresponding switch below.  */
4117               switch (op)
4118                 {
4119                 case DW_CFA_advance_loc:
4120                   break;
4121                 case DW_CFA_offset:
4122                   LEB ();
4123                   if (frame_need_space (fc, opa) >= 0)
4124                     fc->col_type[opa] = DW_CFA_undefined;
4125                   break;
4126                 case DW_CFA_restore:
4127                   if (frame_need_space (fc, opa) >= 0)
4128                     fc->col_type[opa] = DW_CFA_undefined;
4129                   break;
4130                 case DW_CFA_set_loc:
4131                   start += encoded_ptr_size;
4132                   break;
4133                 case DW_CFA_advance_loc1:
4134                   start += 1;
4135                   break;
4136                 case DW_CFA_advance_loc2:
4137                   start += 2;
4138                   break;
4139                 case DW_CFA_advance_loc4:
4140                   start += 4;
4141                   break;
4142                 case DW_CFA_offset_extended:
4143                 case DW_CFA_val_offset:
4144                   reg = LEB (); LEB ();
4145                   if (frame_need_space (fc, reg) >= 0)
4146                     fc->col_type[reg] = DW_CFA_undefined;
4147                   break;
4148                 case DW_CFA_restore_extended:
4149                   reg = LEB ();
4150                   frame_need_space (fc, reg);
4151                   if (frame_need_space (fc, reg) >= 0)
4152                     fc->col_type[reg] = DW_CFA_undefined;
4153                   break;
4154                 case DW_CFA_undefined:
4155                   reg = LEB ();
4156                   if (frame_need_space (fc, reg) >= 0)
4157                     fc->col_type[reg] = DW_CFA_undefined;
4158                   break;
4159                 case DW_CFA_same_value:
4160                   reg = LEB ();
4161                   if (frame_need_space (fc, reg) >= 0)
4162                     fc->col_type[reg] = DW_CFA_undefined;
4163                   break;
4164                 case DW_CFA_register:
4165                   reg = LEB (); LEB ();
4166                   if (frame_need_space (fc, reg) >= 0)
4167                     fc->col_type[reg] = DW_CFA_undefined;
4168                   break;
4169                 case DW_CFA_def_cfa:
4170                   LEB (); LEB ();
4171                   break;
4172                 case DW_CFA_def_cfa_register:
4173                   LEB ();
4174                   break;
4175                 case DW_CFA_def_cfa_offset:
4176                   LEB ();
4177                   break;
4178                 case DW_CFA_def_cfa_expression:
4179                   tmp = LEB ();
4180                   start += tmp;
4181                   break;
4182                 case DW_CFA_expression:
4183                 case DW_CFA_val_expression:
4184                   reg = LEB ();
4185                   tmp = LEB ();
4186                   start += tmp;
4187                   if (frame_need_space (fc, reg) >= 0)
4188                     fc->col_type[reg] = DW_CFA_undefined;
4189                   break;
4190                 case DW_CFA_offset_extended_sf:
4191                 case DW_CFA_val_offset_sf:
4192                   reg = LEB (); SLEB ();
4193                   if (frame_need_space (fc, reg) >= 0)
4194                     fc->col_type[reg] = DW_CFA_undefined;
4195                   break;
4196                 case DW_CFA_def_cfa_sf:
4197                   LEB (); SLEB ();
4198                   break;
4199                 case DW_CFA_def_cfa_offset_sf:
4200                   SLEB ();
4201                   break;
4202                 case DW_CFA_MIPS_advance_loc8:
4203                   start += 8;
4204                   break;
4205                 case DW_CFA_GNU_args_size:
4206                   LEB ();
4207                   break;
4208                 case DW_CFA_GNU_negative_offset_extended:
4209                   reg = LEB (); LEB ();
4210                   if (frame_need_space (fc, reg) >= 0)
4211                     fc->col_type[reg] = DW_CFA_undefined;
4212                   break;
4213                 default:
4214                   break;
4215                 }
4216             }
4217           start = tmp;
4218         }
4219
4220       /* Now we know what registers are used, make a second pass over
4221          the chunk, this time actually printing out the info.  */
4222
4223       while (start < block_end)
4224         {
4225           unsigned op, opa;
4226           unsigned long ul, reg, roffs;
4227           long l, ofs;
4228           dwarf_vma vma;
4229           const char *reg_prefix = "";
4230
4231           op = *start++;
4232           opa = op & 0x3f;
4233           if (op & 0xc0)
4234             op &= 0xc0;
4235
4236           /* Warning: if you add any more cases to this switch, be
4237              sure to add them to the corresponding switch above.  */
4238           switch (op)
4239             {
4240             case DW_CFA_advance_loc:
4241               if (do_debug_frames_interp)
4242                 frame_display_row (fc, &need_col_headers, &max_regs);
4243               else
4244                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
4245                         opa * fc->code_factor,
4246                         fc->pc_begin + opa * fc->code_factor);
4247               fc->pc_begin += opa * fc->code_factor;
4248               break;
4249
4250             case DW_CFA_offset:
4251               roffs = LEB ();
4252               if (opa >= (unsigned int) fc->ncols)
4253                 reg_prefix = bad_reg;
4254               if (! do_debug_frames_interp || *reg_prefix != '\0')
4255                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
4256                         reg_prefix, regname (opa, 0),
4257                         roffs * fc->data_factor);
4258               if (*reg_prefix == '\0')
4259                 {
4260                   fc->col_type[opa] = DW_CFA_offset;
4261                   fc->col_offset[opa] = roffs * fc->data_factor;
4262                 }
4263               break;
4264
4265             case DW_CFA_restore:
4266               if (opa >= (unsigned int) cie->ncols
4267                   || opa >= (unsigned int) fc->ncols)
4268                 reg_prefix = bad_reg;
4269               if (! do_debug_frames_interp || *reg_prefix != '\0')
4270                 printf ("  DW_CFA_restore: %s%s\n",
4271                         reg_prefix, regname (opa, 0));
4272               if (*reg_prefix == '\0')
4273                 {
4274                   fc->col_type[opa] = cie->col_type[opa];
4275                   fc->col_offset[opa] = cie->col_offset[opa];
4276                 }
4277               break;
4278
4279             case DW_CFA_set_loc:
4280               vma = get_encoded_value (start, fc->fde_encoding);
4281               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4282                 vma += section->address + (start - section_start);
4283               start += encoded_ptr_size;
4284               if (do_debug_frames_interp)
4285                 frame_display_row (fc, &need_col_headers, &max_regs);
4286               else
4287                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4288               fc->pc_begin = vma;
4289               break;
4290
4291             case DW_CFA_advance_loc1:
4292               ofs = byte_get (start, 1); start += 1;
4293               if (do_debug_frames_interp)
4294                 frame_display_row (fc, &need_col_headers, &max_regs);
4295               else
4296                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
4297                         ofs * fc->code_factor,
4298                         fc->pc_begin + ofs * fc->code_factor);
4299               fc->pc_begin += ofs * fc->code_factor;
4300               break;
4301
4302             case DW_CFA_advance_loc2:
4303               ofs = byte_get (start, 2); start += 2;
4304               if (do_debug_frames_interp)
4305                 frame_display_row (fc, &need_col_headers, &max_regs);
4306               else
4307                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
4308                         ofs * fc->code_factor,
4309                         fc->pc_begin + ofs * fc->code_factor);
4310               fc->pc_begin += ofs * fc->code_factor;
4311               break;
4312
4313             case DW_CFA_advance_loc4:
4314               ofs = byte_get (start, 4); start += 4;
4315               if (do_debug_frames_interp)
4316                 frame_display_row (fc, &need_col_headers, &max_regs);
4317               else
4318                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
4319                         ofs * fc->code_factor,
4320                         fc->pc_begin + ofs * fc->code_factor);
4321               fc->pc_begin += ofs * fc->code_factor;
4322               break;
4323
4324             case DW_CFA_offset_extended:
4325               reg = LEB ();
4326               roffs = LEB ();
4327               if (reg >= (unsigned int) fc->ncols)
4328                 reg_prefix = bad_reg;
4329               if (! do_debug_frames_interp || *reg_prefix != '\0')
4330                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4331                         reg_prefix, regname (reg, 0),
4332                         roffs * fc->data_factor);
4333               if (*reg_prefix == '\0')
4334                 {
4335                   fc->col_type[reg] = DW_CFA_offset;
4336                   fc->col_offset[reg] = roffs * fc->data_factor;
4337                 }
4338               break;
4339
4340             case DW_CFA_val_offset:
4341               reg = LEB ();
4342               roffs = LEB ();
4343               if (reg >= (unsigned int) fc->ncols)
4344                 reg_prefix = bad_reg;
4345               if (! do_debug_frames_interp || *reg_prefix != '\0')
4346                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
4347                         reg_prefix, regname (reg, 0),
4348                         roffs * fc->data_factor);
4349               if (*reg_prefix == '\0')
4350                 {
4351                   fc->col_type[reg] = DW_CFA_val_offset;
4352                   fc->col_offset[reg] = roffs * fc->data_factor;
4353                 }
4354               break;
4355
4356             case DW_CFA_restore_extended:
4357               reg = LEB ();
4358               if (reg >= (unsigned int) cie->ncols
4359                   || reg >= (unsigned int) fc->ncols)
4360                 reg_prefix = bad_reg;
4361               if (! do_debug_frames_interp || *reg_prefix != '\0')
4362                 printf ("  DW_CFA_restore_extended: %s%s\n",
4363                         reg_prefix, regname (reg, 0));
4364               if (*reg_prefix == '\0')
4365                 {
4366                   fc->col_type[reg] = cie->col_type[reg];
4367                   fc->col_offset[reg] = cie->col_offset[reg];
4368                 }
4369               break;
4370
4371             case DW_CFA_undefined:
4372               reg = LEB ();
4373               if (reg >= (unsigned int) fc->ncols)
4374                 reg_prefix = bad_reg;
4375               if (! do_debug_frames_interp || *reg_prefix != '\0')
4376                 printf ("  DW_CFA_undefined: %s%s\n",
4377                         reg_prefix, regname (reg, 0));
4378               if (*reg_prefix == '\0')
4379                 {
4380                   fc->col_type[reg] = DW_CFA_undefined;
4381                   fc->col_offset[reg] = 0;
4382                 }
4383               break;
4384
4385             case DW_CFA_same_value:
4386               reg = LEB ();
4387               if (reg >= (unsigned int) fc->ncols)
4388                 reg_prefix = bad_reg;
4389               if (! do_debug_frames_interp || *reg_prefix != '\0')
4390                 printf ("  DW_CFA_same_value: %s%s\n",
4391                         reg_prefix, regname (reg, 0));
4392               if (*reg_prefix == '\0')
4393                 {
4394                   fc->col_type[reg] = DW_CFA_same_value;
4395                   fc->col_offset[reg] = 0;
4396                 }
4397               break;
4398
4399             case DW_CFA_register:
4400               reg = LEB ();
4401               roffs = LEB ();
4402               if (reg >= (unsigned int) fc->ncols)
4403                 reg_prefix = bad_reg;
4404               if (! do_debug_frames_interp || *reg_prefix != '\0')
4405                 {
4406                   printf ("  DW_CFA_register: %s%s in ",
4407                           reg_prefix, regname (reg, 0));
4408                   puts (regname (roffs, 0));
4409                 }
4410               if (*reg_prefix == '\0')
4411                 {
4412                   fc->col_type[reg] = DW_CFA_register;
4413                   fc->col_offset[reg] = roffs;
4414                 }
4415               break;
4416
4417             case DW_CFA_remember_state:
4418               if (! do_debug_frames_interp)
4419                 printf ("  DW_CFA_remember_state\n");
4420               rs = xmalloc (sizeof (Frame_Chunk));
4421               rs->ncols = fc->ncols;
4422               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
4423               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
4424               memcpy (rs->col_type, fc->col_type, rs->ncols);
4425               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4426               rs->next = remembered_state;
4427               remembered_state = rs;
4428               break;
4429
4430             case DW_CFA_restore_state:
4431               if (! do_debug_frames_interp)
4432                 printf ("  DW_CFA_restore_state\n");
4433               rs = remembered_state;
4434               if (rs)
4435                 {
4436                   remembered_state = rs->next;
4437                   frame_need_space (fc, rs->ncols - 1);
4438                   memcpy (fc->col_type, rs->col_type, rs->ncols);
4439                   memcpy (fc->col_offset, rs->col_offset,
4440                           rs->ncols * sizeof (int));
4441                   free (rs->col_type);
4442                   free (rs->col_offset);
4443                   free (rs);
4444                 }
4445               else if (do_debug_frames_interp)
4446                 printf ("Mismatched DW_CFA_restore_state\n");
4447               break;
4448
4449             case DW_CFA_def_cfa:
4450               fc->cfa_reg = LEB ();
4451               fc->cfa_offset = LEB ();
4452               fc->cfa_exp = 0;
4453               if (! do_debug_frames_interp)
4454                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
4455                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4456               break;
4457
4458             case DW_CFA_def_cfa_register:
4459               fc->cfa_reg = LEB ();
4460               fc->cfa_exp = 0;
4461               if (! do_debug_frames_interp)
4462                 printf ("  DW_CFA_def_cfa_register: %s\n",
4463                         regname (fc->cfa_reg, 0));
4464               break;
4465
4466             case DW_CFA_def_cfa_offset:
4467               fc->cfa_offset = LEB ();
4468               if (! do_debug_frames_interp)
4469                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4470               break;
4471
4472             case DW_CFA_nop:
4473               if (! do_debug_frames_interp)
4474                 printf ("  DW_CFA_nop\n");
4475               break;
4476
4477             case DW_CFA_def_cfa_expression:
4478               ul = LEB ();
4479               if (! do_debug_frames_interp)
4480                 {
4481                   printf ("  DW_CFA_def_cfa_expression (");
4482                   decode_location_expression (start, eh_addr_size, ul, 0,
4483                                               section);
4484                   printf (")\n");
4485                 }
4486               fc->cfa_exp = 1;
4487               start += ul;
4488               break;
4489
4490             case DW_CFA_expression:
4491               reg = LEB ();
4492               ul = LEB ();
4493               if (reg >= (unsigned int) fc->ncols)
4494                 reg_prefix = bad_reg;
4495               if (! do_debug_frames_interp || *reg_prefix != '\0')
4496                 {
4497                   printf ("  DW_CFA_expression: %s%s (",
4498                           reg_prefix, regname (reg, 0));
4499                   decode_location_expression (start, eh_addr_size,
4500                                               ul, 0, section);
4501                   printf (")\n");
4502                 }
4503               if (*reg_prefix == '\0')
4504                 fc->col_type[reg] = DW_CFA_expression;
4505               start += ul;
4506               break;
4507
4508             case DW_CFA_val_expression:
4509               reg = LEB ();
4510               ul = LEB ();
4511               if (reg >= (unsigned int) fc->ncols)
4512                 reg_prefix = bad_reg;
4513               if (! do_debug_frames_interp || *reg_prefix != '\0')
4514                 {
4515                   printf ("  DW_CFA_val_expression: %s%s (",
4516                           reg_prefix, regname (reg, 0));
4517                   decode_location_expression (start, eh_addr_size, ul, 0,
4518                                               section);
4519                   printf (")\n");
4520                 }
4521               if (*reg_prefix == '\0')
4522                 fc->col_type[reg] = DW_CFA_val_expression;
4523               start += ul;
4524               break;
4525
4526             case DW_CFA_offset_extended_sf:
4527               reg = LEB ();
4528               l = SLEB ();
4529               if (frame_need_space (fc, reg) < 0)
4530                 reg_prefix = bad_reg;
4531               if (! do_debug_frames_interp || *reg_prefix != '\0')
4532                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4533                         reg_prefix, regname (reg, 0),
4534                         l * fc->data_factor);
4535               if (*reg_prefix == '\0')
4536                 {
4537                   fc->col_type[reg] = DW_CFA_offset;
4538                   fc->col_offset[reg] = l * fc->data_factor;
4539                 }
4540               break;
4541
4542             case DW_CFA_val_offset_sf:
4543               reg = LEB ();
4544               l = SLEB ();
4545               if (frame_need_space (fc, reg) < 0)
4546                 reg_prefix = bad_reg;
4547               if (! do_debug_frames_interp || *reg_prefix != '\0')
4548                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4549                         reg_prefix, regname (reg, 0),
4550                         l * fc->data_factor);
4551               if (*reg_prefix == '\0')
4552                 {
4553                   fc->col_type[reg] = DW_CFA_val_offset;
4554                   fc->col_offset[reg] = l * fc->data_factor;
4555                 }
4556               break;
4557
4558             case DW_CFA_def_cfa_sf:
4559               fc->cfa_reg = LEB ();
4560               fc->cfa_offset = SLEB ();
4561               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4562               fc->cfa_exp = 0;
4563               if (! do_debug_frames_interp)
4564                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
4565                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4566               break;
4567
4568             case DW_CFA_def_cfa_offset_sf:
4569               fc->cfa_offset = SLEB ();
4570               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4571               if (! do_debug_frames_interp)
4572                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4573               break;
4574
4575             case DW_CFA_MIPS_advance_loc8:
4576               ofs = byte_get (start, 8); start += 8;
4577               if (do_debug_frames_interp)
4578                 frame_display_row (fc, &need_col_headers, &max_regs);
4579               else
4580                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4581                         ofs * fc->code_factor,
4582                         fc->pc_begin + ofs * fc->code_factor);
4583               fc->pc_begin += ofs * fc->code_factor;
4584               break;
4585
4586             case DW_CFA_GNU_window_save:
4587               if (! do_debug_frames_interp)
4588                 printf ("  DW_CFA_GNU_window_save\n");
4589               break;
4590
4591             case DW_CFA_GNU_args_size:
4592               ul = LEB ();
4593               if (! do_debug_frames_interp)
4594                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
4595               break;
4596
4597             case DW_CFA_GNU_negative_offset_extended:
4598               reg = LEB ();
4599               l = - LEB ();
4600               if (frame_need_space (fc, reg) < 0)
4601                 reg_prefix = bad_reg;
4602               if (! do_debug_frames_interp || *reg_prefix != '\0')
4603                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4604                         reg_prefix, regname (reg, 0),
4605                         l * fc->data_factor);
4606               if (*reg_prefix == '\0')
4607                 {
4608                   fc->col_type[reg] = DW_CFA_offset;
4609                   fc->col_offset[reg] = l * fc->data_factor;
4610                 }
4611               break;
4612
4613             default:
4614               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4615                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4616               else
4617                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4618               start = block_end;
4619             }
4620         }
4621
4622       if (do_debug_frames_interp)
4623         frame_display_row (fc, &need_col_headers, &max_regs);
4624
4625       start = block_end;
4626     }
4627
4628   printf ("\n");
4629
4630   return 1;
4631 }
4632
4633 #undef GET
4634 #undef LEB
4635 #undef SLEB
4636
4637 static int
4638 display_debug_not_supported (struct dwarf_section *section,
4639                              void *file ATTRIBUTE_UNUSED)
4640 {
4641   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4642             section->name);
4643
4644   return 1;
4645 }
4646
4647 void *
4648 cmalloc (size_t nmemb, size_t size)
4649 {
4650   /* Check for overflow.  */
4651   if (nmemb >= ~(size_t) 0 / size)
4652     return NULL;
4653   else
4654     return malloc (nmemb * size);
4655 }
4656
4657 void *
4658 xcmalloc (size_t nmemb, size_t size)
4659 {
4660   /* Check for overflow.  */
4661   if (nmemb >= ~(size_t) 0 / size)
4662     return NULL;
4663   else
4664     return xmalloc (nmemb * size);
4665 }
4666
4667 void *
4668 xcrealloc (void *ptr, size_t nmemb, size_t size)
4669 {
4670   /* Check for overflow.  */
4671   if (nmemb >= ~(size_t) 0 / size)
4672     return NULL;
4673   else
4674     return xrealloc (ptr, nmemb * size);
4675 }
4676
4677 void
4678 error (const char *message, ...)
4679 {
4680   va_list args;
4681
4682   va_start (args, message);
4683   fprintf (stderr, _("%s: Error: "), program_name);
4684   vfprintf (stderr, message, args);
4685   va_end (args);
4686 }
4687
4688 void
4689 warn (const char *message, ...)
4690 {
4691   va_list args;
4692
4693   va_start (args, message);
4694   fprintf (stderr, _("%s: Warning: "), program_name);
4695   vfprintf (stderr, message, args);
4696   va_end (args);
4697 }
4698
4699 void
4700 free_debug_memory (void)
4701 {
4702   enum dwarf_section_display_enum i;
4703
4704   free_abbrevs ();
4705
4706   for (i = 0; i < max; i++)
4707     free_debug_section (i);
4708
4709   if (debug_information != NULL)
4710     {
4711       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4712         {
4713           for (i = 0; i < num_debug_info_entries; i++)
4714             {
4715               if (!debug_information [i].max_loc_offsets)
4716                 {
4717                   free (debug_information [i].loc_offsets);
4718                   free (debug_information [i].have_frame_base);
4719                 }
4720               if (!debug_information [i].max_range_lists)
4721                 free (debug_information [i].range_lists);
4722             }
4723         }
4724
4725       free (debug_information);
4726       debug_information = NULL;
4727       num_debug_info_entries = 0;
4728     }
4729 }
4730
4731 void
4732 dwarf_select_sections_by_names (const char *names)
4733 {
4734   typedef struct
4735   {
4736     const char * option;
4737     int *        variable;
4738     int val;
4739   }
4740   debug_dump_long_opts;
4741
4742   static const debug_dump_long_opts opts_table [] =
4743     {
4744       /* Please keep this table alpha- sorted.  */
4745       { "Ranges", & do_debug_ranges, 1 },
4746       { "abbrev", & do_debug_abbrevs, 1 },
4747       { "aranges", & do_debug_aranges, 1 },
4748       { "frames", & do_debug_frames, 1 },
4749       { "frames-interp", & do_debug_frames_interp, 1 },
4750       { "info", & do_debug_info, 1 },
4751       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
4752       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4753       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4754       { "loc",  & do_debug_loc, 1 },
4755       { "macro", & do_debug_macinfo, 1 },
4756       { "pubnames", & do_debug_pubnames, 1 },
4757       /* This entry is for compatability
4758          with earlier versions of readelf.  */
4759       { "ranges", & do_debug_aranges, 1 },
4760       { "str", & do_debug_str, 1 },
4761       { NULL, NULL, 0 }
4762     };
4763
4764   const char *p;
4765
4766   p = names;
4767   while (*p)
4768     {
4769       const debug_dump_long_opts * entry;
4770
4771       for (entry = opts_table; entry->option; entry++)
4772         {
4773           size_t len = strlen (entry->option);
4774
4775           if (strncmp (p, entry->option, len) == 0
4776               && (p[len] == ',' || p[len] == '\0'))
4777             {
4778               * entry->variable |= entry->val;
4779
4780               /* The --debug-dump=frames-interp option also
4781                  enables the --debug-dump=frames option.  */
4782               if (do_debug_frames_interp)
4783                 do_debug_frames = 1;
4784
4785               p += len;
4786               break;
4787             }
4788         }
4789
4790       if (entry->option == NULL)
4791         {
4792           warn (_("Unrecognized debug option '%s'\n"), p);
4793           p = strchr (p, ',');
4794           if (p == NULL)
4795             break;
4796         }
4797
4798       if (*p == ',')
4799         p++;
4800     }
4801 }
4802
4803 void
4804 dwarf_select_sections_by_letters (const char *letters)
4805 {
4806   unsigned int index = 0;
4807
4808   while (letters[index])
4809     switch (letters[index++])
4810       {
4811       case 'i':
4812         do_debug_info = 1;
4813         break;
4814
4815       case 'a':
4816         do_debug_abbrevs = 1;
4817         break;
4818
4819       case 'l':
4820         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4821         break;
4822
4823       case 'L':
4824         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
4825         break;
4826
4827       case 'p':
4828         do_debug_pubnames = 1;
4829         break;
4830
4831       case 'r':
4832         do_debug_aranges = 1;
4833         break;
4834
4835       case 'R':
4836         do_debug_ranges = 1;
4837         break;
4838
4839       case 'F':
4840         do_debug_frames_interp = 1;
4841       case 'f':
4842         do_debug_frames = 1;
4843         break;
4844
4845       case 'm':
4846         do_debug_macinfo = 1;
4847         break;
4848
4849       case 's':
4850         do_debug_str = 1;
4851         break;
4852
4853       case 'o':
4854         do_debug_loc = 1;
4855         break;
4856
4857       default:
4858         warn (_("Unrecognized debug option '%s'\n"), optarg);
4859         break;
4860       }
4861 }
4862
4863 void
4864 dwarf_select_sections_all (void)
4865 {
4866   do_debug_info = 1;
4867   do_debug_abbrevs = 1;
4868   do_debug_lines = FLAG_DEBUG_LINES_RAW;
4869   do_debug_pubnames = 1;
4870   do_debug_aranges = 1;
4871   do_debug_ranges = 1;
4872   do_debug_frames = 1;
4873   do_debug_macinfo = 1;
4874   do_debug_str = 1;
4875   do_debug_loc = 1;
4876 }
4877
4878 struct dwarf_section_display debug_displays[] =
4879 {
4880   { { ".debug_abbrev",          ".zdebug_abbrev",       NULL,   NULL,   0,      0 },
4881     display_debug_abbrev,               &do_debug_abbrevs,      0 },
4882   { { ".debug_aranges",         ".zdebug_aranges",      NULL,   NULL,   0,      0 },
4883     display_debug_aranges,              &do_debug_aranges,      1 },
4884   { { ".debug_frame",           ".zdebug_frame",        NULL,   NULL,   0,      0 },
4885     display_debug_frames,               &do_debug_frames,       1 },
4886   { { ".debug_info",            ".zdebug_info",         NULL,   NULL,   0,      0 },
4887     display_debug_info,                 &do_debug_info,         1 },
4888   { { ".debug_line",            ".zdebug_line",         NULL,   NULL,   0,      0 },
4889     display_debug_lines,                &do_debug_lines,        1 },
4890   { { ".debug_pubnames",        ".zdebug_pubnames",     NULL,   NULL,   0,      0 },
4891     display_debug_pubnames,             &do_debug_pubnames,     0 },
4892   { { ".eh_frame",              "",                     NULL,   NULL,   0,      0 },
4893     display_debug_frames,               &do_debug_frames,       1 },
4894   { { ".debug_macinfo",         ".zdebug_macinfo",      NULL,   NULL,   0,      0 },
4895     display_debug_macinfo,              &do_debug_macinfo,      0 },
4896   { { ".debug_str",             ".zdebug_str",          NULL,   NULL,   0,      0 },
4897     display_debug_str,                  &do_debug_str,          0 },
4898   { { ".debug_loc",             ".zdebug_loc",          NULL,   NULL,   0,      0 },
4899     display_debug_loc,                  &do_debug_loc,          1 },
4900   { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL,   NULL,   0,      0 },
4901     display_debug_pubnames,             &do_debug_pubnames,     0 },
4902   { { ".debug_ranges",          ".zdebug_ranges",       NULL,   NULL,   0,      0 },
4903     display_debug_ranges,               &do_debug_ranges,       1 },
4904   { { ".debug_static_func",     ".zdebug_static_func",  NULL,   NULL,   0,      0 },
4905     display_debug_not_supported,        NULL,                   0 },
4906   { { ".debug_static_vars",     ".zdebug_static_vars",  NULL,   NULL,   0,      0 },
4907     display_debug_not_supported,        NULL,                   0 },
4908   { { ".debug_types",           ".zdebug_types",        NULL,   NULL,   0,      0 },
4909     display_debug_not_supported,        NULL,                   0 },
4910   { { ".debug_weaknames",       ".zdebug_weaknames",    NULL,   NULL,   0,      0 },
4911     display_debug_not_supported,        NULL,                   0 }
4912 };