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