binutils/dwarf.c

   1 /* dwarf.c -- display DWARF contents of a BFD binary file
   2    Copyright 2005, 2006, 2007, 2008, 2009
   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 or it may also be
1989              a section padding.  */
1990           if (abbrev_number == 0)
1991             {
1992               /* Check if it can be a section padding for the last CU.  */
1993               if (level == 0 && start == end)
1994                 {
1995                   unsigned char *chk;
1996
1997                   for (chk = tags; chk < start; chk++)
1998                     if (*chk != 0)
1999                       break;
2000                   if (chk == start)
2001                     break;
2002                 }
2003
2004               --level;
2005               if (level < 0)
2006                 {
2007                   static unsigned num_bogus_warns = 0;
2008
2009                   if (num_bogus_warns < 3)
2010                     {
2011                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2012                             die_offset);
2013                       num_bogus_warns ++;
2014                       if (num_bogus_warns == 3)
2015                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2016                     }
2017                 }
2018               continue;
2019             }
2020
2021           if (!do_loc)
2022             printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2023                     level, die_offset, abbrev_number);
2024
2025           /* Scan through the abbreviation list until we reach the
2026              correct entry.  */
2027           for (entry = first_abbrev;
2028                entry && entry->entry != abbrev_number;
2029                entry = entry->next)
2030             continue;
2031
2032           if (entry == NULL)
2033             {
2034               if (!do_loc)
2035                 {
2036                   printf ("\n");
2037                   fflush (stdout);
2038                 }
2039               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2040                     die_offset, abbrev_number);
2041               return 0;
2042             }
2043
2044           if (!do_loc)
2045             printf (_(" (%s)\n"), get_TAG_name (entry->tag));
2046
2047           switch (entry->tag)
2048             {
2049             default:
2050               need_base_address = 0;
2051               break;
2052             case DW_TAG_compile_unit:
2053               need_base_address = 1;
2054               break;
2055             case DW_TAG_entry_point:
2056             case DW_TAG_subprogram:
2057               need_base_address = 0;
2058               /* Assuming that there is no DW_AT_frame_base.  */
2059               have_frame_base = 0;
2060               break;
2061             }
2062
2063           for (attr = entry->first_attr; attr; attr = attr->next)
2064             {
2065               if (! do_loc)
2066                 /* Show the offset from where the tag was extracted.  */
2067                 printf ("    <%2lx>", (unsigned long)(tags - section_begin));
2068
2069               tags = read_and_display_attr (attr->attribute,
2070                                             attr->form,
2071                                             tags, cu_offset,
2072                                             compunit.cu_pointer_size,
2073                                             offset_size,
2074                                             compunit.cu_version,
2075                                             debug_information + unit,
2076                                             do_loc, section);
2077             }
2078
2079           if (entry->children)
2080             ++level;
2081         }
2082     }
2083
2084   /* Set num_debug_info_entries here so that it can be used to check if
2085      we need to process .debug_loc and .debug_ranges sections.  */
2086   if ((do_loc || do_debug_loc || do_debug_ranges)
2087       && num_debug_info_entries == 0)
2088     num_debug_info_entries = num_units;
2089
2090   if (!do_loc)
2091     {
2092       printf ("\n");
2093     }
2094
2095   return 1;
2096 }
2097
2098 /* Locate and scan the .debug_info section in the file and record the pointer
2099    sizes and offsets for the compilation units in it.  Usually an executable
2100    will have just one pointer size, but this is not guaranteed, and so we try
2101    not to make any assumptions.  Returns zero upon failure, or the number of
2102    compilation units upon success.  */
2103
2104 static unsigned int
2105 load_debug_info (void * file)
2106 {
2107   /* Reset the last pointer size so that we can issue correct error
2108      messages if we are displaying the contents of more than one section.  */
2109   last_pointer_size = 0;
2110   warned_about_missing_comp_units = FALSE;
2111
2112   /* If we have already tried and failed to load the .debug_info
2113      section then do not bother to repear the task.  */
2114   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2115     return 0;
2116
2117   /* If we already have the information there is nothing else to do.  */
2118   if (num_debug_info_entries > 0)
2119     return num_debug_info_entries;
2120
2121   if (load_debug_section (info, file)
2122       && process_debug_info (&debug_displays [info].section, file, 1))
2123     return num_debug_info_entries;
2124
2125   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2126   return 0;
2127 }
2128
2129 static int
2130 display_debug_lines_raw (struct dwarf_section *section,
2131                          unsigned char *data,
2132                          unsigned char *end)
2133 {
2134   unsigned char *start = section->start;
2135
2136   printf (_("Raw dump of debug contents of section %s:\n\n"),
2137           section->name);
2138
2139   while (data < end)
2140     {
2141       DWARF2_Internal_LineInfo info;
2142       unsigned char *standard_opcodes;
2143       unsigned char *end_of_sequence;
2144       unsigned char *hdrptr;
2145       unsigned long hdroff;
2146       int initial_length_size;
2147       int offset_size;
2148       int i;
2149
2150       hdrptr = data;
2151       hdroff = hdrptr - start;
2152
2153       /* Check the length of the block.  */
2154       info.li_length = byte_get (hdrptr, 4);
2155       hdrptr += 4;
2156
2157       if (info.li_length == 0xffffffff)
2158         {
2159           /* This section is 64-bit DWARF 3.  */
2160           info.li_length = byte_get (hdrptr, 8);
2161           hdrptr += 8;
2162           offset_size = 8;
2163           initial_length_size = 12;
2164         }
2165       else
2166         {
2167           offset_size = 4;
2168           initial_length_size = 4;
2169         }
2170
2171       if (info.li_length + initial_length_size > section->size)
2172         {
2173           warn
2174             (_("The information in section %s appears to be corrupt - the section is too small\n"),
2175              section->name);
2176           return 0;
2177         }
2178
2179       /* Check its version number.  */
2180       info.li_version = byte_get (hdrptr, 2);
2181       hdrptr += 2;
2182       if (info.li_version != 2 && info.li_version != 3)
2183         {
2184           warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2185           return 0;
2186         }
2187
2188       info.li_prologue_length = byte_get (hdrptr, offset_size);
2189       hdrptr += offset_size;
2190       info.li_min_insn_length = byte_get (hdrptr, 1);
2191       hdrptr++;
2192       info.li_default_is_stmt = byte_get (hdrptr, 1);
2193       hdrptr++;
2194       info.li_line_base = byte_get (hdrptr, 1);
2195       hdrptr++;
2196       info.li_line_range = byte_get (hdrptr, 1);
2197       hdrptr++;
2198       info.li_opcode_base = byte_get (hdrptr, 1);
2199       hdrptr++;
2200
2201       /* Sign extend the line base field.  */
2202       info.li_line_base <<= 24;
2203       info.li_line_base >>= 24;
2204
2205       printf (_("  Offset:                      0x%lx\n"), hdroff);
2206       printf (_("  Length:                      %ld\n"), info.li_length);
2207       printf (_("  DWARF Version:               %d\n"), info.li_version);
2208       printf (_("  Prologue Length:             %d\n"), info.li_prologue_length);
2209       printf (_("  Minimum Instruction Length:  %d\n"), info.li_min_insn_length);
2210       printf (_("  Initial value of 'is_stmt':  %d\n"), info.li_default_is_stmt);
2211       printf (_("  Line Base:                   %d\n"), info.li_line_base);
2212       printf (_("  Line Range:                  %d\n"), info.li_line_range);
2213       printf (_("  Opcode Base:                 %d\n"), info.li_opcode_base);
2214
2215       end_of_sequence = data + info.li_length + initial_length_size;
2216
2217       reset_state_machine (info.li_default_is_stmt);
2218
2219       /* Display the contents of the Opcodes table.  */
2220       standard_opcodes = hdrptr;
2221
2222       printf (_("\n Opcodes:\n"));
2223
2224       for (i = 1; i < info.li_opcode_base; i++)
2225         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2226
2227       /* Display the contents of the Directory table.  */
2228       data = standard_opcodes + info.li_opcode_base - 1;
2229
2230       if (*data == 0)
2231         printf (_("\n The Directory Table is empty.\n"));
2232       else
2233         {
2234           printf (_("\n The Directory Table:\n"));
2235
2236           while (*data != 0)
2237             {
2238               printf (_("  %s\n"), data);
2239
2240               data += strlen ((char *) data) + 1;
2241             }
2242         }
2243
2244       /* Skip the NUL at the end of the table.  */
2245       data++;
2246
2247       /* Display the contents of the File Name table.  */
2248       if (*data == 0)
2249         printf (_("\n The File Name Table is empty.\n"));
2250       else
2251         {
2252           printf (_("\n The File Name Table:\n"));
2253           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2254
2255           while (*data != 0)
2256             {
2257               unsigned char *name;
2258               unsigned int bytes_read;
2259
2260               printf (_("  %d\t"), ++state_machine_regs.last_file_entry);
2261               name = data;
2262
2263               data += strlen ((char *) data) + 1;
2264
2265               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2266               data += bytes_read;
2267               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2268               data += bytes_read;
2269               printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2270               data += bytes_read;
2271               printf (_("%s\n"), name);
2272             }
2273         }
2274
2275       /* Skip the NUL at the end of the table.  */
2276       data++;
2277
2278       /* Now display the statements.  */
2279       printf (_("\n Line Number Statements:\n"));
2280
2281       while (data < end_of_sequence)
2282         {
2283           unsigned char op_code;
2284           int adv;
2285           unsigned long int uladv;
2286           unsigned int bytes_read;
2287
2288           op_code = *data++;
2289
2290           if (op_code >= info.li_opcode_base)
2291             {
2292               op_code -= info.li_opcode_base;
2293               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2294               state_machine_regs.address += uladv;
2295               printf (_("  Special opcode %d: advance Address by %lu to 0x%lx"),
2296                       op_code, uladv, state_machine_regs.address);
2297               adv = (op_code % info.li_line_range) + info.li_line_base;
2298               state_machine_regs.line += adv;
2299               printf (_(" and Line by %d to %d\n"),
2300                       adv, state_machine_regs.line);
2301             }
2302           else switch (op_code)
2303             {
2304             case DW_LNS_extended_op:
2305               data += process_extended_line_op (data, info.li_default_is_stmt);
2306               break;
2307
2308             case DW_LNS_copy:
2309               printf (_("  Copy\n"));
2310               break;
2311
2312             case DW_LNS_advance_pc:
2313               uladv = read_leb128 (data, & bytes_read, 0);
2314               uladv *= info.li_min_insn_length;
2315               data += bytes_read;
2316               state_machine_regs.address += uladv;
2317               printf (_("  Advance PC by %lu to 0x%lx\n"), uladv,
2318                       state_machine_regs.address);
2319               break;
2320
2321             case DW_LNS_advance_line:
2322               adv = read_leb128 (data, & bytes_read, 1);
2323               data += bytes_read;
2324               state_machine_regs.line += adv;
2325               printf (_("  Advance Line by %d to %d\n"), adv,
2326                       state_machine_regs.line);
2327               break;
2328
2329             case DW_LNS_set_file:
2330               adv = read_leb128 (data, & bytes_read, 0);
2331               data += bytes_read;
2332               printf (_("  Set File Name to entry %d in the File Name Table\n"),
2333                       adv);
2334               state_machine_regs.file = adv;
2335               break;
2336
2337             case DW_LNS_set_column:
2338               uladv = read_leb128 (data, & bytes_read, 0);
2339               data += bytes_read;
2340               printf (_("  Set column to %lu\n"), uladv);
2341               state_machine_regs.column = uladv;
2342               break;
2343
2344             case DW_LNS_negate_stmt:
2345               adv = state_machine_regs.is_stmt;
2346               adv = ! adv;
2347               printf (_("  Set is_stmt to %d\n"), adv);
2348               state_machine_regs.is_stmt = adv;
2349               break;
2350
2351             case DW_LNS_set_basic_block:
2352               printf (_("  Set basic block\n"));
2353               state_machine_regs.basic_block = 1;
2354               break;
2355
2356             case DW_LNS_const_add_pc:
2357               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2358                       * info.li_min_insn_length);
2359               state_machine_regs.address += uladv;
2360               printf (_("  Advance PC by constant %lu to 0x%lx\n"), uladv,
2361                       state_machine_regs.address);
2362               break;
2363
2364             case DW_LNS_fixed_advance_pc:
2365               uladv = byte_get (data, 2);
2366               data += 2;
2367               state_machine_regs.address += uladv;
2368               printf (_("  Advance PC by fixed size amount %lu to 0x%lx\n"),
2369                       uladv, state_machine_regs.address);
2370               break;
2371
2372             case DW_LNS_set_prologue_end:
2373               printf (_("  Set prologue_end to true\n"));
2374               break;
2375
2376             case DW_LNS_set_epilogue_begin:
2377               printf (_("  Set epilogue_begin to true\n"));
2378               break;
2379
2380             case DW_LNS_set_isa:
2381               uladv = read_leb128 (data, & bytes_read, 0);
2382               data += bytes_read;
2383               printf (_("  Set ISA to %lu\n"), uladv);
2384               break;
2385
2386             default:
2387               printf (_("  Unknown opcode %d with operands: "), op_code);
2388
2389               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2390                 {
2391                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2392                           i == 1 ? "" : ", ");
2393                   data += bytes_read;
2394                 }
2395               putchar ('\n');
2396               break;
2397             }
2398         }
2399       putchar ('\n');
2400     }
2401
2402   return 1;
2403 }
2404
2405 typedef struct
2406 {
2407     unsigned char *name;
2408     unsigned int directory_index;
2409     unsigned int modification_date;
2410     unsigned int length;
2411 } File_Entry;
2412
2413 /* Output a decoded representation of the .debug_line section.  */
2414
2415 static int
2416 display_debug_lines_decoded (struct dwarf_section *section,
2417                              unsigned char *data,
2418                              unsigned char *end)
2419 {
2420   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2421           section->name);
2422
2423   while (data < end)
2424     {
2425       /* This loop amounts to one iteration per compilation unit.  */
2426       DWARF2_Internal_LineInfo info;
2427       unsigned char *standard_opcodes;
2428       unsigned char *end_of_sequence;
2429       unsigned char *hdrptr;
2430       int initial_length_size;
2431       int offset_size;
2432       int i;
2433       File_Entry *file_table = NULL;
2434       unsigned char **directory_table = NULL;
2435       unsigned int prev_line = 0;
2436
2437       hdrptr = data;
2438
2439       /* Extract information from the Line Number Program Header.
2440         (section 6.2.4 in the Dwarf3 doc).  */
2441
2442       /* Get the length of this CU's line number information block.  */
2443       info.li_length = byte_get (hdrptr, 4);
2444       hdrptr += 4;
2445
2446       if (info.li_length == 0xffffffff)
2447         {
2448           /* This section is 64-bit DWARF 3.  */
2449           info.li_length = byte_get (hdrptr, 8);
2450           hdrptr += 8;
2451           offset_size = 8;
2452           initial_length_size = 12;
2453         }
2454       else
2455         {
2456           offset_size = 4;
2457           initial_length_size = 4;
2458         }
2459
2460       if (info.li_length + initial_length_size > section->size)
2461         {
2462           warn (_("The line info appears to be corrupt - "
2463                   "the section is too small\n"));
2464           return 0;
2465         }
2466
2467       /* Get this CU's Line Number Block version number.  */
2468       info.li_version = byte_get (hdrptr, 2);
2469       hdrptr += 2;
2470       if (info.li_version != 2 && info.li_version != 3)
2471         {
2472           warn (_("Only DWARF version 2 and 3 line info is currently "
2473                 "supported.\n"));
2474           return 0;
2475         }
2476
2477       info.li_prologue_length = byte_get (hdrptr, offset_size);
2478       hdrptr += offset_size;
2479       info.li_min_insn_length = byte_get (hdrptr, 1);
2480       hdrptr++;
2481       info.li_default_is_stmt = byte_get (hdrptr, 1);
2482       hdrptr++;
2483       info.li_line_base = byte_get (hdrptr, 1);
2484       hdrptr++;
2485       info.li_line_range = byte_get (hdrptr, 1);
2486       hdrptr++;
2487       info.li_opcode_base = byte_get (hdrptr, 1);
2488       hdrptr++;
2489
2490       /* Sign extend the line base field.  */
2491       info.li_line_base <<= 24;
2492       info.li_line_base >>= 24;
2493
2494       /* Find the end of this CU's Line Number Information Block.  */
2495       end_of_sequence = data + info.li_length + initial_length_size;
2496
2497       reset_state_machine (info.li_default_is_stmt);
2498
2499       /* Save a pointer to the contents of the Opcodes table.  */
2500       standard_opcodes = hdrptr;
2501
2502       /* Traverse the Directory table just to count entries.  */
2503       data = standard_opcodes + info.li_opcode_base - 1;
2504       if (*data != 0)
2505         {
2506           unsigned int n_directories = 0;
2507           unsigned char *ptr_directory_table = data;
2508           int i;
2509
2510           while (*data != 0)
2511             {
2512               data += strlen ((char *) data) + 1;
2513               n_directories++;
2514             }
2515
2516           /* Go through the directory table again to save the directories.  */
2517           directory_table = xmalloc (n_directories * sizeof (unsigned char *));
2518
2519           i = 0;
2520           while (*ptr_directory_table != 0)
2521             {
2522               directory_table[i] = ptr_directory_table;
2523               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2524               i++;
2525             }
2526         }
2527       /* Skip the NUL at the end of the table.  */
2528       data++;
2529
2530       /* Traverse the File Name table just to count the entries.  */
2531       if (*data != 0)
2532         {
2533           unsigned int n_files = 0;
2534           unsigned char *ptr_file_name_table = data;
2535           int i;
2536
2537           while (*data != 0)
2538             {
2539               unsigned int bytes_read;
2540
2541               /* Skip Name, directory index, last modification time and length
2542                  of file.  */
2543               data += strlen ((char *) data) + 1;
2544               read_leb128 (data, & bytes_read, 0);
2545               data += bytes_read;
2546               read_leb128 (data, & bytes_read, 0);
2547               data += bytes_read;
2548               read_leb128 (data, & bytes_read, 0);
2549               data += bytes_read;
2550
2551               n_files++;
2552             }
2553
2554           /* Go through the file table again to save the strings.  */
2555           file_table = xmalloc (n_files * sizeof (File_Entry));
2556
2557           i = 0;
2558           while (*ptr_file_name_table != 0)
2559             {
2560               unsigned int bytes_read;
2561
2562               file_table[i].name = ptr_file_name_table;
2563               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2564
2565               /* We are not interested in directory, time or size.  */
2566               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2567                                                            & bytes_read, 0);
2568               ptr_file_name_table += bytes_read;
2569               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2570                                                              & bytes_read, 0);
2571               ptr_file_name_table += bytes_read;
2572               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2573               ptr_file_name_table += bytes_read;
2574               i++;
2575             }
2576           i = 0;
2577
2578           /* Print the Compilation Unit's name and a header.  */
2579           if (directory_table == NULL)
2580             {
2581               printf (_("CU: %s:\n"), file_table[0].name);
2582               printf (_("File name                            Line number    Starting address\n"));
2583             }
2584           else
2585             {
2586               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2587                 {
2588                   printf (_("CU: %s/%s:\n"), directory_table[0],
2589                           file_table[0].name);
2590                 }
2591               else
2592                 {
2593                   printf (_("%s:\n"), file_table[0].name);
2594                 }
2595               printf (_("File name                            Line number    Starting address\n"));
2596             }
2597         }
2598
2599       /* Skip the NUL at the end of the table.  */
2600       data++;
2601
2602       /* This loop iterates through the Dwarf Line Number Program.  */
2603       while (data < end_of_sequence)
2604         {
2605           unsigned char op_code;
2606           int adv;
2607           unsigned long int uladv;
2608           unsigned int bytes_read;
2609           int is_special_opcode = 0;
2610
2611           op_code = *data++;
2612           prev_line = state_machine_regs.line;
2613
2614           if (op_code >= info.li_opcode_base)
2615             {
2616               op_code -= info.li_opcode_base;
2617               uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2618               state_machine_regs.address += uladv;
2619
2620               adv = (op_code % info.li_line_range) + info.li_line_base;
2621               state_machine_regs.line += adv;
2622               is_special_opcode = 1;
2623             }
2624           else switch (op_code)
2625             {
2626             case DW_LNS_extended_op:
2627               {
2628                 unsigned int ext_op_code_len;
2629                 unsigned int bytes_read;
2630                 unsigned char ext_op_code;
2631                 unsigned char *op_code_data = data;
2632
2633                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
2634                 op_code_data += bytes_read;
2635
2636                 if (ext_op_code_len == 0)
2637                   {
2638                     warn (_("badly formed extended line op encountered!\n"));
2639                     break;
2640                   }
2641                 ext_op_code_len += bytes_read;
2642                 ext_op_code = *op_code_data++;
2643
2644                 switch (ext_op_code)
2645                   {
2646                   case DW_LNE_end_sequence:
2647                     reset_state_machine (info.li_default_is_stmt);
2648                     break;
2649                   case DW_LNE_set_address:
2650                     state_machine_regs.address =
2651                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
2652                     break;
2653                   case DW_LNE_define_file:
2654                     {
2655                       unsigned int dir_index = 0;
2656
2657                       ++state_machine_regs.last_file_entry;
2658                       op_code_data += strlen ((char *) op_code_data) + 1;
2659                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
2660                       op_code_data += bytes_read;
2661                       read_leb128 (op_code_data, & bytes_read, 0);
2662                       op_code_data += bytes_read;
2663                       read_leb128 (op_code_data, & bytes_read, 0);
2664
2665                       printf (_("%s:\n"), directory_table[dir_index]);
2666                       break;
2667                     }
2668                   default:
2669                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
2670                     break;
2671                   }
2672                 data += ext_op_code_len;
2673                 break;
2674               }
2675             case DW_LNS_copy:
2676               break;
2677
2678             case DW_LNS_advance_pc:
2679               uladv = read_leb128 (data, & bytes_read, 0);
2680               uladv *= info.li_min_insn_length;
2681               data += bytes_read;
2682               state_machine_regs.address += uladv;
2683               break;
2684
2685             case DW_LNS_advance_line:
2686               adv = read_leb128 (data, & bytes_read, 1);
2687               data += bytes_read;
2688               state_machine_regs.line += adv;
2689               break;
2690
2691             case DW_LNS_set_file:
2692               adv = read_leb128 (data, & bytes_read, 0);
2693               data += bytes_read;
2694               state_machine_regs.file = adv;
2695               if (file_table[state_machine_regs.file - 1].directory_index == 0)
2696                 {
2697                   /* If directory index is 0, that means current directory.  */
2698                   printf (_("\n./%s:[++]\n"),
2699                           file_table[state_machine_regs.file - 1].name);
2700                 }
2701               else
2702                 {
2703                   /* The directory index starts counting at 1.  */
2704                   printf (_("\n%s/%s:\n"),
2705                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
2706                           file_table[state_machine_regs.file - 1].name);
2707                 }
2708               break;
2709
2710             case DW_LNS_set_column:
2711               uladv = read_leb128 (data, & bytes_read, 0);
2712               data += bytes_read;
2713               state_machine_regs.column = uladv;
2714               break;
2715
2716             case DW_LNS_negate_stmt:
2717               adv = state_machine_regs.is_stmt;
2718               adv = ! adv;
2719               state_machine_regs.is_stmt = adv;
2720               break;
2721
2722             case DW_LNS_set_basic_block:
2723               state_machine_regs.basic_block = 1;
2724               break;
2725
2726             case DW_LNS_const_add_pc:
2727               uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2728                        * info.li_min_insn_length);
2729               state_machine_regs.address += uladv;
2730               break;
2731
2732             case DW_LNS_fixed_advance_pc:
2733               uladv = byte_get (data, 2);
2734               data += 2;
2735               state_machine_regs.address += uladv;
2736               break;
2737
2738             case DW_LNS_set_prologue_end:
2739               break;
2740
2741             case DW_LNS_set_epilogue_begin:
2742               break;
2743
2744             case DW_LNS_set_isa:
2745               uladv = read_leb128 (data, & bytes_read, 0);
2746               data += bytes_read;
2747               printf (_("  Set ISA to %lu\n"), uladv);
2748               break;
2749
2750             default:
2751               printf (_("  Unknown opcode %d with operands: "), op_code);
2752
2753               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2754                 {
2755                   printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2756                           i == 1 ? "" : ", ");
2757                   data += bytes_read;
2758                 }
2759               putchar ('\n');
2760               break;
2761             }
2762
2763           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
2764              to the DWARF address/line matrix.  */
2765           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
2766               || (op_code == DW_LNS_copy))
2767             {
2768               const unsigned int MAX_FILENAME_LENGTH = 35;
2769               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
2770               char *newFileName = NULL;
2771               size_t fileNameLength = strlen (fileName);
2772
2773               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
2774                 {
2775                   newFileName = xmalloc (MAX_FILENAME_LENGTH + 1);
2776                   /* Truncate file name */
2777                   strncpy (newFileName,
2778                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
2779                            MAX_FILENAME_LENGTH + 1);
2780                 }
2781               else
2782                 {
2783                   newFileName = xmalloc (fileNameLength + 1);
2784                   strncpy (newFileName, fileName, fileNameLength + 1);
2785                 }
2786
2787               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
2788                 {
2789                   printf (_("%-35s  %11d  %#18lx\n"), newFileName,
2790                           state_machine_regs.line, state_machine_regs.address);
2791                 }
2792               else
2793                 {
2794                   printf (_("%s  %11d  %#18lx\n"), newFileName,
2795                           state_machine_regs.line, state_machine_regs.address);
2796                 }
2797
2798               if (op_code == DW_LNE_end_sequence)
2799                 printf ("\n");
2800
2801               free (newFileName);
2802             }
2803         }
2804       free (file_table);
2805       file_table = NULL;
2806       free (directory_table);
2807       directory_table = NULL;
2808       putchar ('\n');
2809     }
2810
2811   return 1;
2812 }
2813
2814 static int
2815 display_debug_lines (struct dwarf_section *section, void *file)
2816 {
2817   unsigned char *data = section->start;
2818   unsigned char *end = data + section->size;
2819   int retValRaw = 1;
2820   int retValDecoded = 1;
2821
2822   if (load_debug_info (file) == 0)
2823     {
2824       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2825             section->name);
2826       return 0;
2827     }
2828
2829   if (do_debug_lines == 0)
2830     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
2831
2832   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
2833     retValRaw = display_debug_lines_raw (section, data, end);
2834
2835   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
2836     retValDecoded = display_debug_lines_decoded (section, data, end);
2837
2838   if (!retValRaw || !retValDecoded)
2839     return 0;
2840
2841   return 1;
2842 }
2843
2844 static debug_info *
2845 find_debug_info_for_offset (unsigned long offset)
2846 {
2847   unsigned int i;
2848
2849   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2850     return NULL;
2851
2852   for (i = 0; i < num_debug_info_entries; i++)
2853     if (debug_information[i].cu_offset == offset)
2854       return debug_information + i;
2855
2856   return NULL;
2857 }
2858
2859 static int
2860 display_debug_pubnames (struct dwarf_section *section,
2861                         void *file ATTRIBUTE_UNUSED)
2862 {
2863   DWARF2_Internal_PubNames pubnames;
2864   unsigned char *start = section->start;
2865   unsigned char *end = start + section->size;
2866
2867   /* It does not matter if this load fails,
2868      we test for that later on.  */
2869   load_debug_info (file);
2870
2871   printf (_("Contents of the %s section:\n\n"), section->name);
2872
2873   while (start < end)
2874     {
2875       unsigned char *data;
2876       unsigned long offset;
2877       int offset_size, initial_length_size;
2878
2879       data = start;
2880
2881       pubnames.pn_length = byte_get (data, 4);
2882       data += 4;
2883       if (pubnames.pn_length == 0xffffffff)
2884         {
2885           pubnames.pn_length = byte_get (data, 8);
2886           data += 8;
2887           offset_size = 8;
2888           initial_length_size = 12;
2889         }
2890       else
2891         {
2892           offset_size = 4;
2893           initial_length_size = 4;
2894         }
2895
2896       pubnames.pn_version = byte_get (data, 2);
2897       data += 2;
2898
2899       pubnames.pn_offset = byte_get (data, offset_size);
2900       data += offset_size;
2901
2902       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2903           && num_debug_info_entries > 0
2904           && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2905         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2906               pubnames.pn_offset, section->name);
2907
2908       pubnames.pn_size = byte_get (data, offset_size);
2909       data += offset_size;
2910
2911       start += pubnames.pn_length + initial_length_size;
2912
2913       if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2914         {
2915           static int warned = 0;
2916
2917           if (! warned)
2918             {
2919               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2920               warned = 1;
2921             }
2922
2923           continue;
2924         }
2925
2926       printf (_("  Length:                              %ld\n"),
2927               pubnames.pn_length);
2928       printf (_("  Version:                             %d\n"),
2929               pubnames.pn_version);
2930       printf (_("  Offset into .debug_info section:     0x%lx\n"),
2931               pubnames.pn_offset);
2932       printf (_("  Size of area in .debug_info section: %ld\n"),
2933               pubnames.pn_size);
2934
2935       printf (_("\n    Offset\tName\n"));
2936
2937       do
2938         {
2939           offset = byte_get (data, offset_size);
2940
2941           if (offset != 0)
2942             {
2943               data += offset_size;
2944               printf ("    %-6lx\t%s\n", offset, data);
2945               data += strlen ((char *) data) + 1;
2946             }
2947         }
2948       while (offset != 0);
2949     }
2950
2951   printf ("\n");
2952   return 1;
2953 }
2954
2955 static int
2956 display_debug_macinfo (struct dwarf_section *section,
2957                        void *file ATTRIBUTE_UNUSED)
2958 {
2959   unsigned char *start = section->start;
2960   unsigned char *end = start + section->size;
2961   unsigned char *curr = start;
2962   unsigned int bytes_read;
2963   enum dwarf_macinfo_record_type op;
2964
2965   printf (_("Contents of the %s section:\n\n"), section->name);
2966
2967   while (curr < end)
2968     {
2969       unsigned int lineno;
2970       const char *string;
2971
2972       op = *curr;
2973       curr++;
2974
2975       switch (op)
2976         {
2977         case DW_MACINFO_start_file:
2978           {
2979             unsigned int filenum;
2980
2981             lineno = read_leb128 (curr, & bytes_read, 0);
2982             curr += bytes_read;
2983             filenum = read_leb128 (curr, & bytes_read, 0);
2984             curr += bytes_read;
2985
2986             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2987                     lineno, filenum);
2988           }
2989           break;
2990
2991         case DW_MACINFO_end_file:
2992           printf (_(" DW_MACINFO_end_file\n"));
2993           break;
2994
2995         case DW_MACINFO_define:
2996           lineno = read_leb128 (curr, & bytes_read, 0);
2997           curr += bytes_read;
2998           string = (char *) curr;
2999           curr += strlen (string) + 1;
3000           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3001                   lineno, string);
3002           break;
3003
3004         case DW_MACINFO_undef:
3005           lineno = read_leb128 (curr, & bytes_read, 0);
3006           curr += bytes_read;
3007           string = (char *) curr;
3008           curr += strlen (string) + 1;
3009           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3010                   lineno, string);
3011           break;
3012
3013         case DW_MACINFO_vendor_ext:
3014           {
3015             unsigned int constant;
3016
3017             constant = read_leb128 (curr, & bytes_read, 0);
3018             curr += bytes_read;
3019             string = (char *) curr;
3020             curr += strlen (string) + 1;
3021             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3022                     constant, string);
3023           }
3024           break;
3025         }
3026     }
3027
3028   return 1;
3029 }
3030
3031 static int
3032 display_debug_abbrev (struct dwarf_section *section,
3033                       void *file ATTRIBUTE_UNUSED)
3034 {
3035   abbrev_entry *entry;
3036   unsigned char *start = section->start;
3037   unsigned char *end = start + section->size;
3038
3039   printf (_("Contents of the %s section:\n\n"), section->name);
3040
3041   do
3042     {
3043       free_abbrevs ();
3044
3045       start = process_abbrev_section (start, end);
3046
3047       if (first_abbrev == NULL)
3048         continue;
3049
3050       printf (_("  Number TAG\n"));
3051
3052       for (entry = first_abbrev; entry; entry = entry->next)
3053         {
3054           abbrev_attr *attr;
3055
3056           printf (_("   %ld      %s    [%s]\n"),
3057                   entry->entry,
3058                   get_TAG_name (entry->tag),
3059                   entry->children ? _("has children") : _("no children"));
3060
3061           for (attr = entry->first_attr; attr; attr = attr->next)
3062             printf (_("    %-18s %s\n"),
3063                     get_AT_name (attr->attribute),
3064                     get_FORM_name (attr->form));
3065         }
3066     }
3067   while (start);
3068
3069   printf ("\n");
3070
3071   return 1;
3072 }
3073
3074 static int
3075 display_debug_loc (struct dwarf_section *section, void *file)
3076 {
3077   unsigned char *start = section->start;
3078   unsigned char *section_end;
3079   unsigned long bytes;
3080   unsigned char *section_begin = start;
3081   unsigned int num_loc_list = 0;
3082   unsigned long last_offset = 0;
3083   unsigned int first = 0;
3084   unsigned int i;
3085   unsigned int j;
3086   int seen_first_offset = 0;
3087   int use_debug_info = 1;
3088   unsigned char *next;
3089
3090   bytes = section->size;
3091   section_end = start + bytes;
3092
3093   if (bytes == 0)
3094     {
3095       printf (_("\nThe %s section is empty.\n"), section->name);
3096       return 0;
3097     }
3098
3099   if (load_debug_info (file) == 0)
3100     {
3101       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3102             section->name);
3103       return 0;
3104     }
3105
3106   /* Check the order of location list in .debug_info section. If
3107      offsets of location lists are in the ascending order, we can
3108      use `debug_information' directly.  */
3109   for (i = 0; i < num_debug_info_entries; i++)
3110     {
3111       unsigned int num;
3112
3113       num = debug_information [i].num_loc_offsets;
3114       num_loc_list += num;
3115
3116       /* Check if we can use `debug_information' directly.  */
3117       if (use_debug_info && num != 0)
3118         {
3119           if (!seen_first_offset)
3120             {
3121               /* This is the first location list.  */
3122               last_offset = debug_information [i].loc_offsets [0];
3123               first = i;
3124               seen_first_offset = 1;
3125               j = 1;
3126             }
3127           else
3128             j = 0;
3129
3130           for (; j < num; j++)
3131             {
3132               if (last_offset >
3133                   debug_information [i].loc_offsets [j])
3134                 {
3135                   use_debug_info = 0;
3136                   break;
3137                 }
3138               last_offset = debug_information [i].loc_offsets [j];
3139             }
3140         }
3141     }
3142
3143   if (!use_debug_info)
3144     /* FIXME: Should we handle this case?  */
3145     error (_("Location lists in .debug_info section aren't in ascending order!\n"));
3146
3147   if (!seen_first_offset)
3148     error (_("No location lists in .debug_info section!\n"));
3149
3150   /* DWARF sections under Mach-O have non-zero addresses.  */
3151   if (debug_information [first].num_loc_offsets > 0
3152       && debug_information [first].loc_offsets [0] != section->address)
3153     warn (_("Location lists in %s section start at 0x%lx\n"),
3154           section->name, debug_information [first].loc_offsets [0]);
3155
3156   printf (_("Contents of the %s section:\n\n"), section->name);
3157   printf (_("    Offset   Begin    End      Expression\n"));
3158
3159   seen_first_offset = 0;
3160   for (i = first; i < num_debug_info_entries; i++)
3161     {
3162       dwarf_vma begin;
3163       dwarf_vma end;
3164       unsigned short length;
3165       unsigned long offset;
3166       unsigned int pointer_size;
3167       unsigned long cu_offset;
3168       unsigned long base_address;
3169       int need_frame_base;
3170       int has_frame_base;
3171
3172       pointer_size = debug_information [i].pointer_size;
3173       cu_offset = debug_information [i].cu_offset;
3174
3175       for (j = 0; j < debug_information [i].num_loc_offsets; j++)
3176         {
3177           has_frame_base = debug_information [i].have_frame_base [j];
3178           /* DWARF sections under Mach-O have non-zero addresses.  */
3179           offset = debug_information [i].loc_offsets [j] - section->address;
3180           next = section_begin + offset;
3181           base_address = debug_information [i].base_address;
3182
3183           if (!seen_first_offset)
3184             seen_first_offset = 1;
3185           else
3186             {
3187               if (start < next)
3188                 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
3189                       (unsigned long) (start - section_begin),
3190                       (unsigned long) (next - section_begin));
3191               else if (start > next)
3192                 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
3193                       (unsigned long) (start - section_begin),
3194                       (unsigned long) (next - section_begin));
3195             }
3196           start = next;
3197
3198           if (offset >= bytes)
3199             {
3200               warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3201                     offset);
3202               continue;
3203             }
3204
3205           while (1)
3206             {
3207               if (start + 2 * pointer_size > section_end)
3208                 {
3209                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3210                         offset);
3211                   break;
3212                 }
3213
3214               /* Note: we use sign extension here in order to be sure that
3215                  we can detect the -1 escape value.  Sign extension into the
3216                  top 32 bits of a 32-bit address will not affect the values
3217                  that we display since we always show hex values, and always
3218                  the bottom 32-bits.  */
3219               begin = byte_get_signed (start, pointer_size);
3220               start += pointer_size;
3221               end = byte_get_signed (start, pointer_size);
3222               start += pointer_size;
3223
3224               printf ("    %8.8lx ", offset);
3225
3226               if (begin == 0 && end == 0)
3227                 {
3228                   printf (_("<End of list>\n"));
3229                   break;
3230                 }
3231
3232               /* Check base address specifiers.  */
3233               if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3234                 {
3235                   base_address = end;
3236                   print_dwarf_vma (begin, pointer_size);
3237                   print_dwarf_vma (end, pointer_size);
3238                   printf (_("(base address)\n"));
3239                   continue;
3240                 }
3241
3242               if (start + 2 > section_end)
3243                 {
3244                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3245                         offset);
3246                   break;
3247                 }
3248
3249               length = byte_get (start, 2);
3250               start += 2;
3251
3252               if (start + length > section_end)
3253                 {
3254                   warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3255                         offset);
3256                   break;
3257                 }
3258
3259               print_dwarf_vma (begin + base_address, pointer_size);
3260               print_dwarf_vma (end + base_address, pointer_size);
3261
3262               putchar ('(');
3263               need_frame_base = decode_location_expression (start,
3264                                                             pointer_size,
3265                                                             length,
3266                                                             cu_offset, section);
3267               putchar (')');
3268
3269               if (need_frame_base && !has_frame_base)
3270                 printf (_(" [without DW_AT_frame_base]"));
3271
3272               if (begin == end)
3273                 fputs (_(" (start == end)"), stdout);
3274               else if (begin > end)
3275                 fputs (_(" (start > end)"), stdout);
3276
3277               putchar ('\n');
3278
3279               start += length;
3280             }
3281         }
3282     }
3283
3284   if (start < section_end)
3285     warn (_("There are %ld unused bytes at the end of section %s\n"),
3286           (long) (section_end - start), section->name);
3287   putchar ('\n');
3288   return 1;
3289 }
3290
3291 static int
3292 display_debug_str (struct dwarf_section *section,
3293                    void *file ATTRIBUTE_UNUSED)
3294 {
3295   unsigned char *start = section->start;
3296   unsigned long bytes = section->size;
3297   dwarf_vma addr = section->address;
3298
3299   if (bytes == 0)
3300     {
3301       printf (_("\nThe %s section is empty.\n"), section->name);
3302       return 0;
3303     }
3304
3305   printf (_("Contents of the %s section:\n\n"), section->name);
3306
3307   while (bytes)
3308     {
3309       int j;
3310       int k;
3311       int lbytes;
3312
3313       lbytes = (bytes > 16 ? 16 : bytes);
3314
3315       printf ("  0x%8.8lx ", (unsigned long) addr);
3316
3317       for (j = 0; j < 16; j++)
3318         {
3319           if (j < lbytes)
3320             printf ("%2.2x", start[j]);
3321           else
3322             printf ("  ");
3323
3324           if ((j & 3) == 3)
3325             printf (" ");
3326         }
3327
3328       for (j = 0; j < lbytes; j++)
3329         {
3330           k = start[j];
3331           if (k >= ' ' && k < 0x80)
3332             printf ("%c", k);
3333           else
3334             printf (".");
3335         }
3336
3337       putchar ('\n');
3338
3339       start += lbytes;
3340       addr  += lbytes;
3341       bytes -= lbytes;
3342     }
3343
3344   putchar ('\n');
3345
3346   return 1;
3347 }
3348
3349 static int
3350 display_debug_info (struct dwarf_section *section, void *file)
3351 {
3352   return process_debug_info (section, file, 0);
3353 }
3354
3355
3356 static int
3357 display_debug_aranges (struct dwarf_section *section,
3358                        void *file ATTRIBUTE_UNUSED)
3359 {
3360   unsigned char *start = section->start;
3361   unsigned char *end = start + section->size;
3362
3363   printf (_("Contents of the %s section:\n\n"), section->name);
3364
3365   /* It does not matter if this load fails,
3366      we test for that later on.  */
3367   load_debug_info (file);
3368
3369   while (start < end)
3370     {
3371       unsigned char *hdrptr;
3372       DWARF2_Internal_ARange arange;
3373       unsigned char *ranges;
3374       dwarf_vma length;
3375       dwarf_vma address;
3376       unsigned char address_size;
3377       int excess;
3378       int offset_size;
3379       int initial_length_size;
3380
3381       hdrptr = start;
3382
3383       arange.ar_length = byte_get (hdrptr, 4);
3384       hdrptr += 4;
3385
3386       if (arange.ar_length == 0xffffffff)
3387         {
3388           arange.ar_length = byte_get (hdrptr, 8);
3389           hdrptr += 8;
3390           offset_size = 8;
3391           initial_length_size = 12;
3392         }
3393       else
3394         {
3395           offset_size = 4;
3396           initial_length_size = 4;
3397         }
3398
3399       arange.ar_version = byte_get (hdrptr, 2);
3400       hdrptr += 2;
3401
3402       arange.ar_info_offset = byte_get (hdrptr, offset_size);
3403       hdrptr += offset_size;
3404
3405       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3406           && num_debug_info_entries > 0
3407           && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3408         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3409               arange.ar_info_offset, section->name);
3410
3411       arange.ar_pointer_size = byte_get (hdrptr, 1);
3412       hdrptr += 1;
3413
3414       arange.ar_segment_size = byte_get (hdrptr, 1);
3415       hdrptr += 1;
3416
3417       if (arange.ar_version != 2 && arange.ar_version != 3)
3418         {
3419           warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3420           break;
3421         }
3422
3423       printf (_("  Length:                   %ld\n"), arange.ar_length);
3424       printf (_("  Version:                  %d\n"), arange.ar_version);
3425       printf (_("  Offset into .debug_info:  0x%lx\n"), arange.ar_info_offset);
3426       printf (_("  Pointer Size:             %d\n"), arange.ar_pointer_size);
3427       printf (_("  Segment Size:             %d\n"), arange.ar_segment_size);
3428
3429       address_size = arange.ar_pointer_size + arange.ar_segment_size;
3430
3431       /* The DWARF spec does not require that the address size be a power
3432          of two, but we do.  This will have to change if we ever encounter
3433          an uneven architecture.  */
3434       if ((address_size & (address_size - 1)) != 0)
3435         {
3436           warn (_("Pointer size + Segment size is not a power of two.\n"));
3437           break;
3438         }
3439
3440       if (address_size > 4)
3441         printf (_("\n    Address            Length\n"));
3442       else
3443         printf (_("\n    Address    Length\n"));
3444
3445       ranges = hdrptr;
3446
3447       /* Must pad to an alignment boundary that is twice the address size.  */
3448       excess = (hdrptr - start) % (2 * address_size);
3449       if (excess)
3450         ranges += (2 * address_size) - excess;
3451
3452       start += arange.ar_length + initial_length_size;
3453
3454       while (ranges + 2 * address_size <= start)
3455         {
3456           address = byte_get (ranges, address_size);
3457
3458           ranges += address_size;
3459
3460           length  = byte_get (ranges, address_size);
3461
3462           ranges += address_size;
3463
3464           printf ("    ");
3465           print_dwarf_vma (address, address_size);
3466           print_dwarf_vma (length, address_size);
3467           putchar ('\n');
3468         }
3469     }
3470
3471   printf ("\n");
3472
3473   return 1;
3474 }
3475
3476 /* Each debug_information[x].range_lists[y] gets this representation for
3477    sorting purposes.  */
3478
3479 struct range_entry
3480   {
3481     /* The debug_information[x].range_lists[y] value.  */
3482     unsigned long ranges_offset;
3483
3484     /* Original debug_information to find parameters of the data.  */
3485     debug_info *debug_info_p;
3486   };
3487
3488 /* Sort struct range_entry in ascending order of its RANGES_OFFSET.  */
3489
3490 static int
3491 range_entry_compar (const void *ap, const void *bp)
3492 {
3493   const struct range_entry *a_re = ap;
3494   const struct range_entry *b_re = bp;
3495   const unsigned long a = a_re->ranges_offset;
3496   const unsigned long b = b_re->ranges_offset;
3497
3498   return (a > b) - (b > a);
3499 }
3500
3501 static int
3502 display_debug_ranges (struct dwarf_section *section,
3503                       void *file ATTRIBUTE_UNUSED)
3504 {
3505   unsigned char *start = section->start;
3506   unsigned char *section_end;
3507   unsigned long bytes;
3508   unsigned char *section_begin = start;
3509   unsigned int num_range_list, i;
3510   struct range_entry *range_entries, *range_entry_fill;
3511
3512   bytes = section->size;
3513   section_end = start + bytes;
3514
3515   if (bytes == 0)
3516     {
3517       printf (_("\nThe %s section is empty.\n"), section->name);
3518       return 0;
3519     }
3520
3521   if (load_debug_info (file) == 0)
3522     {
3523       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3524             section->name);
3525       return 0;
3526     }
3527
3528   num_range_list = 0;
3529   for (i = 0; i < num_debug_info_entries; i++)
3530     num_range_list += debug_information [i].num_range_lists;
3531
3532   if (num_range_list == 0)
3533     error (_("No range lists in .debug_info section!\n"));
3534
3535   range_entries = xmalloc (sizeof (*range_entries) * num_range_list);
3536   range_entry_fill = range_entries;
3537
3538   for (i = 0; i < num_debug_info_entries; i++)
3539     {
3540       debug_info *debug_info_p = &debug_information[i];
3541       unsigned int j;
3542
3543       for (j = 0; j < debug_info_p->num_range_lists; j++)
3544         {
3545           range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
3546           range_entry_fill->debug_info_p = debug_info_p;
3547           range_entry_fill++;
3548         }
3549     }
3550
3551   qsort (range_entries, num_range_list, sizeof (*range_entries),
3552          range_entry_compar);
3553
3554   /* DWARF sections under Mach-O have non-zero addresses.  */
3555   if (range_entries[0].ranges_offset != section->address)
3556     warn (_("Range lists in %s section start at 0x%lx\n"),
3557           section->name, range_entries[0].ranges_offset);
3558
3559   printf (_("Contents of the %s section:\n\n"), section->name);
3560   printf (_("    Offset   Begin    End\n"));
3561
3562   for (i = 0; i < num_range_list; i++)
3563     {
3564       struct range_entry *range_entry = &range_entries[i];
3565       debug_info *debug_info_p = range_entry->debug_info_p;
3566       unsigned int pointer_size;
3567       unsigned long offset;
3568       unsigned char *next;
3569       unsigned long base_address;
3570
3571       pointer_size = debug_info_p->pointer_size;
3572
3573       /* DWARF sections under Mach-O have non-zero addresses.  */
3574       offset = range_entry->ranges_offset - section->address;
3575       next = section_begin + offset;
3576       base_address = debug_info_p->base_address;
3577
3578       if (i > 0)
3579         {
3580           if (start < next)
3581             warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3582                   (unsigned long) (start - section_begin),
3583                   (unsigned long) (next - section_begin), section->name);
3584           else if (start > next)
3585             warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3586                   (unsigned long) (start - section_begin),
3587                   (unsigned long) (next - section_begin), section->name);
3588         }
3589       start = next;
3590
3591       while (1)
3592         {
3593           dwarf_vma begin;
3594           dwarf_vma end;
3595
3596           /* Note: we use sign extension here in order to be sure that
3597              we can detect the -1 escape value.  Sign extension into the
3598              top 32 bits of a 32-bit address will not affect the values
3599              that we display since we always show hex values, and always
3600              the bottom 32-bits.  */
3601           begin = byte_get_signed (start, pointer_size);
3602           start += pointer_size;
3603           end = byte_get_signed (start, pointer_size);
3604           start += pointer_size;
3605
3606           printf ("    %8.8lx ", offset);
3607
3608           if (begin == 0 && end == 0)
3609             {
3610               printf (_("<End of list>\n"));
3611               break;
3612             }
3613
3614           /* Check base address specifiers.  */
3615           if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3616             {
3617               base_address = end;
3618               print_dwarf_vma (begin, pointer_size);
3619               print_dwarf_vma (end, pointer_size);
3620               printf ("(base address)\n");
3621               continue;
3622             }
3623
3624           print_dwarf_vma (begin + base_address, pointer_size);
3625           print_dwarf_vma (end + base_address, pointer_size);
3626
3627           if (begin == end)
3628             fputs (_("(start == end)"), stdout);
3629           else if (begin > end)
3630             fputs (_("(start > end)"), stdout);
3631
3632           putchar ('\n');
3633         }
3634     }
3635   putchar ('\n');
3636
3637   free (range_entries);
3638
3639   return 1;
3640 }
3641
3642 typedef struct Frame_Chunk
3643 {
3644   struct Frame_Chunk *next;
3645   unsigned char *chunk_start;
3646   int ncols;
3647   /* DW_CFA_{undefined,same_value,offset,register,unreferenced}  */
3648   short int *col_type;
3649   int *col_offset;
3650   char *augmentation;
3651   unsigned int code_factor;
3652   int data_factor;
3653   unsigned long pc_begin;
3654   unsigned long pc_range;
3655   int cfa_reg;
3656   int cfa_offset;
3657   int ra;
3658   unsigned char fde_encoding;
3659   unsigned char cfa_exp;
3660 }
3661 Frame_Chunk;
3662
3663 static const char *const *dwarf_regnames;
3664 static unsigned int dwarf_regnames_count;
3665
3666 /* A marker for a col_type that means this column was never referenced
3667    in the frame info.  */
3668 #define DW_CFA_unreferenced (-1)
3669
3670 /* Return 0 if not more space is needed, 1 if more space is needed,
3671    -1 for invalid reg.  */
3672
3673 static int
3674 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3675 {
3676   int prev = fc->ncols;
3677
3678   if (reg < (unsigned int) fc->ncols)
3679     return 0;
3680
3681   if (dwarf_regnames_count
3682       && reg > dwarf_regnames_count)
3683     return -1;
3684
3685   fc->ncols = reg + 1;
3686   fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3687   fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3688
3689   while (prev < fc->ncols)
3690     {
3691       fc->col_type[prev] = DW_CFA_unreferenced;
3692       fc->col_offset[prev] = 0;
3693       prev++;
3694     }
3695   return 1;
3696 }
3697
3698 static const char *const dwarf_regnames_i386[] =
3699 {
3700   "eax", "ecx", "edx", "ebx",
3701   "esp", "ebp", "esi", "edi",
3702   "eip", "eflags", NULL,
3703   "st0", "st1", "st2", "st3",
3704   "st4", "st5", "st6", "st7",
3705   NULL, NULL,
3706   "xmm0", "xmm1", "xmm2", "xmm3",
3707   "xmm4", "xmm5", "xmm6", "xmm7",
3708   "mm0", "mm1", "mm2", "mm3",
3709   "mm4", "mm5", "mm6", "mm7",
3710   "fcw", "fsw", "mxcsr",
3711   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3712   "tr", "ldtr"
3713 };
3714
3715 static const char *const dwarf_regnames_x86_64[] =
3716 {
3717   "rax", "rdx", "rcx", "rbx",
3718   "rsi", "rdi", "rbp", "rsp",
3719   "r8",  "r9",  "r10", "r11",
3720   "r12", "r13", "r14", "r15",
3721   "rip",
3722   "xmm0",  "xmm1",  "xmm2",  "xmm3",
3723   "xmm4",  "xmm5",  "xmm6",  "xmm7",
3724   "xmm8",  "xmm9",  "xmm10", "xmm11",
3725   "xmm12", "xmm13", "xmm14", "xmm15",
3726   "st0", "st1", "st2", "st3",
3727   "st4", "st5", "st6", "st7",
3728   "mm0", "mm1", "mm2", "mm3",
3729   "mm4", "mm5", "mm6", "mm7",
3730   "rflags",
3731   "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3732   "fs.base", "gs.base", NULL, NULL,
3733   "tr", "ldtr",
3734   "mxcsr", "fcw", "fsw"
3735 };
3736
3737 void
3738 init_dwarf_regnames (unsigned int e_machine)
3739 {
3740   switch (e_machine)
3741     {
3742     case EM_386:
3743     case EM_486:
3744       dwarf_regnames = dwarf_regnames_i386;
3745       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3746       break;
3747
3748     case EM_X86_64:
3749       dwarf_regnames = dwarf_regnames_x86_64;
3750       dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
3751       break;
3752
3753     default:
3754       break;
3755     }
3756 }
3757
3758 static const char *
3759 regname (unsigned int regno, int row)
3760 {
3761   static char reg[64];
3762   if (dwarf_regnames
3763       && regno < dwarf_regnames_count
3764       && dwarf_regnames [regno] != NULL)
3765     {
3766       if (row)
3767         return dwarf_regnames [regno];
3768       snprintf (reg, sizeof (reg), "r%d (%s)", regno,
3769                 dwarf_regnames [regno]);
3770     }
3771   else
3772     snprintf (reg, sizeof (reg), "r%d", regno);
3773   return reg;
3774 }
3775
3776 static void
3777 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3778 {
3779   int r;
3780   char tmp[100];
3781
3782   if (*max_regs < fc->ncols)
3783     *max_regs = fc->ncols;
3784
3785   if (*need_col_headers)
3786     {
3787       static const char *loc = "   LOC";
3788
3789       *need_col_headers = 0;
3790
3791       printf ("%-*s CFA      ", eh_addr_size * 2, loc);
3792
3793       for (r = 0; r < *max_regs; r++)
3794         if (fc->col_type[r] != DW_CFA_unreferenced)
3795           {
3796             if (r == fc->ra)
3797               printf ("ra      ");
3798             else
3799               printf ("%-5s ", regname (r, 1));
3800           }
3801
3802       printf ("\n");
3803     }
3804
3805   printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
3806   if (fc->cfa_exp)
3807     strcpy (tmp, "exp");
3808   else
3809     sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
3810   printf ("%-8s ", tmp);
3811
3812   for (r = 0; r < fc->ncols; r++)
3813     {
3814       if (fc->col_type[r] != DW_CFA_unreferenced)
3815         {
3816           switch (fc->col_type[r])
3817             {
3818             case DW_CFA_undefined:
3819               strcpy (tmp, "u");
3820               break;
3821             case DW_CFA_same_value:
3822               strcpy (tmp, "s");
3823               break;
3824             case DW_CFA_offset:
3825               sprintf (tmp, "c%+d", fc->col_offset[r]);
3826               break;
3827             case DW_CFA_val_offset:
3828               sprintf (tmp, "v%+d", fc->col_offset[r]);
3829               break;
3830             case DW_CFA_register:
3831               sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
3832               break;
3833             case DW_CFA_expression:
3834               strcpy (tmp, "exp");
3835               break;
3836             case DW_CFA_val_expression:
3837               strcpy (tmp, "vexp");
3838               break;
3839             default:
3840               strcpy (tmp, "n/a");
3841               break;
3842             }
3843           printf ("%-5s ", tmp);
3844         }
3845     }
3846   printf ("\n");
3847 }
3848
3849 #define GET(N)  byte_get (start, N); start += N
3850 #define LEB()   read_leb128 (start, & length_return, 0); start += length_return
3851 #define SLEB()  read_leb128 (start, & length_return, 1); start += length_return
3852
3853 static int
3854 display_debug_frames (struct dwarf_section *section,
3855                       void *file ATTRIBUTE_UNUSED)
3856 {
3857   unsigned char *start = section->start;
3858   unsigned char *end = start + section->size;
3859   unsigned char *section_start = start;
3860   Frame_Chunk *chunks = 0;
3861   Frame_Chunk *remembered_state = 0;
3862   Frame_Chunk *rs;
3863   int is_eh = strcmp (section->name, ".eh_frame") == 0;
3864   unsigned int length_return;
3865   int max_regs = 0;
3866   const char *bad_reg = _("bad register: ");
3867
3868   printf (_("Contents of the %s section:\n"), section->name);
3869
3870   while (start < end)
3871     {
3872       unsigned char *saved_start;
3873       unsigned char *block_end;
3874       unsigned long length;
3875       unsigned long cie_id;
3876       Frame_Chunk *fc;
3877       Frame_Chunk *cie;
3878       int need_col_headers = 1;
3879       unsigned char *augmentation_data = NULL;
3880       unsigned long augmentation_data_len = 0;
3881       int encoded_ptr_size = eh_addr_size;
3882       int offset_size;
3883       int initial_length_size;
3884
3885       saved_start = start;
3886       length = byte_get (start, 4); start += 4;
3887
3888       if (length == 0)
3889         {
3890           printf ("\n%08lx ZERO terminator\n\n",
3891                     (unsigned long)(saved_start - section_start));
3892           continue;
3893         }
3894
3895       if (length == 0xffffffff)
3896         {
3897           length = byte_get (start, 8);
3898           start += 8;
3899           offset_size = 8;
3900           initial_length_size = 12;
3901         }
3902       else
3903         {
3904           offset_size = 4;
3905           initial_length_size = 4;
3906         }
3907
3908       block_end = saved_start + length + initial_length_size;
3909       if (block_end > end)
3910         {
3911           warn ("Invalid length %#08lx in FDE at %#08lx\n",
3912                 length, (unsigned long)(saved_start - section_start));
3913           block_end = end;
3914         }
3915       cie_id = byte_get (start, offset_size); start += offset_size;
3916
3917       if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3918         {
3919           int version;
3920
3921           fc = xmalloc (sizeof (Frame_Chunk));
3922           memset (fc, 0, sizeof (Frame_Chunk));
3923
3924           fc->next = chunks;
3925           chunks = fc;
3926           fc->chunk_start = saved_start;
3927           fc->ncols = 0;
3928           fc->col_type = xmalloc (sizeof (short int));
3929           fc->col_offset = xmalloc (sizeof (int));
3930           frame_need_space (fc, max_regs - 1);
3931
3932           version = *start++;
3933
3934           fc->augmentation = (char *) start;
3935           start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3936
3937           if (fc->augmentation[0] == 'z')
3938             {
3939               fc->code_factor = LEB ();
3940               fc->data_factor = SLEB ();
3941               if (version == 1)
3942                 {
3943                   fc->ra = GET (1);
3944                 }
3945               else
3946                 {
3947                   fc->ra = LEB ();
3948                 }
3949               augmentation_data_len = LEB ();
3950               augmentation_data = start;
3951               start += augmentation_data_len;
3952             }
3953           else if (strcmp (fc->augmentation, "eh") == 0)
3954             {
3955               start += eh_addr_size;
3956               fc->code_factor = LEB ();
3957               fc->data_factor = SLEB ();
3958               if (version == 1)
3959                 {
3960                   fc->ra = GET (1);
3961                 }
3962               else
3963                 {
3964                   fc->ra = LEB ();
3965                 }
3966             }
3967           else
3968             {
3969               fc->code_factor = LEB ();
3970               fc->data_factor = SLEB ();
3971               if (version == 1)
3972                 {
3973                   fc->ra = GET (1);
3974                 }
3975               else
3976                 {
3977                   fc->ra = LEB ();
3978                 }
3979             }
3980           cie = fc;
3981
3982           if (do_debug_frames_interp)
3983             printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3984                     (unsigned long)(saved_start - section_start), length, cie_id,
3985                     fc->augmentation, fc->code_factor, fc->data_factor,
3986                     fc->ra);
3987           else
3988             {
3989               printf ("\n%08lx %08lx %08lx CIE\n",
3990                       (unsigned long)(saved_start - section_start), length, cie_id);
3991               printf ("  Version:               %d\n", version);
3992               printf ("  Augmentation:          \"%s\"\n", fc->augmentation);
3993               printf ("  Code alignment factor: %u\n", fc->code_factor);
3994               printf ("  Data alignment factor: %d\n", fc->data_factor);
3995               printf ("  Return address column: %d\n", fc->ra);
3996
3997               if (augmentation_data_len)
3998                 {
3999                   unsigned long i;
4000                   printf ("  Augmentation data:    ");
4001                   for (i = 0; i < augmentation_data_len; ++i)
4002                     printf (" %02x", augmentation_data[i]);
4003                   putchar ('\n');
4004                 }
4005               putchar ('\n');
4006             }
4007
4008           if (augmentation_data_len)
4009             {
4010               unsigned char *p, *q;
4011               p = (unsigned char *) fc->augmentation + 1;
4012               q = augmentation_data;
4013
4014               while (1)
4015                 {
4016                   if (*p == 'L')
4017                     q++;
4018                   else if (*p == 'P')
4019                     q += 1 + size_of_encoded_value (*q);
4020                   else if (*p == 'R')
4021                     fc->fde_encoding = *q++;
4022                   else
4023                     break;
4024                   p++;
4025                 }
4026
4027               if (fc->fde_encoding)
4028                 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4029             }
4030
4031           frame_need_space (fc, fc->ra);
4032         }
4033       else
4034         {
4035           unsigned char *look_for;
4036           static Frame_Chunk fde_fc;
4037
4038           fc = & fde_fc;
4039           memset (fc, 0, sizeof (Frame_Chunk));
4040
4041           look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4042
4043           for (cie = chunks; cie ; cie = cie->next)
4044             if (cie->chunk_start == look_for)
4045               break;
4046
4047           if (!cie)
4048             {
4049               warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4050                     cie_id, (unsigned long)(saved_start - section_start));
4051               fc->ncols = 0;
4052               fc->col_type = xmalloc (sizeof (short int));
4053               fc->col_offset = xmalloc (sizeof (int));
4054               frame_need_space (fc, max_regs - 1);
4055               cie = fc;
4056               fc->augmentation = "";
4057               fc->fde_encoding = 0;
4058             }
4059           else
4060             {
4061               fc->ncols = cie->ncols;
4062               fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
4063               fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
4064               memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4065               memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4066               fc->augmentation = cie->augmentation;
4067               fc->code_factor = cie->code_factor;
4068               fc->data_factor = cie->data_factor;
4069               fc->cfa_reg = cie->cfa_reg;
4070               fc->cfa_offset = cie->cfa_offset;
4071               fc->ra = cie->ra;
4072               frame_need_space (fc, max_regs - 1);
4073               fc->fde_encoding = cie->fde_encoding;
4074             }
4075
4076           if (fc->fde_encoding)
4077             encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4078
4079           fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4080           if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4081             fc->pc_begin += section->address + (start - section_start);
4082           start += encoded_ptr_size;
4083           fc->pc_range = byte_get (start, encoded_ptr_size);
4084           start += encoded_ptr_size;
4085
4086           if (cie->augmentation[0] == 'z')
4087             {
4088               augmentation_data_len = LEB ();
4089               augmentation_data = start;
4090               start += augmentation_data_len;
4091             }
4092
4093           printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4094                   (unsigned long)(saved_start - section_start), length, cie_id,
4095                   (unsigned long)(cie->chunk_start - section_start),
4096                   fc->pc_begin, fc->pc_begin + fc->pc_range);
4097           if (! do_debug_frames_interp && augmentation_data_len)
4098             {
4099               unsigned long i;
4100
4101               printf ("  Augmentation data:    ");
4102               for (i = 0; i < augmentation_data_len; ++i)
4103                 printf (" %02x", augmentation_data[i]);
4104               putchar ('\n');
4105               putchar ('\n');
4106             }
4107         }
4108
4109       /* At this point, fc is the current chunk, cie (if any) is set, and
4110          we're about to interpret instructions for the chunk.  */
4111       /* ??? At present we need to do this always, since this sizes the
4112          fc->col_type and fc->col_offset arrays, which we write into always.
4113          We should probably split the interpreted and non-interpreted bits
4114          into two different routines, since there's so much that doesn't
4115          really overlap between them.  */
4116       if (1 || do_debug_frames_interp)
4117         {
4118           /* Start by making a pass over the chunk, allocating storage
4119              and taking note of what registers are used.  */
4120           unsigned char *tmp = start;
4121
4122           while (start < block_end)
4123             {
4124               unsigned op, opa;
4125               unsigned long reg, tmp;
4126
4127               op = *start++;
4128               opa = op & 0x3f;
4129               if (op & 0xc0)
4130                 op &= 0xc0;
4131
4132               /* Warning: if you add any more cases to this switch, be
4133                  sure to add them to the corresponding switch below.  */
4134               switch (op)
4135                 {
4136                 case DW_CFA_advance_loc:
4137                   break;
4138                 case DW_CFA_offset:
4139                   LEB ();
4140                   if (frame_need_space (fc, opa) >= 0)
4141                     fc->col_type[opa] = DW_CFA_undefined;
4142                   break;
4143                 case DW_CFA_restore:
4144                   if (frame_need_space (fc, opa) >= 0)
4145                     fc->col_type[opa] = DW_CFA_undefined;
4146                   break;
4147                 case DW_CFA_set_loc:
4148                   start += encoded_ptr_size;
4149                   break;
4150                 case DW_CFA_advance_loc1:
4151                   start += 1;
4152                   break;
4153                 case DW_CFA_advance_loc2:
4154                   start += 2;
4155                   break;
4156                 case DW_CFA_advance_loc4:
4157                   start += 4;
4158                   break;
4159                 case DW_CFA_offset_extended:
4160                 case DW_CFA_val_offset:
4161                   reg = LEB (); LEB ();
4162                   if (frame_need_space (fc, reg) >= 0)
4163                     fc->col_type[reg] = DW_CFA_undefined;
4164                   break;
4165                 case DW_CFA_restore_extended:
4166                   reg = LEB ();
4167                   frame_need_space (fc, reg);
4168                   if (frame_need_space (fc, reg) >= 0)
4169                     fc->col_type[reg] = DW_CFA_undefined;
4170                   break;
4171                 case DW_CFA_undefined:
4172                   reg = LEB ();
4173                   if (frame_need_space (fc, reg) >= 0)
4174                     fc->col_type[reg] = DW_CFA_undefined;
4175                   break;
4176                 case DW_CFA_same_value:
4177                   reg = LEB ();
4178                   if (frame_need_space (fc, reg) >= 0)
4179                     fc->col_type[reg] = DW_CFA_undefined;
4180                   break;
4181                 case DW_CFA_register:
4182                   reg = LEB (); LEB ();
4183                   if (frame_need_space (fc, reg) >= 0)
4184                     fc->col_type[reg] = DW_CFA_undefined;
4185                   break;
4186                 case DW_CFA_def_cfa:
4187                   LEB (); LEB ();
4188                   break;
4189                 case DW_CFA_def_cfa_register:
4190                   LEB ();
4191                   break;
4192                 case DW_CFA_def_cfa_offset:
4193                   LEB ();
4194                   break;
4195                 case DW_CFA_def_cfa_expression:
4196                   tmp = LEB ();
4197                   start += tmp;
4198                   break;
4199                 case DW_CFA_expression:
4200                 case DW_CFA_val_expression:
4201                   reg = LEB ();
4202                   tmp = LEB ();
4203                   start += tmp;
4204                   if (frame_need_space (fc, reg) >= 0)
4205                     fc->col_type[reg] = DW_CFA_undefined;
4206                   break;
4207                 case DW_CFA_offset_extended_sf:
4208                 case DW_CFA_val_offset_sf:
4209                   reg = LEB (); SLEB ();
4210                   if (frame_need_space (fc, reg) >= 0)
4211                     fc->col_type[reg] = DW_CFA_undefined;
4212                   break;
4213                 case DW_CFA_def_cfa_sf:
4214                   LEB (); SLEB ();
4215                   break;
4216                 case DW_CFA_def_cfa_offset_sf:
4217                   SLEB ();
4218                   break;
4219                 case DW_CFA_MIPS_advance_loc8:
4220                   start += 8;
4221                   break;
4222                 case DW_CFA_GNU_args_size:
4223                   LEB ();
4224                   break;
4225                 case DW_CFA_GNU_negative_offset_extended:
4226                   reg = LEB (); LEB ();
4227                   if (frame_need_space (fc, reg) >= 0)
4228                     fc->col_type[reg] = DW_CFA_undefined;
4229                   break;
4230                 default:
4231                   break;
4232                 }
4233             }
4234           start = tmp;
4235         }
4236
4237       /* Now we know what registers are used, make a second pass over
4238          the chunk, this time actually printing out the info.  */
4239
4240       while (start < block_end)
4241         {
4242           unsigned op, opa;
4243           unsigned long ul, reg, roffs;
4244           long l, ofs;
4245           dwarf_vma vma;
4246           const char *reg_prefix = "";
4247
4248           op = *start++;
4249           opa = op & 0x3f;
4250           if (op & 0xc0)
4251             op &= 0xc0;
4252
4253           /* Warning: if you add any more cases to this switch, be
4254              sure to add them to the corresponding switch above.  */
4255           switch (op)
4256             {
4257             case DW_CFA_advance_loc:
4258               if (do_debug_frames_interp)
4259                 frame_display_row (fc, &need_col_headers, &max_regs);
4260               else
4261                 printf ("  DW_CFA_advance_loc: %d to %08lx\n",
4262                         opa * fc->code_factor,
4263                         fc->pc_begin + opa * fc->code_factor);
4264               fc->pc_begin += opa * fc->code_factor;
4265               break;
4266
4267             case DW_CFA_offset:
4268               roffs = LEB ();
4269               if (opa >= (unsigned int) fc->ncols)
4270                 reg_prefix = bad_reg;
4271               if (! do_debug_frames_interp || *reg_prefix != '\0')
4272                 printf ("  DW_CFA_offset: %s%s at cfa%+ld\n",
4273                         reg_prefix, regname (opa, 0),
4274                         roffs * fc->data_factor);
4275               if (*reg_prefix == '\0')
4276                 {
4277                   fc->col_type[opa] = DW_CFA_offset;
4278                   fc->col_offset[opa] = roffs * fc->data_factor;
4279                 }
4280               break;
4281
4282             case DW_CFA_restore:
4283               if (opa >= (unsigned int) cie->ncols
4284                   || opa >= (unsigned int) fc->ncols)
4285                 reg_prefix = bad_reg;
4286               if (! do_debug_frames_interp || *reg_prefix != '\0')
4287                 printf ("  DW_CFA_restore: %s%s\n",
4288                         reg_prefix, regname (opa, 0));
4289               if (*reg_prefix == '\0')
4290                 {
4291                   fc->col_type[opa] = cie->col_type[opa];
4292                   fc->col_offset[opa] = cie->col_offset[opa];
4293                 }
4294               break;
4295
4296             case DW_CFA_set_loc:
4297               vma = get_encoded_value (start, fc->fde_encoding);
4298               if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4299                 vma += section->address + (start - section_start);
4300               start += encoded_ptr_size;
4301               if (do_debug_frames_interp)
4302                 frame_display_row (fc, &need_col_headers, &max_regs);
4303               else
4304                 printf ("  DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4305               fc->pc_begin = vma;
4306               break;
4307
4308             case DW_CFA_advance_loc1:
4309               ofs = byte_get (start, 1); start += 1;
4310               if (do_debug_frames_interp)
4311                 frame_display_row (fc, &need_col_headers, &max_regs);
4312               else
4313                 printf ("  DW_CFA_advance_loc1: %ld to %08lx\n",
4314                         ofs * fc->code_factor,
4315                         fc->pc_begin + ofs * fc->code_factor);
4316               fc->pc_begin += ofs * fc->code_factor;
4317               break;
4318
4319             case DW_CFA_advance_loc2:
4320               ofs = byte_get (start, 2); start += 2;
4321               if (do_debug_frames_interp)
4322                 frame_display_row (fc, &need_col_headers, &max_regs);
4323               else
4324                 printf ("  DW_CFA_advance_loc2: %ld to %08lx\n",
4325                         ofs * fc->code_factor,
4326                         fc->pc_begin + ofs * fc->code_factor);
4327               fc->pc_begin += ofs * fc->code_factor;
4328               break;
4329
4330             case DW_CFA_advance_loc4:
4331               ofs = byte_get (start, 4); start += 4;
4332               if (do_debug_frames_interp)
4333                 frame_display_row (fc, &need_col_headers, &max_regs);
4334               else
4335                 printf ("  DW_CFA_advance_loc4: %ld to %08lx\n",
4336                         ofs * fc->code_factor,
4337                         fc->pc_begin + ofs * fc->code_factor);
4338               fc->pc_begin += ofs * fc->code_factor;
4339               break;
4340
4341             case DW_CFA_offset_extended:
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_offset_extended: %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_offset;
4353                   fc->col_offset[reg] = roffs * fc->data_factor;
4354                 }
4355               break;
4356
4357             case DW_CFA_val_offset:
4358               reg = LEB ();
4359               roffs = LEB ();
4360               if (reg >= (unsigned int) fc->ncols)
4361                 reg_prefix = bad_reg;
4362               if (! do_debug_frames_interp || *reg_prefix != '\0')
4363                 printf ("  DW_CFA_val_offset: %s%s at cfa%+ld\n",
4364                         reg_prefix, regname (reg, 0),
4365                         roffs * fc->data_factor);
4366               if (*reg_prefix == '\0')
4367                 {
4368                   fc->col_type[reg] = DW_CFA_val_offset;
4369                   fc->col_offset[reg] = roffs * fc->data_factor;
4370                 }
4371               break;
4372
4373             case DW_CFA_restore_extended:
4374               reg = LEB ();
4375               if (reg >= (unsigned int) cie->ncols
4376                   || reg >= (unsigned int) fc->ncols)
4377                 reg_prefix = bad_reg;
4378               if (! do_debug_frames_interp || *reg_prefix != '\0')
4379                 printf ("  DW_CFA_restore_extended: %s%s\n",
4380                         reg_prefix, regname (reg, 0));
4381               if (*reg_prefix == '\0')
4382                 {
4383                   fc->col_type[reg] = cie->col_type[reg];
4384                   fc->col_offset[reg] = cie->col_offset[reg];
4385                 }
4386               break;
4387
4388             case DW_CFA_undefined:
4389               reg = LEB ();
4390               if (reg >= (unsigned int) fc->ncols)
4391                 reg_prefix = bad_reg;
4392               if (! do_debug_frames_interp || *reg_prefix != '\0')
4393                 printf ("  DW_CFA_undefined: %s%s\n",
4394                         reg_prefix, regname (reg, 0));
4395               if (*reg_prefix == '\0')
4396                 {
4397                   fc->col_type[reg] = DW_CFA_undefined;
4398                   fc->col_offset[reg] = 0;
4399                 }
4400               break;
4401
4402             case DW_CFA_same_value:
4403               reg = LEB ();
4404               if (reg >= (unsigned int) fc->ncols)
4405                 reg_prefix = bad_reg;
4406               if (! do_debug_frames_interp || *reg_prefix != '\0')
4407                 printf ("  DW_CFA_same_value: %s%s\n",
4408                         reg_prefix, regname (reg, 0));
4409               if (*reg_prefix == '\0')
4410                 {
4411                   fc->col_type[reg] = DW_CFA_same_value;
4412                   fc->col_offset[reg] = 0;
4413                 }
4414               break;
4415
4416             case DW_CFA_register:
4417               reg = LEB ();
4418               roffs = LEB ();
4419               if (reg >= (unsigned int) fc->ncols)
4420                 reg_prefix = bad_reg;
4421               if (! do_debug_frames_interp || *reg_prefix != '\0')
4422                 {
4423                   printf ("  DW_CFA_register: %s%s in ",
4424                           reg_prefix, regname (reg, 0));
4425                   puts (regname (roffs, 0));
4426                 }
4427               if (*reg_prefix == '\0')
4428                 {
4429                   fc->col_type[reg] = DW_CFA_register;
4430                   fc->col_offset[reg] = roffs;
4431                 }
4432               break;
4433
4434             case DW_CFA_remember_state:
4435               if (! do_debug_frames_interp)
4436                 printf ("  DW_CFA_remember_state\n");
4437               rs = xmalloc (sizeof (Frame_Chunk));
4438               rs->ncols = fc->ncols;
4439               rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
4440               rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
4441               memcpy (rs->col_type, fc->col_type, rs->ncols);
4442               memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4443               rs->next = remembered_state;
4444               remembered_state = rs;
4445               break;
4446
4447             case DW_CFA_restore_state:
4448               if (! do_debug_frames_interp)
4449                 printf ("  DW_CFA_restore_state\n");
4450               rs = remembered_state;
4451               if (rs)
4452                 {
4453                   remembered_state = rs->next;
4454                   frame_need_space (fc, rs->ncols - 1);
4455                   memcpy (fc->col_type, rs->col_type, rs->ncols);
4456                   memcpy (fc->col_offset, rs->col_offset,
4457                           rs->ncols * sizeof (int));
4458                   free (rs->col_type);
4459                   free (rs->col_offset);
4460                   free (rs);
4461                 }
4462               else if (do_debug_frames_interp)
4463                 printf ("Mismatched DW_CFA_restore_state\n");
4464               break;
4465
4466             case DW_CFA_def_cfa:
4467               fc->cfa_reg = LEB ();
4468               fc->cfa_offset = LEB ();
4469               fc->cfa_exp = 0;
4470               if (! do_debug_frames_interp)
4471                 printf ("  DW_CFA_def_cfa: %s ofs %d\n",
4472                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4473               break;
4474
4475             case DW_CFA_def_cfa_register:
4476               fc->cfa_reg = LEB ();
4477               fc->cfa_exp = 0;
4478               if (! do_debug_frames_interp)
4479                 printf ("  DW_CFA_def_cfa_register: %s\n",
4480                         regname (fc->cfa_reg, 0));
4481               break;
4482
4483             case DW_CFA_def_cfa_offset:
4484               fc->cfa_offset = LEB ();
4485               if (! do_debug_frames_interp)
4486                 printf ("  DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4487               break;
4488
4489             case DW_CFA_nop:
4490               if (! do_debug_frames_interp)
4491                 printf ("  DW_CFA_nop\n");
4492               break;
4493
4494             case DW_CFA_def_cfa_expression:
4495               ul = LEB ();
4496               if (! do_debug_frames_interp)
4497                 {
4498                   printf ("  DW_CFA_def_cfa_expression (");
4499                   decode_location_expression (start, eh_addr_size, ul, 0,
4500                                               section);
4501                   printf (")\n");
4502                 }
4503               fc->cfa_exp = 1;
4504               start += ul;
4505               break;
4506
4507             case DW_CFA_expression:
4508               reg = LEB ();
4509               ul = LEB ();
4510               if (reg >= (unsigned int) fc->ncols)
4511                 reg_prefix = bad_reg;
4512               if (! do_debug_frames_interp || *reg_prefix != '\0')
4513                 {
4514                   printf ("  DW_CFA_expression: %s%s (",
4515                           reg_prefix, regname (reg, 0));
4516                   decode_location_expression (start, eh_addr_size,
4517                                               ul, 0, section);
4518                   printf (")\n");
4519                 }
4520               if (*reg_prefix == '\0')
4521                 fc->col_type[reg] = DW_CFA_expression;
4522               start += ul;
4523               break;
4524
4525             case DW_CFA_val_expression:
4526               reg = LEB ();
4527               ul = LEB ();
4528               if (reg >= (unsigned int) fc->ncols)
4529                 reg_prefix = bad_reg;
4530               if (! do_debug_frames_interp || *reg_prefix != '\0')
4531                 {
4532                   printf ("  DW_CFA_val_expression: %s%s (",
4533                           reg_prefix, regname (reg, 0));
4534                   decode_location_expression (start, eh_addr_size, ul, 0,
4535                                               section);
4536                   printf (")\n");
4537                 }
4538               if (*reg_prefix == '\0')
4539                 fc->col_type[reg] = DW_CFA_val_expression;
4540               start += ul;
4541               break;
4542
4543             case DW_CFA_offset_extended_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_offset_extended_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_offset;
4555                   fc->col_offset[reg] = l * fc->data_factor;
4556                 }
4557               break;
4558
4559             case DW_CFA_val_offset_sf:
4560               reg = LEB ();
4561               l = SLEB ();
4562               if (frame_need_space (fc, reg) < 0)
4563                 reg_prefix = bad_reg;
4564               if (! do_debug_frames_interp || *reg_prefix != '\0')
4565                 printf ("  DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4566                         reg_prefix, regname (reg, 0),
4567                         l * fc->data_factor);
4568               if (*reg_prefix == '\0')
4569                 {
4570                   fc->col_type[reg] = DW_CFA_val_offset;
4571                   fc->col_offset[reg] = l * fc->data_factor;
4572                 }
4573               break;
4574
4575             case DW_CFA_def_cfa_sf:
4576               fc->cfa_reg = LEB ();
4577               fc->cfa_offset = SLEB ();
4578               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4579               fc->cfa_exp = 0;
4580               if (! do_debug_frames_interp)
4581                 printf ("  DW_CFA_def_cfa_sf: %s ofs %d\n",
4582                         regname (fc->cfa_reg, 0), fc->cfa_offset);
4583               break;
4584
4585             case DW_CFA_def_cfa_offset_sf:
4586               fc->cfa_offset = SLEB ();
4587               fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4588               if (! do_debug_frames_interp)
4589                 printf ("  DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4590               break;
4591
4592             case DW_CFA_MIPS_advance_loc8:
4593               ofs = byte_get (start, 8); start += 8;
4594               if (do_debug_frames_interp)
4595                 frame_display_row (fc, &need_col_headers, &max_regs);
4596               else
4597                 printf ("  DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4598                         ofs * fc->code_factor,
4599                         fc->pc_begin + ofs * fc->code_factor);
4600               fc->pc_begin += ofs * fc->code_factor;
4601               break;
4602
4603             case DW_CFA_GNU_window_save:
4604               if (! do_debug_frames_interp)
4605                 printf ("  DW_CFA_GNU_window_save\n");
4606               break;
4607
4608             case DW_CFA_GNU_args_size:
4609               ul = LEB ();
4610               if (! do_debug_frames_interp)
4611                 printf ("  DW_CFA_GNU_args_size: %ld\n", ul);
4612               break;
4613
4614             case DW_CFA_GNU_negative_offset_extended:
4615               reg = LEB ();
4616               l = - LEB ();
4617               if (frame_need_space (fc, reg) < 0)
4618                 reg_prefix = bad_reg;
4619               if (! do_debug_frames_interp || *reg_prefix != '\0')
4620                 printf ("  DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4621                         reg_prefix, regname (reg, 0),
4622                         l * fc->data_factor);
4623               if (*reg_prefix == '\0')
4624                 {
4625                   fc->col_type[reg] = DW_CFA_offset;
4626                   fc->col_offset[reg] = l * fc->data_factor;
4627                 }
4628               break;
4629
4630             default:
4631               if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4632                 printf (_("  DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4633               else
4634                 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4635               start = block_end;
4636             }
4637         }
4638
4639       if (do_debug_frames_interp)
4640         frame_display_row (fc, &need_col_headers, &max_regs);
4641
4642       start = block_end;
4643     }
4644
4645   printf ("\n");
4646
4647   return 1;
4648 }
4649
4650 #undef GET
4651 #undef LEB
4652 #undef SLEB
4653
4654 static int
4655 display_debug_not_supported (struct dwarf_section *section,
4656                              void *file ATTRIBUTE_UNUSED)
4657 {
4658   printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4659             section->name);
4660
4661   return 1;
4662 }
4663
4664 void *
4665 cmalloc (size_t nmemb, size_t size)
4666 {
4667   /* Check for overflow.  */
4668   if (nmemb >= ~(size_t) 0 / size)
4669     return NULL;
4670   else
4671     return malloc (nmemb * size);
4672 }
4673
4674 void *
4675 xcmalloc (size_t nmemb, size_t size)
4676 {
4677   /* Check for overflow.  */
4678   if (nmemb >= ~(size_t) 0 / size)
4679     return NULL;
4680   else
4681     return xmalloc (nmemb * size);
4682 }
4683
4684 void *
4685 xcrealloc (void *ptr, size_t nmemb, size_t size)
4686 {
4687   /* Check for overflow.  */
4688   if (nmemb >= ~(size_t) 0 / size)
4689     return NULL;
4690   else
4691     return xrealloc (ptr, nmemb * size);
4692 }
4693
4694 void
4695 error (const char *message, ...)
4696 {
4697   va_list args;
4698
4699   va_start (args, message);
4700   fprintf (stderr, _("%s: Error: "), program_name);
4701   vfprintf (stderr, message, args);
4702   va_end (args);
4703 }
4704
4705 void
4706 warn (const char *message, ...)
4707 {
4708   va_list args;
4709
4710   va_start (args, message);
4711   fprintf (stderr, _("%s: Warning: "), program_name);
4712   vfprintf (stderr, message, args);
4713   va_end (args);
4714 }
4715
4716 void
4717 free_debug_memory (void)
4718 {
4719   enum dwarf_section_display_enum i;
4720
4721   free_abbrevs ();
4722
4723   for (i = 0; i < max; i++)
4724     free_debug_section (i);
4725
4726   if (debug_information != NULL)
4727     {
4728       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4729         {
4730           for (i = 0; i < num_debug_info_entries; i++)
4731             {
4732               if (!debug_information [i].max_loc_offsets)
4733                 {
4734                   free (debug_information [i].loc_offsets);
4735                   free (debug_information [i].have_frame_base);
4736                 }
4737               if (!debug_information [i].max_range_lists)
4738                 free (debug_information [i].range_lists);
4739             }
4740         }
4741
4742       free (debug_information);
4743       debug_information = NULL;
4744       num_debug_info_entries = 0;
4745     }
4746 }
4747
4748 void
4749 dwarf_select_sections_by_names (const char *names)
4750 {
4751   typedef struct
4752   {
4753     const char * option;
4754     int *        variable;
4755     int val;
4756   }
4757   debug_dump_long_opts;
4758
4759   static const debug_dump_long_opts opts_table [] =
4760     {
4761       /* Please keep this table alpha- sorted.  */
4762       { "Ranges", & do_debug_ranges, 1 },
4763       { "abbrev", & do_debug_abbrevs, 1 },
4764       { "aranges", & do_debug_aranges, 1 },
4765       { "frames", & do_debug_frames, 1 },
4766       { "frames-interp", & do_debug_frames_interp, 1 },
4767       { "info", & do_debug_info, 1 },
4768       { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility.  */
4769       { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4770       { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4771       { "loc",  & do_debug_loc, 1 },
4772       { "macro", & do_debug_macinfo, 1 },
4773       { "pubnames", & do_debug_pubnames, 1 },
4774       /* This entry is for compatability
4775          with earlier versions of readelf.  */
4776       { "ranges", & do_debug_aranges, 1 },
4777       { "str", & do_debug_str, 1 },
4778       { NULL, NULL, 0 }
4779     };
4780
4781   const char *p;
4782
4783   p = names;
4784   while (*p)
4785     {
4786       const debug_dump_long_opts * entry;
4787
4788       for (entry = opts_table; entry->option; entry++)
4789         {
4790           size_t len = strlen (entry->option);
4791
4792           if (strncmp (p, entry->option, len) == 0
4793               && (p[len] == ',' || p[len] == '\0'))
4794             {
4795               * entry->variable |= entry->val;
4796
4797               /* The --debug-dump=frames-interp option also
4798                  enables the --debug-dump=frames option.  */
4799               if (do_debug_frames_interp)
4800                 do_debug_frames = 1;
4801
4802               p += len;
4803               break;
4804             }
4805         }
4806
4807       if (entry->option == NULL)
4808         {
4809           warn (_("Unrecognized debug option '%s'\n"), p);
4810           p = strchr (p, ',');
4811           if (p == NULL)
4812             break;
4813         }
4814
4815       if (*p == ',')
4816         p++;
4817     }
4818 }
4819
4820 void
4821 dwarf_select_sections_by_letters (const char *letters)
4822 {
4823   unsigned int index = 0;
4824
4825   while (letters[index])
4826     switch (letters[index++])
4827       {
4828       case 'i':
4829         do_debug_info = 1;
4830         break;
4831
4832       case 'a':
4833         do_debug_abbrevs = 1;
4834         break;
4835
4836       case 'l':
4837         do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4838         break;
4839
4840       case 'L':
4841         do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
4842         break;
4843
4844       case 'p':
4845         do_debug_pubnames = 1;
4846         break;
4847
4848       case 'r':
4849         do_debug_aranges = 1;
4850         break;
4851
4852       case 'R':
4853         do_debug_ranges = 1;
4854         break;
4855
4856       case 'F':
4857         do_debug_frames_interp = 1;
4858       case 'f':
4859         do_debug_frames = 1;
4860         break;
4861
4862       case 'm':
4863         do_debug_macinfo = 1;
4864         break;
4865
4866       case 's':
4867         do_debug_str = 1;
4868         break;
4869
4870       case 'o':
4871         do_debug_loc = 1;
4872         break;
4873
4874       default:
4875         warn (_("Unrecognized debug option '%s'\n"), optarg);
4876         break;
4877       }
4878 }
4879
4880 void
4881 dwarf_select_sections_all (void)
4882 {
4883   do_debug_info = 1;
4884   do_debug_abbrevs = 1;
4885   do_debug_lines = FLAG_DEBUG_LINES_RAW;
4886   do_debug_pubnames = 1;
4887   do_debug_aranges = 1;
4888   do_debug_ranges = 1;
4889   do_debug_frames = 1;
4890   do_debug_macinfo = 1;
4891   do_debug_str = 1;
4892   do_debug_loc = 1;
4893 }
4894
4895 struct dwarf_section_display debug_displays[] =
4896 {
4897   { { ".debug_abbrev",          ".zdebug_abbrev",       NULL,   NULL,   0,      0 },
4898     display_debug_abbrev,               &do_debug_abbrevs,      0 },
4899   { { ".debug_aranges",         ".zdebug_aranges",      NULL,   NULL,   0,      0 },
4900     display_debug_aranges,              &do_debug_aranges,      1 },
4901   { { ".debug_frame",           ".zdebug_frame",        NULL,   NULL,   0,      0 },
4902     display_debug_frames,               &do_debug_frames,       1 },
4903   { { ".debug_info",            ".zdebug_info",         NULL,   NULL,   0,      0 },
4904     display_debug_info,                 &do_debug_info,         1 },
4905   { { ".debug_line",            ".zdebug_line",         NULL,   NULL,   0,      0 },
4906     display_debug_lines,                &do_debug_lines,        1 },
4907   { { ".debug_pubnames",        ".zdebug_pubnames",     NULL,   NULL,   0,      0 },
4908     display_debug_pubnames,             &do_debug_pubnames,     0 },
4909   { { ".eh_frame",              "",                     NULL,   NULL,   0,      0 },
4910     display_debug_frames,               &do_debug_frames,       1 },
4911   { { ".debug_macinfo",         ".zdebug_macinfo",      NULL,   NULL,   0,      0 },
4912     display_debug_macinfo,              &do_debug_macinfo,      0 },
4913   { { ".debug_str",             ".zdebug_str",          NULL,   NULL,   0,      0 },
4914     display_debug_str,                  &do_debug_str,          0 },
4915   { { ".debug_loc",             ".zdebug_loc",          NULL,   NULL,   0,      0 },
4916     display_debug_loc,                  &do_debug_loc,          1 },
4917   { { ".debug_pubtypes",        ".zdebug_pubtypes",     NULL,   NULL,   0,      0 },
4918     display_debug_pubnames,             &do_debug_pubnames,     0 },
4919   { { ".debug_ranges",          ".zdebug_ranges",       NULL,   NULL,   0,      0 },
4920     display_debug_ranges,               &do_debug_ranges,       1 },
4921   { { ".debug_static_func",     ".zdebug_static_func",  NULL,   NULL,   0,      0 },
4922     display_debug_not_supported,        NULL,                   0 },
4923   { { ".debug_static_vars",     ".zdebug_static_vars",  NULL,   NULL,   0,      0 },
4924     display_debug_not_supported,        NULL,                   0 },
4925   { { ".debug_types",           ".zdebug_types",        NULL,   NULL,   0,      0 },
4926     display_debug_not_supported,        NULL,                   0 },
4927   { { ".debug_weaknames",       ".zdebug_weaknames",    NULL,   NULL,   0,      0 },
4928     display_debug_not_supported,        NULL,                   0 }
4929 };