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