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