binutils/dwarf.c

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