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 "elf/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           /* GNU extensions.  */
1018         case DW_OP_GNU_push_tls_address:
1019           printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1020           break;
1021         case DW_OP_GNU_uninit:
1022           printf ("DW_OP_GNU_uninit");
1023           /* FIXME: Is there data associated with this OP ?  */
1024           break;
1025         case DW_OP_GNU_encoded_addr:
1026           {
1027             int encoding;
1028             dwarf_vma addr;
1029
1030             encoding = *data++;
1031             addr = get_encoded_value (data, encoding);
1032             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1033               addr += section->address + (data - section->start);
1034             data += size_of_encoded_value (encoding);
1035
1036             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1037             print_dwarf_vma (addr, pointer_size);
1038           }
1039           break;
1040
1041           /* HP extensions.  */
1042         case DW_OP_HP_is_value:
1043           printf ("DW_OP_HP_is_value");
1044           /* FIXME: Is there data associated with this OP ?  */
1045           break;
1046         case DW_OP_HP_fltconst4:
1047           printf ("DW_OP_HP_fltconst4");
1048           /* FIXME: Is there data associated with this OP ?  */
1049           break;
1050         case DW_OP_HP_fltconst8:
1051           printf ("DW_OP_HP_fltconst8");
1052           /* FIXME: Is there data associated with this OP ?  */
1053           break;
1054         case DW_OP_HP_mod_range:
1055           printf ("DW_OP_HP_mod_range");
1056           /* FIXME: Is there data associated with this OP ?  */
1057           break;
1058         case DW_OP_HP_unmod_range:
1059           printf ("DW_OP_HP_unmod_range");
1060           /* FIXME: Is there data associated with this OP ?  */
1061           break;
1062         case DW_OP_HP_tls:
1063           printf ("DW_OP_HP_tls");
1064           /* FIXME: Is there data associated with this OP ?  */
1065           break;
1066
1067           /* PGI (STMicroelectronics) extensions.  */
1068         case DW_OP_PGI_omp_thread_num:
1069           /* Pushes the thread number for the current thread as it would be
1070              returned by the standard OpenMP library function:
1071              omp_get_thread_num().  The "current thread" is the thread for
1072              which the expression is being evaluated.  */
1073           printf ("DW_OP_PGI_omp_thread_num");
1074           break;
1075
1076         default:
1077           if (op >= DW_OP_lo_user
1078               && op <= DW_OP_hi_user)
1079             printf (_("(User defined location op)"));
1080           else
1081             printf (_("(Unknown location op)"));
1082           /* No way to tell where the next op is, so just bail.  */
1083           return need_frame_base;
1084         }
1085
1086       /* Separate the ops.  */
1087       if (data < end)
1088         printf ("; ");
1089     }
1090
1091   return need_frame_base;
1092 }
1093
1094 static unsigned char *
1095 read_and_display_attr_value (unsigned long attribute,
1096                              unsigned long form,
1097                              unsigned char * data,
1098                              unsigned long cu_offset,
1099                              unsigned long pointer_size,
1100                              unsigned long offset_size,
1101                              int dwarf_version,
1102                              debug_info * debug_info_p,
1103                              int do_loc,
1104                              struct dwarf_section * section)
1105 {
1106   unsigned long uvalue = 0;
1107   unsigned char *block_start = NULL;
1108   unsigned char * orig_data = data;
1109   unsigned int bytes_read;
1110
1111   switch (form)
1112     {
1113     default:
1114       break;
1115
1116     case DW_FORM_ref_addr:
1117       if (dwarf_version == 2)
1118         {
1119           uvalue = byte_get (data, pointer_size);
1120           data += pointer_size;
1121         }
1122       else if (dwarf_version == 3)
1123         {
1124           uvalue = byte_get (data, offset_size);
1125           data += offset_size;
1126         }
1127       else
1128         {
1129           error (_("Internal error: DWARF version is not 2 or 3.\n"));
1130         }
1131       break;
1132
1133     case DW_FORM_addr:
1134       uvalue = byte_get (data, pointer_size);
1135       data += pointer_size;
1136       break;
1137
1138     case DW_FORM_strp:
1139       uvalue = byte_get (data, offset_size);
1140       data += offset_size;
1141       break;
1142
1143     case DW_FORM_ref1:
1144     case DW_FORM_flag:
1145     case DW_FORM_data1:
1146       uvalue = byte_get (data++, 1);
1147       break;
1148
1149     case DW_FORM_ref2:
1150     case DW_FORM_data2:
1151       uvalue = byte_get (data, 2);
1152       data += 2;
1153       break;
1154
1155     case DW_FORM_ref4:
1156     case DW_FORM_data4:
1157       uvalue = byte_get (data, 4);
1158       data += 4;
1159       break;
1160
1161     case DW_FORM_sdata:
1162       uvalue = read_leb128 (data, & bytes_read, 1);
1163       data += bytes_read;
1164       break;
1165
1166     case DW_FORM_ref_udata:
1167     case DW_FORM_udata:
1168       uvalue = read_leb128 (data, & bytes_read, 0);
1169       data += bytes_read;
1170       break;
1171
1172     case DW_FORM_indirect:
1173       form = read_leb128 (data, & bytes_read, 0);
1174       data += bytes_read;
1175       if (!do_loc)
1176         printf (" %s", get_FORM_name (form));
1177       return read_and_display_attr_value (attribute, form, data,
1178                                           cu_offset, pointer_size,
1179                                           offset_size, dwarf_version,
1180                                           debug_info_p, do_loc,
1181                                           section);
1182     }
1183
1184   switch (form)
1185     {
1186     case DW_FORM_ref_addr:
1187       if (!do_loc)
1188         printf (" <0x%lx>", uvalue);
1189       break;
1190
1191     case DW_FORM_ref1:
1192     case DW_FORM_ref2:
1193     case DW_FORM_ref4:
1194     case DW_FORM_ref_udata:
1195       if (!do_loc)
1196         printf (" <0x%lx>", uvalue + cu_offset);
1197       break;
1198
1199     case DW_FORM_data4:
1200     case DW_FORM_addr:
1201       if (!do_loc)
1202         printf (" 0x%lx", uvalue);
1203       break;
1204
1205     case DW_FORM_flag:
1206     case DW_FORM_data1:
1207     case DW_FORM_data2:
1208     case DW_FORM_sdata:
1209     case DW_FORM_udata:
1210       if (!do_loc)
1211         printf (" %ld", uvalue);
1212       break;
1213
1214     case DW_FORM_ref8:
1215     case DW_FORM_data8:
1216       if (!do_loc)
1217         {
1218           uvalue = byte_get (data, 4);
1219           printf (" 0x%lx", uvalue);
1220           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1221         }
1222       if ((do_loc || do_debug_loc || do_debug_ranges)
1223           && num_debug_info_entries == 0)
1224         {
1225           if (sizeof (uvalue) == 8)
1226             uvalue = byte_get (data, 8);
1227           else
1228             error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1229         }
1230       data += 8;
1231       break;
1232
1233     case DW_FORM_string:
1234       if (!do_loc)
1235         printf (" %s", data);
1236       data += strlen ((char *) data) + 1;
1237       break;
1238
1239     case DW_FORM_block:
1240       uvalue = read_leb128 (data, & bytes_read, 0);
1241       block_start = data + bytes_read;
1242       if (do_loc)
1243         data = block_start + uvalue;
1244       else
1245         data = display_block (block_start, uvalue);
1246       break;
1247
1248     case DW_FORM_block1:
1249       uvalue = byte_get (data, 1);
1250       block_start = data + 1;
1251       if (do_loc)
1252         data = block_start + uvalue;
1253       else
1254         data = display_block (block_start, uvalue);
1255       break;
1256
1257     case DW_FORM_block2:
1258       uvalue = byte_get (data, 2);
1259       block_start = data + 2;
1260       if (do_loc)
1261         data = block_start + uvalue;
1262       else
1263         data = display_block (block_start, uvalue);
1264       break;
1265
1266     case DW_FORM_block4:
1267       uvalue = byte_get (data, 4);
1268       block_start = data + 4;
1269       if (do_loc)
1270         data = block_start + uvalue;
1271       else
1272         data = display_block (block_start, uvalue);
1273       break;
1274
1275     case DW_FORM_strp:
1276       if (!do_loc)
1277         printf (_(" (indirect string, offset: 0x%lx): %s"),
1278                 uvalue, fetch_indirect_string (uvalue));
1279       break;
1280
1281     case DW_FORM_indirect:
1282       /* Handled above.  */
1283       break;
1284
1285     default:
1286       warn (_("Unrecognized form: %lu\n"), form);
1287       break;
1288     }
1289
1290   if ((do_loc || do_debug_loc || do_debug_ranges)
1291       && num_debug_info_entries == 0)
1292     {
1293       switch (attribute)
1294         {
1295         case DW_AT_frame_base:
1296           have_frame_base = 1;
1297         case DW_AT_location:
1298         case DW_AT_string_length:
1299         case DW_AT_return_addr:
1300         case DW_AT_data_member_location:
1301         case DW_AT_vtable_elem_location:
1302         case DW_AT_segment:
1303         case DW_AT_static_link:
1304         case DW_AT_use_location:
1305           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1306             {
1307               /* Process location list.  */
1308               unsigned int max = debug_info_p->max_loc_offsets;
1309               unsigned int num = debug_info_p->num_loc_offsets;
1310
1311               if (max == 0 || num >= max)
1312                 {
1313                   max += 1024;
1314                   debug_info_p->loc_offsets
1315                     = xcrealloc (debug_info_p->loc_offsets,
1316                                  max, sizeof (*debug_info_p->loc_offsets));
1317                   debug_info_p->have_frame_base
1318                     = xcrealloc (debug_info_p->have_frame_base,
1319                                  max, sizeof (*debug_info_p->have_frame_base));
1320                   debug_info_p->max_loc_offsets = max;
1321                 }
1322               debug_info_p->loc_offsets [num] = uvalue;
1323               debug_info_p->have_frame_base [num] = have_frame_base;
1324               debug_info_p->num_loc_offsets++;
1325             }
1326           break;
1327
1328         case DW_AT_low_pc:
1329           if (need_base_address)
1330             debug_info_p->base_address = uvalue;
1331           break;
1332
1333         case DW_AT_ranges:
1334           if (form == DW_FORM_data4 || form == DW_FORM_data8)
1335             {
1336               /* Process range list.  */
1337               unsigned int max = debug_info_p->max_range_lists;
1338               unsigned int num = debug_info_p->num_range_lists;
1339
1340               if (max == 0 || num >= max)
1341                 {
1342                   max += 1024;
1343                   debug_info_p->range_lists
1344                     = xcrealloc (debug_info_p->range_lists,
1345                                  max, sizeof (*debug_info_p->range_lists));
1346                   debug_info_p->max_range_lists = max;
1347                 }
1348               debug_info_p->range_lists [num] = uvalue;
1349               debug_info_p->num_range_lists++;
1350             }
1351           break;
1352
1353         default:
1354           break;
1355         }
1356     }
1357
1358   if (do_loc)
1359     return data;
1360
1361   /* For some attributes we can display further information.  */
1362   printf ("\t");
1363
1364   switch (attribute)
1365     {
1366     case DW_AT_inline:
1367       switch (uvalue)
1368         {
1369         case DW_INL_not_inlined:
1370           printf (_("(not inlined)"));
1371           break;
1372         case DW_INL_inlined:
1373           printf (_("(inlined)"));
1374           break;
1375         case DW_INL_declared_not_inlined:
1376           printf (_("(declared as inline but ignored)"));
1377           break;
1378         case DW_INL_declared_inlined:
1379           printf (_("(declared as inline and inlined)"));
1380           break;
1381         default:
1382           printf (_("  (Unknown inline attribute value: %lx)"), uvalue);
1383           break;
1384         }
1385       break;
1386
1387     case DW_AT_language:
1388       switch (uvalue)
1389         {
1390           /* Ordered by the numeric value of these constants.  */
1391         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1392         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1393         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1394         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1395         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1396         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1397         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1398         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1399         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1400         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1401           /* DWARF 2.1 values.  */
1402         case DW_LANG_Java:              printf ("(Java)"); break;
1403         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1404         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1405         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1406           /* DWARF 3 values.  */
1407         case DW_LANG_PLI:               printf ("(PLI)"); break;
1408         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1409         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1410         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1411         case DW_LANG_D:                 printf ("(D)"); break;
1412           /* MIPS extension.  */
1413         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1414           /* UPC extension.  */
1415         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1416         default:
1417           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1418             printf ("(implementation defined: %lx)", uvalue);
1419           else
1420             printf ("(Unknown: %lx)", uvalue);
1421           break;
1422         }
1423       break;
1424
1425     case DW_AT_encoding:
1426       switch (uvalue)
1427         {
1428         case DW_ATE_void:               printf ("(void)"); break;
1429         case DW_ATE_address:            printf ("(machine address)"); break;
1430         case DW_ATE_boolean:            printf ("(boolean)"); break;
1431         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1432         case DW_ATE_float:              printf ("(float)"); break;
1433         case DW_ATE_signed:             printf ("(signed)"); break;
1434         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1435         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1436         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1437           /* DWARF 2.1 values:  */
1438         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1439         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1440           /* DWARF 3 values:  */
1441         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1442         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1443         case DW_ATE_edited:             printf ("(edited)"); break;
1444         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1445         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1446           /* HP extensions:  */
1447         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1448         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1449         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1450         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1451         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1452         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1453         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1454
1455         default:
1456           if (uvalue >= DW_ATE_lo_user
1457               && uvalue <= DW_ATE_hi_user)
1458             printf ("(user defined type)");
1459           else
1460             printf ("(unknown type)");
1461           break;
1462         }
1463       break;
1464
1465     case DW_AT_accessibility:
1466       switch (uvalue)
1467         {
1468         case DW_ACCESS_public:          printf ("(public)"); break;
1469         case DW_ACCESS_protected:       printf ("(protected)"); break;
1470         case DW_ACCESS_private:         printf ("(private)"); break;
1471         default:
1472           printf ("(unknown accessibility)");
1473           break;
1474         }
1475       break;
1476
1477     case DW_AT_visibility:
1478       switch (uvalue)
1479         {
1480         case DW_VIS_local:              printf ("(local)"); break;
1481         case DW_VIS_exported:           printf ("(exported)"); break;
1482         case DW_VIS_qualified:          printf ("(qualified)"); break;
1483         default:                        printf ("(unknown visibility)"); break;
1484         }
1485       break;
1486
1487     case DW_AT_virtuality:
1488       switch (uvalue)
1489         {
1490         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1491         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1492         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1493         default:                        printf ("(unknown virtuality)"); break;
1494         }
1495       break;
1496
1497     case DW_AT_identifier_case:
1498       switch (uvalue)
1499         {
1500         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1501         case DW_ID_up_case:             printf ("(up_case)"); break;
1502         case DW_ID_down_case:           printf ("(down_case)"); break;
1503         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1504         default:                        printf ("(unknown case)"); break;
1505         }
1506       break;
1507
1508     case DW_AT_calling_convention:
1509       switch (uvalue)
1510         {
1511         case DW_CC_normal:      printf ("(normal)"); break;
1512         case DW_CC_program:     printf ("(program)"); break;
1513         case DW_CC_nocall:      printf ("(nocall)"); break;
1514         default:
1515           if (uvalue >= DW_CC_lo_user
1516               && uvalue <= DW_CC_hi_user)
1517             printf ("(user defined)");
1518           else
1519             printf ("(unknown convention)");
1520         }
1521       break;
1522
1523     case DW_AT_ordering:
1524       switch (uvalue)
1525         {
1526         case -1: printf ("(undefined)"); break;
1527         case 0:  printf ("(row major)"); break;
1528         case 1:  printf ("(column major)"); break;
1529         }
1530       break;
1531
1532     case DW_AT_frame_base:
1533       have_frame_base = 1;
1534     case DW_AT_location:
1535     case DW_AT_string_length:
1536     case DW_AT_return_addr:
1537     case DW_AT_data_member_location:
1538     case DW_AT_vtable_elem_location:
1539     case DW_AT_segment:
1540     case DW_AT_static_link:
1541     case DW_AT_use_location:
1542       if (form == DW_FORM_data4 || form == DW_FORM_data8)
1543         printf (_("(location list)"));
1544       /* Fall through.  */
1545     case DW_AT_allocated:
1546     case DW_AT_associated:
1547     case DW_AT_data_location:
1548     case DW_AT_stride:
1549     case DW_AT_upper_bound:
1550     case DW_AT_lower_bound:
1551       if (block_start)
1552         {
1553           int need_frame_base;
1554
1555           printf ("(");
1556           need_frame_base = decode_location_expression (block_start,
1557                                                         pointer_size,
1558                                                         uvalue,
1559                                                         cu_offset, section);
1560           printf (")");
1561           if (need_frame_base && !have_frame_base)
1562             printf (_(" [without DW_AT_frame_base]"));
1563         }
1564       break;
1565
1566     case DW_AT_import:
1567       {
1568         if (form == DW_FORM_ref1
1569             || form == DW_FORM_ref2
1570             || form == DW_FORM_ref4)
1571           uvalue += cu_offset;
1572
1573         if (uvalue >= section->size)
1574           warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1575                 uvalue, (unsigned long) (orig_data - section->start));
1576         else
1577           {
1578             unsigned long abbrev_number;
1579             abbrev_entry * entry;
1580
1581             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1582
1583             printf ("[Abbrev Number: %ld", abbrev_number);
1584             for (entry = first_abbrev; entry != NULL; entry = entry->next)
1585               if (entry->entry == abbrev_number)
1586                 break;
1587             if (entry != NULL)
1588               printf (" (%s)", get_TAG_name (entry->tag));
1589             printf ("]");
1590           }
1591       }
1592       break;
1593
1594     default:
1595       break;
1596     }
1597
1598   return data;
1599 }
1600
1601 static char *
1602 get_AT_name (unsigned long attribute)
1603 {
1604   switch (attribute)
1605     {
1606     case DW_AT_sibling:                 return "DW_AT_sibling";
1607     case DW_AT_location:                return "DW_AT_location";
1608     case DW_AT_name:                    return "DW_AT_name";
1609     case DW_AT_ordering:                return "DW_AT_ordering";
1610     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1611     case DW_AT_byte_size:               return "DW_AT_byte_size";
1612     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1613     case DW_AT_bit_size:                return "DW_AT_bit_size";
1614     case DW_AT_element_list:            return "DW_AT_element_list";
1615     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1616     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1617     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1618     case DW_AT_language:                return "DW_AT_language";
1619     case DW_AT_member:                  return "DW_AT_member";
1620     case DW_AT_discr:                   return "DW_AT_discr";
1621     case DW_AT_discr_value:             return "DW_AT_discr_value";
1622     case DW_AT_visibility:              return "DW_AT_visibility";
1623     case DW_AT_import:                  return "DW_AT_import";
1624     case DW_AT_string_length:           return "DW_AT_string_length";
1625     case DW_AT_common_reference:        return "DW_AT_common_reference";
1626     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1627     case DW_AT_const_value:             return "DW_AT_const_value";
1628     case DW_AT_containing_type:         return "DW_AT_containing_type";
1629     case DW_AT_default_value:           return "DW_AT_default_value";
1630     case DW_AT_inline:                  return "DW_AT_inline";
1631     case DW_AT_is_optional:             return "DW_AT_is_optional";
1632     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1633     case DW_AT_producer:                return "DW_AT_producer";
1634     case DW_AT_prototyped:              return "DW_AT_prototyped";
1635     case DW_AT_return_addr:             return "DW_AT_return_addr";
1636     case DW_AT_start_scope:             return "DW_AT_start_scope";
1637     case DW_AT_stride_size:             return "DW_AT_stride_size";
1638     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1639     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1640     case DW_AT_accessibility:           return "DW_AT_accessibility";
1641     case DW_AT_address_class:           return "DW_AT_address_class";
1642     case DW_AT_artificial:              return "DW_AT_artificial";
1643     case DW_AT_base_types:              return "DW_AT_base_types";
1644     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1645     case DW_AT_count:                   return "DW_AT_count";
1646     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1647     case DW_AT_decl_column:             return "DW_AT_decl_column";
1648     case DW_AT_decl_file:               return "DW_AT_decl_file";
1649     case DW_AT_decl_line:               return "DW_AT_decl_line";
1650     case DW_AT_declaration:             return "DW_AT_declaration";
1651     case DW_AT_discr_list:              return "DW_AT_discr_list";
1652     case DW_AT_encoding:                return "DW_AT_encoding";
1653     case DW_AT_external:                return "DW_AT_external";
1654     case DW_AT_frame_base:              return "DW_AT_frame_base";
1655     case DW_AT_friend:                  return "DW_AT_friend";
1656     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1657     case DW_AT_macro_info:              return "DW_AT_macro_info";
1658     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1659     case DW_AT_priority:                return "DW_AT_priority";
1660     case DW_AT_segment:                 return "DW_AT_segment";
1661     case DW_AT_specification:           return "DW_AT_specification";
1662     case DW_AT_static_link:             return "DW_AT_static_link";
1663     case DW_AT_type:                    return "DW_AT_type";
1664     case DW_AT_use_location:            return "DW_AT_use_location";
1665     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1666     case DW_AT_virtuality:              return "DW_AT_virtuality";
1667     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1668       /* DWARF 2.1 values.  */
1669     case DW_AT_allocated:               return "DW_AT_allocated";
1670     case DW_AT_associated:              return "DW_AT_associated";
1671     case DW_AT_data_location:           return "DW_AT_data_location";
1672     case DW_AT_stride:                  return "DW_AT_stride";
1673     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1674     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1675     case DW_AT_extension:               return "DW_AT_extension";
1676     case DW_AT_ranges:                  return "DW_AT_ranges";
1677     case DW_AT_trampoline:              return "DW_AT_trampoline";
1678     case DW_AT_call_column:             return "DW_AT_call_column";
1679     case DW_AT_call_file:               return "DW_AT_call_file";
1680     case DW_AT_call_line:               return "DW_AT_call_line";
1681     case DW_AT_description:             return "DW_AT_description";
1682     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1683     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1684     case DW_AT_small:                   return "DW_AT_small";
1685     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1686     case DW_AT_digit_count:             return "DW_AT_digit_count";
1687     case DW_AT_picture_string:          return "DW_AT_picture_string";
1688     case DW_AT_mutable:                 return "DW_AT_mutable";
1689     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1690     case DW_AT_explicit:                return "DW_AT_explicit";
1691     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1692     case DW_AT_endianity:               return "DW_AT_endianity";
1693     case DW_AT_elemental:               return "DW_AT_elemental";
1694     case DW_AT_pure:                    return "DW_AT_pure";
1695     case DW_AT_recursive:               return "DW_AT_recursive";
1696
1697       /* HP and SGI/MIPS extensions.  */
1698     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1699     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1700     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1701     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1702     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1703     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1704     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1705     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1706     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1707     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1708
1709       /* HP Extensions.  */
1710     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1711     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1712     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1713     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1714     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1715     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1716     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1717     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1718     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1719     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1720     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1721     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1722     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1723
1724       /* One value is shared by the MIPS and HP extensions:  */
1725     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1726
1727       /* GNU extensions.  */
1728     case DW_AT_sf_names:                return "DW_AT_sf_names";
1729     case DW_AT_src_info:                return "DW_AT_src_info";
1730     case DW_AT_mac_info:                return "DW_AT_mac_info";
1731     case DW_AT_src_coords:              return "DW_AT_src_coords";
1732     case DW_AT_body_begin:              return "DW_AT_body_begin";
1733     case DW_AT_body_end:                return "DW_AT_body_end";
1734     case DW_AT_GNU_vector:              return "DW_AT_GNU_vector";
1735
1736       /* UPC extension.  */
1737     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1738
1739     /* PGI (STMicroelectronics) extensions.  */
1740     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1741     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1742     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1743
1744     default:
1745       {
1746         static char buffer[100];
1747
1748         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1749                   attribute);
1750         return buffer;
1751       }
1752     }
1753 }
1754
1755 static unsigned char *
1756 read_and_display_attr (unsigned long attribute,
1757                        unsigned long form,
1758                        unsigned char * data,
1759                        unsigned long cu_offset,
1760                        unsigned long pointer_size,
1761                        unsigned long offset_size,
1762                        int dwarf_version,
1763                        debug_info * debug_info_p,
1764                        int do_loc,
1765                        struct dwarf_section * section)
1766 {
1767   if (!do_loc)
1768     printf ("   %-18s:", get_AT_name (attribute));
1769   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1770                                       pointer_size, offset_size,
1771                                       dwarf_version, debug_info_p,
1772                                       do_loc, section);
1773   if (!do_loc)
1774     printf ("\n");
1775   return data;
1776 }
1777
1778
1779 /* Process the contents of a .debug_info section.  If do_loc is non-zero
1780    then we are scanning for location lists and we do not want to display
1781    anything to the user.  */
1782
1783 static int
1784 process_debug_info (struct dwarf_section *section,
1785                     void *file,
1786                     int do_loc)
1787 {
1788   unsigned char *start = section->start;
1789   unsigned char *end = start + section->size;
1790   unsigned char *section_begin;
1791   unsigned int unit;
1792   unsigned int num_units = 0;
1793
1794   if ((do_loc || do_debug_loc || do_debug_ranges)
1795       && num_debug_info_entries == 0)
1796     {
1797       unsigned long length;
1798
1799       /* First scan the section to get the number of comp units.  */
1800       for (section_begin = start, num_units = 0; section_begin < end;
1801            num_units ++)
1802         {
1803           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
1804              will be the length.  For a 64-bit DWARF section, it'll be
1805              the escape code 0xffffffff followed by an 8 byte length.  */
1806           length = byte_get (section_begin, 4);
1807
1808           if (length == 0xffffffff)
1809             {
1810               length = byte_get (section_begin + 4, 8);
1811               section_begin += length + 12;
1812             }
1813           else if (length >= 0xfffffff0 && length < 0xffffffff)
1814             {
1815               warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1816               return 0;
1817             }
1818           else
1819             section_begin += length + 4;
1820
1821           /* Negative values are illegal, they may even cause infinite
1822              looping.  This can happen if we can't accurately apply
1823              relocations to an object file.  */
1824           if ((signed long) length <= 0)
1825             {
1826               warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1827               return 0;
1828             }
1829         }
1830
1831       if (num_units == 0)
1832         {
1833           error (_("No comp units in %s section ?"), section->name);
1834           return 0;
1835         }
1836
1837       /* Then allocate an array to hold the information.  */
1838       debug_information = cmalloc (num_units,
1839                                    sizeof (* debug_information));
1840       if (debug_information == NULL)
1841         {
1842           error (_("Not enough memory for a debug info array of %u entries"),
1843                  num_units);
1844           return 0;
1845         }
1846     }
1847
1848   if (!do_loc)
1849     {
1850       printf (_("Contents of the %s section:\n\n"), section->name);
1851
1852       load_debug_section (str, file);
1853     }
1854
1855   load_debug_section (abbrev, file);
1856   if (debug_displays [abbrev].section.start == NULL)
1857     {
1858       warn (_("Unable to locate %s section!\n"),
1859             debug_displays [abbrev].section.name);
1860       return 0;
1861     }
1862
1863   for (section_begin = start, unit = 0; start < end; unit++)
1864     {
1865       DWARF2_Internal_CompUnit compunit;
1866       unsigned char *hdrptr;
1867       unsigned char *cu_abbrev_offset_ptr;
1868       unsigned char *tags;
1869       int level;
1870       unsigned long cu_offset;
1871       int offset_size;
1872       int initial_length_size;
1873
1874       hdrptr = start;
1875
1876       compunit.cu_length = byte_get (hdrptr, 4);
1877       hdrptr += 4;
1878
1879       if (compunit.cu_length == 0xffffffff)
1880         {
1881           compunit.cu_length = byte_get (hdrptr, 8);
1882           hdrptr += 8;
1883           offset_size = 8;
1884           initial_length_size = 12;
1885         }
1886       else
1887         {
1888           offset_size = 4;
1889           initial_length_size = 4;
1890         }
1891
1892       compunit.cu_version = byte_get (hdrptr, 2);
1893       hdrptr += 2;
1894
1895       cu_offset = start - section_begin;
1896
1897       cu_abbrev_offset_ptr = hdrptr;
1898       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1899       hdrptr += offset_size;
1900
1901       compunit.cu_pointer_size = byte_get (hdrptr, 1);
1902       hdrptr += 1;
1903       if ((do_loc || do_debug_loc || do_debug_ranges)
1904           && num_debug_info_entries == 0)
1905         {
1906           debug_information [unit].cu_offset = cu_offset;
1907           debug_information [unit].pointer_size
1908             = compunit.cu_pointer_size;
1909           debug_information [unit].base_address = 0;
1910           debug_information [unit].loc_offsets = NULL;
1911           debug_information [unit].have_frame_base = NULL;
1912           debug_information [unit].max_loc_offsets = 0;
1913           debug_information [unit].num_loc_offsets = 0;
1914           debug_information [unit].range_lists = NULL;
1915           debug_information [unit].max_range_lists= 0;
1916           debug_information [unit].num_range_lists = 0;
1917         }
1918
1919       if (!do_loc)
1920         {
1921           printf (_("  Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1922           printf (_("   Length:        0x%lx (%s)\n"), compunit.cu_length,
1923                   initial_length_size == 8 ? "64-bit" : "32-bit");
1924           printf (_("   Version:       %d\n"), compunit.cu_version);
1925           printf (_("   Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1926           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
1927         }
1928
1929       if (cu_offset + compunit.cu_length + initial_length_size
1930           > section->size)
1931         {
1932           warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1933                 cu_offset, compunit.cu_length);
1934           break;
1935         }
1936       tags = hdrptr;
1937       start += compunit.cu_length + initial_length_size;
1938
1939       if (compunit.cu_version != 2 && compunit.cu_version != 3)
1940         {
1941           warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1942                 cu_offset, compunit.cu_version);
1943           continue;
1944         }
1945
1946       free_abbrevs ();
1947
1948       /* Process the abbrevs used by this compilation unit. DWARF
1949          sections under Mach-O have non-zero addresses.  */
1950       if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1951         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1952               (unsigned long) compunit.cu_abbrev_offset,
1953               (unsigned long) debug_displays [abbrev].section.size);
1954       else
1955         process_abbrev_section
1956           ((unsigned char *) debug_displays [abbrev].section.start
1957            + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1958            (unsigned char *) debug_displays [abbrev].section.start
1959            + debug_displays [abbrev].section.size);
1960
1961       level = 0;
1962       while (tags < start)
1963         {
1964           unsigned int bytes_read;
1965           unsigned long abbrev_number;
1966           unsigned long die_offset;
1967           abbrev_entry *entry;
1968           abbrev_attr *attr;
1969
1970           die_offset = tags - section_begin;
1971
1972           abbrev_number = read_leb128 (tags, & bytes_read, 0);
1973           tags += bytes_read;
1974
1975           /* A null DIE marks the end of a list of siblings.  */
1976           if (abbrev_number == 0)
1977             {
1978               --level;
1979               if (level < 0)
1980                 {
1981                   static unsigned num_bogus_warns = 0;
1982
1983                   if (num_bogus_warns < 3)
1984                     {
1985                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1986                             die_offset);
1987                       num_bogus_warns ++;
1988                       if (num_bogus_warns == 3)
1989                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1990                     }
1991                 }
1992               continue;
1993             }
1994
1995           if (!do_loc)
1996             printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1997                     level, die_offset, abbrev_number);
1998
1999           /* Scan through the abbreviation list until we reach the
2000              correct entry.  */
2001           for (entry = first_abbrev;
2002                entry && entry->entry != abbrev_number;
2003                entry = entry->next)
2004             continue;
2005
2006           if (entry == NULL)
2007             {
2008               if (!do_loc)
2009                 {
2010                   printf ("\n");
2011                   fflush (stdout);
2012                 }
2013               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2014                     die_offset, abbrev_number);
2015               return 0;
2016             }
2017
2018           if (!do_loc)
2019             printf (_(" (%s)\n"), get_TAG_name (entry->tag));
2020
2021           switch (entry->tag)
2022             {
2023             default:
2024               need_base_address = 0;
2025               break;
2026             case DW_TAG_compile_unit:
2027               need_base_address = 1;
2028               break;
2029             case DW_TAG_entry_point:
2030             case DW_TAG_subprogram:
2031               need_base_address = 0;
2032               /* Assuming that there is no DW_AT_frame_base.  */
2033               have_frame_base = 0;
2034               break;
2035             }
2036
2037           for (attr = entry->first_attr; attr; attr = attr->next)
2038             {
2039               if (! do_loc)
2040                 /* Show the offset from where the tag was extracted.  */
2041                 printf ("    <%2lx>", (unsigned long)(tags - section_begin));
2042
2043               tags = read_and_display_attr (attr->attribute,
2044                                             attr->form,
2045                                             tags, cu_offset,
2046                                             compunit.cu_pointer_size,
2047                                             offset_size,
2048                                             compunit.cu_version,
2049                                             debug_information + unit,
2050                                             do_loc, section);
2051             }
2052
2053           if (entry->children)
2054             ++level;
2055         }
2056     }
2057
2058   /* Set num_debug_info_entries here so that it can be used to check if
2059      we need to process .debug_loc and .debug_ranges sections.  */
2060   if ((do_loc || do_debug_loc || do_debug_ranges)
2061       && num_debug_info_entries == 0)
2062     num_debug_info_entries = num_units;
2063
2064   if (!do_loc)
2065     {
2066       printf ("\n");
2067     }
2068
2069   return 1;
2070 }
2071
2072 /* Locate and scan the .debug_info section in the file and record the pointer
2073    sizes and offsets for the compilation units in it.  Usually an executable
2074    will have just one pointer size, but this is not guaranteed, and so we try
2075    not to make any assumptions.  Returns zero upon failure, or the number of
2076    compilation units upon success.  */
2077
2078 static unsigned int
2079 load_debug_info (void * file)
2080 {
2081   /* Reset the last pointer size so that we can issue correct error
2082      messages if we are displaying the contents of more than one section.  */
2083   last_pointer_size = 0;
2084   warned_about_missing_comp_units = FALSE;
2085
2086   /* If we have already tried and failed to load the .debug_info
2087      section then do not bother to repear the task.  */
2088   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2089     return 0;
2090
2091   /* If we already have the information there is nothing else to do.  */
2092   if (num_debug_info_entries > 0)
2093     return num_debug_info_entries;
2094
2095   if (load_debug_section (info, file)
2096       && process_debug_info (&debug_displays [info].section, file, 1))
2097     return num_debug_info_entries;
2098
2099   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2100   return 0;
2101 }
2102
2103 static int
2104 display_debug_lines_raw (struct dwarf_section *section,
2105                          unsigned char *data,
2106                          unsigned char *end)
2107 {
2108   unsigned char *start = section->start;
2109
2110   printf (_("Raw dump of debug contents of section %s:\n\n"),
2111           section->name);
2112
2113   while (data < end)
2114     {
2115       DWARF2_Internal_LineInfo info;
2116       unsigned char *standard_opcodes;
2117       unsigned char *end_of_sequence;
2118       unsigned char *hdrptr;
2119       unsigned long hdroff;
2120       int initial_length_size;
2121       int offset_size;
2122       int i;
2123
2124       hdrptr = data;
2125       hdroff = hdrptr - start;
2126
2127       /* Check the length of the block.  */
2128       info.li_length = byte_get (hdrptr, 4);
2129       hdrptr += 4;
2130
2131       if (info.li_length == 0xffffffff)
2132         {
2133           /* This section is 64-bit DWARF 3.  */
2134           info.li_length = byte_get (hdrptr, 8);
2135           hdrptr += 8;
2136           offset_size = 8;
2137           initial_length_size = 12;
2138         }
2139       else
2140         {
2141           offset_size = 4;
2142           initial_length_size = 4;
2143         }
2144
2145       if (info.li_length + initial_length_size > section->size)
2146         {
2147           warn
2148             (_("The line info appears to be corrupt - the section is too small\n"));
2149           return 0;
2150         }
2151
2152       /* Check its version number.  */
2153       info.li_version = byte_get (hdrptr, 2);
2154       hdrptr += 2;
2155       if (info.li_version != 2 && info.li_version != 3)
2156         {
2157           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2158           return 0;
2159         }
2160
2161       info.li_prologue_length = byte_get (hdrptr, offset_size);
2162       hdrptr += offset_size;
2163       info.li_min_insn_length = byte_get (hdrptr, 1);
2164       hdrptr++;
2165       info.li_default_is_stmt = byte_get (hdrptr, 1);
2166       hdrptr++;
2167       info.li_line_base = byte_get (hdrptr, 1);
2168       hdrptr++;
2169       info.li_line_range = byte_get (hdrptr, 1);
2170       hdrptr++;
2171       info.li_opcode_base = byte_get (hdrptr, 1);
2172       hdrptr++;
2173
2174       /* Sign extend the line base field.  */
2175       info.li_line_base <<= 24;
2176       info.li_line_base >>= 24;
2177
2178       printf (_("  Offset:                      0x%lx\n"), hdroff);
2179       printf (_("  Length:                      %ld\n"), info.li_length);
2180       printf (_("  DWARF Version:               %d\n"), info.li_version);
2181       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
2182       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
2183       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
2184       printf (_("  Line Base:                   %d\n"), info.li_line_base);
2185       printf (_("  Line Range:                  %d\n"), info.li_line_range);
2186       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
2187
2188       end_of_sequence = data + info.li_length + initial_length_size;
2189
2190       reset_state_machine (info.li_default_is_stmt);
2191
2192       /* Display the contents of the Opcodes table.  */
2193       standard_opcodes = hdrptr;
2194
2195       printf (_("\n Opcodes:\n"));
2196
2197       for (i = 1; i < info.li_opcode_base; i++)
2198         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2199
2200       /* Display the contents of the Directory table.  */
2201       data = standard_opcodes + info.li_opcode_base - 1;
2202
2203       if (*data == 0)
2204         printf (_("\n The Directory Table is empty.\n"));
2205       else
2206         {
2207           printf (_("\n The Directory Table:\n"));
2208
2209           while (*data != 0)
2210             {
2211               printf (_("  %s\n"), data);
2212
2213               data += strlen ((char *) data) + 1;
2214             }
2215         }
2216
2217       /* Skip the NUL at the end of the table.  */
2218       data++;
2219
2220       /* Display the contents of the File Name table.  */
2221       if (*data == 0)
2222         printf (_("\n The File Name Table is empty.\n"));
2223       else
2224         {
2225           printf (_("\n The File Name Table:\n"));
2226           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2227
2228           while (*data != 0)
2229             {
2230               unsigned char *name;
2231               unsigned int bytes_read;
2232
2233               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
2234               name = data;
2235
2236               data += strlen ((char *) data) + 1;
2237
2238               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2239               data += bytes_read;
2240               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2241               data += bytes_read;
2242               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2243               data += bytes_read;
2244               printf (_("%s\n"), name);
2245             }
2246         }
2247
2248       /* Skip the NUL at the end of the table.  */
2249       data++;
2250
2251       /* Now display the statements.  */
2252       printf (_("\n Line Number Statements:\n"));
2253
2254       while (data < end_of_sequence)
2255         {
2256           unsigned char op_code;
2257           int adv;
2258           unsigned long int uladv;
2259           unsigned int bytes_read;
2260
2261           op_code = *data++;
2262
2263           if (op_code >= info.li_opcode_base)
2264             {
2265               op_code -= info.li_opcode_base;
2266               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2267               state_machine_regs.address += uladv;
2268               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
2269                       op_code, uladv, state_machine_regs.address);
2270               adv = (op_code % info.li_line_range) + info.li_line_base;
2271               state_machine_regs.line += adv;
2272               printf (_(" and Line by %d to %d\n"),
2273                       adv, state_machine_regs.line);
2274             }
2275           else switch (op_code)
2276             {
2277             case DW_LNS_extended_op:
2278               data += process_extended_line_op (data, info.li_default_is_stmt);
2279               break;
2280
2281             case DW_LNS_copy:
2282               printf (_("  Copy\n"));
2283               break;
2284
2285             case DW_LNS_advance_pc:
2286               uladv = read_leb128 (data, & bytes_read, 0);
2287               uladv *= info.li_min_insn_length;
2288               data += bytes_read;
2289               state_machine_regs.address += uladv;
2290               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2291                       state_machine_regs.address);
2292               break;
2293
2294             case DW_LNS_advance_line:
2295               adv = read_leb128 (data, & bytes_read, 1);
2296               data += bytes_read;
2297               state_machine_regs.line += adv;
2298               printf (_("  Advance Line by %d to %d\n"), adv,
2299                       state_machine_regs.line);
2300               break;
2301
2302             case DW_LNS_set_file:
2303               adv = read_leb128 (data, & bytes_read, 0);
2304               data += bytes_read;
2305               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2306                       adv);
2307               state_machine_regs.file = adv;
2308               break;
2309
2310             case DW_LNS_set_column:
2311               uladv = read_leb128 (data, & bytes_read, 0);
2312               data += bytes_read;
2313               printf (_("  Set column to %lu\n"), uladv);
2314               state_machine_regs.column = uladv;
2315               break;
2316
2317             case DW_LNS_negate_stmt:
2318               adv = state_machine_regs.is_stmt;
2319               adv = ! adv;
2320               printf (_("  Set is_stmt to %d\n"), adv);
2321               state_machine_regs.is_stmt = adv;
2322               break;
2323
2324             case DW_LNS_set_basic_block:
2325               printf (_("  Set basic block\n"));
2326               state_machine_regs.basic_block = 1;
2327               break;
2328
2329             case DW_LNS_const_add_pc:
2330               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2331                       * info.li_min_insn_length);
2332               state_machine_regs.address += uladv;
2333               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2334                       state_machine_regs.address);
2335               break;
2336
2337             case DW_LNS_fixed_advance_pc:
2338               uladv = byte_get (data, 2);
2339               data += 2;
2340               state_machine_regs.address += uladv;
2341               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2342                       uladv, state_machine_regs.address);
2343               break;
2344
2345             case DW_LNS_set_prologue_end:
2346               printf (_("  Set prologue_end to true\n"));
2347               break;
2348
2349             case DW_LNS_set_epilogue_begin:
2350               printf (_("  Set epilogue_begin to true\n"));
2351               break;
2352
2353             case DW_LNS_set_isa:
2354               uladv = read_leb128 (data, & bytes_read, 0);
2355               data += bytes_read;
2356               printf (_("  Set ISA to %lu\n"), uladv);
2357               break;
2358
2359             default:
2360               printf (_("  Unknown opcode %d with operands: "), op_code);
2361
2362               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2363                 {
2364                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2365                           i == 1 ? "" : ", ");
2366                   data += bytes_read;
2367                 }
2368               putchar ('\n');
2369               break;
2370             }
2371         }
2372       putchar ('\n');
2373     }
2374
2375   return 1;
2376 }
2377
2378 typedef struct
2379 {
2380     unsigned char *name;
2381     unsigned int directory_index;
2382     unsigned int modification_date;
2383     unsigned int length;
2384 } File_Entry;
2385
2386 /* Output a decoded representation of the .debug_line section.  */
2387
2388 static int
2389 display_debug_lines_decoded (struct dwarf_section *section,
2390                              unsigned char *data,
2391                              unsigned char *end)
2392 {
2393   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2394           section->name);
2395
2396   while (data < end)
2397     {
2398       /* This loop amounts to one iteration per compilation unit.  */
2399       DWARF2_Internal_LineInfo info;
2400       unsigned char *standard_opcodes;
2401       unsigned char *end_of_sequence;
2402       unsigned char *hdrptr;
2403       int initial_length_size;
2404       int offset_size;
2405       int i;
2406       File_Entry *file_table = NULL;
2407       unsigned char **directory_table = NULL;
2408       unsigned int prev_line = 0;
2409
2410       hdrptr = data;
2411
2412       /* Extract information from the Line Number Program Header.
2413         (section 6.2.4 in the Dwarf3 doc).  */
2414
2415       /* Get the length of this CU's line number information block.  */
2416       info.li_length = byte_get (hdrptr, 4);
2417       hdrptr += 4;
2418
2419       if (info.li_length == 0xffffffff)
2420         {
2421           /* This section is 64-bit DWARF 3.  */
2422           info.li_length = byte_get (hdrptr, 8);
2423           hdrptr += 8;
2424           offset_size = 8;
2425           initial_length_size = 12;
2426         }
2427       else
2428         {
2429           offset_size = 4;
2430           initial_length_size = 4;
2431         }
2432
2433       if (info.li_length + initial_length_size > section->size)
2434         {
2435           warn (_("The line info appears to be corrupt - "
2436                   "the section is too small\n"));
2437           return 0;
2438         }
2439
2440       /* Get this CU's Line Number Block version number.  */
2441       info.li_version = byte_get (hdrptr, 2);
2442       hdrptr += 2;
2443       if (info.li_version != 2 && info.li_version != 3)
2444         {
2445           warn (_("Only DWARF version 2 and 3 line info is currently "
2446                 "supported.\n"));
2447           return 0;
2448         }
2449
2450       info.li_prologue_length = byte_get (hdrptr, offset_size);
2451       hdrptr += offset_size;
2452       info.li_min_insn_length = byte_get (hdrptr, 1);
2453       hdrptr++;
2454       info.li_default_is_stmt = byte_get (hdrptr, 1);
2455       hdrptr++;
2456       info.li_line_base = byte_get (hdrptr, 1);
2457       hdrptr++;
2458       info.li_line_range = byte_get (hdrptr, 1);
2459       hdrptr++;
2460       info.li_opcode_base = byte_get (hdrptr, 1);
2461       hdrptr++;
2462
2463       /* Sign extend the line base field.  */
2464       info.li_line_base <<= 24;
2465       info.li_line_base >>= 24;
2466
2467       /* Find the end of this CU's Line Number Information Block.  */
2468       end_of_sequence = data + info.li_length + initial_length_size;
2469
2470       reset_state_machine (info.li_default_is_stmt);
2471
2472       /* Save a pointer to the contents of the Opcodes table.  */
2473       standard_opcodes = hdrptr;
2474
2475       /* Traverse the Directory table just to count entries.  */
2476       data = standard_opcodes + info.li_opcode_base - 1;
2477       if (*data != 0)
2478         {
2479           unsigned int n_directories = 0;
2480           unsigned char *ptr_directory_table = data;
2481           int i;
2482
2483           while (*data != 0)
2484             {
2485               data += strlen ((char *) data) + 1;
2486               n_directories++;
2487             }
2488
2489           /* Go through the directory table again to save the directories.  */
2490           directory_table = xmalloc (n_directories * sizeof (unsigned char *));
2491
2492           i = 0;
2493           while (*ptr_directory_table != 0)
2494             {
2495               directory_table[i] = ptr_directory_table;
2496               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2497               i++;
2498             }
2499         }
2500       /* Skip the NUL at the end of the table.  */
2501       data++;
2502
2503       /* Traverse the File Name table just to count the entries.  */
2504       if (*data != 0)
2505         {
2506           unsigned int n_files = 0;
2507           unsigned char *ptr_file_name_table = data;
2508           int i;
2509
2510           while (*data != 0)
2511             {
2512               unsigned int bytes_read;
2513
2514               /* Skip Name, directory index, last modification time and length
2515                  of file.  */
2516               data += strlen ((char *) data) + 1;
2517               read_leb128 (data, & bytes_read, 0);
2518               data += bytes_read;
2519               read_leb128 (data, & bytes_read, 0);
2520               data += bytes_read;
2521               read_leb128 (data, & bytes_read, 0);
2522               data += bytes_read;
2523
2524               n_files++;
2525             }
2526
2527           /* Go through the file table again to save the strings.  */
2528           file_table = xmalloc (n_files * sizeof (File_Entry));
2529
2530           i = 0;
2531           while (*ptr_file_name_table != 0)
2532             {
2533               unsigned int bytes_read;
2534
2535               file_table[i].name = ptr_file_name_table;
2536               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2537
2538               /* We are not interested in directory, time or size.  */
2539               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2540                                                            & bytes_read, 0);
2541               ptr_file_name_table += bytes_read;
2542               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2543                                                              & bytes_read, 0);
2544               ptr_file_name_table += bytes_read;
2545               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2546               ptr_file_name_table += bytes_read;
2547               i++;
2548             }
2549           i = 0;
2550
2551           /* Print the Compilation Unit's name and a header.  */
2552           if (directory_table == NULL)
2553             {
2554               printf (_("CU: %s:\n"), file_table[0].name);
2555               printf (_("File name                            Line number    Starting address\n"));
2556             }
2557           else
2558             {
2559               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2560                 {
2561                   printf (_("CU: %s/%s:\n"), directory_table[0],
2562                           file_table[0].name);
2563                 }
2564               else
2565                 {
2566                   printf (_("%s:\n"), file_table[0].name);
2567                 }
2568               printf (_("File name                            Line number    Starting address\n"));
2569             }
2570         }
2571
2572       /* Skip the NUL at the end of the table.  */
2573       data++;
2574
2575       /* This loop iterates through the Dwarf Line Number Program.  */
2576       while (data < end_of_sequence)
2577         {
2578           unsigned char op_code;
2579           int adv;
2580           unsigned long int uladv;
2581           unsigned int bytes_read;
2582           int is_special_opcode = 0;
2583
2584           op_code = *data++;
2585           prev_line = state_machine_regs.line;
2586
2587           if (op_code >= info.li_opcode_base)
2588             {
2589               op_code -= info.li_opcode_base;
2590               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2591               state_machine_regs.address += uladv;
2592
2593               adv = (op_code % info.li_line_range) + info.li_line_base;
2594               state_machine_regs.line += adv;
2595               is_special_opcode = 1;
2596             }
2597           else switch (op_code)
2598             {
2599             case DW_LNS_extended_op:
2600               {
2601                 unsigned int ext_op_code_len;
2602                 unsigned int bytes_read;
2603                 unsigned char ext_op_code;
2604                 unsigned char *op_code_data = data;
2605
2606                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
2607                 op_code_data += bytes_read;
2608
2609                 if (ext_op_code_len == 0)
2610                   {
2611                     warn (_("badly formed extended line op encountered!\n"));
2612                     break;
2613                   }
2614                 ext_op_code_len += bytes_read;
2615                 ext_op_code = *op_code_data++;
2616
2617                 switch (ext_op_code)
2618                   {
2619                   case DW_LNE_end_sequence:
2620                     reset_state_machine (info.li_default_is_stmt);
2621                     break;
2622                   case DW_LNE_set_address:
2623                     state_machine_regs.address =
2624                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
2625                     break;
2626                   case DW_LNE_define_file:
2627                     {
2628                       unsigned int dir_index = 0;
2629
2630                       ++state_machine_regs.last_file_entry;
2631                       op_code_data += strlen ((char *) op_code_data) + 1;
2632                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
2633                       op_code_data += bytes_read;
2634                       read_leb128 (op_code_data, & bytes_read, 0);
2635                       op_code_data += bytes_read;
2636                       read_leb128 (op_code_data, & bytes_read, 0);
2637
2638                       printf (_("%s:\n"), directory_table[dir_index]);
2639                       break;
2640                     }
2641                   default:
2642                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
2643                     break;
2644                   }
2645                 data += ext_op_code_len;
2646                 break;
2647               }
2648             case DW_LNS_copy:
2649               break;
2650
2651             case DW_LNS_advance_pc:
2652               uladv = read_leb128 (data, & bytes_read, 0);
2653               uladv *= info.li_min_insn_length;
2654               data += bytes_read;
2655               state_machine_regs.address += uladv;
2656               break;
2657
2658             case DW_LNS_advance_line:
2659               adv = read_leb128 (data, & bytes_read, 1);
2660               data += bytes_read;
2661               state_machine_regs.line += adv;
2662               break;
2663
2664             case DW_LNS_set_file:
2665               adv = read_leb128 (data, & bytes_read, 0);
2666               data += bytes_read;
2667               state_machine_regs.file = adv;
2668               if (file_table[state_machine_regs.file - 1].directory_index == 0)
2669                 {
2670                   /* If directory index is 0, that means current directory.  */
2671                   printf (_("\n./%s:[++]\n"),
2672                           file_table[state_machine_regs.file - 1].name);
2673                 }
2674               else
2675                 {
2676                   /* The directory index starts counting at 1.  */
2677                   printf (_("\n%s/%s:\n"),
2678                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
2679                           file_table[state_machine_regs.file - 1].name);
2680                 }
2681               break;
2682
2683             case DW_LNS_set_column:
2684               uladv = read_leb128 (data, & bytes_read, 0);
2685               data += bytes_read;
2686               state_machine_regs.column = uladv;
2687               break;
2688
2689             case DW_LNS_negate_stmt:
2690               adv = state_machine_regs.is_stmt;
2691               adv = ! adv;
2692               state_machine_regs.is_stmt = adv;
2693               break;
2694
2695             case DW_LNS_set_basic_block:
2696               state_machine_regs.basic_block = 1;
2697               break;
2698
2699             case DW_LNS_const_add_pc:
2700               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2701                        * info.li_min_insn_length);
2702               state_machine_regs.address += uladv;
2703               break;
2704
2705             case DW_LNS_fixed_advance_pc:
2706               uladv = byte_get (data, 2);
2707               data += 2;
2708               state_machine_regs.address += uladv;
2709               break;
2710
2711             case DW_LNS_set_prologue_end:
2712               break;
2713
2714             case DW_LNS_set_epilogue_begin:
2715               break;
2716
2717             case DW_LNS_set_isa:
2718               uladv = read_leb128 (data, & bytes_read, 0);
2719               data += bytes_read;
2720               printf (_("  Set ISA to %lu\n"), uladv);
2721               break;
2722
2723             default:
2724               printf (_("  Unknown opcode %d with operands: "), op_code);
2725
2726               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2727                 {
2728                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2729                           i == 1 ? "" : ", ");
2730                   data += bytes_read;
2731                 }
2732               putchar ('\n');
2733               break;
2734             }
2735
2736           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2737              to the DWARF address/line matrix.  */
2738           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
2739               || (op_code == DW_LNS_copy))
2740             {
2741               const unsigned int MAX_FILENAME_LENGTH = 35;
2742               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
2743               char *newFileName = NULL;
2744               size_t fileNameLength = strlen (fileName);
2745
2746               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
2747                 {
2748                   newFileName = xmalloc (MAX_FILENAME_LENGTH + 1);
2749                   /* Truncate file name */
2750                   strncpy (newFileName,
2751                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
2752                            MAX_FILENAME_LENGTH + 1);
2753                 }
2754               else
2755                 {
2756                   newFileName = xmalloc (fileNameLength + 1);
2757                   strncpy (newFileName, fileName, fileNameLength + 1);
2758                 }
2759
2760               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
2761                 {
2762                   printf (_("%-35s  %11d  %#18lx\n"), newFileName,
2763                           state_machine_regs.line, state_machine_regs.address);
2764                 }
2765               else
2766                 {
2767                   printf (_("%s  %11d  %#18lx\n"), newFileName,
2768                           state_machine_regs.line, state_machine_regs.address);
2769                 }
2770
2771               if (op_code == DW_LNE_end_sequence)
2772                 printf ("\n");
2773
2774               free (newFileName);
2775             }
2776         }
2777       free (file_table);
2778       file_table = NULL;
2779       free (directory_table);
2780       directory_table = NULL;
2781       putchar ('\n');
2782     }
2783
2784   return 1;
2785 }
2786
2787 static int
2788 display_debug_lines (struct dwarf_section *section, void *file)
2789 {
2790   unsigned char *data = section->start;
2791   unsigned char *end = data + section->size;
2792   int retValRaw = 1;
2793   int retValDecoded = 1;
2794
2795   if (load_debug_info (file) == 0)
2796     {
2797       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2798             section->name);
2799       return 0;
2800     }
2801
2802   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
2803     retValRaw = display_debug_lines_raw (section, data, end);
2804
2805   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
2806     retValDecoded = display_debug_lines_decoded (section, data, end);
2807
2808   if (!retValRaw || !retValDecoded)
2809     return 0;
2810
2811   return 1;
2812 }
2813
2814 static debug_info *
2815 find_debug_info_for_offset (unsigned long offset)
2816 {
2817   unsigned int i;
2818
2819   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2820     return NULL;
2821
2822   for (i = 0; i < num_debug_info_entries; i++)
2823     if (debug_information[i].cu_offset == offset)
2824       return debug_information + i;
2825
2826   return NULL;
2827 }
2828
2829 static int
2830 display_debug_pubnames (struct dwarf_section *section,
2831                         void *file ATTRIBUTE_UNUSED)
2832 {
2833   DWARF2_Internal_PubNames pubnames;
2834   unsigned char *start = section->start;
2835   unsigned char *end = start + section->size;
2836
2837   /* It does not matter if this load fails,
2838      we test for that later on.  */
2839   load_debug_info (file);
2840
2841   printf (_("Contents of the %s section:\n\n"), section->name);
2842
2843   while (start < end)
2844     {
2845       unsigned char *data;
2846       unsigned long offset;
2847       int offset_size, initial_length_size;
2848
2849       data = start;
2850
2851       pubnames.pn_length = byte_get (data, 4);
2852       data += 4;
2853       if (pubnames.pn_length == 0xffffffff)
2854         {
2855           pubnames.pn_length = byte_get (data, 8);
2856           data += 8;
2857           offset_size = 8;
2858           initial_length_size = 12;
2859         }
2860       else
2861         {
2862           offset_size = 4;
2863           initial_length_size = 4;
2864         }
2865
2866       pubnames.pn_version = byte_get (data, 2);
2867       data += 2;
2868
2869       pubnames.pn_offset = byte_get (data, offset_size);
2870       data += offset_size;
2871
2872       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2873           && num_debug_info_entries > 0
2874           && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2875         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2876               pubnames.pn_offset, section->name);
2877
2878       pubnames.pn_size = byte_get (data, offset_size);
2879       data += offset_size;
2880
2881       start += pubnames.pn_length + initial_length_size;
2882
2883       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2884         {
2885           static int warned = 0;
2886
2887           if (! warned)
2888             {
2889               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2890               warned = 1;
2891             }
2892
2893           continue;
2894         }
2895
2896       printf (_("  Length:                              %ld\n"),
2897               pubnames.pn_length);
2898       printf (_("  Version:                             %d\n"),
2899               pubnames.pn_version);
2900       printf (_("  Offset into .debug_info section:     0x%lx\n"),
2901               pubnames.pn_offset);
2902       printf (_("  Size of area in .debug_info section: %ld\n"),
2903               pubnames.pn_size);
2904
2905       printf (_("\n    Offset\tName\n"));
2906
2907       do
2908         {
2909           offset = byte_get (data, offset_size);
2910
2911           if (offset != 0)
2912             {
2913               data += offset_size;
2914               printf ("    %-6lx\t%s\n", offset, data);
2915               data += strlen ((char *) data) + 1;
2916             }
2917         }
2918       while (offset != 0);
2919     }
2920
2921   printf ("\n");
2922   return 1;
2923 }
2924
2925 static int
2926 display_debug_macinfo (struct dwarf_section *section,
2927                        void *file ATTRIBUTE_UNUSED)
2928 {
2929   unsigned char *start = section->start;
2930   unsigned char *end = start + section->size;
2931   unsigned char *curr = start;
2932   unsigned int bytes_read;
2933   enum dwarf_macinfo_record_type op;
2934
2935   printf (_("Contents of the %s section:\n\n"), section->name);
2936
2937   while (curr < end)
2938     {
2939       unsigned int lineno;
2940       const char *string;
2941
2942       op = *curr;
2943       curr++;
2944
2945       switch (op)
2946         {
2947         case DW_MACINFO_start_file:
2948           {
2949             unsigned int filenum;
2950
2951             lineno = read_leb128 (curr, & bytes_read, 0);
2952             curr += bytes_read;
2953             filenum = read_leb128 (curr, & bytes_read, 0);
2954             curr += bytes_read;
2955
2956             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2957                     lineno, filenum);
2958           }
2959           break;
2960
2961         case DW_MACINFO_end_file:
2962           printf (_(" DW_MACINFO_end_file\n"));
2963           break;
2964
2965         case DW_MACINFO_define:
2966           lineno = read_leb128 (curr, & bytes_read, 0);
2967           curr += bytes_read;
2968           string = (char *) curr;
2969           curr += strlen (string) + 1;
2970           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2971                   lineno, string);
2972           break;
2973
2974         case DW_MACINFO_undef:
2975           lineno = read_leb128 (curr, & bytes_read, 0);
2976           curr += bytes_read;
2977           string = (char *) curr;
2978           curr += strlen (string) + 1;
2979           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2980                   lineno, string);
2981           break;
2982
2983         case DW_MACINFO_vendor_ext:
2984           {
2985             unsigned int constant;
2986
2987             constant = read_leb128 (curr, & bytes_read, 0);
2988             curr += bytes_read;
2989             string = (char *) curr;
2990             curr += strlen (string) + 1;
2991             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2992                     constant, string);
2993           }
2994           break;
2995         }
2996     }
2997
2998   return 1;
2999 }
3000
3001 static int
3002 display_debug_abbrev (struct dwarf_section *section,
3003                       void *file ATTRIBUTE_UNUSED)
3004 {
3005   abbrev_entry *entry;
3006   unsigned char *start = section->start;
3007   unsigned char *end = start + section->size;
3008
3009   printf (_("Contents of the %s section:\n\n"), section->name);
3010
3011   do
3012     {
3013       free_abbrevs ();
3014
3015       start = process_abbrev_section (start, end);
3016
3017       if (first_abbrev == NULL)
3018         continue;
3019
3020       printf (_("  Number TAG\n"));
3021
3022       for (entry = first_abbrev; entry; entry = entry->next)
3023         {
3024           abbrev_attr *attr;
3025
3026           printf (_("   %ld      %s    [%s]\n"),
3027                   entry->entry,
3028                   get_TAG_name (entry->tag),
3029                   entry->children ? _("has children") : _("no children"));
3030
3031           for (attr = entry->first_attr; attr; attr = attr->next)
3032             printf (_("    %-18s %s\n"),
3033                     get_AT_name (attr->attribute),
3034                     get_FORM_name (attr->form));
3035         }
3036     }
3037   while (start);
3038
3039   printf ("\n");
3040
3041   return 1;
3042 }
3043
3044 static int
3045 display_debug_loc (struct dwarf_section *section, void *file)
3046 {
3047   unsigned char *start = section->start;
3048   unsigned char *section_end;
3049   unsigned long bytes;
3050   unsigned char *section_begin = start;
3051   unsigned int num_loc_list = 0;
3052   unsigned long last_offset = 0;
3053   unsigned int first = 0;
3054   unsigned int i;
3055   unsigned int j;
3056   int seen_first_offset = 0;
3057   int use_debug_info = 1;
3058   unsigned char *next;
3059
3060   bytes = section->size;
3061   section_end = start + bytes;
3062
3063   if (bytes == 0)
3064     {
3065       printf (_("\nThe %s section is empty.\n"), section->name);
3066       return 0;
3067     }
3068
3069   if (load_debug_info (file) == 0)
3070     {
3071       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3072             section->name);
3073       return 0;
3074     }
3075
3076   /* Check the order of location list in .debug_info section. If
3077      offsets of location lists are in the ascending order, we can
3078      use `debug_information' directly.  */
3079   for (i = 0; i < num_debug_info_entries; i++)
3080     {
3081       unsigned int num;
3082
3083       num = debug_information [i].num_loc_offsets;
3084       num_loc_list += num;
3085
3086       /* Check if we can use `debug_information' directly.  */
3087       if (use_debug_info && num != 0)
3088         {
3089           if (!seen_first_offset)
3090             {
3091               /* This is the first location list.  */
3092               last_offset = debug_information [i].loc_offsets [0];
3093               first = i;
3094               seen_first_offset = 1;
3095               j = 1;
3096             }
3097           else
3098             j = 0;
3099
3100           for (; j < num; j++)
3101             {
3102               if (last_offset >
3103                   debug_information [i].loc_offsets [j])
3104                 {
3105                   use_debug_info = 0;
3106                   break;
3107                 }
3108               last_offset = debug_information [i].loc_offsets [j];
3109             }
3110         }
3111     }
3112
3113   if (!use_debug_info)
3114     /* FIXME: Should we handle this case?  */
3115     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3116
3117   if (!seen_first_offset)
3118     error (_("No location lists in .debug_info section!\n"));
3119
3120   /* DWARF sections under Mach-O have non-zero addresses.  */
3121   if (debug_information [first].num_loc_offsets > 0
3122       && debug_information [first].loc_offsets [0] != section->address)
3123     warn (_("Location lists in %s section start at 0x%lx\n"),
3124           section->name, debug_information [first].loc_offsets [0]);
3125
3126   printf (_("Contents of the %s section:\n\n"), section->name);
3127   printf (_("    Offset   Begin    End      Expression\n"));
3128
3129   seen_first_offset = 0;
3130   for (i = first; i < num_debug_info_entries; i++)
3131     {
3132       dwarf_vma begin;
3133       dwarf_vma end;
3134       unsigned short length;
3135       unsigned long offset;
3136       unsigned int pointer_size;
3137       unsigned long cu_offset;
3138       unsigned long base_address;
3139       int need_frame_base;
3140       int has_frame_base;
3141
3142       pointer_size = debug_information [i].pointer_size;
3143       cu_offset = debug_information [i].cu_offset;
3144
3145       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3146         {
3147           has_frame_base = debug_information [i].have_frame_base [j];
3148           /* DWARF sections under Mach-O have non-zero addresses.  */
3149           offset = debug_information [i].loc_offsets [j] - section->address;
3150           next = section_begin + offset;
3151           base_address = debug_information [i].base_address;
3152
3153           if (!seen_first_offset)
3154             seen_first_offset = 1;
3155           else
3156             {
3157               if (start < next)
3158                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3159                       (unsigned long) (start - section_begin),
3160                       (unsigned long) (next - section_begin));
3161               else if (start > next)
3162                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3163                       (unsigned long) (start - section_begin),
3164                       (unsigned long) (next - section_begin));
3165             }
3166           start = next;
3167
3168           if (offset >= bytes)
3169             {
3170               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3171                     offset);
3172               continue;
3173             }
3174
3175           while (1)
3176             {
3177               if (start + 2 * pointer_size > section_end)
3178                 {
3179                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3180                         offset);
3181                   break;
3182                 }
3183
3184               /* Note: we use sign extension here in order to be sure that
3185                  we can detect the -1 escape value.  Sign extension into the
3186                  top 32 bits of a 32-bit address will not affect the values
3187                  that we display since we always show hex values, and always
3188                  the bottom 32-bits.  */
3189               begin = byte_get_signed (start, pointer_size);
3190               start += pointer_size;
3191               end = byte_get_signed (start, pointer_size);
3192               start += pointer_size;
3193
3194               printf ("    %8.8lx ", offset);
3195
3196               if (begin == 0 && end == 0)
3197                 {
3198                   printf (_("<End of list>\n"));
3199                   break;
3200                 }
3201
3202               /* Check base address specifiers.  */
3203               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3204                 {
3205                   base_address = end;
3206                   print_dwarf_vma (begin, pointer_size);
3207                   print_dwarf_vma (end, pointer_size);
3208                   printf (_("(base address)\n"));
3209                   continue;
3210                 }
3211
3212               if (start + 2 > section_end)
3213                 {
3214                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3215                         offset);
3216                   break;
3217                 }
3218
3219               length = byte_get (start, 2);
3220               start += 2;
3221
3222               if (start + length > section_end)
3223                 {
3224                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3225                         offset);
3226                   break;
3227                 }
3228
3229               print_dwarf_vma (begin + base_address, pointer_size);
3230               print_dwarf_vma (end + base_address, pointer_size);
3231
3232               putchar ('(');
3233               need_frame_base = decode_location_expression (start,
3234                                                             pointer_size,
3235                                                             length,
3236                                                             cu_offset, section);
3237               putchar (')');
3238
3239               if (need_frame_base && !has_frame_base)
3240                 printf (_(" [without DW_AT_frame_base]"));
3241
3242               if (begin == end)
3243                 fputs (_(" (start == end)"), stdout);
3244               else if (begin > end)
3245                 fputs (_(" (start > end)"), stdout);
3246
3247               putchar ('\n');
3248
3249               start += length;
3250             }
3251         }
3252     }
3253
3254   if (start < section_end)
3255     warn (_("There are %ld unused bytes at the end of section %s\n"),
3256           (long) (section_end - start), section->name);
3257   return 1;
3258 }
3259
3260 static int
3261 display_debug_str (struct dwarf_section *section,
3262                    void *file ATTRIBUTE_UNUSED)
3263 {
3264   unsigned char *start = section->start;
3265   unsigned long bytes = section->size;
3266   dwarf_vma addr = section->address;
3267
3268   if (bytes == 0)
3269     {
3270       printf (_("\nThe %s section is empty.\n"), section->name);
3271       return 0;
3272     }
3273
3274   printf (_("Contents of the %s section:\n\n"), section->name);
3275
3276   while (bytes)
3277     {
3278       int j;
3279       int k;
3280       int lbytes;
3281
3282       lbytes = (bytes > 16 ? 16 : bytes);
3283
3284       printf ("  0x%8.8lx ", (unsigned long) addr);
3285
3286       for (j = 0; j < 16; j++)
3287         {
3288           if (j < lbytes)
3289             printf ("%2.2x", start[j]);
3290           else
3291             printf ("  ");
3292
3293           if ((j & 3) == 3)
3294             printf (" ");
3295         }
3296
3297       for (j = 0; j < lbytes; j++)
3298         {
3299           k = start[j];
3300           if (k >= ' ' && k < 0x80)
3301             printf ("%c", k);
3302           else
3303             printf (".");
3304         }
3305
3306       putchar ('\n');
3307
3308       start += lbytes;
3309       addr  += lbytes;
3310       bytes -= lbytes;
3311     }
3312
3313   putchar ('\n');
3314
3315   return 1;
3316 }
3317
3318 static int
3319 display_debug_info (struct dwarf_section *section, void *file)
3320 {
3321   return process_debug_info (section, file, 0);
3322 }
3323
3324
3325 static int
3326 display_debug_aranges (struct dwarf_section *section,
3327                        void *file ATTRIBUTE_UNUSED)
3328 {
3329   unsigned char *start = section->start;
3330   unsigned char *end = start + section->size;
3331
3332   printf (_("Contents of the %s section:\n\n"), section->name);
3333
3334   /* It does not matter if this load fails,
3335      we test for that later on.  */
3336   load_debug_info (file);
3337
3338   while (start < end)
3339     {
3340       unsigned char *hdrptr;
3341       DWARF2_Internal_ARange arange;
3342       unsigned char *ranges;
3343       dwarf_vma length;
3344       dwarf_vma address;
3345       unsigned char address_size;
3346       int excess;
3347       int offset_size;
3348       int initial_length_size;
3349
3350       hdrptr = start;
3351
3352       arange.ar_length = byte_get (hdrptr, 4);
3353       hdrptr += 4;
3354
3355       if (arange.ar_length == 0xffffffff)
3356         {
3357           arange.ar_length = byte_get (hdrptr, 8);
3358           hdrptr += 8;
3359           offset_size = 8;
3360           initial_length_size = 12;
3361         }
3362       else
3363         {
3364           offset_size = 4;
3365           initial_length_size = 4;
3366         }
3367
3368       arange.ar_version = byte_get (hdrptr, 2);
3369       hdrptr += 2;
3370
3371       arange.ar_info_offset = byte_get (hdrptr, offset_size);
3372       hdrptr += offset_size;
3373
3374       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3375           && num_debug_info_entries > 0
3376           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3377         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3378               arange.ar_info_offset, section->name);
3379
3380       arange.ar_pointer_size = byte_get (hdrptr, 1);
3381       hdrptr += 1;
3382
3383       arange.ar_segment_size = byte_get (hdrptr, 1);
3384       hdrptr += 1;
3385
3386       if (arange.ar_version != 2 && arange.ar_version != 3)
3387         {
3388           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3389           break;
3390         }
3391
3392       printf (_("  Length:                   %ld\n"), arange.ar_length);
3393       printf (_("  Version:                  %d\n"), arange.ar_version);
3394       printf (_("  Offset into .debug_info:  0x%lx\n"), arange.ar_info_offset);
3395       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
3396       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
3397
3398       address_size = arange.ar_pointer_size + arange.ar_segment_size;
3399
3400       /* The DWARF spec does not require that the address size be a power
3401          of two, but we do.  This will have to change if we ever encounter
3402          an uneven architecture.  */
3403       if ((address_size & (address_size - 1)) != 0)
3404         {
3405           warn (_("Pointer size + Segment size is not a power of two.\n"));
3406           break;
3407         }
3408
3409       if (address_size > 4)
3410         printf (_("\n    Address            Length\n"));
3411       else
3412         printf (_("\n    Address    Length\n"));
3413
3414       ranges = hdrptr;
3415
3416       /* Must pad to an alignment boundary that is twice the address size.  */
3417       excess = (hdrptr - start) % (2 * address_size);
3418       if (excess)
3419         ranges += (2 * address_size) - excess;
3420
3421       start += arange.ar_length + initial_length_size;
3422
3423       while (ranges + 2 * address_size <= start)
3424         {
3425           address = byte_get (ranges, address_size);
3426
3427           ranges += address_size;
3428
3429           length  = byte_get (ranges, address_size);
3430
3431           ranges += address_size;
3432
3433           printf ("    ");
3434           print_dwarf_vma (address, address_size);
3435           print_dwarf_vma (length, address_size);
3436           putchar ('\n');
3437         }
3438     }
3439
3440   printf ("\n");
3441
3442   return 1;
3443 }
3444
3445 static int
3446 display_debug_ranges (struct dwarf_section *section,
3447                       void *file ATTRIBUTE_UNUSED)
3448 {
3449   unsigned char *start = section->start;
3450   unsigned char *section_end;
3451   unsigned long bytes;
3452   unsigned char *section_begin = start;
3453   unsigned int num_range_list = 0;
3454   unsigned long last_offset = 0;
3455   unsigned int first = 0;
3456   unsigned int i;
3457   unsigned int j;
3458   int seen_first_offset = 0;
3459   int use_debug_info = 1;
3460   unsigned char *next;
3461
3462   bytes = section->size;
3463   section_end = start + bytes;
3464
3465   if (bytes == 0)
3466     {
3467       printf (_("\nThe %s section is empty.\n"), section->name);
3468       return 0;
3469     }
3470
3471   if (load_debug_info (file) == 0)
3472     {
3473       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3474             section->name);
3475       return 0;
3476     }
3477
3478   /* Check the order of range list in .debug_info section. If
3479      offsets of range lists are in the ascending order, we can
3480      use `debug_information' directly.  */
3481   for (i = 0; i < num_debug_info_entries; i++)
3482     {
3483       unsigned int num;
3484
3485       num = debug_information [i].num_range_lists;
3486       num_range_list += num;
3487
3488       /* Check if we can use `debug_information' directly.  */
3489       if (use_debug_info && num != 0)
3490         {
3491           if (!seen_first_offset)
3492             {
3493               /* This is the first range list.  */
3494               last_offset = debug_information [i].range_lists [0];
3495               first = i;
3496               seen_first_offset = 1;
3497               j = 1;
3498             }
3499           else
3500             j = 0;
3501
3502           for (; j < num; j++)
3503             {
3504               if (last_offset >
3505                   debug_information [i].range_lists [j])
3506                 {
3507                   use_debug_info = 0;
3508                   break;
3509                 }
3510               last_offset = debug_information [i].range_lists [j];
3511             }
3512         }
3513     }
3514
3515   if (!use_debug_info)
3516     /* FIXME: Should we handle this case?  */
3517     error (_("Range lists in .debug_info section aren't in ascending order!\n"));
3518
3519   if (!seen_first_offset)
3520     error (_("No range lists in .debug_info section!\n"));
3521
3522   /* DWARF sections under Mach-O have non-zero addresses.  */
3523   if (debug_information [first].num_range_lists > 0
3524       && debug_information [first].range_lists [0] != section->address)
3525     warn (_("Range lists in %s section start at 0x%lx\n"),
3526           section->name, debug_information [first].range_lists [0]);
3527
3528   printf (_("Contents of the %s section:\n\n"), section->name);
3529   printf (_("    Offset   Begin    End\n"));
3530
3531   seen_first_offset = 0;
3532   for (i = first; i < num_debug_info_entries; i++)
3533     {
3534       dwarf_vma begin;
3535       dwarf_vma end;
3536       unsigned long offset;
3537       unsigned int pointer_size;
3538       unsigned long base_address;
3539
3540       pointer_size = debug_information [i].pointer_size;
3541
3542       for (j = 0; j < debug_information [i].num_range_lists; j++)
3543         {
3544           /* DWARF sections under Mach-O have non-zero addresses.  */
3545           offset = debug_information [i].range_lists [j] - section->address;
3546           next = section_begin + offset;
3547           base_address = debug_information [i].base_address;
3548
3549           if (!seen_first_offset)
3550             seen_first_offset = 1;
3551           else
3552             {
3553               if (start < next)
3554                 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3555                       (unsigned long) (start - section_begin),
3556                       (unsigned long) (next - section_begin), section->name);
3557               else if (start > next)
3558                 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3559                       (unsigned long) (start - section_begin),
3560                       (unsigned long) (next - section_begin), section->name);
3561             }
3562           start = next;
3563
3564           while (1)
3565             {
3566               /* Note: we use sign extension here in order to be sure that
3567                  we can detect the -1 escape value.  Sign extension into the
3568                  top 32 bits of a 32-bit address will not affect the values
3569                  that we display since we always show hex values, and always
3570                  the bottom 32-bits.  */
3571               begin = byte_get_signed (start, pointer_size);
3572               start += pointer_size;
3573               end = byte_get_signed (start, pointer_size);
3574               start += pointer_size;
3575
3576               printf ("    %8.8lx ", offset);
3577
3578               if (begin == 0 && end == 0)
3579                 {
3580                   printf (_("<End of list>\n"));
3581                   break;
3582                 }
3583
3584               /* Check base address specifiers.  */
3585               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3586                 {
3587                   base_address = end;
3588                   print_dwarf_vma (begin, pointer_size);
3589                   print_dwarf_vma (end, pointer_size);
3590                   printf ("(base address)\n");
3591                   continue;
3592                 }
3593
3594               print_dwarf_vma (begin + base_address, pointer_size);
3595               print_dwarf_vma (end + base_address, pointer_size);
3596
3597               if (begin == end)
3598                 fputs (_("(start == end)"), stdout);
3599               else if (begin > end)
3600                 fputs (_("(start > end)"), stdout);
3601
3602               putchar ('\n');
3603             }
3604         }
3605     }
3606   putchar ('\n');
3607   return 1;
3608 }
3609
3610 typedef struct Frame_Chunk
3611 {
3612   struct Frame_Chunk *next;
3613   unsigned char *chunk_start;
3614   int ncols;
3615   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
3616   short int *col_type;
3617   int *col_offset;
3618   char *augmentation;
3619   unsigned int code_factor;
3620   int data_factor;
3621   unsigned long pc_begin;
3622   unsigned long pc_range;
3623   int cfa_reg;
3624   int cfa_offset;
3625   int ra;
3626   unsigned char fde_encoding;
3627   unsigned char cfa_exp;
3628 }
3629 Frame_Chunk;
3630
3631 static const char *const *dwarf_regnames;
3632 static unsigned int dwarf_regnames_count;
3633
3634 /* A marker for a col_type that means this column was never referenced
3635    in the frame info.  */
3636 #define DW_CFA_unreferenced (-1)
3637
3638 /* Return 0 if not more space is needed, 1 if more space is needed,
3639    -1 for invalid reg.  */
3640
3641 static int
3642 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3643 {
3644   int prev = fc->ncols;
3645
3646   if (reg < (unsigned int) fc->ncols)
3647     return 0;
3648
3649   if (dwarf_regnames_count
3650       && reg > dwarf_regnames_count)
3651     return -1;
3652
3653   fc->ncols = reg + 1;
3654   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3655   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3656
3657   while (prev < fc->ncols)
3658     {
3659       fc->col_type[prev] = DW_CFA_unreferenced;
3660       fc->col_offset[prev] = 0;
3661       prev++;
3662     }
3663   return 1;
3664 }
3665
3666 static const char *const dwarf_regnames_i386[] =
3667 {
3668   "eax", "ecx", "edx", "ebx",
3669   "esp", "ebp", "esi", "edi",
3670   "eip", "eflags", NULL,
3671   "st0", "st1", "st2", "st3",
3672   "st4", "st5", "st6", "st7",
3673   NULL, NULL,
3674   "xmm0", "xmm1", "xmm2", "xmm3",
3675   "xmm4", "xmm5", "xmm6", "xmm7",
3676   "mm0", "mm1", "mm2", "mm3",
3677   "mm4", "mm5", "mm6", "mm7",
3678   "fcw", "fsw", "mxcsr",
3679   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3680   "tr", "ldtr"
3681 };
3682
3683 static const char *const dwarf_regnames_x86_64[] =
3684 {
3685   "rax", "rdx", "rcx", "rbx",
3686   "rsi", "rdi", "rbp", "rsp",
3687   "r8",  "r9",  "r10", "r11",
3688   "r12", "r13", "r14", "r15",
3689   "rip",
3690   "xmm0",  "xmm1",  "xmm2",  "xmm3",
3691   "xmm4",  "xmm5",  "xmm6",  "xmm7",
3692   "xmm8",  "xmm9",  "xmm10", "xmm11",
3693   "xmm12", "xmm13", "xmm14", "xmm15",
3694   "st0", "st1", "st2", "st3",
3695   "st4", "st5", "st6", "st7",
3696   "mm0", "mm1", "mm2", "mm3",
3697   "mm4", "mm5", "mm6", "mm7",
3698   "rflags",
3699   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3700   "fs.base", "gs.base", NULL, NULL,
3701   "tr", "ldtr",
3702   "mxcsr", "fcw", "fsw"
3703 };
3704
3705 void
3706 init_dwarf_regnames (unsigned int e_machine)
3707 {
3708   switch (e_machine)
3709     {
3710     case EM_386:
3711     case EM_486:
3712       dwarf_regnames = dwarf_regnames_i386;
3713       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3714       break;
3715
3716     case EM_X86_64:
3717       dwarf_regnames = dwarf_regnames_x86_64;
3718       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
3719       break;
3720
3721     default:
3722       break;
3723     }
3724 }
3725
3726 static const char *
3727 regname (unsigned int regno, int row)
3728 {
3729   static char reg[64];
3730   if (dwarf_regnames
3731       && regno < dwarf_regnames_count
3732       && dwarf_regnames [regno] != NULL)
3733     {
3734       if (row)
3735         return dwarf_regnames [regno];
3736       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
3737                 dwarf_regnames [regno]);
3738     }
3739   else
3740     snprintf (reg, sizeof (reg), "r%d", regno);
3741   return reg;
3742 }
3743
3744 static void
3745 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3746 {
3747   int r;
3748   char tmp[100];
3749
3750   if (*max_regs < fc->ncols)
3751     *max_regs = fc->ncols;
3752
3753   if (*need_col_headers)
3754     {
3755       static const char *loc = "   LOC";
3756
3757       *need_col_headers = 0;
3758
3759       printf ("%-*s CFA      ", eh_addr_size * 2, loc);
3760
3761       for (r = 0; r < *max_regs; r++)
3762         if (fc->col_type[r] != DW_CFA_unreferenced)
3763           {
3764             if (r == fc->ra)
3765               printf ("ra      ");
3766             else
3767               printf ("%-5s ", regname (r, 1));
3768           }
3769
3770       printf ("\n");
3771     }
3772
3773   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
3774   if (fc->cfa_exp)
3775     strcpy (tmp, "exp");
3776   else
3777     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
3778   printf ("%-8s ", tmp);
3779
3780   for (r = 0; r < fc->ncols; r++)
3781     {
3782       if (fc->col_type[r] != DW_CFA_unreferenced)
3783         {
3784           switch (fc->col_type[r])
3785             {
3786             case DW_CFA_undefined:
3787               strcpy (tmp, "u");
3788               break;
3789             case DW_CFA_same_value:
3790               strcpy (tmp, "s");
3791               break;
3792             case DW_CFA_offset:
3793               sprintf (tmp, "c%+d", fc->col_offset[r]);
3794               break;
3795             case DW_CFA_val_offset:
3796               sprintf (tmp, "v%+d", fc->col_offset[r]);
3797               break;
3798             case DW_CFA_register:
3799               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
3800               break;
3801             case DW_CFA_expression:
3802               strcpy (tmp, "exp");
3803               break;
3804             case DW_CFA_val_expression:
3805               strcpy (tmp, "vexp");
3806               break;
3807             default:
3808               strcpy (tmp, "n/a");
3809               break;
3810             }
3811           printf ("%-5s ", tmp);
3812         }
3813     }
3814   printf ("\n");
3815 }
3816
3817 #define GET(N)  byte_get (start, N); start += N
3818 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
3819 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
3820
3821 static int
3822 display_debug_frames (struct dwarf_section *section,
3823                       void *file ATTRIBUTE_UNUSED)
3824 {
3825   unsigned char *start = section->start;
3826   unsigned char *end = start + section->size;
3827   unsigned char *section_start = start;
3828   Frame_Chunk *chunks = 0;
3829   Frame_Chunk *remembered_state = 0;
3830   Frame_Chunk *rs;
3831   int is_eh = strcmp (section->name, ".eh_frame") == 0;
3832   unsigned int length_return;
3833   int max_regs = 0;
3834   const char *bad_reg = _("bad register: ");
3835
3836   printf (_("Contents of the %s section:\n"), section->name);
3837
3838   while (start < end)
3839     {
3840       unsigned char *saved_start;
3841       unsigned char *block_end;
3842       unsigned long length;
3843       unsigned long cie_id;
3844       Frame_Chunk *fc;
3845       Frame_Chunk *cie;
3846       int need_col_headers = 1;
3847       unsigned char *augmentation_data = NULL;
3848       unsigned long augmentation_data_len = 0;
3849       int encoded_ptr_size = eh_addr_size;
3850       int offset_size;
3851       int initial_length_size;
3852
3853       saved_start = start;
3854       length = byte_get (start, 4); start += 4;
3855
3856       if (length == 0)
3857         {
3858           printf ("\n%08lx ZERO terminator\n\n",
3859                     (unsigned long)(saved_start - section_start));
3860           continue;
3861         }
3862
3863       if (length == 0xffffffff)
3864         {
3865           length = byte_get (start, 8);
3866           start += 8;
3867           offset_size = 8;
3868           initial_length_size = 12;
3869         }
3870       else
3871         {
3872           offset_size = 4;
3873           initial_length_size = 4;
3874         }
3875
3876       block_end = saved_start + length + initial_length_size;
3877       if (block_end > end)
3878         {
3879           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3880                 length, (unsigned long)(saved_start - section_start));
3881           block_end = end;
3882         }
3883       cie_id = byte_get (start, offset_size); start += offset_size;
3884
3885       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3886         {
3887           int version;
3888
3889           fc = xmalloc (sizeof (Frame_Chunk));
3890           memset (fc, 0, sizeof (Frame_Chunk));
3891
3892           fc->next = chunks;
3893           chunks = fc;
3894           fc->chunk_start = saved_start;
3895           fc->ncols = 0;
3896           fc->col_type = xmalloc (sizeof (short int));
3897           fc->col_offset = xmalloc (sizeof (int));
3898           frame_need_space (fc, max_regs - 1);
3899
3900           version = *start++;
3901
3902           fc->augmentation = (char *) start;
3903           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3904
3905           if (fc->augmentation[0] == 'z')
3906             {
3907               fc->code_factor = LEB ();
3908               fc->data_factor = SLEB ();
3909               if (version == 1)
3910                 {
3911                   fc->ra = GET (1);
3912                 }
3913               else
3914                 {
3915                   fc->ra = LEB ();
3916                 }
3917               augmentation_data_len = LEB ();
3918               augmentation_data = start;
3919               start += augmentation_data_len;
3920             }
3921           else if (strcmp (fc->augmentation, "eh") == 0)
3922             {
3923               start += eh_addr_size;
3924               fc->code_factor = LEB ();
3925               fc->data_factor = SLEB ();
3926               if (version == 1)
3927                 {
3928                   fc->ra = GET (1);
3929                 }
3930               else
3931                 {
3932                   fc->ra = LEB ();
3933                 }
3934             }
3935           else
3936             {
3937               fc->code_factor = LEB ();
3938               fc->data_factor = SLEB ();
3939               if (version == 1)
3940                 {
3941                   fc->ra = GET (1);
3942                 }
3943               else
3944                 {
3945                   fc->ra = LEB ();
3946                 }
3947             }
3948           cie = fc;
3949
3950           if (do_debug_frames_interp)
3951             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3952                     (unsigned long)(saved_start - section_start), length, cie_id,
3953                     fc->augmentation, fc->code_factor, fc->data_factor,
3954                     fc->ra);
3955           else
3956             {
3957               printf ("\n%08lx %08lx %08lx CIE\n",
3958                       (unsigned long)(saved_start - section_start), length, cie_id);
3959               printf ("  Version:               %d\n", version);
3960               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3961               printf ("  Code alignment factor: %u\n", fc->code_factor);
3962               printf ("  Data alignment factor: %d\n", fc->data_factor);
3963               printf ("  Return address column: %d\n", fc->ra);
3964
3965               if (augmentation_data_len)
3966                 {
3967                   unsigned long i;
3968                   printf ("  Augmentation data:    ");
3969                   for (i = 0; i < augmentation_data_len; ++i)
3970                     printf (" %02x", augmentation_data[i]);
3971                   putchar ('\n');
3972                 }
3973               putchar ('\n');
3974             }
3975
3976           if (augmentation_data_len)
3977             {
3978               unsigned char *p, *q;
3979               p = (unsigned char *) fc->augmentation + 1;
3980               q = augmentation_data;
3981
3982               while (1)
3983                 {
3984                   if (*p == 'L')
3985                     q++;
3986                   else if (*p == 'P')
3987                     q += 1 + size_of_encoded_value (*q);
3988                   else if (*p == 'R')
3989                     fc->fde_encoding = *q++;
3990                   else
3991                     break;
3992                   p++;
3993                 }
3994
3995               if (fc->fde_encoding)
3996                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3997             }
3998
3999           frame_need_space (fc, fc->ra);
4000         }
4001       else
4002         {
4003           unsigned char *look_for;
4004           static Frame_Chunk fde_fc;
4005
4006           fc = & fde_fc;
4007           memset (fc, 0, sizeof (Frame_Chunk));
4008
4009           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4010
4011           for (cie = chunks; cie ; cie = cie->next)
4012             if (cie->chunk_start == look_for)
4013               break;
4014
4015           if (!cie)
4016             {
4017               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4018                     cie_id, (unsigned long)(saved_start - section_start));
4019               fc->ncols = 0;
4020               fc->col_type = xmalloc (sizeof (short int));
4021               fc->col_offset = xmalloc (sizeof (int));
4022               frame_need_space (fc, max_regs - 1);
4023               cie = fc;
4024               fc->augmentation = "";
4025               fc->fde_encoding = 0;
4026             }
4027           else
4028             {
4029               fc->ncols = cie->ncols;
4030               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
4031               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
4032               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4033               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4034               fc->augmentation = cie->augmentation;
4035               fc->code_factor = cie->code_factor;
4036               fc->data_factor = cie->data_factor;
4037               fc->cfa_reg = cie->cfa_reg;
4038               fc->cfa_offset = cie->cfa_offset;
4039               fc->ra = cie->ra;
4040               frame_need_space (fc, max_regs - 1);
4041               fc->fde_encoding = cie->fde_encoding;
4042             }
4043
4044           if (fc->fde_encoding)
4045             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4046
4047           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4048           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4049             fc->pc_begin += section->address + (start - section_start);
4050           start += encoded_ptr_size;
4051           fc->pc_range = byte_get (start, encoded_ptr_size);
4052           start += encoded_ptr_size;
4053
4054           if (cie->augmentation[0] == 'z')
4055             {
4056               augmentation_data_len = LEB ();
4057               augmentation_data = start;
4058               start += augmentation_data_len;
4059             }
4060
4061           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4062                   (unsigned long)(saved_start - section_start), length, cie_id,
4063                   (unsigned long)(cie->chunk_start - section_start),
4064                   fc->pc_begin, fc->pc_begin + fc->pc_range);
4065           if (! do_debug_frames_interp && augmentation_data_len)
4066             {
4067               unsigned long i;
4068
4069               printf ("  Augmentation data:    ");
4070               for (i = 0; i < augmentation_data_len; ++i)
4071                 printf (" %02x", augmentation_data[i]);
4072               putchar ('\n');
4073               putchar ('\n');
4074             }
4075         }
4076
4077       /* At this point, fc is the current chunk, cie (if any) is set, and
4078          we're about to interpret instructions for the chunk.  */
4079       /* ??? At present we need to do this always, since this sizes the
4080          fc->col_type and fc->col_offset arrays, which we write into always.
4081          We should probably split the interpreted and non-interpreted bits
4082          into two different routines, since there's so much that doesn't
4083          really overlap between them.  */
4084       if (1 || do_debug_frames_interp)
4085         {
4086           /* Start by making a pass over the chunk, allocating storage
4087              and taking note of what registers are used.  */
4088           unsigned char *tmp = start;
4089
4090           while (start < block_end)
4091             {
4092               unsigned op, opa;
4093               unsigned long reg, tmp;
4094
4095               op = *start++;
4096               opa = op & 0x3f;
4097               if (op & 0xc0)
4098                 op &= 0xc0;
4099
4100               /* Warning: if you add any more cases to this switch, be
4101                  sure to add them to the corresponding switch below.  */
4102               switch (op)
4103                 {
4104                 case DW_CFA_advance_loc:
4105                   break;
4106                 case DW_CFA_offset:
4107                   LEB ();
4108                   if (frame_need_space (fc, opa) >= 0)
4109                     fc->col_type[opa] = DW_CFA_undefined;
4110                   break;
4111                 case DW_CFA_restore:
4112                   if (frame_need_space (fc, opa) >= 0)
4113                     fc->col_type[opa] = DW_CFA_undefined;
4114                   break;
4115                 case DW_CFA_set_loc:
4116                   start += encoded_ptr_size;
4117                   break;
4118                 case DW_CFA_advance_loc1:
4119                   start += 1;
4120                   break;
4121                 case DW_CFA_advance_loc2:
4122                   start += 2;
4123                   break;
4124                 case DW_CFA_advance_loc4:
4125                   start += 4;
4126                   break;
4127                 case DW_CFA_offset_extended:
4128                 case DW_CFA_val_offset:
4129                   reg = LEB (); LEB ();
4130                   if (frame_need_space (fc, reg) >= 0)
4131                     fc->col_type[reg] = DW_CFA_undefined;
4132                   break;
4133                 case DW_CFA_restore_extended:
4134                   reg = LEB ();
4135                   frame_need_space (fc, reg);
4136                   if (frame_need_space (fc, reg) >= 0)
4137                     fc->col_type[reg] = DW_CFA_undefined;
4138                   break;
4139                 case DW_CFA_undefined:
4140                   reg = LEB ();
4141                   if (frame_need_space (fc, reg) >= 0)
4142                     fc->col_type[reg] = DW_CFA_undefined;
4143                   break;
4144                 case DW_CFA_same_value:
4145                   reg = LEB ();
4146                   if (frame_need_space (fc, reg) >= 0)
4147                     fc->col_type[reg] = DW_CFA_undefined;
4148                   break;
4149                 case DW_CFA_register:
4150                   reg = LEB (); LEB ();
4151                   if (frame_need_space (fc, reg) >= 0)
4152                     fc->col_type[reg] = DW_CFA_undefined;
4153                   break;
4154                 case DW_CFA_def_cfa:
4155                   LEB (); LEB ();
4156                   break;
4157                 case DW_CFA_def_cfa_register:
4158                   LEB ();
4159                   break;
4160                 case DW_CFA_def_cfa_offset:
4161                   LEB ();
4162                   break;
4163                 case DW_CFA_def_cfa_expression:
4164                   tmp = LEB ();
4165                   start += tmp;
4166                   break;
4167                 case DW_CFA_expression:
4168                 case DW_CFA_val_expression:
4169                   reg = LEB ();
4170                   tmp = LEB ();
4171                   start += tmp;
4172                   if (frame_need_space (fc, reg) >= 0)
4173                     fc->col_type[reg] = DW_CFA_undefined;
4174                   break;
4175                 case DW_CFA_offset_extended_sf:
4176                 case DW_CFA_val_offset_sf:
4177                   reg = LEB (); SLEB ();
4178                   if (frame_need_space (fc, reg) >= 0)
4179                     fc->col_type[reg] = DW_CFA_undefined;
4180                   break;
4181                 case DW_CFA_def_cfa_sf:
4182                   LEB (); SLEB ();
4183                   break;
4184                 case DW_CFA_def_cfa_offset_sf:
4185                   SLEB ();
4186                   break;
4187                 case DW_CFA_MIPS_advance_loc8:
4188                   start += 8;
4189                   break;
4190                 case DW_CFA_GNU_args_size:
4191                   LEB ();
4192                   break;
4193                 case DW_CFA_GNU_negative_offset_extended:
4194                   reg = LEB (); LEB ();
4195                   if (frame_need_space (fc, reg) >= 0)
4196                     fc->col_type[reg] = DW_CFA_undefined;
4197                   break;
4198                 default:
4199                   break;
4200                 }
4201             }
4202           start = tmp;
4203         }
4204
4205       /* Now we know what registers are used, make a second pass over
4206          the chunk, this time actually printing out the info.  */
4207
4208       while (start < block_end)
4209         {
4210           unsigned op, opa;
4211           unsigned long ul, reg, roffs;
4212           long l, ofs;
4213           dwarf_vma vma;
4214           const char *reg_prefix = "";
4215
4216           op = *start++;
4217           opa = op & 0x3f;
4218           if (op & 0xc0)
4219             op &= 0xc0;
4220
4221           /* Warning: if you add any more cases to this switch, be
4222              sure to add them to the corresponding switch above.  */
4223           switch (op)
4224             {
4225             case DW_CFA_advance_loc:
4226               if (do_debug_frames_interp)
4227                 frame_display_row (fc, &need_col_headers, &max_regs);
4228               else
4229                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
4230                         opa * fc->code_factor,
4231                         fc->pc_begin + opa * fc->code_factor);
4232               fc->pc_begin += opa * fc->code_factor;
4233               break;
4234
4235             case DW_CFA_offset:
4236               roffs = LEB ();
4237               if (opa >= (unsigned int) fc->ncols)
4238                 reg_prefix = bad_reg;
4239               if (! do_debug_frames_interp || *reg_prefix != '\0')
4240                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
4241                         reg_prefix, regname (opa, 0),
4242                         roffs * fc->data_factor);
4243               if (*reg_prefix == '\0')
4244                 {
4245                   fc->col_type[opa] = DW_CFA_offset;
4246                   fc->col_offset[opa] = roffs * fc->data_factor;
4247                 }
4248               break;
4249
4250             case DW_CFA_restore:
4251               if (opa >= (unsigned int) cie->ncols
4252                   || opa >= (unsigned int) fc->ncols)
4253                 reg_prefix = bad_reg;
4254               if (! do_debug_frames_interp || *reg_prefix != '\0')
4255                 printf ("  DW_CFA_restore: %s%s\n",
4256                         reg_prefix, regname (opa, 0));
4257               if (*reg_prefix == '\0')
4258                 {
4259                   fc->col_type[opa] = cie->col_type[opa];
4260                   fc->col_offset[opa] = cie->col_offset[opa];
4261                 }
4262               break;
4263
4264             case DW_CFA_set_loc:
4265               vma = get_encoded_value (start, fc->fde_encoding);
4266               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4267                 vma += section->address + (start - section_start);
4268               start += encoded_ptr_size;
4269               if (do_debug_frames_interp)
4270                 frame_display_row (fc, &need_col_headers, &max_regs);
4271               else
4272                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4273               fc->pc_begin = vma;
4274               break;
4275
4276             case DW_CFA_advance_loc1:
4277               ofs = byte_get (start, 1); start += 1;
4278               if (do_debug_frames_interp)
4279                 frame_display_row (fc, &need_col_headers, &max_regs);
4280               else
4281                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
4282                         ofs * fc->code_factor,
4283                         fc->pc_begin + ofs * fc->code_factor);
4284               fc->pc_begin += ofs * fc->code_factor;
4285               break;
4286
4287             case DW_CFA_advance_loc2:
4288               ofs = byte_get (start, 2); start += 2;
4289               if (do_debug_frames_interp)
4290                 frame_display_row (fc, &need_col_headers, &max_regs);
4291               else
4292                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
4293                         ofs * fc->code_factor,
4294                         fc->pc_begin + ofs * fc->code_factor);
4295               fc->pc_begin += ofs * fc->code_factor;
4296               break;
4297
4298             case DW_CFA_advance_loc4:
4299               ofs = byte_get (start, 4); start += 4;
4300               if (do_debug_frames_interp)
4301                 frame_display_row (fc, &need_col_headers, &max_regs);
4302               else
4303                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
4304                         ofs * fc->code_factor,
4305                         fc->pc_begin + ofs * fc->code_factor);
4306               fc->pc_begin += ofs * fc->code_factor;
4307               break;
4308
4309             case DW_CFA_offset_extended:
4310               reg = LEB ();
4311               roffs = LEB ();
4312               if (reg >= (unsigned int) fc->ncols)
4313                 reg_prefix = bad_reg;
4314               if (! do_debug_frames_interp || *reg_prefix != '\0')
4315                 printf ("  DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4316                         reg_prefix, regname (reg, 0),
4317                         roffs * fc->data_factor);
4318               if (*reg_prefix == '\0')
4319                 {
4320                   fc->col_type[reg] = DW_CFA_offset;
4321                   fc->col_offset[reg] = roffs * fc->data_factor;
4322                 }
4323               break;
4324
4325             case DW_CFA_val_offset:
4326               reg = LEB ();
4327               roffs = LEB ();
4328               if (reg >= (unsigned int) fc->ncols)
4329                 reg_prefix = bad_reg;
4330               if (! do_debug_frames_interp || *reg_prefix != '\0')
4331                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
4332                         reg_prefix, regname (reg, 0),
4333                         roffs * fc->data_factor);
4334               if (*reg_prefix == '\0')
4335                 {
4336                   fc->col_type[reg] = DW_CFA_val_offset;
4337                   fc->col_offset[reg] = roffs * fc->data_factor;
4338                 }
4339               break;
4340
4341             case DW_CFA_restore_extended:
4342               reg = LEB ();
4343               if (reg >= (unsigned int) cie->ncols
4344                   || reg >= (unsigned int) fc->ncols)
4345                 reg_prefix = bad_reg;
4346               if (! do_debug_frames_interp || *reg_prefix != '\0')
4347                 printf ("  DW_CFA_restore_extended: %s%s\n",
4348                         reg_prefix, regname (reg, 0));
4349               if (*reg_prefix == '\0')
4350                 {
4351                   fc->col_type[reg] = cie->col_type[reg];
4352                   fc->col_offset[reg] = cie->col_offset[reg];
4353                 }
4354               break;
4355
4356             case DW_CFA_undefined:
4357               reg = LEB ();
4358               if (reg >= (unsigned int) fc->ncols)
4359                 reg_prefix = bad_reg;
4360               if (! do_debug_frames_interp || *reg_prefix != '\0')
4361                 printf ("  DW_CFA_undefined: %s%s\n",
4362                         reg_prefix, regname (reg, 0));
4363               if (*reg_prefix == '\0')
4364                 {
4365                   fc->col_type[reg] = DW_CFA_undefined;
4366                   fc->col_offset[reg] = 0;
4367                 }
4368               break;
4369
4370             case DW_CFA_same_value:
4371               reg = LEB ();
4372               if (reg >= (unsigned int) fc->ncols)
4373                 reg_prefix = bad_reg;
4374               if (! do_debug_frames_interp || *reg_prefix != '\0')
4375                 printf ("  DW_CFA_same_value: %s%s\n",
4376                         reg_prefix, regname (reg, 0));
4377               if (*reg_prefix == '\0')
4378                 {
4379                   fc->col_type[reg] = DW_CFA_same_value;
4380                   fc->col_offset[reg] = 0;
4381                 }
4382               break;
4383
4384             case DW_CFA_register:
4385               reg = LEB ();
4386               roffs = LEB ();
4387               if (reg >= (unsigned int) fc->ncols)
4388                 reg_prefix = bad_reg;
4389               if (! do_debug_frames_interp || *reg_prefix != '\0')
4390                 {
4391                   printf ("  DW_CFA_register: %s%s in ",
4392                           reg_prefix, regname (reg, 0));
4393                   puts (regname (roffs, 0));
4394                 }
4395               if (*reg_prefix == '\0')
4396                 {
4397                   fc->col_type[reg] = DW_CFA_register;
4398                   fc->col_offset[reg] = roffs;
4399                 }
4400               break;
4401
4402             case DW_CFA_remember_state:
4403               if (! do_debug_frames_interp)
4404                 printf ("  DW_CFA_remember_state\n");
4405               rs = xmalloc (sizeof (Frame_Chunk));
4406               rs->ncols = fc->ncols;
4407               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
4408               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
4409               memcpy (rs->col_type, fc->col_type, rs->ncols);
4410               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4411               rs->next = remembered_state;
4412               remembered_state = rs;
4413               break;
4414
4415             case DW_CFA_restore_state:
4416               if (! do_debug_frames_interp)
4417                 printf ("  DW_CFA_restore_state\n");
4418               rs = remembered_state;
4419               if (rs)
4420                 {
4421                   remembered_state = rs->next;
4422                   frame_need_space (fc, rs->ncols - 1);
4423                   memcpy (fc->col_type, rs->col_type, rs->ncols);
4424                   memcpy (fc->col_offset, rs->col_offset,
4425                           rs->ncols * sizeof (int));
4426                   free (rs->col_type);
4427                   free (rs->col_offset);
4428                   free (rs);
4429                 }
4430               else if (do_debug_frames_interp)
4431                 printf ("Mismatched DW_CFA_restore_state\n");
4432               break;
4433
4434             case DW_CFA_def_cfa:
4435               fc->cfa_reg = LEB ();
4436               fc->cfa_offset = LEB ();
4437               fc->cfa_exp = 0;
4438               if (! do_debug_frames_interp)
4439                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
4440                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4441               break;
4442
4443             case DW_CFA_def_cfa_register:
4444               fc->cfa_reg = LEB ();
4445               fc->cfa_exp = 0;
4446               if (! do_debug_frames_interp)
4447                 printf ("  DW_CFA_def_cfa_register: %s\n",
4448                         regname (fc->cfa_reg, 0));
4449               break;
4450
4451             case DW_CFA_def_cfa_offset:
4452               fc->cfa_offset = LEB ();
4453               if (! do_debug_frames_interp)
4454                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4455               break;
4456
4457             case DW_CFA_nop:
4458               if (! do_debug_frames_interp)
4459                 printf ("  DW_CFA_nop\n");
4460               break;
4461
4462             case DW_CFA_def_cfa_expression:
4463               ul = LEB ();
4464               if (! do_debug_frames_interp)
4465                 {
4466                   printf ("  DW_CFA_def_cfa_expression (");
4467                   decode_location_expression (start, eh_addr_size, ul, 0,
4468                                               section);
4469                   printf (")\n");
4470                 }
4471               fc->cfa_exp = 1;
4472               start += ul;
4473               break;
4474
4475             case DW_CFA_expression:
4476               reg = LEB ();
4477               ul = LEB ();
4478               if (reg >= (unsigned int) fc->ncols)
4479                 reg_prefix = bad_reg;
4480               if (! do_debug_frames_interp || *reg_prefix != '\0')
4481                 {
4482                   printf ("  DW_CFA_expression: %s%s (",
4483                           reg_prefix, regname (reg, 0));
4484                   decode_location_expression (start, eh_addr_size,
4485                                               ul, 0, section);
4486                   printf (")\n");
4487                 }
4488               if (*reg_prefix == '\0')
4489                 fc->col_type[reg] = DW_CFA_expression;
4490               start += ul;
4491               break;
4492
4493             case DW_CFA_val_expression:
4494               reg = LEB ();
4495               ul = LEB ();
4496               if (reg >= (unsigned int) fc->ncols)
4497                 reg_prefix = bad_reg;
4498               if (! do_debug_frames_interp || *reg_prefix != '\0')
4499                 {
4500                   printf ("  DW_CFA_val_expression: %s%s (",
4501                           reg_prefix, regname (reg, 0));
4502                   decode_location_expression (start, eh_addr_size, ul, 0,
4503                                               section);
4504                   printf (")\n");
4505                 }
4506               if (*reg_prefix == '\0')
4507                 fc->col_type[reg] = DW_CFA_val_expression;
4508               start += ul;
4509               break;
4510
4511             case DW_CFA_offset_extended_sf:
4512               reg = LEB ();
4513               l = SLEB ();
4514               if (frame_need_space (fc, reg) < 0)
4515                 reg_prefix = bad_reg;
4516               if (! do_debug_frames_interp || *reg_prefix != '\0')
4517                 printf ("  DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4518                         reg_prefix, regname (reg, 0),
4519                         l * fc->data_factor);
4520               if (*reg_prefix == '\0')
4521                 {
4522                   fc->col_type[reg] = DW_CFA_offset;
4523                   fc->col_offset[reg] = l * fc->data_factor;
4524                 }
4525               break;
4526
4527             case DW_CFA_val_offset_sf:
4528               reg = LEB ();
4529               l = SLEB ();
4530               if (frame_need_space (fc, reg) < 0)
4531                 reg_prefix = bad_reg;
4532               if (! do_debug_frames_interp || *reg_prefix != '\0')
4533                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4534                         reg_prefix, regname (reg, 0),
4535                         l * fc->data_factor);
4536               if (*reg_prefix == '\0')
4537                 {
4538                   fc->col_type[reg] = DW_CFA_val_offset;
4539                   fc->col_offset[reg] = l * fc->data_factor;
4540                 }
4541               break;
4542
4543             case DW_CFA_def_cfa_sf:
4544               fc->cfa_reg = LEB ();
4545               fc->cfa_offset = SLEB ();
4546               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4547               fc->cfa_exp = 0;
4548               if (! do_debug_frames_interp)
4549                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
4550                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4551               break;
4552
4553             case DW_CFA_def_cfa_offset_sf:
4554               fc->cfa_offset = SLEB ();
4555               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4556               if (! do_debug_frames_interp)
4557                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4558               break;
4559
4560             case DW_CFA_MIPS_advance_loc8:
4561               ofs = byte_get (start, 8); start += 8;
4562               if (do_debug_frames_interp)
4563                 frame_display_row (fc, &need_col_headers, &max_regs);
4564               else
4565                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4566                         ofs * fc->code_factor,
4567                         fc->pc_begin + ofs * fc->code_factor);
4568               fc->pc_begin += ofs * fc->code_factor;
4569               break;
4570
4571             case DW_CFA_GNU_window_save:
4572               if (! do_debug_frames_interp)
4573                 printf ("  DW_CFA_GNU_window_save\n");
4574               break;
4575
4576             case DW_CFA_GNU_args_size:
4577               ul = LEB ();
4578               if (! do_debug_frames_interp)
4579                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
4580               break;
4581
4582             case DW_CFA_GNU_negative_offset_extended:
4583               reg = LEB ();
4584               l = - LEB ();
4585               if (frame_need_space (fc, reg) < 0)
4586                 reg_prefix = bad_reg;
4587               if (! do_debug_frames_interp || *reg_prefix != '\0')
4588                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4589                         reg_prefix, regname (reg, 0),
4590                         l * fc->data_factor);
4591               if (*reg_prefix == '\0')
4592                 {
4593                   fc->col_type[reg] = DW_CFA_offset;
4594                   fc->col_offset[reg] = l * fc->data_factor;
4595                 }
4596               break;
4597
4598             default:
4599               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4600                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4601               else
4602                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4603               start = block_end;
4604             }
4605         }
4606
4607       if (do_debug_frames_interp)
4608         frame_display_row (fc, &need_col_headers, &max_regs);
4609
4610       start = block_end;
4611     }
4612
4613   printf ("\n");
4614
4615   return 1;
4616 }
4617
4618 #undef GET
4619 #undef LEB
4620 #undef SLEB
4621
4622 static int
4623 display_debug_not_supported (struct dwarf_section *section,
4624                              void *file ATTRIBUTE_UNUSED)
4625 {
4626   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4627             section->name);
4628
4629   return 1;
4630 }
4631
4632 void *
4633 cmalloc (size_t nmemb, size_t size)
4634 {
4635   /* Check for overflow.  */
4636   if (nmemb >= ~(size_t) 0 / size)
4637     return NULL;
4638   else
4639     return malloc (nmemb * size);
4640 }
4641
4642 void *
4643 xcmalloc (size_t nmemb, size_t size)
4644 {
4645   /* Check for overflow.  */
4646   if (nmemb >= ~(size_t) 0 / size)
4647     return NULL;
4648   else
4649     return xmalloc (nmemb * size);
4650 }
4651
4652 void *
4653 xcrealloc (void *ptr, size_t nmemb, size_t size)
4654 {
4655   /* Check for overflow.  */
4656   if (nmemb >= ~(size_t) 0 / size)
4657     return NULL;
4658   else
4659     return xrealloc (ptr, nmemb * size);
4660 }
4661
4662 void
4663 error (const char *message, ...)
4664 {
4665   va_list args;
4666
4667   va_start (args, message);
4668   fprintf (stderr, _("%s: Error: "), program_name);
4669   vfprintf (stderr, message, args);
4670   va_end (args);
4671 }
4672
4673 void
4674 warn (const char *message, ...)
4675 {
4676   va_list args;
4677
4678   va_start (args, message);
4679   fprintf (stderr, _("%s: Warning: "), program_name);
4680   vfprintf (stderr, message, args);
4681   va_end (args);
4682 }
4683
4684 void
4685 free_debug_memory (void)
4686 {
4687   enum dwarf_section_display_enum i;
4688
4689   free_abbrevs ();
4690
4691   for (i = 0; i < max; i++)
4692     free_debug_section (i);
4693
4694   if (debug_information != NULL)
4695     {
4696       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4697         {
4698           for (i = 0; i < num_debug_info_entries; i++)
4699             {
4700               if (!debug_information [i].max_loc_offsets)
4701                 {
4702                   free (debug_information [i].loc_offsets);
4703                   free (debug_information [i].have_frame_base);
4704                 }
4705               if (!debug_information [i].max_range_lists)
4706                 free (debug_information [i].range_lists);
4707             }
4708         }
4709
4710       free (debug_information);
4711       debug_information = NULL;
4712       num_debug_info_entries = 0;
4713     }
4714 }
4715
4716 void
4717 dwarf_select_sections_by_names (const char *names)
4718 {
4719   typedef struct
4720   {
4721     const char * option;
4722     int *        variable;
4723     int val;
4724   }
4725   debug_dump_long_opts;
4726
4727   static const debug_dump_long_opts opts_table [] =
4728     {
4729       /* Please keep this table alpha- sorted.  */
4730       { "Ranges", & do_debug_ranges, 1 },
4731       { "abbrev", & do_debug_abbrevs, 1 },
4732       { "aranges", & do_debug_aranges, 1 },
4733       { "frames", & do_debug_frames, 1 },
4734       { "frames-interp", & do_debug_frames_interp, 1 },
4735       { "info", & do_debug_info, 1 },
4736       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
4737       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4738       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4739       { "loc",  & do_debug_loc, 1 },
4740       { "macro", & do_debug_macinfo, 1 },
4741       { "pubnames", & do_debug_pubnames, 1 },
4742       /* This entry is for compatability
4743          with earlier versions of readelf.  */
4744       { "ranges", & do_debug_aranges, 1 },
4745       { "str", & do_debug_str, 1 },
4746       { NULL, NULL, 0 }
4747     };
4748
4749   const char *p;
4750
4751   p = names;
4752   while (*p)
4753     {
4754       const debug_dump_long_opts * entry;
4755
4756       for (entry = opts_table; entry->option; entry++)
4757         {
4758           size_t len = strlen (entry->option);
4759
4760           if (strncmp (p, entry->option, len) == 0
4761               && (p[len] == ',' || p[len] == '\0'))
4762             {
4763               * entry->variable |= entry->val;
4764
4765               /* The --debug-dump=frames-interp option also
4766                  enables the --debug-dump=frames option.  */
4767               if (do_debug_frames_interp)
4768                 do_debug_frames = 1;
4769
4770               p += len;
4771               break;
4772             }
4773         }
4774
4775       if (entry->option == NULL)
4776         {
4777           warn (_("Unrecognized debug option '%s'\n"), p);
4778           p = strchr (p, ',');
4779           if (p == NULL)
4780             break;
4781         }
4782
4783       if (*p == ',')
4784         p++;
4785     }
4786 }
4787
4788 void
4789 dwarf_select_sections_by_letters (const char *letters)
4790 {
4791   unsigned int index = 0;
4792
4793   while (letters[index])
4794     switch (letters[index++])
4795       {
4796       case 'i':
4797         do_debug_info = 1;
4798         break;
4799
4800       case 'a':
4801         do_debug_abbrevs = 1;
4802         break;
4803
4804       case 'l':
4805         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4806         break;
4807
4808       case 'L':
4809         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
4810         break;
4811
4812       case 'p':
4813         do_debug_pubnames = 1;
4814         break;
4815
4816       case 'r':
4817         do_debug_aranges = 1;
4818         break;
4819
4820       case 'R':
4821         do_debug_ranges = 1;
4822         break;
4823
4824       case 'F':
4825         do_debug_frames_interp = 1;
4826       case 'f':
4827         do_debug_frames = 1;
4828         break;
4829
4830       case 'm':
4831         do_debug_macinfo = 1;
4832         break;
4833
4834       case 's':
4835         do_debug_str = 1;
4836         break;
4837
4838       case 'o':
4839         do_debug_loc = 1;
4840         break;
4841
4842       default:
4843         warn (_("Unrecognized debug option '%s'\n"), optarg);
4844         break;
4845       }
4846 }
4847
4848 void
4849 dwarf_select_sections_all (void)
4850 {
4851   do_debug_info = 1;
4852   do_debug_abbrevs = 1;
4853   do_debug_lines = FLAG_DEBUG_LINES_RAW;
4854   do_debug_pubnames = 1;
4855   do_debug_aranges = 1;
4856   do_debug_ranges = 1;
4857   do_debug_frames = 1;
4858   do_debug_macinfo = 1;
4859   do_debug_str = 1;
4860   do_debug_loc = 1;
4861 }
4862
4863 struct dwarf_section_display debug_displays[] =
4864 {
4865   { { ".debug_abbrev",          ".zdebug_abbrev",       NULL,   NULL,   0,      0 },
4866     display_debug_abbrev,               &do_debug_abbrevs,      0,      0 },
4867   { { ".debug_aranges",         ".zdebug_aranges",      NULL,   NULL,   0,      0 },
4868     display_debug_aranges,              &do_debug_aranges,      0,      0 },
4869   { { ".debug_frame",           ".zdebug_frame",        NULL,   NULL,   0,      0 },
4870     display_debug_frames,               &do_debug_frames,       1,      0 },
4871   { { ".debug_info",            ".zdebug_info",         NULL,   NULL,   0,      0 },
4872     display_debug_info,                 &do_debug_info,         1,      0 },
4873   { { ".debug_line",            ".zdebug_line",         NULL,   NULL,   0,      0 },
4874     display_debug_lines,                &do_debug_lines,        0,      0 },
4875   { { ".debug_pubnames",        ".zdebug_pubnames",     NULL,   NULL,   0,      0 },
4876     display_debug_pubnames,             &do_debug_pubnames,     0,      0 },
4877   { { ".eh_frame",              "",                     NULL,   NULL,   0,      0 },
4878     display_debug_frames,               &do_debug_frames,       1,      1 },
4879   { { ".debug_macinfo",         ".zdebug_macinfo",      NULL,   NULL,   0,      0 },
4880     display_debug_macinfo,              &do_debug_macinfo,      0,      0 },
4881   { { ".debug_str",             ".zdebug_str",          NULL,   NULL,   0,      0 },
4882     display_debug_str,                  &do_debug_str,          0,      0 },
4883   { { ".debug_loc",             ".zdebug_loc",          NULL,   NULL,   0,      0 },
4884     display_debug_loc,                  &do_debug_loc,          0,      0 },
4885   { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL,   NULL,   0,      0 },
4886     display_debug_pubnames,             &do_debug_pubnames,     0,      0 },
4887   { { ".debug_ranges",          ".zdebug_ranges",       NULL,   NULL,   0,      0 },
4888     display_debug_ranges,               &do_debug_ranges,       0,      0 },
4889   { { ".debug_static_func",     ".zdebug_static_func",  NULL,   NULL,   0,      0 },
4890     display_debug_not_supported,        NULL,                   0,      0 },
4891   { { ".debug_static_vars",     ".zdebug_static_vars",  NULL,   NULL,   0,      0 },
4892     display_debug_not_supported,        NULL,                   0,      0 },
4893   { { ".debug_types",           ".zdebug_types",        NULL,   NULL,   0,      0 },
4894     display_debug_not_supported,        NULL,                   0,      0 },
4895   { { ".debug_weaknames",       ".zdebug_weaknames",    NULL,   NULL,   0,      0 },
4896     display_debug_not_supported,        NULL,                   0,      0 }
4897 };