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