binutils/dwarf.c

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