Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / binutils / dwarf.c
1 /* dwarf.c -- display DWARF contents of a BFD binary file
2    Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011
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 "bfd_stdint.h"
26 #include "bucomm.h"
27 #include "elfcomm.h"
28 #include "elf/common.h"
29 #include "dwarf2.h"
30 #include "dwarf.h"
31
32 static const char *regname (unsigned int regno, int row);
33
34 static int have_frame_base;
35 static int need_base_address;
36
37 static unsigned int last_pointer_size = 0;
38 static int warned_about_missing_comp_units = FALSE;
39
40 static unsigned int num_debug_info_entries = 0;
41 static debug_info *debug_information = NULL;
42 /* Special value for num_debug_info_entries to indicate
43    that the .debug_info section could not be loaded/parsed.  */
44 #define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1
45
46 int eh_addr_size;
47
48 int do_debug_info;
49 int do_debug_abbrevs;
50 int do_debug_lines;
51 int do_debug_pubnames;
52 int do_debug_pubtypes;
53 int do_debug_aranges;
54 int do_debug_ranges;
55 int do_debug_frames;
56 int do_debug_frames_interp;
57 int do_debug_macinfo;
58 int do_debug_str;
59 int do_debug_loc;
60 int do_gdb_index;
61 int do_trace_info;
62 int do_trace_abbrevs;
63 int do_trace_aranges;
64 int do_wide;
65
66 int dwarf_cutoff_level = -1;
67 unsigned long dwarf_start_die;
68
69 /* Values for do_debug_lines.  */
70 #define FLAG_DEBUG_LINES_RAW     1
71 #define FLAG_DEBUG_LINES_DECODED 2
72
73 static int
74 size_of_encoded_value (int encoding)
75 {
76   switch (encoding & 0x7)
77     {
78     default:    /* ??? */
79     case 0:     return eh_addr_size;
80     case 2:     return 2;
81     case 3:     return 4;
82     case 4:     return 8;
83     }
84 }
85
86 static dwarf_vma
87 get_encoded_value (unsigned char *data,
88                    int encoding,
89                    struct dwarf_section *section)
90 {
91   int size = size_of_encoded_value (encoding);
92   dwarf_vma val;
93
94   if (encoding & DW_EH_PE_signed)
95     val = byte_get_signed (data, size);
96   else
97     val = byte_get (data, size);
98
99   if ((encoding & 0x70) == DW_EH_PE_pcrel)
100     val += section->address + (data - section->start);
101   return val;
102 }
103
104 /* Print a dwarf_vma value (typically an address, offset or length) in
105    hexadecimal format, followed by a space.  The length of the value (and
106    hence the precision displayed) is determined by the byte_size parameter.  */
107
108 static void
109 print_dwarf_vma (dwarf_vma val, unsigned byte_size)
110 {
111   static char buff[18];
112   int offset = 0;
113
114   /* Printf does not have a way of specifiying a maximum field width for an
115      integer value, so we print the full value into a buffer and then select
116      the precision we need.  */
117 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
118 #ifndef __MINGW32__
119   snprintf (buff, sizeof (buff), "%16.16llx ", val);
120 #else
121   snprintf (buff, sizeof (buff), "%016I64x ", val);
122 #endif
123 #else
124   snprintf (buff, sizeof (buff), "%16.16lx ", val);
125 #endif
126
127   if (byte_size != 0)
128     {
129       if (byte_size > 0 && byte_size <= 8)
130         offset = 16 - 2 * byte_size;
131       else
132         error ("Wrong size in print_dwarf_vma");
133     }
134
135   fputs (buff + offset, stdout);
136 }
137
138 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
139 #ifndef __MINGW32__
140 #define  DWARF_VMA_FMT "ll"
141 #else
142 #define  DWARF_VMA_FMT "I64"
143 #endif
144 #else
145 #define  DWARF_VMA_FMT "l"
146 #endif
147
148 static const char *
149 dwarf_vmatoa (const char *fmtch, dwarf_vma value)
150 {
151   /* As dwarf_vmatoa is used more then once in a printf call
152      for output, we are cycling through an fixed array of pointers
153      for return address.  */
154   static int buf_pos = 0;
155   static struct dwarf_vmatoa_buf
156   {
157     char place[64];
158   } buf[16];
159   char fmt[32];
160   char *ret;
161
162   sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
163
164   ret = buf[buf_pos++].place;
165   buf_pos %= ARRAY_SIZE (buf);
166
167   snprintf (ret, sizeof (buf[0].place), fmt, value);
168
169   return ret;
170 }
171
172 dwarf_vma
173 read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
174 {
175   dwarf_vma result = 0;
176   unsigned int num_read = 0;
177   unsigned int shift = 0;
178   unsigned char byte;
179
180   do
181     {
182       byte = *data++;
183       num_read++;
184
185       result |= ((dwarf_vma) (byte & 0x7f)) << shift;
186
187       shift += 7;
188
189     }
190   while (byte & 0x80);
191
192   if (length_return != NULL)
193     *length_return = num_read;
194
195   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
196     result |= -1L << shift;
197
198   return result;
199 }
200
201 /* Create a signed version to avoid painful typecasts.  */
202 static dwarf_signed_vma
203 read_sleb128 (unsigned char *data, unsigned int *length_return)
204 {
205   return (dwarf_signed_vma) read_leb128 (data, length_return, 1);
206 }
207
208 typedef struct State_Machine_Registers
209 {
210   dwarf_vma address;
211   unsigned int file;
212   unsigned int line;
213   unsigned int column;
214   int is_stmt;
215   int basic_block;
216   unsigned char op_index;
217   unsigned char end_sequence;
218 /* This variable hold the number of the last entry seen
219    in the File Table.  */
220   unsigned int last_file_entry;
221 } SMR;
222
223 static SMR state_machine_regs;
224
225 static void
226 reset_state_machine (int is_stmt)
227 {
228   state_machine_regs.address = 0;
229   state_machine_regs.op_index = 0;
230   state_machine_regs.file = 1;
231   state_machine_regs.line = 1;
232   state_machine_regs.column = 0;
233   state_machine_regs.is_stmt = is_stmt;
234   state_machine_regs.basic_block = 0;
235   state_machine_regs.end_sequence = 0;
236   state_machine_regs.last_file_entry = 0;
237 }
238
239 /* Handled an extend line op.
240    Returns the number of bytes read.  */
241
242 static int
243 process_extended_line_op (unsigned char *data, int is_stmt)
244 {
245   unsigned char op_code;
246   unsigned int bytes_read;
247   unsigned int len;
248   unsigned char *name;
249   dwarf_vma adr;
250
251   len = read_leb128 (data, & bytes_read, 0);
252   data += bytes_read;
253
254   if (len == 0)
255     {
256       warn (_("badly formed extended line op encountered!\n"));
257       return bytes_read;
258     }
259
260   len += bytes_read;
261   op_code = *data++;
262
263   printf (_("  Extended opcode %d: "), op_code);
264
265   switch (op_code)
266     {
267     case DW_LNE_end_sequence:
268       printf (_("End of Sequence\n\n"));
269       reset_state_machine (is_stmt);
270       break;
271
272     case DW_LNE_set_address:
273       adr = byte_get (data, len - bytes_read - 1);
274       printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
275       state_machine_regs.address = adr;
276       state_machine_regs.op_index = 0;
277       break;
278
279     case DW_LNE_define_file:
280       printf (_("  define new File Table entry\n"));
281       printf (_("  Entry\tDir\tTime\tSize\tName\n"));
282
283       printf ("   %d\t", ++state_machine_regs.last_file_entry);
284       name = data;
285       data += strlen ((char *) data) + 1;
286       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
287       data += bytes_read;
288       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
289       data += bytes_read;
290       printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
291       printf ("%s\n\n", name);
292       break;
293
294     case DW_LNE_set_discriminator:
295       printf (_("set Discriminator to %s\n"),
296               dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
297       break;
298
299     /* HP extensions.  */
300     case DW_LNE_HP_negate_is_UV_update:
301       printf ("DW_LNE_HP_negate_is_UV_update\n");
302       break;
303     case DW_LNE_HP_push_context:
304       printf ("DW_LNE_HP_push_context\n");
305       break;
306     case DW_LNE_HP_pop_context:
307       printf ("DW_LNE_HP_pop_context\n");
308       break;
309     case DW_LNE_HP_set_file_line_column:
310       printf ("DW_LNE_HP_set_file_line_column\n");
311       break;
312     case DW_LNE_HP_set_routine_name:
313       printf ("DW_LNE_HP_set_routine_name\n");
314       break;
315     case DW_LNE_HP_set_sequence:
316       printf ("DW_LNE_HP_set_sequence\n");
317       break;
318     case DW_LNE_HP_negate_post_semantics:
319       printf ("DW_LNE_HP_negate_post_semantics\n");
320       break;
321     case DW_LNE_HP_negate_function_exit:
322       printf ("DW_LNE_HP_negate_function_exit\n");
323       break;
324     case DW_LNE_HP_negate_front_end_logical:
325       printf ("DW_LNE_HP_negate_front_end_logical\n");
326       break;
327     case DW_LNE_HP_define_proc:
328       printf ("DW_LNE_HP_define_proc\n");
329       break;
330     case DW_LNE_HP_source_file_correlation:
331       {
332         unsigned char *edata = data + len - bytes_read - 1;
333
334         printf ("DW_LNE_HP_source_file_correlation\n");
335
336         while (data < edata)
337           {
338             unsigned int opc;
339
340             opc = read_leb128 (data, & bytes_read, 0);
341             data += bytes_read;
342
343             switch (opc)
344               {
345               case DW_LNE_HP_SFC_formfeed:
346                 printf ("    DW_LNE_HP_SFC_formfeed\n");
347                 break;
348               case DW_LNE_HP_SFC_set_listing_line:
349                 printf ("    DW_LNE_HP_SFC_set_listing_line (%s)\n",
350                         dwarf_vmatoa ("u",
351                                       read_leb128 (data, & bytes_read, 0)));
352                 data += bytes_read;
353                 break;
354               case DW_LNE_HP_SFC_associate:
355                 printf ("    DW_LNE_HP_SFC_associate ");
356                 printf (_("(%s"),
357                         dwarf_vmatoa ("u",
358                                       read_leb128 (data, & bytes_read, 0)));
359                 data += bytes_read;
360                 printf (_(",%s"),
361                         dwarf_vmatoa ("u",
362                                       read_leb128 (data, & bytes_read, 0)));
363                 data += bytes_read;
364                 printf (_(",%s)\n"),
365                         dwarf_vmatoa ("u",
366                                       read_leb128 (data, & bytes_read, 0)));
367                 data += bytes_read;
368                 break;
369               default:
370                 printf ("    UNKNOW DW_LNE_HP_SFC opcode (%u)\n", opc);
371                 data = edata;
372                 break;
373               }
374           }
375       }
376       break;
377
378     default:
379       {
380         unsigned int rlen = len - bytes_read - 1;
381
382         if (op_code >= DW_LNE_lo_user
383             /* The test against DW_LNW_hi_user is redundant due to
384                the limited range of the unsigned char data type used
385                for op_code.  */
386             /*&& op_code <= DW_LNE_hi_user*/)
387           printf (_("user defined: "));
388         else
389           printf (_("UNKNOWN: "));
390         printf (_("length %d ["), rlen);
391         for (; rlen; rlen--)
392           printf (" %02x", *data++);
393         printf ("]\n");
394       }
395       break;
396     }
397
398   return len;
399 }
400
401 static const char *
402 fetch_indirect_string (dwarf_vma offset)
403 {
404   struct dwarf_section *section = &debug_displays [str].section;
405
406   if (section->start == NULL)
407     return _("<no .debug_str section>");
408
409   /* DWARF sections under Mach-O have non-zero addresses.  */
410   offset -= section->address;
411   if (offset > section->size)
412     {
413       warn (_("DW_FORM_strp offset too big: %s\n"),
414             dwarf_vmatoa ("x", offset));
415       return _("<offset is too big>");
416     }
417
418   return (const char *) section->start + offset;
419 }
420
421 /* FIXME:  There are better and more efficient ways to handle
422    these structures.  For now though, I just want something that
423    is simple to implement.  */
424 typedef struct abbrev_attr
425 {
426   unsigned long attribute;
427   unsigned long form;
428   struct abbrev_attr *next;
429 }
430 abbrev_attr;
431
432 typedef struct abbrev_entry
433 {
434   unsigned long entry;
435   unsigned long tag;
436   int children;
437   struct abbrev_attr *first_attr;
438   struct abbrev_attr *last_attr;
439   struct abbrev_entry *next;
440 }
441 abbrev_entry;
442
443 static abbrev_entry *first_abbrev = NULL;
444 static abbrev_entry *last_abbrev = NULL;
445
446 static void
447 free_abbrevs (void)
448 {
449   abbrev_entry *abbrv;
450
451   for (abbrv = first_abbrev; abbrv;)
452     {
453       abbrev_entry *next_abbrev = abbrv->next;
454       abbrev_attr *attr;
455
456       for (attr = abbrv->first_attr; attr;)
457         {
458           abbrev_attr *next_attr = attr->next;
459
460           free (attr);
461           attr = next_attr;
462         }
463
464       free (abbrv);
465       abbrv = next_abbrev;
466     }
467
468   last_abbrev = first_abbrev = NULL;
469 }
470
471 static void
472 add_abbrev (unsigned long number, unsigned long tag, int children)
473 {
474   abbrev_entry *entry;
475
476   entry = (abbrev_entry *) malloc (sizeof (*entry));
477   if (entry == NULL)
478     /* ugg */
479     return;
480
481   entry->entry      = number;
482   entry->tag        = tag;
483   entry->children   = children;
484   entry->first_attr = NULL;
485   entry->last_attr  = NULL;
486   entry->next       = NULL;
487
488   if (first_abbrev == NULL)
489     first_abbrev = entry;
490   else
491     last_abbrev->next = entry;
492
493   last_abbrev = entry;
494 }
495
496 static void
497 add_abbrev_attr (unsigned long attribute, unsigned long form)
498 {
499   abbrev_attr *attr;
500
501   attr = (abbrev_attr *) malloc (sizeof (*attr));
502   if (attr == NULL)
503     /* ugg */
504     return;
505
506   attr->attribute = attribute;
507   attr->form      = form;
508   attr->next      = NULL;
509
510   if (last_abbrev->first_attr == NULL)
511     last_abbrev->first_attr = attr;
512   else
513     last_abbrev->last_attr->next = attr;
514
515   last_abbrev->last_attr = attr;
516 }
517
518 /* Processes the (partial) contents of a .debug_abbrev section.
519    Returns NULL if the end of the section was encountered.
520    Returns the address after the last byte read if the end of
521    an abbreviation set was found.  */
522
523 static unsigned char *
524 process_abbrev_section (unsigned char *start, unsigned char *end)
525 {
526   if (first_abbrev != NULL)
527     return NULL;
528
529   while (start < end)
530     {
531       unsigned int bytes_read;
532       unsigned long entry;
533       unsigned long tag;
534       unsigned long attribute;
535       int children;
536
537       entry = read_leb128 (start, & bytes_read, 0);
538       start += bytes_read;
539
540       /* A single zero is supposed to end the section according
541          to the standard.  If there's more, then signal that to
542          the caller.  */
543       if (entry == 0)
544         return start == end ? NULL : start;
545
546       tag = read_leb128 (start, & bytes_read, 0);
547       start += bytes_read;
548
549       children = *start++;
550
551       add_abbrev (entry, tag, children);
552
553       do
554         {
555           unsigned long form;
556
557           attribute = read_leb128 (start, & bytes_read, 0);
558           start += bytes_read;
559
560           form = read_leb128 (start, & bytes_read, 0);
561           start += bytes_read;
562
563           if (attribute != 0)
564             add_abbrev_attr (attribute, form);
565         }
566       while (attribute != 0);
567     }
568
569   return NULL;
570 }
571
572 static char *
573 get_TAG_name (unsigned long tag)
574 {
575   switch (tag)
576     {
577     case DW_TAG_padding:                return "DW_TAG_padding";
578     case DW_TAG_array_type:             return "DW_TAG_array_type";
579     case DW_TAG_class_type:             return "DW_TAG_class_type";
580     case DW_TAG_entry_point:            return "DW_TAG_entry_point";
581     case DW_TAG_enumeration_type:       return "DW_TAG_enumeration_type";
582     case DW_TAG_formal_parameter:       return "DW_TAG_formal_parameter";
583     case DW_TAG_imported_declaration:   return "DW_TAG_imported_declaration";
584     case DW_TAG_label:                  return "DW_TAG_label";
585     case DW_TAG_lexical_block:          return "DW_TAG_lexical_block";
586     case DW_TAG_member:                 return "DW_TAG_member";
587     case DW_TAG_pointer_type:           return "DW_TAG_pointer_type";
588     case DW_TAG_reference_type:         return "DW_TAG_reference_type";
589     case DW_TAG_compile_unit:           return "DW_TAG_compile_unit";
590     case DW_TAG_string_type:            return "DW_TAG_string_type";
591     case DW_TAG_structure_type:         return "DW_TAG_structure_type";
592     case DW_TAG_subroutine_type:        return "DW_TAG_subroutine_type";
593     case DW_TAG_typedef:                return "DW_TAG_typedef";
594     case DW_TAG_union_type:             return "DW_TAG_union_type";
595     case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
596     case DW_TAG_variant:                return "DW_TAG_variant";
597     case DW_TAG_common_block:           return "DW_TAG_common_block";
598     case DW_TAG_common_inclusion:       return "DW_TAG_common_inclusion";
599     case DW_TAG_inheritance:            return "DW_TAG_inheritance";
600     case DW_TAG_inlined_subroutine:     return "DW_TAG_inlined_subroutine";
601     case DW_TAG_module:                 return "DW_TAG_module";
602     case DW_TAG_ptr_to_member_type:     return "DW_TAG_ptr_to_member_type";
603     case DW_TAG_set_type:               return "DW_TAG_set_type";
604     case DW_TAG_subrange_type:          return "DW_TAG_subrange_type";
605     case DW_TAG_with_stmt:              return "DW_TAG_with_stmt";
606     case DW_TAG_access_declaration:     return "DW_TAG_access_declaration";
607     case DW_TAG_base_type:              return "DW_TAG_base_type";
608     case DW_TAG_catch_block:            return "DW_TAG_catch_block";
609     case DW_TAG_const_type:             return "DW_TAG_const_type";
610     case DW_TAG_constant:               return "DW_TAG_constant";
611     case DW_TAG_enumerator:             return "DW_TAG_enumerator";
612     case DW_TAG_file_type:              return "DW_TAG_file_type";
613     case DW_TAG_friend:                 return "DW_TAG_friend";
614     case DW_TAG_namelist:               return "DW_TAG_namelist";
615     case DW_TAG_namelist_item:          return "DW_TAG_namelist_item";
616     case DW_TAG_packed_type:            return "DW_TAG_packed_type";
617     case DW_TAG_subprogram:             return "DW_TAG_subprogram";
618     case DW_TAG_template_type_param:    return "DW_TAG_template_type_param";
619     case DW_TAG_template_value_param:   return "DW_TAG_template_value_param";
620     case DW_TAG_thrown_type:            return "DW_TAG_thrown_type";
621     case DW_TAG_try_block:              return "DW_TAG_try_block";
622     case DW_TAG_variant_part:           return "DW_TAG_variant_part";
623     case DW_TAG_variable:               return "DW_TAG_variable";
624     case DW_TAG_volatile_type:          return "DW_TAG_volatile_type";
625     case DW_TAG_MIPS_loop:              return "DW_TAG_MIPS_loop";
626     case DW_TAG_format_label:           return "DW_TAG_format_label";
627     case DW_TAG_function_template:      return "DW_TAG_function_template";
628     case DW_TAG_class_template:         return "DW_TAG_class_template";
629       /* DWARF 2.1 values.  */
630     case DW_TAG_dwarf_procedure:        return "DW_TAG_dwarf_procedure";
631     case DW_TAG_restrict_type:          return "DW_TAG_restrict_type";
632     case DW_TAG_interface_type:         return "DW_TAG_interface_type";
633     case DW_TAG_namespace:              return "DW_TAG_namespace";
634     case DW_TAG_imported_module:        return "DW_TAG_imported_module";
635     case DW_TAG_unspecified_type:       return "DW_TAG_unspecified_type";
636     case DW_TAG_partial_unit:           return "DW_TAG_partial_unit";
637     case DW_TAG_imported_unit:          return "DW_TAG_imported_unit";
638     case DW_TAG_condition:              return "DW_TAG_condition";
639     case DW_TAG_shared_type:            return "DW_TAG_shared_type";
640       /* DWARF 4 values.  */
641     case DW_TAG_type_unit:              return "DW_TAG_type_unit";
642     case DW_TAG_rvalue_reference_type:  return "DW_TAG_rvalue_reference_type";
643     case DW_TAG_template_alias:         return "DW_TAG_template_alias";
644       /* UPC values.  */
645     case DW_TAG_upc_shared_type:        return "DW_TAG_upc_shared_type";
646     case DW_TAG_upc_strict_type:        return "DW_TAG_upc_strict_type";
647     case DW_TAG_upc_relaxed_type:       return "DW_TAG_upc_relaxed_type";
648       /* GNU values.  */
649     case DW_TAG_GNU_call_site:          return "DW_TAG_GNU_call_site";
650     case DW_TAG_GNU_call_site_parameter:return "DW_TAG_GNU_call_site_parameter";
651     default:
652       {
653         static char buffer[100];
654
655         snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
656         return buffer;
657       }
658     }
659 }
660
661 static char *
662 get_FORM_name (unsigned long form)
663 {
664   switch (form)
665     {
666     case DW_FORM_addr:          return "DW_FORM_addr";
667     case DW_FORM_block2:        return "DW_FORM_block2";
668     case DW_FORM_block4:        return "DW_FORM_block4";
669     case DW_FORM_data2:         return "DW_FORM_data2";
670     case DW_FORM_data4:         return "DW_FORM_data4";
671     case DW_FORM_data8:         return "DW_FORM_data8";
672     case DW_FORM_string:        return "DW_FORM_string";
673     case DW_FORM_block:         return "DW_FORM_block";
674     case DW_FORM_block1:        return "DW_FORM_block1";
675     case DW_FORM_data1:         return "DW_FORM_data1";
676     case DW_FORM_flag:          return "DW_FORM_flag";
677     case DW_FORM_sdata:         return "DW_FORM_sdata";
678     case DW_FORM_strp:          return "DW_FORM_strp";
679     case DW_FORM_udata:         return "DW_FORM_udata";
680     case DW_FORM_ref_addr:      return "DW_FORM_ref_addr";
681     case DW_FORM_ref1:          return "DW_FORM_ref1";
682     case DW_FORM_ref2:          return "DW_FORM_ref2";
683     case DW_FORM_ref4:          return "DW_FORM_ref4";
684     case DW_FORM_ref8:          return "DW_FORM_ref8";
685     case DW_FORM_ref_udata:     return "DW_FORM_ref_udata";
686     case DW_FORM_indirect:      return "DW_FORM_indirect";
687       /* DWARF 4 values.  */
688     case DW_FORM_sec_offset:    return "DW_FORM_sec_offset";
689     case DW_FORM_exprloc:       return "DW_FORM_exprloc";
690     case DW_FORM_flag_present:  return "DW_FORM_flag_present";
691     case DW_FORM_ref_sig8:      return "DW_FORM_ref_sig8";
692     default:
693       {
694         static char buffer[100];
695
696         snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
697         return buffer;
698       }
699     }
700 }
701
702 static unsigned char *
703 display_block (unsigned char *data, dwarf_vma length)
704 {
705   printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
706
707   while (length --)
708     printf ("%lx ", (unsigned long) byte_get (data++, 1));
709
710   return data;
711 }
712
713 static int
714 decode_location_expression (unsigned char * data,
715                             unsigned int pointer_size,
716                             unsigned int offset_size,
717                             int dwarf_version,
718                             dwarf_vma length,
719                             dwarf_vma cu_offset,
720                             struct dwarf_section * section)
721 {
722   unsigned op;
723   unsigned int bytes_read;
724   dwarf_vma uvalue;
725   unsigned char *end = data + length;
726   int need_frame_base = 0;
727
728   while (data < end)
729     {
730       op = *data++;
731
732       switch (op)
733         {
734         case DW_OP_addr:
735          printf ("DW_OP_addr: %s",
736                  dwarf_vmatoa ("x", byte_get (data, pointer_size)));
737           data += pointer_size;
738           break;
739         case DW_OP_deref:
740           printf ("DW_OP_deref");
741           break;
742         case DW_OP_const1u:
743           printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
744           break;
745         case DW_OP_const1s:
746           printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
747           break;
748         case DW_OP_const2u:
749           printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
750           data += 2;
751           break;
752         case DW_OP_const2s:
753           printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
754           data += 2;
755           break;
756         case DW_OP_const4u:
757           printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
758           data += 4;
759           break;
760         case DW_OP_const4s:
761           printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
762           data += 4;
763           break;
764         case DW_OP_const8u:
765           printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
766                   (unsigned long) byte_get (data + 4, 4));
767           data += 8;
768           break;
769         case DW_OP_const8s:
770           printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
771                   (long) byte_get (data + 4, 4));
772           data += 8;
773           break;
774         case DW_OP_constu:
775           printf ("DW_OP_constu: %s",
776                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
777           data += bytes_read;
778           break;
779         case DW_OP_consts:
780           printf ("DW_OP_consts: %s",
781                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
782           data += bytes_read;
783           break;
784         case DW_OP_dup:
785           printf ("DW_OP_dup");
786           break;
787         case DW_OP_drop:
788           printf ("DW_OP_drop");
789           break;
790         case DW_OP_over:
791           printf ("DW_OP_over");
792           break;
793         case DW_OP_pick:
794           printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
795           break;
796         case DW_OP_swap:
797           printf ("DW_OP_swap");
798           break;
799         case DW_OP_rot:
800           printf ("DW_OP_rot");
801           break;
802         case DW_OP_xderef:
803           printf ("DW_OP_xderef");
804           break;
805         case DW_OP_abs:
806           printf ("DW_OP_abs");
807           break;
808         case DW_OP_and:
809           printf ("DW_OP_and");
810           break;
811         case DW_OP_div:
812           printf ("DW_OP_div");
813           break;
814         case DW_OP_minus:
815           printf ("DW_OP_minus");
816           break;
817         case DW_OP_mod:
818           printf ("DW_OP_mod");
819           break;
820         case DW_OP_mul:
821           printf ("DW_OP_mul");
822           break;
823         case DW_OP_neg:
824           printf ("DW_OP_neg");
825           break;
826         case DW_OP_not:
827           printf ("DW_OP_not");
828           break;
829         case DW_OP_or:
830           printf ("DW_OP_or");
831           break;
832         case DW_OP_plus:
833           printf ("DW_OP_plus");
834           break;
835         case DW_OP_plus_uconst:
836           printf ("DW_OP_plus_uconst: %s",
837                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
838           data += bytes_read;
839           break;
840         case DW_OP_shl:
841           printf ("DW_OP_shl");
842           break;
843         case DW_OP_shr:
844           printf ("DW_OP_shr");
845           break;
846         case DW_OP_shra:
847           printf ("DW_OP_shra");
848           break;
849         case DW_OP_xor:
850           printf ("DW_OP_xor");
851           break;
852         case DW_OP_bra:
853           printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
854           data += 2;
855           break;
856         case DW_OP_eq:
857           printf ("DW_OP_eq");
858           break;
859         case DW_OP_ge:
860           printf ("DW_OP_ge");
861           break;
862         case DW_OP_gt:
863           printf ("DW_OP_gt");
864           break;
865         case DW_OP_le:
866           printf ("DW_OP_le");
867           break;
868         case DW_OP_lt:
869           printf ("DW_OP_lt");
870           break;
871         case DW_OP_ne:
872           printf ("DW_OP_ne");
873           break;
874         case DW_OP_skip:
875           printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
876           data += 2;
877           break;
878
879         case DW_OP_lit0:
880         case DW_OP_lit1:
881         case DW_OP_lit2:
882         case DW_OP_lit3:
883         case DW_OP_lit4:
884         case DW_OP_lit5:
885         case DW_OP_lit6:
886         case DW_OP_lit7:
887         case DW_OP_lit8:
888         case DW_OP_lit9:
889         case DW_OP_lit10:
890         case DW_OP_lit11:
891         case DW_OP_lit12:
892         case DW_OP_lit13:
893         case DW_OP_lit14:
894         case DW_OP_lit15:
895         case DW_OP_lit16:
896         case DW_OP_lit17:
897         case DW_OP_lit18:
898         case DW_OP_lit19:
899         case DW_OP_lit20:
900         case DW_OP_lit21:
901         case DW_OP_lit22:
902         case DW_OP_lit23:
903         case DW_OP_lit24:
904         case DW_OP_lit25:
905         case DW_OP_lit26:
906         case DW_OP_lit27:
907         case DW_OP_lit28:
908         case DW_OP_lit29:
909         case DW_OP_lit30:
910         case DW_OP_lit31:
911           printf ("DW_OP_lit%d", op - DW_OP_lit0);
912           break;
913
914         case DW_OP_reg0:
915         case DW_OP_reg1:
916         case DW_OP_reg2:
917         case DW_OP_reg3:
918         case DW_OP_reg4:
919         case DW_OP_reg5:
920         case DW_OP_reg6:
921         case DW_OP_reg7:
922         case DW_OP_reg8:
923         case DW_OP_reg9:
924         case DW_OP_reg10:
925         case DW_OP_reg11:
926         case DW_OP_reg12:
927         case DW_OP_reg13:
928         case DW_OP_reg14:
929         case DW_OP_reg15:
930         case DW_OP_reg16:
931         case DW_OP_reg17:
932         case DW_OP_reg18:
933         case DW_OP_reg19:
934         case DW_OP_reg20:
935         case DW_OP_reg21:
936         case DW_OP_reg22:
937         case DW_OP_reg23:
938         case DW_OP_reg24:
939         case DW_OP_reg25:
940         case DW_OP_reg26:
941         case DW_OP_reg27:
942         case DW_OP_reg28:
943         case DW_OP_reg29:
944         case DW_OP_reg30:
945         case DW_OP_reg31:
946           printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
947                   regname (op - DW_OP_reg0, 1));
948           break;
949
950         case DW_OP_breg0:
951         case DW_OP_breg1:
952         case DW_OP_breg2:
953         case DW_OP_breg3:
954         case DW_OP_breg4:
955         case DW_OP_breg5:
956         case DW_OP_breg6:
957         case DW_OP_breg7:
958         case DW_OP_breg8:
959         case DW_OP_breg9:
960         case DW_OP_breg10:
961         case DW_OP_breg11:
962         case DW_OP_breg12:
963         case DW_OP_breg13:
964         case DW_OP_breg14:
965         case DW_OP_breg15:
966         case DW_OP_breg16:
967         case DW_OP_breg17:
968         case DW_OP_breg18:
969         case DW_OP_breg19:
970         case DW_OP_breg20:
971         case DW_OP_breg21:
972         case DW_OP_breg22:
973         case DW_OP_breg23:
974         case DW_OP_breg24:
975         case DW_OP_breg25:
976         case DW_OP_breg26:
977         case DW_OP_breg27:
978         case DW_OP_breg28:
979         case DW_OP_breg29:
980         case DW_OP_breg30:
981         case DW_OP_breg31:
982           printf ("DW_OP_breg%d (%s): %s",
983                   op - DW_OP_breg0,
984                   regname (op - DW_OP_breg0, 1),
985                   dwarf_vmatoa ("d", (dwarf_signed_vma)
986                     read_leb128 (data, &bytes_read, 1)));
987           data += bytes_read;
988           break;
989
990         case DW_OP_regx:
991           uvalue = read_leb128 (data, &bytes_read, 0);
992           data += bytes_read;
993           printf ("DW_OP_regx: %s (%s)",
994                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
995           break;
996         case DW_OP_fbreg:
997           need_frame_base = 1;
998           printf ("DW_OP_fbreg: %s",
999                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1000           data += bytes_read;
1001           break;
1002         case DW_OP_bregx:
1003           uvalue = read_leb128 (data, &bytes_read, 0);
1004           data += bytes_read;
1005           printf ("DW_OP_bregx: %s (%s) %s",
1006                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1007                   dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read)));
1008           data += bytes_read;
1009           break;
1010         case DW_OP_piece:
1011           printf ("DW_OP_piece: %s",
1012                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1013           data += bytes_read;
1014           break;
1015         case DW_OP_deref_size:
1016           printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
1017           break;
1018         case DW_OP_xderef_size:
1019           printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
1020           break;
1021         case DW_OP_nop:
1022           printf ("DW_OP_nop");
1023           break;
1024
1025           /* DWARF 3 extensions.  */
1026         case DW_OP_push_object_address:
1027           printf ("DW_OP_push_object_address");
1028           break;
1029         case DW_OP_call2:
1030           /* XXX: Strictly speaking for 64-bit DWARF3 files
1031              this ought to be an 8-byte wide computation.  */
1032           printf ("DW_OP_call2: <0x%s>",
1033                   dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2)
1034                                      + cu_offset));
1035           data += 2;
1036           break;
1037         case DW_OP_call4:
1038           /* XXX: Strictly speaking for 64-bit DWARF3 files
1039              this ought to be an 8-byte wide computation.  */
1040           printf ("DW_OP_call4: <0x%s>",
1041                   dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4)
1042                                      + cu_offset));
1043           data += 4;
1044           break;
1045         case DW_OP_call_ref:
1046           /* XXX: Strictly speaking for 64-bit DWARF3 files
1047              this ought to be an 8-byte wide computation.  */
1048           if (dwarf_version == -1)
1049             {
1050               printf (_("(DW_OP_call_ref in frame info)"));
1051               /* No way to tell where the next op is, so just bail.  */
1052               return need_frame_base;
1053             }
1054           if (dwarf_version == 2)
1055             {
1056               printf ("DW_OP_call_ref: <0x%s>",
1057                       dwarf_vmatoa ("x", byte_get (data, pointer_size)));
1058               data += pointer_size;
1059             }
1060           else
1061             {
1062               printf ("DW_OP_call_ref: <0x%s>",
1063                       dwarf_vmatoa ("x", byte_get (data, offset_size)));
1064               data += offset_size;
1065             }
1066           break;
1067         case DW_OP_form_tls_address:
1068           printf ("DW_OP_form_tls_address");
1069           break;
1070         case DW_OP_call_frame_cfa:
1071           printf ("DW_OP_call_frame_cfa");
1072           break;
1073         case DW_OP_bit_piece:
1074           printf ("DW_OP_bit_piece: ");
1075           printf ("size: %s ",
1076                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1077           data += bytes_read;
1078           printf ("offset: %s ",
1079                   dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0)));
1080           data += bytes_read;
1081           break;
1082
1083           /* DWARF 4 extensions.  */
1084         case DW_OP_stack_value:
1085           printf ("DW_OP_stack_value");
1086           break;
1087
1088         case DW_OP_implicit_value:
1089           printf ("DW_OP_implicit_value");
1090           uvalue = read_leb128 (data, &bytes_read, 0);
1091           data += bytes_read;
1092           display_block (data, uvalue);
1093           data += uvalue;
1094           break;
1095
1096           /* GNU extensions.  */
1097         case DW_OP_GNU_push_tls_address:
1098           printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
1099           break;
1100         case DW_OP_GNU_uninit:
1101           printf ("DW_OP_GNU_uninit");
1102           /* FIXME: Is there data associated with this OP ?  */
1103           break;
1104         case DW_OP_GNU_encoded_addr:
1105           {
1106             int encoding;
1107             dwarf_vma addr;
1108
1109             encoding = *data++;
1110             addr = get_encoded_value (data, encoding, section);
1111             data += size_of_encoded_value (encoding);
1112
1113             printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1114             print_dwarf_vma (addr, pointer_size);
1115           }
1116           break;
1117         case DW_OP_GNU_implicit_pointer:
1118           /* XXX: Strictly speaking for 64-bit DWARF3 files
1119              this ought to be an 8-byte wide computation.  */
1120           if (dwarf_version == -1)
1121             {
1122               printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1123               /* No way to tell where the next op is, so just bail.  */
1124               return need_frame_base;
1125             }
1126           if (dwarf_version == 2)
1127             {
1128               printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1129                       dwarf_vmatoa ("x", byte_get (data, pointer_size)),
1130                       dwarf_vmatoa ("d", read_sleb128 (data + pointer_size,
1131                                      &bytes_read)));
1132               data += pointer_size + bytes_read;
1133             }
1134           else
1135             {
1136               printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1137                       dwarf_vmatoa ("x", byte_get (data, offset_size)),
1138                       dwarf_vmatoa ("d", read_sleb128 (data + offset_size,
1139                                      &bytes_read)));
1140               data += offset_size + bytes_read;
1141             }
1142           break;
1143         case DW_OP_GNU_entry_value:
1144           uvalue = read_leb128 (data, &bytes_read, 0);
1145           data += bytes_read;
1146           printf ("DW_OP_GNU_entry_value: (");
1147           if (decode_location_expression (data, pointer_size, offset_size,
1148                                           dwarf_version, uvalue,
1149                                           cu_offset, section))
1150             need_frame_base = 1;
1151           putchar (')');
1152           data += uvalue;
1153           break;
1154         case DW_OP_GNU_const_type:
1155           uvalue = read_leb128 (data, &bytes_read, 0);
1156           data += bytes_read;
1157           printf ("DW_OP_GNU_const_type: <0x%s> ",
1158                   dwarf_vmatoa ("x", cu_offset + uvalue));
1159           uvalue = byte_get (data++, 1);
1160           display_block (data, uvalue);
1161           data += uvalue;
1162           break;
1163         case DW_OP_GNU_regval_type:
1164           uvalue = read_leb128 (data, &bytes_read, 0);
1165           data += bytes_read;
1166           printf ("DW_OP_GNU_regval_type: %s (%s)",
1167                   dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1168           uvalue = read_leb128 (data, &bytes_read, 0);
1169           data += bytes_read;
1170           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1171           break;
1172         case DW_OP_GNU_deref_type:
1173           printf ("DW_OP_GNU_deref_type: %ld", (long) byte_get (data++, 1));
1174           uvalue = read_leb128 (data, &bytes_read, 0);
1175           data += bytes_read;
1176           printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1177           break;
1178         case DW_OP_GNU_convert:
1179           uvalue = read_leb128 (data, &bytes_read, 0);
1180           data += bytes_read;
1181           printf ("DW_OP_GNU_convert <0x%s>",
1182                   dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1183           break;
1184         case DW_OP_GNU_reinterpret:
1185           uvalue = read_leb128 (data, &bytes_read, 0);
1186           data += bytes_read;
1187           printf ("DW_OP_GNU_reinterpret <0x%s>",
1188                   dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1189           break;
1190         case DW_OP_GNU_parameter_ref:
1191           printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1192                   dwarf_vmatoa ("x", cu_offset + byte_get (data, 4)));
1193           data += 4;
1194           break;
1195
1196           /* HP extensions.  */
1197         case DW_OP_HP_is_value:
1198           printf ("DW_OP_HP_is_value");
1199           /* FIXME: Is there data associated with this OP ?  */
1200           break;
1201         case DW_OP_HP_fltconst4:
1202           printf ("DW_OP_HP_fltconst4");
1203           /* FIXME: Is there data associated with this OP ?  */
1204           break;
1205         case DW_OP_HP_fltconst8:
1206           printf ("DW_OP_HP_fltconst8");
1207           /* FIXME: Is there data associated with this OP ?  */
1208           break;
1209         case DW_OP_HP_mod_range:
1210           printf ("DW_OP_HP_mod_range");
1211           /* FIXME: Is there data associated with this OP ?  */
1212           break;
1213         case DW_OP_HP_unmod_range:
1214           printf ("DW_OP_HP_unmod_range");
1215           /* FIXME: Is there data associated with this OP ?  */
1216           break;
1217         case DW_OP_HP_tls:
1218           printf ("DW_OP_HP_tls");
1219           /* FIXME: Is there data associated with this OP ?  */
1220           break;
1221
1222           /* PGI (STMicroelectronics) extensions.  */
1223         case DW_OP_PGI_omp_thread_num:
1224           /* Pushes the thread number for the current thread as it would be
1225              returned by the standard OpenMP library function:
1226              omp_get_thread_num().  The "current thread" is the thread for
1227              which the expression is being evaluated.  */
1228           printf ("DW_OP_PGI_omp_thread_num");
1229           break;
1230
1231         default:
1232           if (op >= DW_OP_lo_user
1233               && op <= DW_OP_hi_user)
1234             printf (_("(User defined location op)"));
1235           else
1236             printf (_("(Unknown location op)"));
1237           /* No way to tell where the next op is, so just bail.  */
1238           return need_frame_base;
1239         }
1240
1241       /* Separate the ops.  */
1242       if (data < end)
1243         printf ("; ");
1244     }
1245
1246   return need_frame_base;
1247 }
1248
1249 static unsigned char *
1250 read_and_display_attr_value (unsigned long attribute,
1251                              unsigned long form,
1252                              unsigned char * data,
1253                              dwarf_vma cu_offset,
1254                              dwarf_vma pointer_size,
1255                              dwarf_vma offset_size,
1256                              int dwarf_version,
1257                              debug_info * debug_info_p,
1258                              int do_loc,
1259                              struct dwarf_section * section)
1260 {
1261   dwarf_vma uvalue = 0;
1262   unsigned char *block_start = NULL;
1263   unsigned char * orig_data = data;
1264   unsigned int bytes_read;
1265
1266   switch (form)
1267     {
1268     default:
1269       break;
1270
1271     case DW_FORM_ref_addr:
1272       if (dwarf_version == 2)
1273         {
1274           uvalue = byte_get (data, pointer_size);
1275           data += pointer_size;
1276         }
1277       else if (dwarf_version == 3 || dwarf_version == 4)
1278         {
1279           uvalue = byte_get (data, offset_size);
1280           data += offset_size;
1281         }
1282       else
1283         error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1284
1285       break;
1286
1287     case DW_FORM_addr:
1288       uvalue = byte_get (data, pointer_size);
1289       data += pointer_size;
1290       break;
1291
1292     case DW_FORM_strp:
1293     case DW_FORM_sec_offset:
1294       uvalue = byte_get (data, offset_size);
1295       data += offset_size;
1296       break;
1297
1298     case DW_FORM_flag_present:
1299       uvalue = 1;
1300       break;
1301
1302     case DW_FORM_ref1:
1303     case DW_FORM_flag:
1304     case DW_FORM_data1:
1305       uvalue = byte_get (data++, 1);
1306       break;
1307
1308     case DW_FORM_ref2:
1309     case DW_FORM_data2:
1310       uvalue = byte_get (data, 2);
1311       data += 2;
1312       break;
1313
1314     case DW_FORM_ref4:
1315     case DW_FORM_data4:
1316       uvalue = byte_get (data, 4);
1317       data += 4;
1318       break;
1319
1320     case DW_FORM_sdata:
1321       uvalue = read_leb128 (data, & bytes_read, 1);
1322       data += bytes_read;
1323       break;
1324
1325     case DW_FORM_ref_udata:
1326     case DW_FORM_udata:
1327       uvalue = read_leb128 (data, & bytes_read, 0);
1328       data += bytes_read;
1329       break;
1330
1331     case DW_FORM_indirect:
1332       form = read_leb128 (data, & bytes_read, 0);
1333       data += bytes_read;
1334       if (!do_loc)
1335         printf (" %s", get_FORM_name (form));
1336       return read_and_display_attr_value (attribute, form, data,
1337                                           cu_offset, pointer_size,
1338                                           offset_size, dwarf_version,
1339                                           debug_info_p, do_loc,
1340                                           section);
1341     }
1342
1343   switch (form)
1344     {
1345     case DW_FORM_ref_addr:
1346       if (!do_loc)
1347         printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1348       break;
1349
1350     case DW_FORM_ref1:
1351     case DW_FORM_ref2:
1352     case DW_FORM_ref4:
1353     case DW_FORM_ref_udata:
1354       if (!do_loc)
1355         printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1356       break;
1357
1358     case DW_FORM_data4:
1359     case DW_FORM_addr:
1360     case DW_FORM_sec_offset:
1361       if (!do_loc)
1362         printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1363       break;
1364
1365     case DW_FORM_flag_present:
1366     case DW_FORM_flag:
1367     case DW_FORM_data1:
1368     case DW_FORM_data2:
1369     case DW_FORM_sdata:
1370     case DW_FORM_udata:
1371       if (!do_loc)
1372         printf (" %s", dwarf_vmatoa ("d", uvalue));
1373       break;
1374
1375     case DW_FORM_ref8:
1376     case DW_FORM_data8:
1377       if (!do_loc)
1378         {
1379           uvalue = byte_get (data, 4);
1380           printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1381           printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
1382         }
1383       if ((do_loc || do_debug_loc || do_debug_ranges)
1384           && num_debug_info_entries == 0)
1385         {
1386           if (sizeof (uvalue) == 8)
1387             uvalue = byte_get (data, 8);
1388           else
1389             error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1390         }
1391       data += 8;
1392       break;
1393
1394     case DW_FORM_string:
1395       if (!do_loc)
1396         printf (" %s", data);
1397       data += strlen ((char *) data) + 1;
1398       break;
1399
1400     case DW_FORM_block:
1401     case DW_FORM_exprloc:
1402       uvalue = read_leb128 (data, & bytes_read, 0);
1403       block_start = data + bytes_read;
1404       if (do_loc)
1405         data = block_start + uvalue;
1406       else
1407         data = display_block (block_start, uvalue);
1408       break;
1409
1410     case DW_FORM_block1:
1411       uvalue = byte_get (data, 1);
1412       block_start = data + 1;
1413       if (do_loc)
1414         data = block_start + uvalue;
1415       else
1416         data = display_block (block_start, uvalue);
1417       break;
1418
1419     case DW_FORM_block2:
1420       uvalue = byte_get (data, 2);
1421       block_start = data + 2;
1422       if (do_loc)
1423         data = block_start + uvalue;
1424       else
1425         data = display_block (block_start, uvalue);
1426       break;
1427
1428     case DW_FORM_block4:
1429       uvalue = byte_get (data, 4);
1430       block_start = data + 4;
1431       if (do_loc)
1432         data = block_start + uvalue;
1433       else
1434         data = display_block (block_start, uvalue);
1435       break;
1436
1437     case DW_FORM_strp:
1438       if (!do_loc)
1439         printf (_(" (indirect string, offset: 0x%s): %s"),
1440                 dwarf_vmatoa ("x", uvalue),
1441                 fetch_indirect_string (uvalue));
1442       break;
1443
1444     case DW_FORM_indirect:
1445       /* Handled above.  */
1446       break;
1447
1448     case DW_FORM_ref_sig8:
1449       if (!do_loc)
1450         {
1451           int i;
1452           printf (" signature: ");
1453           for (i = 0; i < 8; i++)
1454             {
1455               printf ("%02x", (unsigned) byte_get (data, 1));
1456               data += 1;
1457             }
1458         }
1459       else
1460         data += 8;
1461       break;
1462
1463     default:
1464       warn (_("Unrecognized form: %lu\n"), form);
1465       break;
1466     }
1467
1468   if ((do_loc || do_debug_loc || do_debug_ranges)
1469       && num_debug_info_entries == 0
1470       && debug_info_p != NULL)
1471     {
1472       switch (attribute)
1473         {
1474         case DW_AT_frame_base:
1475           have_frame_base = 1;
1476         case DW_AT_location:
1477         case DW_AT_string_length:
1478         case DW_AT_return_addr:
1479         case DW_AT_data_member_location:
1480         case DW_AT_vtable_elem_location:
1481         case DW_AT_segment:
1482         case DW_AT_static_link:
1483         case DW_AT_use_location:
1484         case DW_AT_GNU_call_site_value:
1485         case DW_AT_GNU_call_site_data_value:
1486         case DW_AT_GNU_call_site_target:
1487         case DW_AT_GNU_call_site_target_clobbered:
1488           if ((dwarf_version < 4
1489                && (form == DW_FORM_data4 || form == DW_FORM_data8))
1490               || form == DW_FORM_sec_offset)
1491             {
1492               /* Process location list.  */
1493               unsigned int lmax = debug_info_p->max_loc_offsets;
1494               unsigned int num = debug_info_p->num_loc_offsets;
1495
1496               if (lmax == 0 || num >= lmax)
1497                 {
1498                   lmax += 1024;
1499                   debug_info_p->loc_offsets = (dwarf_vma *)
1500                       xcrealloc (debug_info_p->loc_offsets,
1501                                  lmax, sizeof (*debug_info_p->loc_offsets));
1502                   debug_info_p->have_frame_base = (int *)
1503                       xcrealloc (debug_info_p->have_frame_base,
1504                                  lmax, sizeof (*debug_info_p->have_frame_base));
1505                   debug_info_p->max_loc_offsets = lmax;
1506                 }
1507               debug_info_p->loc_offsets [num] = uvalue;
1508               debug_info_p->have_frame_base [num] = have_frame_base;
1509               debug_info_p->num_loc_offsets++;
1510             }
1511           break;
1512
1513         case DW_AT_low_pc:
1514           if (need_base_address)
1515             debug_info_p->base_address = uvalue;
1516           break;
1517
1518         case DW_AT_ranges:
1519           if ((dwarf_version < 4
1520                && (form == DW_FORM_data4 || form == DW_FORM_data8))
1521               || form == DW_FORM_sec_offset)
1522             {
1523               /* Process range list.  */
1524               unsigned int lmax = debug_info_p->max_range_lists;
1525               unsigned int num = debug_info_p->num_range_lists;
1526
1527               if (lmax == 0 || num >= lmax)
1528                 {
1529                   lmax += 1024;
1530                   debug_info_p->range_lists = (dwarf_vma *)
1531                       xcrealloc (debug_info_p->range_lists,
1532                                  lmax, sizeof (*debug_info_p->range_lists));
1533                   debug_info_p->max_range_lists = lmax;
1534                 }
1535               debug_info_p->range_lists [num] = uvalue;
1536               debug_info_p->num_range_lists++;
1537             }
1538           break;
1539
1540         default:
1541           break;
1542         }
1543     }
1544
1545   if (do_loc || attribute == 0)
1546     return data;
1547
1548   /* For some attributes we can display further information.  */
1549   printf ("\t");
1550
1551   switch (attribute)
1552     {
1553     case DW_AT_inline:
1554       switch (uvalue)
1555         {
1556         case DW_INL_not_inlined:
1557           printf (_("(not inlined)"));
1558           break;
1559         case DW_INL_inlined:
1560           printf (_("(inlined)"));
1561           break;
1562         case DW_INL_declared_not_inlined:
1563           printf (_("(declared as inline but ignored)"));
1564           break;
1565         case DW_INL_declared_inlined:
1566           printf (_("(declared as inline and inlined)"));
1567           break;
1568         default:
1569           printf (_("  (Unknown inline attribute value: %s)"),
1570                   dwarf_vmatoa ("x", uvalue));
1571           break;
1572         }
1573       break;
1574
1575     case DW_AT_language:
1576       switch (uvalue)
1577         {
1578           /* Ordered by the numeric value of these constants.  */
1579         case DW_LANG_C89:               printf ("(ANSI C)"); break;
1580         case DW_LANG_C:                 printf ("(non-ANSI C)"); break;
1581         case DW_LANG_Ada83:             printf ("(Ada)"); break;
1582         case DW_LANG_C_plus_plus:       printf ("(C++)"); break;
1583         case DW_LANG_Cobol74:           printf ("(Cobol 74)"); break;
1584         case DW_LANG_Cobol85:           printf ("(Cobol 85)"); break;
1585         case DW_LANG_Fortran77:         printf ("(FORTRAN 77)"); break;
1586         case DW_LANG_Fortran90:         printf ("(Fortran 90)"); break;
1587         case DW_LANG_Pascal83:          printf ("(ANSI Pascal)"); break;
1588         case DW_LANG_Modula2:           printf ("(Modula 2)"); break;
1589           /* DWARF 2.1 values.  */
1590         case DW_LANG_Java:              printf ("(Java)"); break;
1591         case DW_LANG_C99:               printf ("(ANSI C99)"); break;
1592         case DW_LANG_Ada95:             printf ("(ADA 95)"); break;
1593         case DW_LANG_Fortran95:         printf ("(Fortran 95)"); break;
1594           /* DWARF 3 values.  */
1595         case DW_LANG_PLI:               printf ("(PLI)"); break;
1596         case DW_LANG_ObjC:              printf ("(Objective C)"); break;
1597         case DW_LANG_ObjC_plus_plus:    printf ("(Objective C++)"); break;
1598         case DW_LANG_UPC:               printf ("(Unified Parallel C)"); break;
1599         case DW_LANG_D:                 printf ("(D)"); break;
1600           /* DWARF 4 values.  */
1601         case DW_LANG_Python:            printf ("(Python)"); break;
1602           /* MIPS extension.  */
1603         case DW_LANG_Mips_Assembler:    printf ("(MIPS assembler)"); break;
1604           /* UPC extension.  */
1605         case DW_LANG_Upc:               printf ("(Unified Parallel C)"); break;
1606         default:
1607           if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1608             printf ("(implementation defined: %s)",
1609                     dwarf_vmatoa ("x", uvalue));
1610           else
1611             printf ("(Unknown: %s)", dwarf_vmatoa ("x", uvalue));
1612           break;
1613         }
1614       break;
1615
1616     case DW_AT_encoding:
1617       switch (uvalue)
1618         {
1619         case DW_ATE_void:               printf ("(void)"); break;
1620         case DW_ATE_address:            printf ("(machine address)"); break;
1621         case DW_ATE_boolean:            printf ("(boolean)"); break;
1622         case DW_ATE_complex_float:      printf ("(complex float)"); break;
1623         case DW_ATE_float:              printf ("(float)"); break;
1624         case DW_ATE_signed:             printf ("(signed)"); break;
1625         case DW_ATE_signed_char:        printf ("(signed char)"); break;
1626         case DW_ATE_unsigned:           printf ("(unsigned)"); break;
1627         case DW_ATE_unsigned_char:      printf ("(unsigned char)"); break;
1628           /* DWARF 2.1 values:  */
1629         case DW_ATE_imaginary_float:    printf ("(imaginary float)"); break;
1630         case DW_ATE_decimal_float:      printf ("(decimal float)"); break;
1631           /* DWARF 3 values:  */
1632         case DW_ATE_packed_decimal:     printf ("(packed_decimal)"); break;
1633         case DW_ATE_numeric_string:     printf ("(numeric_string)"); break;
1634         case DW_ATE_edited:             printf ("(edited)"); break;
1635         case DW_ATE_signed_fixed:       printf ("(signed_fixed)"); break;
1636         case DW_ATE_unsigned_fixed:     printf ("(unsigned_fixed)"); break;
1637           /* HP extensions:  */
1638         case DW_ATE_HP_float80:         printf ("(HP_float80)"); break;
1639         case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1640         case DW_ATE_HP_float128:        printf ("(HP_float128)"); break;
1641         case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1642         case DW_ATE_HP_floathpintel:    printf ("(HP_floathpintel)"); break;
1643         case DW_ATE_HP_imaginary_float80:       printf ("(HP_imaginary_float80)"); break;
1644         case DW_ATE_HP_imaginary_float128:      printf ("(HP_imaginary_float128)"); break;
1645
1646         default:
1647           if (uvalue >= DW_ATE_lo_user
1648               && uvalue <= DW_ATE_hi_user)
1649             printf ("(user defined type)");
1650           else
1651             printf ("(unknown type)");
1652           break;
1653         }
1654       break;
1655
1656     case DW_AT_accessibility:
1657       switch (uvalue)
1658         {
1659         case DW_ACCESS_public:          printf ("(public)"); break;
1660         case DW_ACCESS_protected:       printf ("(protected)"); break;
1661         case DW_ACCESS_private:         printf ("(private)"); break;
1662         default:
1663           printf ("(unknown accessibility)");
1664           break;
1665         }
1666       break;
1667
1668     case DW_AT_visibility:
1669       switch (uvalue)
1670         {
1671         case DW_VIS_local:              printf ("(local)"); break;
1672         case DW_VIS_exported:           printf ("(exported)"); break;
1673         case DW_VIS_qualified:          printf ("(qualified)"); break;
1674         default:                        printf ("(unknown visibility)"); break;
1675         }
1676       break;
1677
1678     case DW_AT_virtuality:
1679       switch (uvalue)
1680         {
1681         case DW_VIRTUALITY_none:        printf ("(none)"); break;
1682         case DW_VIRTUALITY_virtual:     printf ("(virtual)"); break;
1683         case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1684         default:                        printf ("(unknown virtuality)"); break;
1685         }
1686       break;
1687
1688     case DW_AT_identifier_case:
1689       switch (uvalue)
1690         {
1691         case DW_ID_case_sensitive:      printf ("(case_sensitive)"); break;
1692         case DW_ID_up_case:             printf ("(up_case)"); break;
1693         case DW_ID_down_case:           printf ("(down_case)"); break;
1694         case DW_ID_case_insensitive:    printf ("(case_insensitive)"); break;
1695         default:                        printf ("(unknown case)"); break;
1696         }
1697       break;
1698
1699     case DW_AT_calling_convention:
1700       switch (uvalue)
1701         {
1702         case DW_CC_normal:      printf ("(normal)"); break;
1703         case DW_CC_program:     printf ("(program)"); break;
1704         case DW_CC_nocall:      printf ("(nocall)"); break;
1705         default:
1706           if (uvalue >= DW_CC_lo_user
1707               && uvalue <= DW_CC_hi_user)
1708             printf ("(user defined)");
1709           else
1710             printf ("(unknown convention)");
1711         }
1712       break;
1713
1714     case DW_AT_ordering:
1715       switch (uvalue)
1716         {
1717         case -1: printf ("(undefined)"); break;
1718         case 0:  printf ("(row major)"); break;
1719         case 1:  printf ("(column major)"); break;
1720         }
1721       break;
1722
1723     case DW_AT_frame_base:
1724       have_frame_base = 1;
1725     case DW_AT_location:
1726     case DW_AT_string_length:
1727     case DW_AT_return_addr:
1728     case DW_AT_data_member_location:
1729     case DW_AT_vtable_elem_location:
1730     case DW_AT_segment:
1731     case DW_AT_static_link:
1732     case DW_AT_use_location:
1733     case DW_AT_GNU_call_site_value:
1734     case DW_AT_GNU_call_site_data_value:
1735     case DW_AT_GNU_call_site_target:
1736     case DW_AT_GNU_call_site_target_clobbered:
1737       if ((dwarf_version < 4
1738            && (form == DW_FORM_data4 || form == DW_FORM_data8))
1739           || form == DW_FORM_sec_offset)
1740         printf (_("(location list)"));
1741       /* Fall through.  */
1742     case DW_AT_allocated:
1743     case DW_AT_associated:
1744     case DW_AT_data_location:
1745     case DW_AT_stride:
1746     case DW_AT_upper_bound:
1747     case DW_AT_lower_bound:
1748       if (block_start)
1749         {
1750           int need_frame_base;
1751
1752           printf ("(");
1753           need_frame_base = decode_location_expression (block_start,
1754                                                         pointer_size,
1755                                                         offset_size,
1756                                                         dwarf_version,
1757                                                         uvalue,
1758                                                         cu_offset, section);
1759           printf (")");
1760           if (need_frame_base && !have_frame_base)
1761             printf (_(" [without DW_AT_frame_base]"));
1762         }
1763       break;
1764
1765     case DW_AT_import:
1766       {
1767         if (form == DW_FORM_ref_sig8)
1768           break;
1769
1770         if (form == DW_FORM_ref1
1771             || form == DW_FORM_ref2
1772             || form == DW_FORM_ref4)
1773           uvalue += cu_offset;
1774
1775         if (uvalue >= section->size)
1776           warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1777                 dwarf_vmatoa ("x", uvalue),
1778                 (unsigned long) (orig_data - section->start));
1779         else
1780           {
1781             unsigned long abbrev_number;
1782             abbrev_entry * entry;
1783
1784             abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
1785
1786             printf ("[Abbrev Number: %ld", abbrev_number);
1787             for (entry = first_abbrev; entry != NULL; entry = entry->next)
1788               if (entry->entry == abbrev_number)
1789                 break;
1790             if (entry != NULL)
1791               printf (" (%s)", get_TAG_name (entry->tag));
1792             printf ("]");
1793           }
1794       }
1795       break;
1796
1797     default:
1798       break;
1799     }
1800
1801   return data;
1802 }
1803
1804 static char *
1805 get_AT_name (unsigned long attribute)
1806 {
1807   switch (attribute)
1808     {
1809     case DW_AT_sibling:                 return "DW_AT_sibling";
1810     case DW_AT_location:                return "DW_AT_location";
1811     case DW_AT_name:                    return "DW_AT_name";
1812     case DW_AT_ordering:                return "DW_AT_ordering";
1813     case DW_AT_subscr_data:             return "DW_AT_subscr_data";
1814     case DW_AT_byte_size:               return "DW_AT_byte_size";
1815     case DW_AT_bit_offset:              return "DW_AT_bit_offset";
1816     case DW_AT_bit_size:                return "DW_AT_bit_size";
1817     case DW_AT_element_list:            return "DW_AT_element_list";
1818     case DW_AT_stmt_list:               return "DW_AT_stmt_list";
1819     case DW_AT_low_pc:                  return "DW_AT_low_pc";
1820     case DW_AT_high_pc:                 return "DW_AT_high_pc";
1821     case DW_AT_language:                return "DW_AT_language";
1822     case DW_AT_member:                  return "DW_AT_member";
1823     case DW_AT_discr:                   return "DW_AT_discr";
1824     case DW_AT_discr_value:             return "DW_AT_discr_value";
1825     case DW_AT_visibility:              return "DW_AT_visibility";
1826     case DW_AT_import:                  return "DW_AT_import";
1827     case DW_AT_string_length:           return "DW_AT_string_length";
1828     case DW_AT_common_reference:        return "DW_AT_common_reference";
1829     case DW_AT_comp_dir:                return "DW_AT_comp_dir";
1830     case DW_AT_const_value:             return "DW_AT_const_value";
1831     case DW_AT_containing_type:         return "DW_AT_containing_type";
1832     case DW_AT_default_value:           return "DW_AT_default_value";
1833     case DW_AT_inline:                  return "DW_AT_inline";
1834     case DW_AT_is_optional:             return "DW_AT_is_optional";
1835     case DW_AT_lower_bound:             return "DW_AT_lower_bound";
1836     case DW_AT_producer:                return "DW_AT_producer";
1837     case DW_AT_prototyped:              return "DW_AT_prototyped";
1838     case DW_AT_return_addr:             return "DW_AT_return_addr";
1839     case DW_AT_start_scope:             return "DW_AT_start_scope";
1840     case DW_AT_stride_size:             return "DW_AT_stride_size";
1841     case DW_AT_upper_bound:             return "DW_AT_upper_bound";
1842     case DW_AT_abstract_origin:         return "DW_AT_abstract_origin";
1843     case DW_AT_accessibility:           return "DW_AT_accessibility";
1844     case DW_AT_address_class:           return "DW_AT_address_class";
1845     case DW_AT_artificial:              return "DW_AT_artificial";
1846     case DW_AT_base_types:              return "DW_AT_base_types";
1847     case DW_AT_calling_convention:      return "DW_AT_calling_convention";
1848     case DW_AT_count:                   return "DW_AT_count";
1849     case DW_AT_data_member_location:    return "DW_AT_data_member_location";
1850     case DW_AT_decl_column:             return "DW_AT_decl_column";
1851     case DW_AT_decl_file:               return "DW_AT_decl_file";
1852     case DW_AT_decl_line:               return "DW_AT_decl_line";
1853     case DW_AT_declaration:             return "DW_AT_declaration";
1854     case DW_AT_discr_list:              return "DW_AT_discr_list";
1855     case DW_AT_encoding:                return "DW_AT_encoding";
1856     case DW_AT_external:                return "DW_AT_external";
1857     case DW_AT_frame_base:              return "DW_AT_frame_base";
1858     case DW_AT_friend:                  return "DW_AT_friend";
1859     case DW_AT_identifier_case:         return "DW_AT_identifier_case";
1860     case DW_AT_macro_info:              return "DW_AT_macro_info";
1861     case DW_AT_namelist_items:          return "DW_AT_namelist_items";
1862     case DW_AT_priority:                return "DW_AT_priority";
1863     case DW_AT_segment:                 return "DW_AT_segment";
1864     case DW_AT_specification:           return "DW_AT_specification";
1865     case DW_AT_static_link:             return "DW_AT_static_link";
1866     case DW_AT_type:                    return "DW_AT_type";
1867     case DW_AT_use_location:            return "DW_AT_use_location";
1868     case DW_AT_variable_parameter:      return "DW_AT_variable_parameter";
1869     case DW_AT_virtuality:              return "DW_AT_virtuality";
1870     case DW_AT_vtable_elem_location:    return "DW_AT_vtable_elem_location";
1871       /* DWARF 2.1 values.  */
1872     case DW_AT_allocated:               return "DW_AT_allocated";
1873     case DW_AT_associated:              return "DW_AT_associated";
1874     case DW_AT_data_location:           return "DW_AT_data_location";
1875     case DW_AT_stride:                  return "DW_AT_stride";
1876     case DW_AT_entry_pc:                return "DW_AT_entry_pc";
1877     case DW_AT_use_UTF8:                return "DW_AT_use_UTF8";
1878     case DW_AT_extension:               return "DW_AT_extension";
1879     case DW_AT_ranges:                  return "DW_AT_ranges";
1880     case DW_AT_trampoline:              return "DW_AT_trampoline";
1881     case DW_AT_call_column:             return "DW_AT_call_column";
1882     case DW_AT_call_file:               return "DW_AT_call_file";
1883     case DW_AT_call_line:               return "DW_AT_call_line";
1884     case DW_AT_description:             return "DW_AT_description";
1885     case DW_AT_binary_scale:            return "DW_AT_binary_scale";
1886     case DW_AT_decimal_scale:           return "DW_AT_decimal_scale";
1887     case DW_AT_small:                   return "DW_AT_small";
1888     case DW_AT_decimal_sign:            return "DW_AT_decimal_sign";
1889     case DW_AT_digit_count:             return "DW_AT_digit_count";
1890     case DW_AT_picture_string:          return "DW_AT_picture_string";
1891     case DW_AT_mutable:                 return "DW_AT_mutable";
1892     case DW_AT_threads_scaled:          return "DW_AT_threads_scaled";
1893     case DW_AT_explicit:                return "DW_AT_explicit";
1894     case DW_AT_object_pointer:          return "DW_AT_object_pointer";
1895     case DW_AT_endianity:               return "DW_AT_endianity";
1896     case DW_AT_elemental:               return "DW_AT_elemental";
1897     case DW_AT_pure:                    return "DW_AT_pure";
1898     case DW_AT_recursive:               return "DW_AT_recursive";
1899       /* DWARF 4 values.  */
1900     case DW_AT_signature:               return "DW_AT_signature";
1901     case DW_AT_main_subprogram:         return "DW_AT_main_subprogram";
1902     case DW_AT_data_bit_offset:         return "DW_AT_data_bit_offset";
1903     case DW_AT_const_expr:              return "DW_AT_const_expr";
1904     case DW_AT_enum_class:              return "DW_AT_enum_class";
1905     case DW_AT_linkage_name:            return "DW_AT_linkage_name";
1906
1907       /* HP and SGI/MIPS extensions.  */
1908     case DW_AT_MIPS_loop_begin:                 return "DW_AT_MIPS_loop_begin";
1909     case DW_AT_MIPS_tail_loop_begin:            return "DW_AT_MIPS_tail_loop_begin";
1910     case DW_AT_MIPS_epilog_begin:               return "DW_AT_MIPS_epilog_begin";
1911     case DW_AT_MIPS_loop_unroll_factor:         return "DW_AT_MIPS_loop_unroll_factor";
1912     case DW_AT_MIPS_software_pipeline_depth:    return "DW_AT_MIPS_software_pipeline_depth";
1913     case DW_AT_MIPS_linkage_name:               return "DW_AT_MIPS_linkage_name";
1914     case DW_AT_MIPS_stride:                     return "DW_AT_MIPS_stride";
1915     case DW_AT_MIPS_abstract_name:              return "DW_AT_MIPS_abstract_name";
1916     case DW_AT_MIPS_clone_origin:               return "DW_AT_MIPS_clone_origin";
1917     case DW_AT_MIPS_has_inlines:                return "DW_AT_MIPS_has_inlines";
1918
1919       /* HP Extensions.  */
1920     case DW_AT_HP_block_index:                  return "DW_AT_HP_block_index";
1921     case DW_AT_HP_actuals_stmt_list:            return "DW_AT_HP_actuals_stmt_list";
1922     case DW_AT_HP_proc_per_section:             return "DW_AT_HP_proc_per_section";
1923     case DW_AT_HP_raw_data_ptr:                 return "DW_AT_HP_raw_data_ptr";
1924     case DW_AT_HP_pass_by_reference:            return "DW_AT_HP_pass_by_reference";
1925     case DW_AT_HP_opt_level:                    return "DW_AT_HP_opt_level";
1926     case DW_AT_HP_prof_version_id:              return "DW_AT_HP_prof_version_id";
1927     case DW_AT_HP_opt_flags:                    return "DW_AT_HP_opt_flags";
1928     case DW_AT_HP_cold_region_low_pc:           return "DW_AT_HP_cold_region_low_pc";
1929     case DW_AT_HP_cold_region_high_pc:          return "DW_AT_HP_cold_region_high_pc";
1930     case DW_AT_HP_all_variables_modifiable:     return "DW_AT_HP_all_variables_modifiable";
1931     case DW_AT_HP_linkage_name:                 return "DW_AT_HP_linkage_name";
1932     case DW_AT_HP_prof_flags:                   return "DW_AT_HP_prof_flags";
1933
1934       /* One value is shared by the MIPS and HP extensions:  */
1935     case DW_AT_MIPS_fde:                        return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1936
1937       /* GNU extensions.  */
1938     case DW_AT_sf_names:                        return "DW_AT_sf_names";
1939     case DW_AT_src_info:                        return "DW_AT_src_info";
1940     case DW_AT_mac_info:                        return "DW_AT_mac_info";
1941     case DW_AT_src_coords:                      return "DW_AT_src_coords";
1942     case DW_AT_body_begin:                      return "DW_AT_body_begin";
1943     case DW_AT_body_end:                        return "DW_AT_body_end";
1944     case DW_AT_GNU_vector:                      return "DW_AT_GNU_vector";
1945     case DW_AT_GNU_guarded_by:                  return "DW_AT_GNU_guarded_by";
1946     case DW_AT_GNU_pt_guarded_by:               return "DW_AT_GNU_pt_guarded_by";
1947     case DW_AT_GNU_guarded:                     return "DW_AT_GNU_guarded";
1948     case DW_AT_GNU_pt_guarded:                  return "DW_AT_GNU_pt_guarded";
1949     case DW_AT_GNU_locks_excluded:              return "DW_AT_GNU_locks_excluded";
1950     case DW_AT_GNU_exclusive_locks_required:    return "DW_AT_GNU_exclusive_locks_required";
1951     case DW_AT_GNU_shared_locks_required:       return "DW_AT_GNU_shared_locks_required";
1952     case DW_AT_GNU_odr_signature:               return "DW_AT_GNU_odr_signature";
1953     case DW_AT_use_GNAT_descriptive_type:       return "DW_AT_use_GNAT_descriptive_type";
1954     case DW_AT_GNAT_descriptive_type:           return "DW_AT_GNAT_descriptive_type";
1955     case DW_AT_GNU_call_site_value:             return "DW_AT_GNU_call_site_value";
1956     case DW_AT_GNU_call_site_data_value:        return "DW_AT_GNU_call_site_data_value";
1957     case DW_AT_GNU_call_site_target:            return "DW_AT_GNU_call_site_target";
1958     case DW_AT_GNU_call_site_target_clobbered:  return "DW_AT_GNU_call_site_target_clobbered";
1959     case DW_AT_GNU_tail_call:                   return "DW_AT_GNU_tail_call";
1960     case DW_AT_GNU_all_tail_call_sites:         return "DW_AT_GNU_all_tail_call_sites";
1961     case DW_AT_GNU_all_call_sites:              return "DW_AT_GNU_all_call_sites";
1962     case DW_AT_GNU_all_source_call_sites:       return "DW_AT_GNU_all_source_call_sites";
1963     case DW_AT_GNU_macros:                      return "DW_AT_GNU_macros";
1964
1965       /* UPC extension.  */
1966     case DW_AT_upc_threads_scaled:      return "DW_AT_upc_threads_scaled";
1967
1968     /* PGI (STMicroelectronics) extensions.  */
1969     case DW_AT_PGI_lbase:               return "DW_AT_PGI_lbase";
1970     case DW_AT_PGI_soffset:             return "DW_AT_PGI_soffset";
1971     case DW_AT_PGI_lstride:             return "DW_AT_PGI_lstride";
1972
1973     default:
1974       {
1975         static char buffer[100];
1976
1977         snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1978                   attribute);
1979         return buffer;
1980       }
1981     }
1982 }
1983
1984 static unsigned char *
1985 read_and_display_attr (unsigned long attribute,
1986                        unsigned long form,
1987                        unsigned char * data,
1988                        dwarf_vma cu_offset,
1989                        dwarf_vma pointer_size,
1990                        dwarf_vma offset_size,
1991                        int dwarf_version,
1992                        debug_info * debug_info_p,
1993                        int do_loc,
1994                        struct dwarf_section * section)
1995 {
1996   if (!do_loc)
1997     printf ("   %-18s:", get_AT_name (attribute));
1998   data = read_and_display_attr_value (attribute, form, data, cu_offset,
1999                                       pointer_size, offset_size,
2000                                       dwarf_version, debug_info_p,
2001                                       do_loc, section);
2002   if (!do_loc)
2003     printf ("\n");
2004   return data;
2005 }
2006
2007
2008 /* Process the contents of a .debug_info section.  If do_loc is non-zero
2009    then we are scanning for location lists and we do not want to display
2010    anything to the user.  If do_types is non-zero, we are processing
2011    a .debug_types section instead of a .debug_info section.  */
2012
2013 static int
2014 process_debug_info (struct dwarf_section *section,
2015                     void *file,
2016                     enum dwarf_section_display_enum abbrev_sec,
2017                     int do_loc,
2018                     int do_types)
2019 {
2020   unsigned char *start = section->start;
2021   unsigned char *end = start + section->size;
2022   unsigned char *section_begin;
2023   unsigned int unit;
2024   unsigned int num_units = 0;
2025
2026   if ((do_loc || do_debug_loc || do_debug_ranges)
2027       && num_debug_info_entries == 0
2028       && ! do_types)
2029     {
2030       dwarf_vma length;
2031
2032       /* First scan the section to get the number of comp units.  */
2033       for (section_begin = start, num_units = 0; section_begin < end;
2034            num_units ++)
2035         {
2036           /* Read the first 4 bytes.  For a 32-bit DWARF section, this
2037              will be the length.  For a 64-bit DWARF section, it'll be
2038              the escape code 0xffffffff followed by an 8 byte length.  */
2039           length = byte_get (section_begin, 4);
2040
2041           if (length == 0xffffffff)
2042             {
2043               length = byte_get (section_begin + 4, 8);
2044               section_begin += length + 12;
2045             }
2046           else if (length >= 0xfffffff0 && length < 0xffffffff)
2047             {
2048               warn (_("Reserved length value (0x%s) found in section %s\n"),
2049                     dwarf_vmatoa ("x", length), section->name);
2050               return 0;
2051             }
2052           else
2053             section_begin += length + 4;
2054
2055           /* Negative values are illegal, they may even cause infinite
2056              looping.  This can happen if we can't accurately apply
2057              relocations to an object file.  */
2058           if ((signed long) length <= 0)
2059             {
2060               warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2061                     dwarf_vmatoa ("x", length), section->name);
2062               return 0;
2063             }
2064         }
2065
2066       if (num_units == 0)
2067         {
2068           error (_("No comp units in %s section ?"), section->name);
2069           return 0;
2070         }
2071
2072       /* Then allocate an array to hold the information.  */
2073       debug_information = (debug_info *) cmalloc (num_units,
2074                                                   sizeof (* debug_information));
2075       if (debug_information == NULL)
2076         {
2077           error (_("Not enough memory for a debug info array of %u entries"),
2078                  num_units);
2079           return 0;
2080         }
2081     }
2082
2083   if (!do_loc)
2084     {
2085       if (dwarf_start_die == 0)
2086         printf (_("Contents of the %s section:\n\n"), section->name);
2087
2088       load_debug_section (str, file);
2089     }
2090
2091   load_debug_section (abbrev_sec, file);
2092   if (debug_displays [abbrev_sec].section.start == NULL)
2093     {
2094       warn (_("Unable to locate %s section!\n"),
2095             debug_displays [abbrev_sec].section.name);
2096       return 0;
2097     }
2098
2099   for (section_begin = start, unit = 0; start < end; unit++)
2100     {
2101       DWARF2_Internal_CompUnit compunit;
2102       unsigned char *hdrptr;
2103       unsigned char *tags;
2104       int level, last_level, saved_level;
2105       dwarf_vma cu_offset;
2106       int offset_size;
2107       int initial_length_size;
2108       unsigned char signature[8] = { 0 };
2109       dwarf_vma type_offset = 0;
2110
2111       hdrptr = start;
2112
2113       compunit.cu_length = byte_get (hdrptr, 4);
2114       hdrptr += 4;
2115
2116       if (compunit.cu_length == 0xffffffff)
2117         {
2118           compunit.cu_length = byte_get (hdrptr, 8);
2119           hdrptr += 8;
2120           offset_size = 8;
2121           initial_length_size = 12;
2122         }
2123       else
2124         {
2125           offset_size = 4;
2126           initial_length_size = 4;
2127         }
2128
2129       compunit.cu_version = byte_get (hdrptr, 2);
2130       hdrptr += 2;
2131
2132       cu_offset = start - section_begin;
2133
2134       compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2135       hdrptr += offset_size;
2136
2137       compunit.cu_pointer_size = byte_get (hdrptr, 1);
2138       hdrptr += 1;
2139
2140       if (do_types)
2141         {
2142           int i;
2143
2144           for (i = 0; i < 8; i++)
2145             {
2146               signature[i] = byte_get (hdrptr, 1);
2147               hdrptr += 1;
2148             }
2149
2150           type_offset = byte_get (hdrptr, offset_size);
2151           hdrptr += offset_size;
2152         }
2153
2154       if ((do_loc || do_debug_loc || do_debug_ranges)
2155           && num_debug_info_entries == 0
2156           && ! do_types)
2157         {
2158           debug_information [unit].cu_offset = cu_offset;
2159           debug_information [unit].pointer_size
2160             = compunit.cu_pointer_size;
2161           debug_information [unit].offset_size = offset_size;
2162           debug_information [unit].dwarf_version = compunit.cu_version;
2163           debug_information [unit].base_address = 0;
2164           debug_information [unit].loc_offsets = NULL;
2165           debug_information [unit].have_frame_base = NULL;
2166           debug_information [unit].max_loc_offsets = 0;
2167           debug_information [unit].num_loc_offsets = 0;
2168           debug_information [unit].range_lists = NULL;
2169           debug_information [unit].max_range_lists= 0;
2170           debug_information [unit].num_range_lists = 0;
2171         }
2172
2173       if (!do_loc && dwarf_start_die == 0)
2174         {
2175           printf (_("  Compilation Unit @ offset 0x%s:\n"),
2176                   dwarf_vmatoa ("x", cu_offset));
2177           printf (_("   Length:        0x%s (%s)\n"),
2178                   dwarf_vmatoa ("x", compunit.cu_length),
2179                   offset_size == 8 ? "64-bit" : "32-bit");
2180           printf (_("   Version:       %d\n"), compunit.cu_version);
2181           printf (_("   Abbrev Offset: %s\n"),
2182                   dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
2183           printf (_("   Pointer Size:  %d\n"), compunit.cu_pointer_size);
2184           if (do_types)
2185             {
2186               int i;
2187               printf (_("   Signature:     "));
2188               for (i = 0; i < 8; i++)
2189                 printf ("%02x", signature[i]);
2190               printf ("\n");
2191              printf (_("   Type Offset:   0x%s\n"),
2192                      dwarf_vmatoa ("x", type_offset));
2193             }
2194         }
2195
2196       if (cu_offset + compunit.cu_length + initial_length_size
2197           > section->size)
2198         {
2199           warn (_("Debug info is corrupted, length of CU at %s"
2200                   " extends beyond end of section (length = %s)\n"),
2201                 dwarf_vmatoa ("x", cu_offset),
2202                 dwarf_vmatoa ("x", compunit.cu_length));
2203           break;
2204         }
2205       tags = hdrptr;
2206       start += compunit.cu_length + initial_length_size;
2207
2208       if (compunit.cu_version != 2
2209           && compunit.cu_version != 3
2210           && compunit.cu_version != 4)
2211         {
2212           warn (_("CU at offset %s contains corrupt or "
2213                   "unsupported version number: %d.\n"),
2214                 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2215           continue;
2216         }
2217
2218       free_abbrevs ();
2219
2220       /* Process the abbrevs used by this compilation unit. DWARF
2221          sections under Mach-O have non-zero addresses.  */
2222       if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
2223         warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2224               (unsigned long) compunit.cu_abbrev_offset,
2225               (unsigned long) debug_displays [abbrev_sec].section.size);
2226       else
2227         process_abbrev_section
2228           ((unsigned char *) debug_displays [abbrev_sec].section.start
2229            + compunit.cu_abbrev_offset,
2230            (unsigned char *) debug_displays [abbrev_sec].section.start
2231            + debug_displays [abbrev_sec].section.size);
2232
2233       level = 0;
2234       last_level = level;
2235       saved_level = -1;
2236       while (tags < start)
2237         {
2238           unsigned int bytes_read;
2239           unsigned long abbrev_number;
2240           unsigned long die_offset;
2241           abbrev_entry *entry;
2242           abbrev_attr *attr;
2243           int do_printing = 1;
2244
2245           die_offset = tags - section_begin;
2246
2247           abbrev_number = read_leb128 (tags, & bytes_read, 0);
2248           tags += bytes_read;
2249
2250           /* A null DIE marks the end of a list of siblings or it may also be
2251              a section padding.  */
2252           if (abbrev_number == 0)
2253             {
2254               /* Check if it can be a section padding for the last CU.  */
2255               if (level == 0 && start == end)
2256                 {
2257                   unsigned char *chk;
2258
2259                   for (chk = tags; chk < start; chk++)
2260                     if (*chk != 0)
2261                       break;
2262                   if (chk == start)
2263                     break;
2264                 }
2265
2266               --level;
2267               if (level < 0)
2268                 {
2269                   static unsigned num_bogus_warns = 0;
2270
2271                   if (num_bogus_warns < 3)
2272                     {
2273                       warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2274                             die_offset);
2275                       num_bogus_warns ++;
2276                       if (num_bogus_warns == 3)
2277                         warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2278                     }
2279                 }
2280               if (dwarf_start_die != 0 && level < saved_level)
2281                 return 1;
2282               continue;
2283             }
2284
2285           if (!do_loc)
2286             {
2287               if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2288                 do_printing = 0;
2289               else
2290                 {
2291                   if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2292                     saved_level = level;
2293                   do_printing = (dwarf_cutoff_level == -1
2294                                  || level < dwarf_cutoff_level);
2295                   if (do_printing)
2296                     printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2297                             level, die_offset, abbrev_number);
2298                   else if (dwarf_cutoff_level == -1
2299                            || last_level < dwarf_cutoff_level)
2300                     printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2301                   last_level = level;
2302                 }
2303             }
2304
2305           /* Scan through the abbreviation list until we reach the
2306              correct entry.  */
2307           for (entry = first_abbrev;
2308                entry && entry->entry != abbrev_number;
2309                entry = entry->next)
2310             continue;
2311
2312           if (entry == NULL)
2313             {
2314               if (!do_loc && do_printing)
2315                 {
2316                   printf ("\n");
2317                   fflush (stdout);
2318                 }
2319               warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2320                     die_offset, abbrev_number);
2321               return 0;
2322             }
2323
2324           if (!do_loc && do_printing)
2325             printf (" (%s)\n", get_TAG_name (entry->tag));
2326
2327           switch (entry->tag)
2328             {
2329             default:
2330               need_base_address = 0;
2331               break;
2332             case DW_TAG_compile_unit:
2333               need_base_address = 1;
2334               break;
2335             case DW_TAG_entry_point:
2336             case DW_TAG_subprogram:
2337               need_base_address = 0;
2338               /* Assuming that there is no DW_AT_frame_base.  */
2339               have_frame_base = 0;
2340               break;
2341             }
2342
2343           for (attr = entry->first_attr; attr; attr = attr->next)
2344             {
2345               debug_info *arg;
2346
2347               if (! do_loc && do_printing)
2348                 /* Show the offset from where the tag was extracted.  */
2349                 printf ("    <%lx>", (unsigned long)(tags - section_begin));
2350
2351               arg = debug_information;
2352               if (debug_information)
2353                 arg += unit;
2354
2355               tags = read_and_display_attr (attr->attribute,
2356                                             attr->form,
2357                                             tags, cu_offset,
2358                                             compunit.cu_pointer_size,
2359                                             offset_size,
2360                                             compunit.cu_version,
2361                                             arg,
2362                                             do_loc || ! do_printing, section);
2363             }
2364
2365           if (entry->children)
2366             ++level;
2367         }
2368     }
2369
2370   /* Set num_debug_info_entries here so that it can be used to check if
2371      we need to process .debug_loc and .debug_ranges sections.  */
2372   if ((do_loc || do_debug_loc || do_debug_ranges)
2373       && num_debug_info_entries == 0
2374       && ! do_types)
2375     num_debug_info_entries = num_units;
2376
2377   if (!do_loc)
2378     printf ("\n");
2379
2380   return 1;
2381 }
2382
2383 /* Locate and scan the .debug_info section in the file and record the pointer
2384    sizes and offsets for the compilation units in it.  Usually an executable
2385    will have just one pointer size, but this is not guaranteed, and so we try
2386    not to make any assumptions.  Returns zero upon failure, or the number of
2387    compilation units upon success.  */
2388
2389 static unsigned int
2390 load_debug_info (void * file)
2391 {
2392   /* Reset the last pointer size so that we can issue correct error
2393      messages if we are displaying the contents of more than one section.  */
2394   last_pointer_size = 0;
2395   warned_about_missing_comp_units = FALSE;
2396
2397   /* If we have already tried and failed to load the .debug_info
2398      section then do not bother to repear the task.  */
2399   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2400     return 0;
2401
2402   /* If we already have the information there is nothing else to do.  */
2403   if (num_debug_info_entries > 0)
2404     return num_debug_info_entries;
2405
2406   if (load_debug_section (info, file)
2407       && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2408     return num_debug_info_entries;
2409
2410   num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2411   return 0;
2412 }
2413
2414 static int
2415 display_debug_lines_raw (struct dwarf_section *section,
2416                          unsigned char *data,
2417                          unsigned char *end)
2418 {
2419   unsigned char *start = section->start;
2420
2421   printf (_("Raw dump of debug contents of section %s:\n\n"),
2422           section->name);
2423
2424   while (data < end)
2425     {
2426       DWARF2_Internal_LineInfo linfo;
2427       unsigned char *standard_opcodes;
2428       unsigned char *end_of_sequence;
2429       unsigned char *hdrptr;
2430       unsigned long hdroff;
2431       int initial_length_size;
2432       int offset_size;
2433       int i;
2434
2435       hdrptr = data;
2436       hdroff = hdrptr - start;
2437
2438       /* Check the length of the block.  */
2439       linfo.li_length = byte_get (hdrptr, 4);
2440       hdrptr += 4;
2441
2442       if (linfo.li_length == 0xffffffff)
2443         {
2444           /* This section is 64-bit DWARF 3.  */
2445           linfo.li_length = byte_get (hdrptr, 8);
2446           hdrptr += 8;
2447           offset_size = 8;
2448           initial_length_size = 12;
2449         }
2450       else
2451         {
2452           offset_size = 4;
2453           initial_length_size = 4;
2454         }
2455
2456       if (linfo.li_length + initial_length_size > section->size)
2457         {
2458           warn
2459             (_("The information in section %s appears to be corrupt - the section is too small\n"),
2460              section->name);
2461           return 0;
2462         }
2463
2464       /* Check its version number.  */
2465       linfo.li_version = byte_get (hdrptr, 2);
2466       hdrptr += 2;
2467       if (linfo.li_version != 2
2468           && linfo.li_version != 3
2469           && linfo.li_version != 4)
2470         {
2471           warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2472           return 0;
2473         }
2474
2475       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2476       hdrptr += offset_size;
2477       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2478       hdrptr++;
2479       if (linfo.li_version >= 4)
2480         {
2481           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2482           hdrptr++;
2483           if (linfo.li_max_ops_per_insn == 0)
2484             {
2485               warn (_("Invalid maximum operations per insn.\n"));
2486               return 0;
2487             }
2488         }
2489       else
2490         linfo.li_max_ops_per_insn = 1;
2491       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2492       hdrptr++;
2493       linfo.li_line_base = byte_get (hdrptr, 1);
2494       hdrptr++;
2495       linfo.li_line_range = byte_get (hdrptr, 1);
2496       hdrptr++;
2497       linfo.li_opcode_base = byte_get (hdrptr, 1);
2498       hdrptr++;
2499
2500       /* Sign extend the line base field.  */
2501       linfo.li_line_base <<= 24;
2502       linfo.li_line_base >>= 24;
2503
2504       printf (_("  Offset:                      0x%lx\n"), hdroff);
2505       printf (_("  Length:                      %ld\n"), (long) linfo.li_length);
2506       printf (_("  DWARF Version:               %d\n"), linfo.li_version);
2507       printf (_("  Prologue Length:             %d\n"), linfo.li_prologue_length);
2508       printf (_("  Minimum Instruction Length:  %d\n"), linfo.li_min_insn_length);
2509       if (linfo.li_version >= 4)
2510         printf (_("  Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2511       printf (_("  Initial value of 'is_stmt':  %d\n"), linfo.li_default_is_stmt);
2512       printf (_("  Line Base:                   %d\n"), linfo.li_line_base);
2513       printf (_("  Line Range:                  %d\n"), linfo.li_line_range);
2514       printf (_("  Opcode Base:                 %d\n"), linfo.li_opcode_base);
2515
2516       end_of_sequence = data + linfo.li_length + initial_length_size;
2517
2518       reset_state_machine (linfo.li_default_is_stmt);
2519
2520       /* Display the contents of the Opcodes table.  */
2521       standard_opcodes = hdrptr;
2522
2523       printf (_("\n Opcodes:\n"));
2524
2525       for (i = 1; i < linfo.li_opcode_base; i++)
2526         printf (_("  Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2527
2528       /* Display the contents of the Directory table.  */
2529       data = standard_opcodes + linfo.li_opcode_base - 1;
2530
2531       if (*data == 0)
2532         printf (_("\n The Directory Table is empty.\n"));
2533       else
2534         {
2535           printf (_("\n The Directory Table:\n"));
2536
2537           while (*data != 0)
2538             {
2539               printf ("  %s\n", data);
2540
2541               data += strlen ((char *) data) + 1;
2542             }
2543         }
2544
2545       /* Skip the NUL at the end of the table.  */
2546       data++;
2547
2548       /* Display the contents of the File Name table.  */
2549       if (*data == 0)
2550         printf (_("\n The File Name Table is empty.\n"));
2551       else
2552         {
2553           printf (_("\n The File Name Table:\n"));
2554           printf (_("  Entry\tDir\tTime\tSize\tName\n"));
2555
2556           while (*data != 0)
2557             {
2558               unsigned char *name;
2559               unsigned int bytes_read;
2560
2561               printf ("  %d\t", ++state_machine_regs.last_file_entry);
2562               name = data;
2563
2564               data += strlen ((char *) data) + 1;
2565
2566               printf ("%s\t",
2567                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2568               data += bytes_read;
2569               printf ("%s\t",
2570                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2571               data += bytes_read;
2572               printf ("%s\t",
2573                       dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
2574               data += bytes_read;
2575               printf ("%s\n", name);
2576             }
2577         }
2578
2579       /* Skip the NUL at the end of the table.  */
2580       data++;
2581
2582       /* Now display the statements.  */
2583       printf (_("\n Line Number Statements:\n"));
2584
2585       while (data < end_of_sequence)
2586         {
2587           unsigned char op_code;
2588           dwarf_signed_vma adv;
2589           dwarf_vma uladv;
2590           unsigned int bytes_read;
2591
2592           op_code = *data++;
2593
2594           if (op_code >= linfo.li_opcode_base)
2595             {
2596               op_code -= linfo.li_opcode_base;
2597               uladv = (op_code / linfo.li_line_range);
2598               if (linfo.li_max_ops_per_insn == 1)
2599                 {
2600                   uladv *= linfo.li_min_insn_length;
2601                   state_machine_regs.address += uladv;
2602                   printf (_("  Special opcode %d: "
2603                             "advance Address by %s to 0x%s"),
2604                           op_code, dwarf_vmatoa ("u", uladv),
2605                           dwarf_vmatoa ("x", state_machine_regs.address));
2606                 }
2607               else
2608                 {
2609                   state_machine_regs.address
2610                     += ((state_machine_regs.op_index + uladv)
2611                         / linfo.li_max_ops_per_insn)
2612                        * linfo.li_min_insn_length;
2613                   state_machine_regs.op_index
2614                     = (state_machine_regs.op_index + uladv)
2615                       % linfo.li_max_ops_per_insn;
2616                   printf (_("  Special opcode %d: "
2617                             "advance Address by %s to 0x%s[%d]"),
2618                           op_code, dwarf_vmatoa ("u", uladv),
2619                           dwarf_vmatoa ("x", state_machine_regs.address),
2620                           state_machine_regs.op_index);
2621                 }
2622               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
2623               state_machine_regs.line += adv;
2624               printf (_(" and Line by %s to %d\n"),
2625                       dwarf_vmatoa ("d", adv), state_machine_regs.line);
2626             }
2627           else switch (op_code)
2628             {
2629             case DW_LNS_extended_op:
2630               data += process_extended_line_op (data, linfo.li_default_is_stmt);
2631               break;
2632
2633             case DW_LNS_copy:
2634               printf (_("  Copy\n"));
2635               break;
2636
2637             case DW_LNS_advance_pc:
2638               uladv = read_leb128 (data, & bytes_read, 0);
2639               data += bytes_read;
2640               if (linfo.li_max_ops_per_insn == 1)
2641                 {
2642                   uladv *= linfo.li_min_insn_length;
2643                   state_machine_regs.address += uladv;
2644                   printf (_("  Advance PC by %s to 0x%s\n"),
2645                           dwarf_vmatoa ("u", uladv),
2646                           dwarf_vmatoa ("x", state_machine_regs.address));
2647                 }
2648               else
2649                 {
2650                   state_machine_regs.address
2651                     += ((state_machine_regs.op_index + uladv)
2652                         / linfo.li_max_ops_per_insn)
2653                        * linfo.li_min_insn_length;
2654                   state_machine_regs.op_index
2655                     = (state_machine_regs.op_index + uladv)
2656                       % linfo.li_max_ops_per_insn;
2657                   printf (_("  Advance PC by %s to 0x%s[%d]\n"),
2658                           dwarf_vmatoa ("u", uladv),
2659                           dwarf_vmatoa ("x", state_machine_regs.address),
2660                           state_machine_regs.op_index);
2661                 }
2662               break;
2663
2664             case DW_LNS_advance_line:
2665               adv = read_sleb128 (data, & bytes_read);
2666               data += bytes_read;
2667               state_machine_regs.line += adv;
2668               printf (_("  Advance Line by %s to %d\n"),
2669                         dwarf_vmatoa ("d", adv),
2670                         state_machine_regs.line);
2671               break;
2672
2673             case DW_LNS_set_file:
2674               adv = read_leb128 (data, & bytes_read, 0);
2675               data += bytes_read;
2676               printf (_("  Set File Name to entry %s in the File Name Table\n"),
2677                       dwarf_vmatoa ("d", adv));
2678               state_machine_regs.file = adv;
2679               break;
2680
2681             case DW_LNS_set_column:
2682               uladv = read_leb128 (data, & bytes_read, 0);
2683               data += bytes_read;
2684               printf (_("  Set column to %s\n"),
2685                       dwarf_vmatoa ("u", uladv));
2686               state_machine_regs.column = uladv;
2687               break;
2688
2689             case DW_LNS_negate_stmt:
2690               adv = state_machine_regs.is_stmt;
2691               adv = ! adv;
2692               printf (_("  Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
2693               state_machine_regs.is_stmt = adv;
2694               break;
2695
2696             case DW_LNS_set_basic_block:
2697               printf (_("  Set basic block\n"));
2698               state_machine_regs.basic_block = 1;
2699               break;
2700
2701             case DW_LNS_const_add_pc:
2702               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2703               if (linfo.li_max_ops_per_insn)
2704                 {
2705                   uladv *= linfo.li_min_insn_length;
2706                   state_machine_regs.address += uladv;
2707                   printf (_("  Advance PC by constant %s to 0x%s\n"),
2708                           dwarf_vmatoa ("u", uladv),
2709                           dwarf_vmatoa ("x", state_machine_regs.address));
2710                 }
2711               else
2712                 {
2713                   state_machine_regs.address
2714                     += ((state_machine_regs.op_index + uladv)
2715                         / linfo.li_max_ops_per_insn)
2716                        * linfo.li_min_insn_length;
2717                   state_machine_regs.op_index
2718                     = (state_machine_regs.op_index + uladv)
2719                       % linfo.li_max_ops_per_insn;
2720                   printf (_("  Advance PC by constant %s to 0x%s[%d]\n"),
2721                           dwarf_vmatoa ("u", uladv),
2722                           dwarf_vmatoa ("x", state_machine_regs.address),
2723                           state_machine_regs.op_index);
2724                 }
2725               break;
2726
2727             case DW_LNS_fixed_advance_pc:
2728               uladv = byte_get (data, 2);
2729               data += 2;
2730               state_machine_regs.address += uladv;
2731               state_machine_regs.op_index = 0;
2732               printf (_("  Advance PC by fixed size amount %s to 0x%s\n"),
2733                       dwarf_vmatoa ("u", uladv),
2734                       dwarf_vmatoa ("x", state_machine_regs.address));
2735               break;
2736
2737             case DW_LNS_set_prologue_end:
2738               printf (_("  Set prologue_end to true\n"));
2739               break;
2740
2741             case DW_LNS_set_epilogue_begin:
2742               printf (_("  Set epilogue_begin to true\n"));
2743               break;
2744
2745             case DW_LNS_set_isa:
2746               uladv = read_leb128 (data, & bytes_read, 0);
2747               data += bytes_read;
2748               printf (_("  Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
2749               break;
2750
2751             default:
2752               printf (_("  Unknown opcode %d with operands: "), op_code);
2753
2754               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2755                 {
2756                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2757                                                          &bytes_read, 0)),
2758                           i == 1 ? "" : ", ");
2759                   data += bytes_read;
2760                 }
2761               putchar ('\n');
2762               break;
2763             }
2764         }
2765       putchar ('\n');
2766     }
2767
2768   return 1;
2769 }
2770
2771 typedef struct
2772 {
2773   unsigned char *name;
2774   unsigned int directory_index;
2775   unsigned int modification_date;
2776   unsigned int length;
2777 } File_Entry;
2778
2779 /* Output a decoded representation of the .debug_line section.  */
2780
2781 static int
2782 display_debug_lines_decoded (struct dwarf_section *section,
2783                              unsigned char *data,
2784                              unsigned char *end)
2785 {
2786   printf (_("Decoded dump of debug contents of section %s:\n\n"),
2787           section->name);
2788
2789   while (data < end)
2790     {
2791       /* This loop amounts to one iteration per compilation unit.  */
2792       DWARF2_Internal_LineInfo linfo;
2793       unsigned char *standard_opcodes;
2794       unsigned char *end_of_sequence;
2795       unsigned char *hdrptr;
2796       int initial_length_size;
2797       int offset_size;
2798       int i;
2799       File_Entry *file_table = NULL;
2800       unsigned char **directory_table = NULL;
2801
2802       hdrptr = data;
2803
2804       /* Extract information from the Line Number Program Header.
2805         (section 6.2.4 in the Dwarf3 doc).  */
2806
2807       /* Get the length of this CU's line number information block.  */
2808       linfo.li_length = byte_get (hdrptr, 4);
2809       hdrptr += 4;
2810
2811       if (linfo.li_length == 0xffffffff)
2812         {
2813           /* This section is 64-bit DWARF 3.  */
2814           linfo.li_length = byte_get (hdrptr, 8);
2815           hdrptr += 8;
2816           offset_size = 8;
2817           initial_length_size = 12;
2818         }
2819       else
2820         {
2821           offset_size = 4;
2822           initial_length_size = 4;
2823         }
2824
2825       if (linfo.li_length + initial_length_size > section->size)
2826         {
2827           warn (_("The line info appears to be corrupt - "
2828                   "the section is too small\n"));
2829           return 0;
2830         }
2831
2832       /* Get this CU's Line Number Block version number.  */
2833       linfo.li_version = byte_get (hdrptr, 2);
2834       hdrptr += 2;
2835       if (linfo.li_version != 2
2836           && linfo.li_version != 3
2837           && linfo.li_version != 4)
2838         {
2839           warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2840                 "supported.\n"));
2841           return 0;
2842         }
2843
2844       linfo.li_prologue_length = byte_get (hdrptr, offset_size);
2845       hdrptr += offset_size;
2846       linfo.li_min_insn_length = byte_get (hdrptr, 1);
2847       hdrptr++;
2848       if (linfo.li_version >= 4)
2849         {
2850           linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2851           hdrptr++;
2852           if (linfo.li_max_ops_per_insn == 0)
2853             {
2854               warn (_("Invalid maximum operations per insn.\n"));
2855               return 0;
2856             }
2857         }
2858       else
2859         linfo.li_max_ops_per_insn = 1;
2860       linfo.li_default_is_stmt = byte_get (hdrptr, 1);
2861       hdrptr++;
2862       linfo.li_line_base = byte_get (hdrptr, 1);
2863       hdrptr++;
2864       linfo.li_line_range = byte_get (hdrptr, 1);
2865       hdrptr++;
2866       linfo.li_opcode_base = byte_get (hdrptr, 1);
2867       hdrptr++;
2868
2869       /* Sign extend the line base field.  */
2870       linfo.li_line_base <<= 24;
2871       linfo.li_line_base >>= 24;
2872
2873       /* Find the end of this CU's Line Number Information Block.  */
2874       end_of_sequence = data + linfo.li_length + initial_length_size;
2875
2876       reset_state_machine (linfo.li_default_is_stmt);
2877
2878       /* Save a pointer to the contents of the Opcodes table.  */
2879       standard_opcodes = hdrptr;
2880
2881       /* Traverse the Directory table just to count entries.  */
2882       data = standard_opcodes + linfo.li_opcode_base - 1;
2883       if (*data != 0)
2884         {
2885           unsigned int n_directories = 0;
2886           unsigned char *ptr_directory_table = data;
2887
2888           while (*data != 0)
2889             {
2890               data += strlen ((char *) data) + 1;
2891               n_directories++;
2892             }
2893
2894           /* Go through the directory table again to save the directories.  */
2895           directory_table = (unsigned char **)
2896               xmalloc (n_directories * sizeof (unsigned char *));
2897
2898           i = 0;
2899           while (*ptr_directory_table != 0)
2900             {
2901               directory_table[i] = ptr_directory_table;
2902               ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2903               i++;
2904             }
2905         }
2906       /* Skip the NUL at the end of the table.  */
2907       data++;
2908
2909       /* Traverse the File Name table just to count the entries.  */
2910       if (*data != 0)
2911         {
2912           unsigned int n_files = 0;
2913           unsigned char *ptr_file_name_table = data;
2914
2915           while (*data != 0)
2916             {
2917               unsigned int bytes_read;
2918
2919               /* Skip Name, directory index, last modification time and length
2920                  of file.  */
2921               data += strlen ((char *) data) + 1;
2922               read_leb128 (data, & bytes_read, 0);
2923               data += bytes_read;
2924               read_leb128 (data, & bytes_read, 0);
2925               data += bytes_read;
2926               read_leb128 (data, & bytes_read, 0);
2927               data += bytes_read;
2928
2929               n_files++;
2930             }
2931
2932           /* Go through the file table again to save the strings.  */
2933           file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
2934
2935           i = 0;
2936           while (*ptr_file_name_table != 0)
2937             {
2938               unsigned int bytes_read;
2939
2940               file_table[i].name = ptr_file_name_table;
2941               ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2942
2943               /* We are not interested in directory, time or size.  */
2944               file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2945                                                            & bytes_read, 0);
2946               ptr_file_name_table += bytes_read;
2947               file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2948                                                              & bytes_read, 0);
2949               ptr_file_name_table += bytes_read;
2950               file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2951               ptr_file_name_table += bytes_read;
2952               i++;
2953             }
2954           i = 0;
2955
2956           /* Print the Compilation Unit's name and a header.  */
2957           if (directory_table == NULL)
2958             {
2959               printf (_("CU: %s:\n"), file_table[0].name);
2960               printf (_("File name                            Line number    Starting address\n"));
2961             }
2962           else
2963             {
2964               if (do_wide || strlen ((char *) directory_table[0]) < 76)
2965                 printf (_("CU: %s/%s:\n"), directory_table[0],
2966                         file_table[0].name);
2967               else
2968                 printf ("%s:\n", file_table[0].name);
2969
2970               printf (_("File name                            Line number    Starting address\n"));
2971             }
2972         }
2973
2974       /* Skip the NUL at the end of the table.  */
2975       data++;
2976
2977       /* This loop iterates through the Dwarf Line Number Program.  */
2978       while (data < end_of_sequence)
2979         {
2980           unsigned char op_code;
2981           int adv;
2982           unsigned long int uladv;
2983           unsigned int bytes_read;
2984           int is_special_opcode = 0;
2985
2986           op_code = *data++;
2987
2988           if (op_code >= linfo.li_opcode_base)
2989             {
2990               op_code -= linfo.li_opcode_base;
2991               uladv = (op_code / linfo.li_line_range);
2992               if (linfo.li_max_ops_per_insn == 1)
2993                 {
2994                   uladv *= linfo.li_min_insn_length;
2995                   state_machine_regs.address += uladv;
2996                 }
2997               else
2998                 {
2999                   state_machine_regs.address
3000                     += ((state_machine_regs.op_index + uladv)
3001                         / linfo.li_max_ops_per_insn)
3002                        * linfo.li_min_insn_length;
3003                   state_machine_regs.op_index
3004                     = (state_machine_regs.op_index + uladv)
3005                       % linfo.li_max_ops_per_insn;
3006                 }
3007
3008               adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3009               state_machine_regs.line += adv;
3010               is_special_opcode = 1;
3011             }
3012           else switch (op_code)
3013             {
3014             case DW_LNS_extended_op:
3015               {
3016                 unsigned int ext_op_code_len;
3017                 unsigned char ext_op_code;
3018                 unsigned char *op_code_data = data;
3019
3020                 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3021                 op_code_data += bytes_read;
3022
3023                 if (ext_op_code_len == 0)
3024                   {
3025                     warn (_("badly formed extended line op encountered!\n"));
3026                     break;
3027                   }
3028                 ext_op_code_len += bytes_read;
3029                 ext_op_code = *op_code_data++;
3030
3031                 switch (ext_op_code)
3032                   {
3033                   case DW_LNE_end_sequence:
3034                     reset_state_machine (linfo.li_default_is_stmt);
3035                     break;
3036                   case DW_LNE_set_address:
3037                     state_machine_regs.address =
3038                     byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
3039                     state_machine_regs.op_index = 0;
3040                     break;
3041                   case DW_LNE_define_file:
3042                     {
3043                       unsigned int dir_index = 0;
3044
3045                       ++state_machine_regs.last_file_entry;
3046                       op_code_data += strlen ((char *) op_code_data) + 1;
3047                       dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3048                       op_code_data += bytes_read;
3049                       read_leb128 (op_code_data, & bytes_read, 0);
3050                       op_code_data += bytes_read;
3051                       read_leb128 (op_code_data, & bytes_read, 0);
3052
3053                       printf ("%s:\n", directory_table[dir_index]);
3054                       break;
3055                     }
3056                   default:
3057                     printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3058                     break;
3059                   }
3060                 data += ext_op_code_len;
3061                 break;
3062               }
3063             case DW_LNS_copy:
3064               break;
3065
3066             case DW_LNS_advance_pc:
3067               uladv = read_leb128 (data, & bytes_read, 0);
3068               data += bytes_read;
3069               if (linfo.li_max_ops_per_insn == 1)
3070                 {
3071                   uladv *= linfo.li_min_insn_length;
3072                   state_machine_regs.address += uladv;
3073                 }
3074               else
3075                 {
3076                   state_machine_regs.address
3077                     += ((state_machine_regs.op_index + uladv)
3078                         / linfo.li_max_ops_per_insn)
3079                        * linfo.li_min_insn_length;
3080                   state_machine_regs.op_index
3081                     = (state_machine_regs.op_index + uladv)
3082                       % linfo.li_max_ops_per_insn;
3083                 }
3084               break;
3085
3086             case DW_LNS_advance_line:
3087               adv = read_sleb128 (data, & bytes_read);
3088               data += bytes_read;
3089               state_machine_regs.line += adv;
3090               break;
3091
3092             case DW_LNS_set_file:
3093               adv = read_leb128 (data, & bytes_read, 0);
3094               data += bytes_read;
3095               state_machine_regs.file = adv;
3096               if (file_table[state_machine_regs.file - 1].directory_index == 0)
3097                 {
3098                   /* If directory index is 0, that means current directory.  */
3099                   printf ("\n./%s:[++]\n",
3100                           file_table[state_machine_regs.file - 1].name);
3101                 }
3102               else
3103                 {
3104                   /* The directory index starts counting at 1.  */
3105                   printf ("\n%s/%s:\n",
3106                           directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3107                           file_table[state_machine_regs.file - 1].name);
3108                 }
3109               break;
3110
3111             case DW_LNS_set_column:
3112               uladv = read_leb128 (data, & bytes_read, 0);
3113               data += bytes_read;
3114               state_machine_regs.column = uladv;
3115               break;
3116
3117             case DW_LNS_negate_stmt:
3118               adv = state_machine_regs.is_stmt;
3119               adv = ! adv;
3120               state_machine_regs.is_stmt = adv;
3121               break;
3122
3123             case DW_LNS_set_basic_block:
3124               state_machine_regs.basic_block = 1;
3125               break;
3126
3127             case DW_LNS_const_add_pc:
3128               uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3129               if (linfo.li_max_ops_per_insn == 1)
3130                 {
3131                   uladv *= linfo.li_min_insn_length;
3132                   state_machine_regs.address += uladv;
3133                 }
3134               else
3135                 {
3136                   state_machine_regs.address
3137                     += ((state_machine_regs.op_index + uladv)
3138                         / linfo.li_max_ops_per_insn)
3139                        * linfo.li_min_insn_length;
3140                   state_machine_regs.op_index
3141                     = (state_machine_regs.op_index + uladv)
3142                       % linfo.li_max_ops_per_insn;
3143                 }
3144               break;
3145
3146             case DW_LNS_fixed_advance_pc:
3147               uladv = byte_get (data, 2);
3148               data += 2;
3149               state_machine_regs.address += uladv;
3150               state_machine_regs.op_index = 0;
3151               break;
3152
3153             case DW_LNS_set_prologue_end:
3154               break;
3155
3156             case DW_LNS_set_epilogue_begin:
3157               break;
3158
3159             case DW_LNS_set_isa:
3160               uladv = read_leb128 (data, & bytes_read, 0);
3161               data += bytes_read;
3162               printf (_("  Set ISA to %lu\n"), uladv);
3163               break;
3164
3165             default:
3166               printf (_("  Unknown opcode %d with operands: "), op_code);
3167
3168               for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3169                 {
3170                   printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3171                                                          &bytes_read, 0)),
3172                           i == 1 ? "" : ", ");
3173                   data += bytes_read;
3174                 }
3175               putchar ('\n');
3176               break;
3177             }
3178
3179           /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3180              to the DWARF address/line matrix.  */
3181           if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3182               || (op_code == DW_LNS_copy))
3183             {
3184               const unsigned int MAX_FILENAME_LENGTH = 35;
3185               char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3186               char *newFileName = NULL;
3187               size_t fileNameLength = strlen (fileName);
3188
3189               if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3190                 {
3191                   newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3192                   /* Truncate file name */
3193                   strncpy (newFileName,
3194                            fileName + fileNameLength - MAX_FILENAME_LENGTH,
3195                            MAX_FILENAME_LENGTH + 1);
3196                 }
3197               else
3198                 {
3199                   newFileName = (char *) xmalloc (fileNameLength + 1);
3200                   strncpy (newFileName, fileName, fileNameLength + 1);
3201                 }
3202
3203               if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3204                 {
3205                   if (linfo.li_max_ops_per_insn == 1)
3206                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x\n",
3207                             newFileName, state_machine_regs.line,
3208                             state_machine_regs.address);
3209                   else
3210                     printf ("%-35s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3211                             newFileName, state_machine_regs.line,
3212                             state_machine_regs.address,
3213                             state_machine_regs.op_index);
3214                 }
3215               else
3216                 {
3217                   if (linfo.li_max_ops_per_insn == 1)
3218                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x\n",
3219                             newFileName, state_machine_regs.line,
3220                             state_machine_regs.address);
3221                   else
3222                     printf ("%s  %11d  %#18" DWARF_VMA_FMT "x[%d]\n",
3223                             newFileName, state_machine_regs.line,
3224                             state_machine_regs.address,
3225                             state_machine_regs.op_index);
3226                 }
3227
3228               if (op_code == DW_LNE_end_sequence)
3229                 printf ("\n");
3230
3231               free (newFileName);
3232             }
3233         }
3234       free (file_table);
3235       file_table = NULL;
3236       free (directory_table);
3237       directory_table = NULL;
3238       putchar ('\n');
3239     }
3240
3241   return 1;
3242 }
3243
3244 static int
3245 display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
3246 {
3247   unsigned char *data = section->start;
3248   unsigned char *end = data + section->size;
3249   int retValRaw = 1;
3250   int retValDecoded = 1;
3251
3252   if (do_debug_lines == 0)
3253     do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3254
3255   if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3256     retValRaw = display_debug_lines_raw (section, data, end);
3257
3258   if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3259     retValDecoded = display_debug_lines_decoded (section, data, end);
3260
3261   if (!retValRaw || !retValDecoded)
3262     return 0;
3263
3264   return 1;
3265 }
3266
3267 static debug_info *
3268 find_debug_info_for_offset (unsigned long offset)
3269 {
3270   unsigned int i;
3271
3272   if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3273     return NULL;
3274
3275   for (i = 0; i < num_debug_info_entries; i++)
3276     if (debug_information[i].cu_offset == offset)
3277       return debug_information + i;
3278
3279   return NULL;
3280 }
3281
3282 static int
3283 display_debug_pubnames (struct dwarf_section *section,
3284                         void *file ATTRIBUTE_UNUSED)
3285 {
3286   DWARF2_Internal_PubNames names;
3287   unsigned char *start = section->start;
3288   unsigned char *end = start + section->size;
3289
3290   /* It does not matter if this load fails,
3291      we test for that later on.  */
3292   load_debug_info (file);
3293
3294   printf (_("Contents of the %s section:\n\n"), section->name);
3295
3296   while (start < end)
3297     {
3298       unsigned char *data;
3299       unsigned long offset;
3300       int offset_size, initial_length_size;
3301
3302       data = start;
3303
3304       names.pn_length = byte_get (data, 4);
3305       data += 4;
3306       if (names.pn_length == 0xffffffff)
3307         {
3308           names.pn_length = byte_get (data, 8);
3309           data += 8;
3310           offset_size = 8;
3311           initial_length_size = 12;
3312         }
3313       else
3314         {
3315           offset_size = 4;
3316           initial_length_size = 4;
3317         }
3318
3319       names.pn_version = byte_get (data, 2);
3320       data += 2;
3321
3322       names.pn_offset = byte_get (data, offset_size);
3323       data += offset_size;
3324
3325       if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3326           && num_debug_info_entries > 0
3327           && find_debug_info_for_offset (names.pn_offset) == NULL)
3328         warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3329               (unsigned long) names.pn_offset, section->name);
3330
3331       names.pn_size = byte_get (data, offset_size);
3332       data += offset_size;
3333
3334       start += names.pn_length + initial_length_size;
3335
3336       if (names.pn_version != 2 && names.pn_version != 3)
3337         {
3338           static int warned = 0;
3339
3340           if (! warned)
3341             {
3342               warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3343               warned = 1;
3344             }
3345
3346           continue;
3347         }
3348
3349       printf (_("  Length:                              %ld\n"),
3350               (long) names.pn_length);
3351       printf (_("  Version:                             %d\n"),
3352               names.pn_version);
3353       printf (_("  Offset into .debug_info section:     0x%lx\n"),
3354               (unsigned long) names.pn_offset);
3355       printf (_("  Size of area in .debug_info section: %ld\n"),
3356               (long) names.pn_size);
3357
3358       printf (_("\n    Offset\tName\n"));
3359
3360       do
3361         {
3362           offset = byte_get (data, offset_size);
3363
3364           if (offset != 0)
3365             {
3366               data += offset_size;
3367               printf ("    %-6lx\t%s\n", offset, data);
3368               data += strlen ((char *) data) + 1;
3369             }
3370         }
3371       while (offset != 0);
3372     }
3373
3374   printf ("\n");
3375   return 1;
3376 }
3377
3378 static int
3379 display_debug_macinfo (struct dwarf_section *section,
3380                        void *file ATTRIBUTE_UNUSED)
3381 {
3382   unsigned char *start = section->start;
3383   unsigned char *end = start + section->size;
3384   unsigned char *curr = start;
3385   unsigned int bytes_read;
3386   enum dwarf_macinfo_record_type op;
3387
3388   printf (_("Contents of the %s section:\n\n"), section->name);
3389
3390   while (curr < end)
3391     {
3392       unsigned int lineno;
3393       const char *string;
3394
3395       op = (enum dwarf_macinfo_record_type) *curr;
3396       curr++;
3397
3398       switch (op)
3399         {
3400         case DW_MACINFO_start_file:
3401           {
3402             unsigned int filenum;
3403
3404             lineno = read_leb128 (curr, & bytes_read, 0);
3405             curr += bytes_read;
3406             filenum = read_leb128 (curr, & bytes_read, 0);
3407             curr += bytes_read;
3408
3409             printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3410                     lineno, filenum);
3411           }
3412           break;
3413
3414         case DW_MACINFO_end_file:
3415           printf (_(" DW_MACINFO_end_file\n"));
3416           break;
3417
3418         case DW_MACINFO_define:
3419           lineno = read_leb128 (curr, & bytes_read, 0);
3420           curr += bytes_read;
3421           string = (char *) curr;
3422           curr += strlen (string) + 1;
3423           printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3424                   lineno, string);
3425           break;
3426
3427         case DW_MACINFO_undef:
3428           lineno = read_leb128 (curr, & bytes_read, 0);
3429           curr += bytes_read;
3430           string = (char *) curr;
3431           curr += strlen (string) + 1;
3432           printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3433                   lineno, string);
3434           break;
3435
3436         case DW_MACINFO_vendor_ext:
3437           {
3438             unsigned int constant;
3439
3440             constant = read_leb128 (curr, & bytes_read, 0);
3441             curr += bytes_read;
3442             string = (char *) curr;
3443             curr += strlen (string) + 1;
3444             printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3445                     constant, string);
3446           }
3447           break;
3448         }
3449     }
3450
3451   return 1;
3452 }
3453
3454 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3455    filename and dirname corresponding to file name table entry with index
3456    FILEIDX.  Return NULL on failure.  */
3457
3458 static unsigned char *
3459 get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
3460                                unsigned char **dir_name)
3461 {
3462   struct dwarf_section *section = &debug_displays [line].section;
3463   unsigned char *hdrptr, *dirtable, *file_name;
3464   unsigned int offset_size, initial_length_size;
3465   unsigned int version, opcode_base, bytes_read;
3466   dwarf_vma length, diridx;
3467
3468   *dir_name = NULL;
3469   if (section->start == NULL
3470       || line_offset >= section->size
3471       || fileidx == 0)
3472     return NULL;
3473
3474   hdrptr = section->start + line_offset;
3475   length = byte_get (hdrptr, 4);
3476   hdrptr += 4;
3477   if (length == 0xffffffff)
3478     {
3479       /* This section is 64-bit DWARF 3.  */
3480       length = byte_get (hdrptr, 8);
3481       hdrptr += 8;
3482       offset_size = 8;
3483       initial_length_size = 12;
3484     }
3485   else
3486     {
3487       offset_size = 4;
3488       initial_length_size = 4;
3489     }
3490   if (length + initial_length_size > section->size)
3491     return NULL;
3492   version = byte_get (hdrptr, 2);
3493   hdrptr += 2;
3494   if (version != 2 && version != 3 && version != 4)
3495     return NULL;
3496   hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length.  */
3497   if (version >= 4)
3498     hdrptr++;               /* Skip max_ops_per_insn.  */
3499   hdrptr += 3;              /* Skip default_is_stmt, line_base, line_range.  */
3500   opcode_base = byte_get (hdrptr, 1);
3501   if (opcode_base == 0)
3502     return NULL;
3503   hdrptr++;
3504   hdrptr += opcode_base - 1;
3505   dirtable = hdrptr;
3506   /* Skip over dirname table.  */
3507   while (*hdrptr != '\0')
3508     hdrptr += strlen ((char *) hdrptr) + 1;
3509   hdrptr++;                 /* Skip the NUL at the end of the table.  */
3510   /* Now skip over preceding filename table entries.  */
3511   for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3512     {
3513       hdrptr += strlen ((char *) hdrptr) + 1;
3514       read_leb128 (hdrptr, &bytes_read, 0);
3515       hdrptr += bytes_read;
3516       read_leb128 (hdrptr, &bytes_read, 0);
3517       hdrptr += bytes_read;
3518       read_leb128 (hdrptr, &bytes_read, 0);
3519       hdrptr += bytes_read;
3520     }
3521   if (*hdrptr == '\0')
3522     return NULL;
3523   file_name = hdrptr;
3524   hdrptr += strlen ((char *) hdrptr) + 1;
3525   diridx = read_leb128 (hdrptr, &bytes_read, 0);
3526   if (diridx == 0)
3527     return file_name;
3528   for (; *dirtable != '\0' && diridx > 1; diridx--)
3529     dirtable += strlen ((char *) dirtable) + 1;
3530   if (*dirtable == '\0')
3531     return NULL;
3532   *dir_name = dirtable;
3533   return file_name;
3534 }
3535
3536 static int
3537 display_debug_macro (struct dwarf_section *section,
3538                      void *file)
3539 {
3540   unsigned char *start = section->start;
3541   unsigned char *end = start + section->size;
3542   unsigned char *curr = start;
3543   unsigned char *extended_op_buf[256];
3544   unsigned int bytes_read;
3545
3546   load_debug_section (str, file);
3547   load_debug_section (line, file);
3548
3549   printf (_("Contents of the %s section:\n\n"), section->name);
3550
3551   while (curr < end)
3552     {
3553       unsigned int lineno, version, flags;
3554       unsigned int offset_size = 4;
3555       const char *string;
3556       dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3557       unsigned char **extended_ops = NULL;
3558
3559       version = byte_get (curr, 2);
3560       curr += 2;
3561
3562       if (version != 4)
3563         {
3564           error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3565                  section->name);
3566           return 0;
3567         }
3568
3569       flags = byte_get (curr++, 1);
3570       if (flags & 1)
3571         offset_size = 8;
3572       printf (_("  Offset:                      0x%lx\n"),
3573               (unsigned long) sec_offset);
3574       printf (_("  Version:                     %d\n"), version);
3575       printf (_("  Offset size:                 %d\n"), offset_size);
3576       if (flags & 2)
3577         {
3578           line_offset = byte_get (curr, offset_size);
3579           curr += offset_size;
3580           printf (_("  Offset into .debug_line:     0x%lx\n"),
3581                   (unsigned long) line_offset);
3582         }
3583       if (flags & 4)
3584         {
3585           unsigned int i, count = byte_get (curr++, 1), op;
3586           dwarf_vma nargs, n;
3587           memset (extended_op_buf, 0, sizeof (extended_op_buf));
3588           extended_ops = extended_op_buf;
3589           if (count)
3590             {
3591               printf (_("  Extension opcode arguments:\n"));
3592               for (i = 0; i < count; i++)
3593                 {
3594                   op = byte_get (curr++, 1);
3595                   extended_ops[op] = curr;
3596                   nargs = read_leb128 (curr, &bytes_read, 0);
3597                   curr += bytes_read;
3598                   if (nargs == 0)
3599                     printf (_("    DW_MACRO_GNU_%02x has no arguments\n"), op);
3600                   else
3601                     {
3602                       printf (_("    DW_MACRO_GNU_%02x arguments: "), op);
3603                       for (n = 0; n < nargs; n++)
3604                         {
3605                           unsigned int form = byte_get (curr++, 1);
3606                           printf ("%s%s", get_FORM_name (form),
3607                                   n == nargs - 1 ? "\n" : ", ");
3608                           switch (form)
3609                             {
3610                             case DW_FORM_data1:
3611                             case DW_FORM_data2:
3612                             case DW_FORM_data4:
3613                             case DW_FORM_data8:
3614                             case DW_FORM_sdata:
3615                             case DW_FORM_udata:
3616                             case DW_FORM_block:
3617                             case DW_FORM_block1:
3618                             case DW_FORM_block2:
3619                             case DW_FORM_block4:
3620                             case DW_FORM_flag:
3621                             case DW_FORM_string:
3622                             case DW_FORM_strp:
3623                             case DW_FORM_sec_offset:
3624                               break;
3625                             default:
3626                               error (_("Invalid extension opcode form %s\n"),
3627                                      get_FORM_name (form));
3628                               return 0;
3629                             }
3630                         }
3631                     }
3632                 }
3633             }
3634         }
3635       printf ("\n");
3636
3637       while (1)
3638         {
3639           unsigned int op;
3640
3641           if (curr >= end)
3642             {
3643               error (_(".debug_macro section not zero terminated\n"));
3644               return 0;
3645             }
3646
3647           op = byte_get (curr++, 1);
3648           if (op == 0)
3649             break;
3650
3651           switch (op)
3652             {
3653             case DW_MACRO_GNU_start_file:
3654               {
3655                 unsigned int filenum;
3656                 unsigned char *file_name = NULL, *dir_name = NULL;
3657
3658                 lineno = read_leb128 (curr, &bytes_read, 0);
3659                 curr += bytes_read;
3660                 filenum = read_leb128 (curr, &bytes_read, 0);
3661                 curr += bytes_read;
3662
3663                 if ((flags & 2) == 0)
3664                   error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3665                 else
3666                   file_name
3667                     = get_line_filename_and_dirname (line_offset, filenum,
3668                                                      &dir_name);
3669                 if (file_name == NULL)
3670                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3671                           lineno, filenum);
3672                 else
3673                   printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3674                           lineno, filenum,
3675                           dir_name != NULL ? (const char *) dir_name : "",
3676                           dir_name != NULL ? "/" : "", file_name);
3677               }
3678               break;
3679
3680             case DW_MACRO_GNU_end_file:
3681               printf (_(" DW_MACRO_GNU_end_file\n"));
3682               break;
3683
3684             case DW_MACRO_GNU_define:
3685               lineno = read_leb128 (curr, &bytes_read, 0);
3686               curr += bytes_read;
3687               string = (char *) curr;
3688               curr += strlen (string) + 1;
3689               printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3690                       lineno, string);
3691               break;
3692
3693             case DW_MACRO_GNU_undef:
3694               lineno = read_leb128 (curr, &bytes_read, 0);
3695               curr += bytes_read;
3696               string = (char *) curr;
3697               curr += strlen (string) + 1;
3698               printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3699                       lineno, string);
3700               break;
3701
3702             case DW_MACRO_GNU_define_indirect:
3703               lineno = read_leb128 (curr, &bytes_read, 0);
3704               curr += bytes_read;
3705               offset = byte_get (curr, offset_size);
3706               curr += offset_size;
3707               string = fetch_indirect_string (offset);
3708               printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3709                       lineno, string);
3710               break;
3711
3712             case DW_MACRO_GNU_undef_indirect:
3713               lineno = read_leb128 (curr, &bytes_read, 0);
3714               curr += bytes_read;
3715               offset = byte_get (curr, offset_size);
3716               curr += offset_size;
3717               string = fetch_indirect_string (offset);
3718               printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3719                       lineno, string);
3720               break;
3721
3722             case DW_MACRO_GNU_transparent_include:
3723               offset = byte_get (curr, offset_size);
3724               curr += offset_size;
3725               printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3726                       (unsigned long) offset);
3727               break;
3728
3729             default:
3730               if (extended_ops == NULL || extended_ops[op] == NULL)
3731                 {
3732                   error (_(" Unknown macro opcode %02x seen\n"), op);
3733                   return 0;
3734                 }
3735               else
3736                 {
3737                   /* Skip over unhandled opcodes.  */
3738                   dwarf_vma nargs, n;
3739                   unsigned char *desc = extended_ops[op];
3740                   nargs = read_leb128 (desc, &bytes_read, 0);
3741                   desc += bytes_read;
3742                   if (nargs == 0)
3743                     {
3744                       printf (_(" DW_MACRO_GNU_%02x\n"), op);
3745                       break;
3746                     }
3747                   printf (_(" DW_MACRO_GNU_%02x -"), op);
3748                   for (n = 0; n < nargs; n++)
3749                     {
3750                       curr
3751                         = read_and_display_attr_value (0, byte_get (desc++, 1),
3752                                                        curr, 0, 0, offset_size,
3753                                                        version, NULL, 0, NULL);
3754                       if (n != nargs - 1)
3755                         printf (",");
3756                     }
3757                   printf ("\n");
3758                 }
3759               break;
3760             }
3761         }
3762
3763       printf ("\n");
3764     }   
3765
3766   return 1;
3767 }
3768
3769 static int
3770 display_debug_abbrev (struct dwarf_section *section,
3771                       void *file ATTRIBUTE_UNUSED)
3772 {
3773   abbrev_entry *entry;
3774   unsigned char *start = section->start;
3775   unsigned char *end = start + section->size;
3776
3777   printf (_("Contents of the %s section:\n\n"), section->name);
3778
3779   do
3780     {
3781       free_abbrevs ();
3782
3783       start = process_abbrev_section (start, end);
3784
3785       if (first_abbrev == NULL)
3786         continue;
3787
3788       printf (_("  Number TAG\n"));
3789
3790       for (entry = first_abbrev; entry; entry = entry->next)
3791         {
3792           abbrev_attr *attr;
3793
3794           printf ("   %ld      %s    [%s]\n",
3795                   entry->entry,
3796                   get_TAG_name (entry->tag),
3797                   entry->children ? _("has children") : _("no children"));
3798
3799           for (attr = entry->first_attr; attr; attr = attr->next)
3800             printf ("    %-18s %s\n",
3801                     get_AT_name (attr->attribute),
3802                     get_FORM_name (attr->form));
3803         }
3804     }
3805   while (start);
3806
3807   printf ("\n");
3808
3809   return 1;
3810 }
3811
3812 /* Sort array of indexes in ascending order of loc_offsets[idx].  */
3813
3814 static dwarf_vma *loc_offsets;
3815
3816 static int
3817 loc_offsets_compar (const void *ap, const void *bp)
3818 {
3819   dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3820   dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3821
3822   return (a > b) - (b > a);
3823 }
3824
3825 static int
3826 display_debug_loc (struct dwarf_section *section, void *file)
3827 {
3828   unsigned char *start = section->start;
3829   unsigned char *section_end;
3830   unsigned long bytes;
3831   unsigned char *section_begin = start;
3832   unsigned int num_loc_list = 0;
3833   unsigned long last_offset = 0;
3834   unsigned int first = 0;
3835   unsigned int i;
3836   unsigned int j;
3837   unsigned int k;
3838   int seen_first_offset = 0;
3839   int locs_sorted = 1;
3840   unsigned char *next;
3841   unsigned int *array = NULL;
3842
3843   bytes = section->size;
3844   section_end = start + bytes;
3845
3846   if (bytes == 0)
3847     {
3848       printf (_("\nThe %s section is empty.\n"), section->name);
3849       return 0;
3850     }
3851
3852   if (load_debug_info (file) == 0)
3853     {
3854       warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3855             section->name);
3856       return 0;
3857     }
3858
3859   /* Check the order of location list in .debug_info section. If
3860      offsets of location lists are in the ascending order, we can
3861      use `debug_information' directly.  */
3862   for (i = 0; i < num_debug_info_entries; i++)
3863     {
3864       unsigned int num;
3865
3866       num = debug_information [i].num_loc_offsets;
3867       if (num > num_loc_list)
3868         num_loc_list = num;
3869
3870       /* Check if we can use `debug_information' directly.  */
3871       if (locs_sorted && num != 0)
3872         {
3873           if (!seen_first_offset)
3874             {
3875               /* This is the first location list.  */
3876               last_offset = debug_information [i].loc_offsets [0];
3877               first = i;
3878               seen_first_offset = 1;
3879               j = 1;
3880             }