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
size_of_encoded_value(int encoding)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
get_encoded_value(unsigned char ** pdata,int encoding,struct dwarf_section * section,unsigned char * end)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 *
dwarf_vmatoa_1(const char * fmtch,dwarf_vma value,unsigned num_bytes)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 *
dwarf_vmatoa(const char * fmtch,dwarf_vma value)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
print_dwarf_vma(dwarf_vma value,unsigned num_bytes)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 *
dwarf_vmatoa64(dwarf_vma hvalue,dwarf_vma lvalue,char * buf,unsigned int buf_len)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
read_leb128(unsigned char * data,unsigned int * length_return,bfd_boolean sign,const unsigned char * const end)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
read_sleb128(unsigned char * data,unsigned int * length_return,const unsigned char * const end)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
read_uleb128(unsigned char * data,unsigned int * length_return,const unsigned char * const end)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 unsigned int discriminator;
369 unsigned int context;
370 unsigned int subprogram;
371 int is_stmt;
372 int basic_block;
373 unsigned char op_index;
374 unsigned char end_sequence;
375 /* This variable hold the number of the last entry seen
376 in the File Table. */
377 unsigned int last_file_entry;
378 } SMR;
379
380 static SMR state_machine_regs;
381
382 static void
reset_state_machine(int is_stmt)383 reset_state_machine (int is_stmt)
384 {
385 state_machine_regs.address = 0;
386 state_machine_regs.op_index = 0;
387 state_machine_regs.file = 1;
388 state_machine_regs.line = 1;
389 state_machine_regs.column = 0;
390 state_machine_regs.discriminator = 0;
391 state_machine_regs.context = 0;
392 state_machine_regs.subprogram = 0;
393 state_machine_regs.is_stmt = is_stmt;
394 state_machine_regs.basic_block = 0;
395 state_machine_regs.end_sequence = 0;
396 state_machine_regs.last_file_entry = 0;
397 }
398
399 /* Build a logicals table for reference when reading the actuals table. */
400
401 static SMR *logicals_table = NULL;
402 static unsigned int logicals_allocated = 0;
403 static unsigned int logicals_count = 0;
404
405 static void
free_logicals(void)406 free_logicals (void)
407 {
408 free (logicals_table);
409 logicals_allocated = 0;
410 logicals_count = 0;
411 logicals_table = NULL;
412 }
413
414 static void
append_logical(void)415 append_logical (void)
416 {
417 if (logicals_allocated == 0)
418 {
419 logicals_allocated = 4;
420 logicals_table = (SMR *) xmalloc (logicals_allocated * sizeof (SMR));
421 }
422 if (logicals_count >= logicals_allocated)
423 {
424 logicals_allocated *= 2;
425 logicals_table = (SMR *)
426 xrealloc (logicals_table, logicals_allocated * sizeof (SMR));
427 }
428 logicals_table[logicals_count++] = state_machine_regs;
429 printf (_("\t\tLogical %u: 0x%s[%u] file %u line %u discrim %u context %u subprog %u is_stmt %d\n"),
430 logicals_count,
431 dwarf_vmatoa ("x", state_machine_regs.address),
432 state_machine_regs.op_index,
433 state_machine_regs.file,
434 state_machine_regs.line,
435 state_machine_regs.discriminator,
436 state_machine_regs.context,
437 state_machine_regs.subprogram,
438 state_machine_regs.is_stmt);
439 }
440
441 /* Handled an extend line op.
442 Returns the number of bytes read. */
443
444 static int
process_extended_line_op(unsigned char * data,int is_stmt,unsigned char * end,int is_logical)445 process_extended_line_op (unsigned char * data,
446 int is_stmt,
447 unsigned char * end,
448 int is_logical)
449 {
450 unsigned char op_code;
451 unsigned int bytes_read;
452 unsigned int len;
453 unsigned char *name;
454 unsigned char *orig_data = data;
455 dwarf_vma adr;
456
457 len = read_uleb128 (data, & bytes_read, end);
458 data += bytes_read;
459
460 if (len == 0 || data == end)
461 {
462 warn (_("Badly formed extended line op encountered!\n"));
463 return bytes_read;
464 }
465
466 len += bytes_read;
467 op_code = *data++;
468
469 printf (_(" Extended opcode %d: "), op_code);
470
471 switch (op_code)
472 {
473 case DW_LNE_end_sequence:
474 printf (_("End of Sequence\n\n"));
475 if (is_logical)
476 append_logical ();
477 reset_state_machine (is_stmt);
478 break;
479
480 case DW_LNE_set_address:
481 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
482 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
483 state_machine_regs.address = adr;
484 state_machine_regs.op_index = 0;
485 break;
486
487 case DW_LNE_define_file:
488 printf (_("define new File Table entry\n"));
489 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
490 printf (" %d\t", ++state_machine_regs.last_file_entry);
491
492 name = data;
493 data += strnlen ((char *) data, end - data) + 1;
494 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
495 data += bytes_read;
496 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
497 data += bytes_read;
498 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
499 data += bytes_read;
500 printf ("%s\n\n", name);
501
502 if (((unsigned int) (data - orig_data) != len) || data == end)
503 warn (_("DW_LNE_define_file: Bad opcode length\n"));
504 break;
505
506 case DW_LNE_set_discriminator:
507 {
508 unsigned int discrim;
509
510 discrim = read_uleb128 (data, & bytes_read, end);
511 data += bytes_read;
512 printf (_("set Discriminator to %u\n"), discrim);
513 state_machine_regs.discriminator = discrim;
514 }
515 break;
516
517 /* HP extensions. */
518 case DW_LNE_HP_negate_is_UV_update:
519 printf ("DW_LNE_HP_negate_is_UV_update\n");
520 break;
521 case DW_LNE_HP_push_context:
522 printf ("DW_LNE_HP_push_context\n");
523 break;
524 case DW_LNE_HP_pop_context:
525 printf ("DW_LNE_HP_pop_context\n");
526 break;
527 case DW_LNE_HP_set_file_line_column:
528 printf ("DW_LNE_HP_set_file_line_column\n");
529 break;
530 case DW_LNE_HP_set_routine_name:
531 printf ("DW_LNE_HP_set_routine_name\n");
532 break;
533 case DW_LNE_HP_set_sequence:
534 printf ("DW_LNE_HP_set_sequence\n");
535 break;
536 case DW_LNE_HP_negate_post_semantics:
537 printf ("DW_LNE_HP_negate_post_semantics\n");
538 break;
539 case DW_LNE_HP_negate_function_exit:
540 printf ("DW_LNE_HP_negate_function_exit\n");
541 break;
542 case DW_LNE_HP_negate_front_end_logical:
543 printf ("DW_LNE_HP_negate_front_end_logical\n");
544 break;
545 case DW_LNE_HP_define_proc:
546 printf ("DW_LNE_HP_define_proc\n");
547 break;
548 case DW_LNE_HP_source_file_correlation:
549 {
550 unsigned char *edata = data + len - bytes_read - 1;
551
552 printf ("DW_LNE_HP_source_file_correlation\n");
553
554 while (data < edata)
555 {
556 unsigned int opc;
557
558 opc = read_uleb128 (data, & bytes_read, edata);
559 data += bytes_read;
560
561 switch (opc)
562 {
563 case DW_LNE_HP_SFC_formfeed:
564 printf (" DW_LNE_HP_SFC_formfeed\n");
565 break;
566 case DW_LNE_HP_SFC_set_listing_line:
567 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
568 dwarf_vmatoa ("u",
569 read_uleb128 (data, & bytes_read, edata)));
570 data += bytes_read;
571 break;
572 case DW_LNE_HP_SFC_associate:
573 printf (" DW_LNE_HP_SFC_associate ");
574 printf ("(%s",
575 dwarf_vmatoa ("u",
576 read_uleb128 (data, & bytes_read, edata)));
577 data += bytes_read;
578 printf (",%s",
579 dwarf_vmatoa ("u",
580 read_uleb128 (data, & bytes_read, edata)));
581 data += bytes_read;
582 printf (",%s)\n",
583 dwarf_vmatoa ("u",
584 read_uleb128 (data, & bytes_read, edata)));
585 data += bytes_read;
586 break;
587 default:
588 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
589 data = edata;
590 break;
591 }
592 }
593 }
594 break;
595
596 default:
597 {
598 unsigned int rlen = len - bytes_read - 1;
599
600 if (op_code >= DW_LNE_lo_user
601 /* The test against DW_LNW_hi_user is redundant due to
602 the limited range of the unsigned char data type used
603 for op_code. */
604 /*&& op_code <= DW_LNE_hi_user*/)
605 printf (_("user defined: "));
606 else
607 printf (_("UNKNOWN: "));
608 printf (_("length %d ["), rlen);
609 for (; rlen; rlen--)
610 printf (" %02x", *data++);
611 printf ("]\n");
612 }
613 break;
614 }
615
616 return len;
617 }
618
619 static const unsigned char *
fetch_indirect_string(dwarf_vma offset)620 fetch_indirect_string (dwarf_vma offset)
621 {
622 struct dwarf_section *section = &debug_displays [str].section;
623
624 if (section->start == NULL)
625 return (const unsigned char *) _("<no .debug_str section>");
626
627 if (offset >= section->size)
628 {
629 warn (_("DW_FORM_strp offset too big: %s\n"),
630 dwarf_vmatoa ("x", offset));
631 return (const unsigned char *) _("<offset is too big>");
632 }
633
634 return (const unsigned char *) section->start + offset;
635 }
636
637 static const unsigned char *
fetch_indirect_line_string(dwarf_vma offset)638 fetch_indirect_line_string (dwarf_vma offset)
639 {
640 struct dwarf_section *section = &debug_displays [line_str].section;
641
642 if (section->start == NULL)
643 return (const unsigned char *) _("<no .debug_line_str section>");
644
645 if (offset >= section->size)
646 {
647 warn (_("DW_FORM_line_strp offset too big: %s\n"),
648 dwarf_vmatoa ("x", offset));
649 return (const unsigned char *) _("<offset is too big>");
650 }
651
652 return (const unsigned char *) section->start + offset;
653 }
654
655 static const char *
fetch_indexed_string(dwarf_vma idx,struct cu_tu_set * this_set,dwarf_vma offset_size,int dwo)656 fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
657 dwarf_vma offset_size, int dwo)
658 {
659 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
660 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
661 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
662 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
663 dwarf_vma index_offset = idx * offset_size;
664 dwarf_vma str_offset;
665
666 if (index_section->start == NULL)
667 return (dwo ? _("<no .debug_str_offsets.dwo section>")
668 : _("<no .debug_str_offsets section>"));
669
670 if (this_set != NULL)
671 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
672 if (index_offset + offset_size > index_section->size)
673 {
674 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
675 dwarf_vmatoa ("x", index_offset));
676 return _("<index offset is too big>");
677 }
678
679 if (str_section->start == NULL)
680 return (dwo ? _("<no .debug_str.dwo section>")
681 : _("<no .debug_str section>"));
682
683 str_offset = byte_get (index_section->start + index_offset, offset_size);
684 str_offset -= str_section->address;
685 if (str_offset >= str_section->size)
686 {
687 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
688 dwarf_vmatoa ("x", str_offset));
689 return _("<indirect index offset is too big>");
690 }
691
692 return (const char *) str_section->start + str_offset;
693 }
694
695 static const char *
fetch_indexed_value(dwarf_vma offset,dwarf_vma bytes)696 fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
697 {
698 struct dwarf_section *section = &debug_displays [debug_addr].section;
699
700 if (section->start == NULL)
701 return (_("<no .debug_addr section>"));
702
703 if (offset + bytes > section->size)
704 {
705 warn (_("Offset into section %s too big: %s\n"),
706 section->name, dwarf_vmatoa ("x", offset));
707 return "<offset too big>";
708 }
709
710 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
711 }
712
713
714 /* FIXME: There are better and more efficient ways to handle
715 these structures. For now though, I just want something that
716 is simple to implement. */
717 typedef struct abbrev_attr
718 {
719 unsigned long attribute;
720 unsigned long form;
721 struct abbrev_attr *next;
722 }
723 abbrev_attr;
724
725 typedef struct abbrev_entry
726 {
727 unsigned long entry;
728 unsigned long tag;
729 int children;
730 struct abbrev_attr *first_attr;
731 struct abbrev_attr *last_attr;
732 struct abbrev_entry *next;
733 }
734 abbrev_entry;
735
736 static abbrev_entry *first_abbrev = NULL;
737 static abbrev_entry *last_abbrev = NULL;
738
739 static void
free_abbrevs(void)740 free_abbrevs (void)
741 {
742 abbrev_entry *abbrv;
743
744 for (abbrv = first_abbrev; abbrv;)
745 {
746 abbrev_entry *next_abbrev = abbrv->next;
747 abbrev_attr *attr;
748
749 for (attr = abbrv->first_attr; attr;)
750 {
751 abbrev_attr *next_attr = attr->next;
752
753 free (attr);
754 attr = next_attr;
755 }
756
757 free (abbrv);
758 abbrv = next_abbrev;
759 }
760
761 last_abbrev = first_abbrev = NULL;
762 }
763
764 static void
add_abbrev(unsigned long number,unsigned long tag,int children)765 add_abbrev (unsigned long number, unsigned long tag, int children)
766 {
767 abbrev_entry *entry;
768
769 entry = (abbrev_entry *) malloc (sizeof (*entry));
770 if (entry == NULL)
771 /* ugg */
772 return;
773
774 entry->entry = number;
775 entry->tag = tag;
776 entry->children = children;
777 entry->first_attr = NULL;
778 entry->last_attr = NULL;
779 entry->next = NULL;
780
781 if (first_abbrev == NULL)
782 first_abbrev = entry;
783 else
784 last_abbrev->next = entry;
785
786 last_abbrev = entry;
787 }
788
789 static void
add_abbrev_attr(unsigned long attribute,unsigned long form)790 add_abbrev_attr (unsigned long attribute, unsigned long form)
791 {
792 abbrev_attr *attr;
793
794 attr = (abbrev_attr *) malloc (sizeof (*attr));
795 if (attr == NULL)
796 /* ugg */
797 return;
798
799 attr->attribute = attribute;
800 attr->form = form;
801 attr->next = NULL;
802
803 if (last_abbrev->first_attr == NULL)
804 last_abbrev->first_attr = attr;
805 else
806 last_abbrev->last_attr->next = attr;
807
808 last_abbrev->last_attr = attr;
809 }
810
811 /* Processes the (partial) contents of a .debug_abbrev section.
812 Returns NULL if the end of the section was encountered.
813 Returns the address after the last byte read if the end of
814 an abbreviation set was found. */
815
816 static unsigned char *
process_abbrev_section(unsigned char * start,unsigned char * end)817 process_abbrev_section (unsigned char *start, unsigned char *end)
818 {
819 if (first_abbrev != NULL)
820 return NULL;
821
822 while (start < end)
823 {
824 unsigned int bytes_read;
825 unsigned long entry;
826 unsigned long tag;
827 unsigned long attribute;
828 int children;
829
830 entry = read_uleb128 (start, & bytes_read, end);
831 start += bytes_read;
832
833 /* A single zero is supposed to end the section according
834 to the standard. If there's more, then signal that to
835 the caller. */
836 if (start == end)
837 return NULL;
838 if (entry == 0)
839 return start;
840
841 tag = read_uleb128 (start, & bytes_read, end);
842 start += bytes_read;
843 if (start == end)
844 return NULL;
845
846 children = *start++;
847
848 add_abbrev (entry, tag, children);
849
850 do
851 {
852 unsigned long form;
853
854 attribute = read_uleb128 (start, & bytes_read, end);
855 start += bytes_read;
856 if (start == end)
857 break;
858
859 form = read_uleb128 (start, & bytes_read, end);
860 start += bytes_read;
861 if (start == end)
862 break;
863
864 add_abbrev_attr (attribute, form);
865 }
866 while (attribute != 0);
867 }
868
869 /* Report the missing single zero which ends the section. */
870 error (_(".debug_abbrev section not zero terminated\n"));
871
872 return NULL;
873 }
874
875 static const char *
get_TAG_name(unsigned long tag)876 get_TAG_name (unsigned long tag)
877 {
878 const char *name = get_DW_TAG_name ((unsigned int)tag);
879
880 if (name == NULL)
881 {
882 static char buffer[100];
883
884 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
885 return buffer;
886 }
887
888 return name;
889 }
890
891 static const char *
get_FORM_name(unsigned long form)892 get_FORM_name (unsigned long form)
893 {
894 const char *name;
895
896 if (form == 0)
897 return "DW_FORM value: 0";
898
899 name = get_DW_FORM_name (form);
900 if (name == NULL)
901 {
902 static char buffer[100];
903
904 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
905 return buffer;
906 }
907
908 return name;
909 }
910
911 static unsigned char *
display_block(unsigned char * data,dwarf_vma length,const unsigned char * const end)912 display_block (unsigned char *data,
913 dwarf_vma length,
914 const unsigned char * const end)
915 {
916 dwarf_vma maxlen;
917
918 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));
919
920 maxlen = (dwarf_vma) (end - data);
921 length = length > maxlen ? maxlen : length;
922
923 while (length --)
924 printf ("%lx ", (unsigned long) byte_get (data++, 1));
925
926 return data;
927 }
928
929 static int
decode_location_expression(unsigned char * data,unsigned int pointer_size,unsigned int offset_size,int dwarf_version,dwarf_vma length,dwarf_vma cu_offset,struct dwarf_section * section)930 decode_location_expression (unsigned char * data,
931 unsigned int pointer_size,
932 unsigned int offset_size,
933 int dwarf_version,
934 dwarf_vma length,
935 dwarf_vma cu_offset,
936 struct dwarf_section * section)
937 {
938 unsigned op;
939 unsigned int bytes_read;
940 dwarf_vma uvalue;
941 dwarf_signed_vma svalue;
942 unsigned char *end = data + length;
943 int need_frame_base = 0;
944
945 while (data < end)
946 {
947 op = *data++;
948
949 switch (op)
950 {
951 case DW_OP_addr:
952 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
953 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
954 break;
955 case DW_OP_deref:
956 printf ("DW_OP_deref");
957 break;
958 case DW_OP_const1u:
959 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
960 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
961 break;
962 case DW_OP_const1s:
963 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
964 printf ("DW_OP_const1s: %ld", (long) svalue);
965 break;
966 case DW_OP_const2u:
967 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
968 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
969 break;
970 case DW_OP_const2s:
971 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
972 printf ("DW_OP_const2s: %ld", (long) svalue);
973 break;
974 case DW_OP_const4u:
975 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
976 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
977 break;
978 case DW_OP_const4s:
979 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
980 printf ("DW_OP_const4s: %ld", (long) svalue);
981 break;
982 case DW_OP_const8u:
983 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
984 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
985 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
986 printf ("%lu", (unsigned long) uvalue);
987 break;
988 case DW_OP_const8s:
989 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
990 printf ("DW_OP_const8s: %ld ", (long) svalue);
991 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
992 printf ("%ld", (long) svalue);
993 break;
994 case DW_OP_constu:
995 printf ("DW_OP_constu: %s",
996 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
997 data += bytes_read;
998 break;
999 case DW_OP_consts:
1000 printf ("DW_OP_consts: %s",
1001 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1002 data += bytes_read;
1003 break;
1004 case DW_OP_dup:
1005 printf ("DW_OP_dup");
1006 break;
1007 case DW_OP_drop:
1008 printf ("DW_OP_drop");
1009 break;
1010 case DW_OP_over:
1011 printf ("DW_OP_over");
1012 break;
1013 case DW_OP_pick:
1014 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1015 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
1016 break;
1017 case DW_OP_swap:
1018 printf ("DW_OP_swap");
1019 break;
1020 case DW_OP_rot:
1021 printf ("DW_OP_rot");
1022 break;
1023 case DW_OP_xderef:
1024 printf ("DW_OP_xderef");
1025 break;
1026 case DW_OP_abs:
1027 printf ("DW_OP_abs");
1028 break;
1029 case DW_OP_and:
1030 printf ("DW_OP_and");
1031 break;
1032 case DW_OP_div:
1033 printf ("DW_OP_div");
1034 break;
1035 case DW_OP_minus:
1036 printf ("DW_OP_minus");
1037 break;
1038 case DW_OP_mod:
1039 printf ("DW_OP_mod");
1040 break;
1041 case DW_OP_mul:
1042 printf ("DW_OP_mul");
1043 break;
1044 case DW_OP_neg:
1045 printf ("DW_OP_neg");
1046 break;
1047 case DW_OP_not:
1048 printf ("DW_OP_not");
1049 break;
1050 case DW_OP_or:
1051 printf ("DW_OP_or");
1052 break;
1053 case DW_OP_plus:
1054 printf ("DW_OP_plus");
1055 break;
1056 case DW_OP_plus_uconst:
1057 printf ("DW_OP_plus_uconst: %s",
1058 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1059 data += bytes_read;
1060 break;
1061 case DW_OP_shl:
1062 printf ("DW_OP_shl");
1063 break;
1064 case DW_OP_shr:
1065 printf ("DW_OP_shr");
1066 break;
1067 case DW_OP_shra:
1068 printf ("DW_OP_shra");
1069 break;
1070 case DW_OP_xor:
1071 printf ("DW_OP_xor");
1072 break;
1073 case DW_OP_bra:
1074 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1075 printf ("DW_OP_bra: %ld", (long) svalue);
1076 break;
1077 case DW_OP_eq:
1078 printf ("DW_OP_eq");
1079 break;
1080 case DW_OP_ge:
1081 printf ("DW_OP_ge");
1082 break;
1083 case DW_OP_gt:
1084 printf ("DW_OP_gt");
1085 break;
1086 case DW_OP_le:
1087 printf ("DW_OP_le");
1088 break;
1089 case DW_OP_lt:
1090 printf ("DW_OP_lt");
1091 break;
1092 case DW_OP_ne:
1093 printf ("DW_OP_ne");
1094 break;
1095 case DW_OP_skip:
1096 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1097 printf ("DW_OP_skip: %ld", (long) svalue);
1098 break;
1099
1100 case DW_OP_lit0:
1101 case DW_OP_lit1:
1102 case DW_OP_lit2:
1103 case DW_OP_lit3:
1104 case DW_OP_lit4:
1105 case DW_OP_lit5:
1106 case DW_OP_lit6:
1107 case DW_OP_lit7:
1108 case DW_OP_lit8:
1109 case DW_OP_lit9:
1110 case DW_OP_lit10:
1111 case DW_OP_lit11:
1112 case DW_OP_lit12:
1113 case DW_OP_lit13:
1114 case DW_OP_lit14:
1115 case DW_OP_lit15:
1116 case DW_OP_lit16:
1117 case DW_OP_lit17:
1118 case DW_OP_lit18:
1119 case DW_OP_lit19:
1120 case DW_OP_lit20:
1121 case DW_OP_lit21:
1122 case DW_OP_lit22:
1123 case DW_OP_lit23:
1124 case DW_OP_lit24:
1125 case DW_OP_lit25:
1126 case DW_OP_lit26:
1127 case DW_OP_lit27:
1128 case DW_OP_lit28:
1129 case DW_OP_lit29:
1130 case DW_OP_lit30:
1131 case DW_OP_lit31:
1132 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1133 break;
1134
1135 case DW_OP_reg0:
1136 case DW_OP_reg1:
1137 case DW_OP_reg2:
1138 case DW_OP_reg3:
1139 case DW_OP_reg4:
1140 case DW_OP_reg5:
1141 case DW_OP_reg6:
1142 case DW_OP_reg7:
1143 case DW_OP_reg8:
1144 case DW_OP_reg9:
1145 case DW_OP_reg10:
1146 case DW_OP_reg11:
1147 case DW_OP_reg12:
1148 case DW_OP_reg13:
1149 case DW_OP_reg14:
1150 case DW_OP_reg15:
1151 case DW_OP_reg16:
1152 case DW_OP_reg17:
1153 case DW_OP_reg18:
1154 case DW_OP_reg19:
1155 case DW_OP_reg20:
1156 case DW_OP_reg21:
1157 case DW_OP_reg22:
1158 case DW_OP_reg23:
1159 case DW_OP_reg24:
1160 case DW_OP_reg25:
1161 case DW_OP_reg26:
1162 case DW_OP_reg27:
1163 case DW_OP_reg28:
1164 case DW_OP_reg29:
1165 case DW_OP_reg30:
1166 case DW_OP_reg31:
1167 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1168 regname (op - DW_OP_reg0, 1));
1169 break;
1170
1171 case DW_OP_breg0:
1172 case DW_OP_breg1:
1173 case DW_OP_breg2:
1174 case DW_OP_breg3:
1175 case DW_OP_breg4:
1176 case DW_OP_breg5:
1177 case DW_OP_breg6:
1178 case DW_OP_breg7:
1179 case DW_OP_breg8:
1180 case DW_OP_breg9:
1181 case DW_OP_breg10:
1182 case DW_OP_breg11:
1183 case DW_OP_breg12:
1184 case DW_OP_breg13:
1185 case DW_OP_breg14:
1186 case DW_OP_breg15:
1187 case DW_OP_breg16:
1188 case DW_OP_breg17:
1189 case DW_OP_breg18:
1190 case DW_OP_breg19:
1191 case DW_OP_breg20:
1192 case DW_OP_breg21:
1193 case DW_OP_breg22:
1194 case DW_OP_breg23:
1195 case DW_OP_breg24:
1196 case DW_OP_breg25:
1197 case DW_OP_breg26:
1198 case DW_OP_breg27:
1199 case DW_OP_breg28:
1200 case DW_OP_breg29:
1201 case DW_OP_breg30:
1202 case DW_OP_breg31:
1203 printf ("DW_OP_breg%d (%s): %s",
1204 op - DW_OP_breg0,
1205 regname (op - DW_OP_breg0, 1),
1206 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1207 data += bytes_read;
1208 break;
1209
1210 case DW_OP_regx:
1211 uvalue = read_uleb128 (data, &bytes_read, end);
1212 data += bytes_read;
1213 printf ("DW_OP_regx: %s (%s)",
1214 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1215 break;
1216 case DW_OP_fbreg:
1217 need_frame_base = 1;
1218 printf ("DW_OP_fbreg: %s",
1219 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1220 data += bytes_read;
1221 break;
1222 case DW_OP_bregx:
1223 uvalue = read_uleb128 (data, &bytes_read, end);
1224 data += bytes_read;
1225 printf ("DW_OP_bregx: %s (%s) %s",
1226 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
1227 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
1228 data += bytes_read;
1229 break;
1230 case DW_OP_piece:
1231 printf ("DW_OP_piece: %s",
1232 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1233 data += bytes_read;
1234 break;
1235 case DW_OP_deref_size:
1236 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1237 printf ("DW_OP_deref_size: %ld", (long) uvalue);
1238 break;
1239 case DW_OP_xderef_size:
1240 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1241 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
1242 break;
1243 case DW_OP_nop:
1244 printf ("DW_OP_nop");
1245 break;
1246
1247 /* DWARF 3 extensions. */
1248 case DW_OP_push_object_address:
1249 printf ("DW_OP_push_object_address");
1250 break;
1251 case DW_OP_call2:
1252 /* XXX: Strictly speaking for 64-bit DWARF3 files
1253 this ought to be an 8-byte wide computation. */
1254 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1255 printf ("DW_OP_call2: <0x%s>",
1256 dwarf_vmatoa ("x", svalue + cu_offset));
1257 break;
1258 case DW_OP_call4:
1259 /* XXX: Strictly speaking for 64-bit DWARF3 files
1260 this ought to be an 8-byte wide computation. */
1261 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1262 printf ("DW_OP_call4: <0x%s>",
1263 dwarf_vmatoa ("x", svalue + cu_offset));
1264 break;
1265 case DW_OP_call_ref:
1266 /* XXX: Strictly speaking for 64-bit DWARF3 files
1267 this ought to be an 8-byte wide computation. */
1268 if (dwarf_version == -1)
1269 {
1270 printf (_("(DW_OP_call_ref in frame info)"));
1271 /* No way to tell where the next op is, so just bail. */
1272 return need_frame_base;
1273 }
1274 if (dwarf_version == 2)
1275 {
1276 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1277 }
1278 else
1279 {
1280 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1281 }
1282 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
1283 break;
1284 case DW_OP_form_tls_address:
1285 printf ("DW_OP_form_tls_address");
1286 break;
1287 case DW_OP_call_frame_cfa:
1288 printf ("DW_OP_call_frame_cfa");
1289 break;
1290 case DW_OP_bit_piece:
1291 printf ("DW_OP_bit_piece: ");
1292 printf (_("size: %s "),
1293 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1294 data += bytes_read;
1295 printf (_("offset: %s "),
1296 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
1297 data += bytes_read;
1298 break;
1299
1300 /* DWARF 4 extensions. */
1301 case DW_OP_stack_value:
1302 printf ("DW_OP_stack_value");
1303 break;
1304
1305 case DW_OP_implicit_value:
1306 printf ("DW_OP_implicit_value");
1307 uvalue = read_uleb128 (data, &bytes_read, end);
1308 data += bytes_read;
1309 display_block (data, uvalue, end);
1310 data += uvalue;
1311 break;
1312
1313 /* GNU extensions. */
1314 case DW_OP_GNU_push_tls_address:
1315 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1316 break;
1317 case DW_OP_GNU_uninit:
1318 printf ("DW_OP_GNU_uninit");
1319 /* FIXME: Is there data associated with this OP ? */
1320 break;
1321 case DW_OP_GNU_encoded_addr:
1322 {
1323 int encoding;
1324 dwarf_vma addr;
1325
1326 encoding = *data++;
1327 addr = get_encoded_value (&data, encoding, section, end);
1328
1329 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1330 print_dwarf_vma (addr, pointer_size);
1331 }
1332 break;
1333 case DW_OP_GNU_implicit_pointer:
1334 /* XXX: Strictly speaking for 64-bit DWARF3 files
1335 this ought to be an 8-byte wide computation. */
1336 if (dwarf_version == -1)
1337 {
1338 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1339 /* No way to tell where the next op is, so just bail. */
1340 return need_frame_base;
1341 }
1342 if (dwarf_version == 2)
1343 {
1344 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1345 }
1346 else
1347 {
1348 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1349 }
1350 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1351 dwarf_vmatoa ("x", uvalue),
1352 dwarf_vmatoa ("d", read_sleb128 (data,
1353 &bytes_read, end)));
1354 data += bytes_read;
1355 break;
1356 case DW_OP_GNU_entry_value:
1357 uvalue = read_uleb128 (data, &bytes_read, end);
1358 data += bytes_read;
1359 printf ("DW_OP_GNU_entry_value: (");
1360 if (decode_location_expression (data, pointer_size, offset_size,
1361 dwarf_version, uvalue,
1362 cu_offset, section))
1363 need_frame_base = 1;
1364 putchar (')');
1365 data += uvalue;
1366 break;
1367 case DW_OP_GNU_const_type:
1368 uvalue = read_uleb128 (data, &bytes_read, end);
1369 data += bytes_read;
1370 printf ("DW_OP_GNU_const_type: <0x%s> ",
1371 dwarf_vmatoa ("x", cu_offset + uvalue));
1372 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1373 display_block (data, uvalue, end);
1374 data += uvalue;
1375 break;
1376 case DW_OP_GNU_regval_type:
1377 uvalue = read_uleb128 (data, &bytes_read, end);
1378 data += bytes_read;
1379 printf ("DW_OP_GNU_regval_type: %s (%s)",
1380 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
1381 uvalue = read_uleb128 (data, &bytes_read, end);
1382 data += bytes_read;
1383 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1384 break;
1385 case DW_OP_GNU_deref_type:
1386 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1387 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue);
1388 uvalue = read_uleb128 (data, &bytes_read, end);
1389 data += bytes_read;
1390 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1391 break;
1392 case DW_OP_GNU_convert:
1393 uvalue = read_uleb128 (data, &bytes_read, end);
1394 data += bytes_read;
1395 printf ("DW_OP_GNU_convert <0x%s>",
1396 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1397 break;
1398 case DW_OP_GNU_reinterpret:
1399 uvalue = read_uleb128 (data, &bytes_read, end);
1400 data += bytes_read;
1401 printf ("DW_OP_GNU_reinterpret <0x%s>",
1402 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1403 break;
1404 case DW_OP_GNU_parameter_ref:
1405 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1406 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1407 dwarf_vmatoa ("x", cu_offset + uvalue));
1408 break;
1409 case DW_OP_GNU_addr_index:
1410 uvalue = read_uleb128 (data, &bytes_read, end);
1411 data += bytes_read;
1412 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1413 break;
1414 case DW_OP_GNU_const_index:
1415 uvalue = read_uleb128 (data, &bytes_read, end);
1416 data += bytes_read;
1417 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1418 break;
1419
1420 /* HP extensions. */
1421 case DW_OP_HP_is_value:
1422 printf ("DW_OP_HP_is_value");
1423 /* FIXME: Is there data associated with this OP ? */
1424 break;
1425 case DW_OP_HP_fltconst4:
1426 printf ("DW_OP_HP_fltconst4");
1427 /* FIXME: Is there data associated with this OP ? */
1428 break;
1429 case DW_OP_HP_fltconst8:
1430 printf ("DW_OP_HP_fltconst8");
1431 /* FIXME: Is there data associated with this OP ? */
1432 break;
1433 case DW_OP_HP_mod_range:
1434 printf ("DW_OP_HP_mod_range");
1435 /* FIXME: Is there data associated with this OP ? */
1436 break;
1437 case DW_OP_HP_unmod_range:
1438 printf ("DW_OP_HP_unmod_range");
1439 /* FIXME: Is there data associated with this OP ? */
1440 break;
1441 case DW_OP_HP_tls:
1442 printf ("DW_OP_HP_tls");
1443 /* FIXME: Is there data associated with this OP ? */
1444 break;
1445
1446 /* PGI (STMicroelectronics) extensions. */
1447 case DW_OP_PGI_omp_thread_num:
1448 /* Pushes the thread number for the current thread as it would be
1449 returned by the standard OpenMP library function:
1450 omp_get_thread_num(). The "current thread" is the thread for
1451 which the expression is being evaluated. */
1452 printf ("DW_OP_PGI_omp_thread_num");
1453 break;
1454
1455 default:
1456 if (op >= DW_OP_lo_user
1457 && op <= DW_OP_hi_user)
1458 printf (_("(User defined location op)"));
1459 else
1460 printf (_("(Unknown location op)"));
1461 /* No way to tell where the next op is, so just bail. */
1462 return need_frame_base;
1463 }
1464
1465 /* Separate the ops. */
1466 if (data < end)
1467 printf ("; ");
1468 }
1469
1470 return need_frame_base;
1471 }
1472
1473 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1474 This is used for DWARF package files. */
1475
1476 static struct cu_tu_set *
find_cu_tu_set_v2(dwarf_vma cu_offset,int do_types)1477 find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1478 {
1479 struct cu_tu_set *p;
1480 unsigned int nsets;
1481 unsigned int dw_sect;
1482
1483 if (do_types)
1484 {
1485 p = tu_sets;
1486 nsets = tu_count;
1487 dw_sect = DW_SECT_TYPES;
1488 }
1489 else
1490 {
1491 p = cu_sets;
1492 nsets = cu_count;
1493 dw_sect = DW_SECT_INFO;
1494 }
1495 while (nsets > 0)
1496 {
1497 if (p->section_offsets [dw_sect] == cu_offset)
1498 return p;
1499 p++;
1500 nsets--;
1501 }
1502 return NULL;
1503 }
1504
1505 /* Add INC to HIGH_BITS:LOW_BITS. */
1506 static void
add64(dwarf_vma * high_bits,dwarf_vma * low_bits,dwarf_vma inc)1507 add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1508 {
1509 dwarf_vma tmp = * low_bits;
1510
1511 tmp += inc;
1512
1513 /* FIXME: There is probably a better way of handling this:
1514
1515 We need to cope with dwarf_vma being a 32-bit or 64-bit
1516 type. Plus regardless of its size LOW_BITS is meant to
1517 only hold 32-bits, so if there is overflow or wrap around
1518 we must propagate into HIGH_BITS. */
1519 if (tmp < * low_bits)
1520 {
1521 ++ * high_bits;
1522 }
1523 else if (sizeof (tmp) > 8
1524 && (tmp >> 31) > 1)
1525 {
1526 ++ * high_bits;
1527 tmp &= 0xFFFFFFFF;
1528 }
1529
1530 * low_bits = tmp;
1531 }
1532
1533 static unsigned char *
read_and_display_attr_value(unsigned long attribute,unsigned long form,unsigned char * data,unsigned char * end,dwarf_vma cu_offset,dwarf_vma pointer_size,dwarf_vma offset_size,int dwarf_version,debug_info * debug_info_p,int do_loc,struct dwarf_section * section,struct cu_tu_set * this_set)1534 read_and_display_attr_value (unsigned long attribute,
1535 unsigned long form,
1536 unsigned char * data,
1537 unsigned char * end,
1538 dwarf_vma cu_offset,
1539 dwarf_vma pointer_size,
1540 dwarf_vma offset_size,
1541 int dwarf_version,
1542 debug_info * debug_info_p,
1543 int do_loc,
1544 struct dwarf_section * section,
1545 struct cu_tu_set * this_set)
1546 {
1547 dwarf_vma uvalue = 0;
1548 unsigned char *block_start = NULL;
1549 unsigned char * orig_data = data;
1550 unsigned int bytes_read;
1551
1552 if (data > end || (data == end && form != DW_FORM_flag_present))
1553 {
1554 warn (_("Corrupt attribute\n"));
1555 return data;
1556 }
1557
1558 switch (form)
1559 {
1560 default:
1561 break;
1562
1563 case DW_FORM_ref_addr:
1564 if (dwarf_version == 2)
1565 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1566 else if (dwarf_version == 3 || dwarf_version == 4)
1567 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1568 else
1569 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1570
1571 break;
1572
1573 case DW_FORM_addr:
1574 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1575 break;
1576
1577 case DW_FORM_strp:
1578 case DW_FORM_sec_offset:
1579 case DW_FORM_GNU_ref_alt:
1580 case DW_FORM_GNU_strp_alt:
1581 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
1582 break;
1583
1584 case DW_FORM_flag_present:
1585 uvalue = 1;
1586 break;
1587
1588 case DW_FORM_ref1:
1589 case DW_FORM_flag:
1590 case DW_FORM_data1:
1591 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1592 break;
1593
1594 case DW_FORM_ref2:
1595 case DW_FORM_data2:
1596 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
1597 break;
1598
1599 case DW_FORM_ref4:
1600 case DW_FORM_data4:
1601 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1602 break;
1603
1604 case DW_FORM_sdata:
1605 uvalue = read_sleb128 (data, & bytes_read, end);
1606 data += bytes_read;
1607 break;
1608
1609 case DW_FORM_GNU_str_index:
1610 uvalue = read_uleb128 (data, & bytes_read, end);
1611 data += bytes_read;
1612 break;
1613
1614 case DW_FORM_ref_udata:
1615 case DW_FORM_udata:
1616 uvalue = read_uleb128 (data, & bytes_read, end);
1617 data += bytes_read;
1618 break;
1619
1620 case DW_FORM_indirect:
1621 form = read_uleb128 (data, & bytes_read, end);
1622 data += bytes_read;
1623 if (!do_loc)
1624 printf (" %s", get_FORM_name (form));
1625 return read_and_display_attr_value (attribute, form, data, end,
1626 cu_offset, pointer_size,
1627 offset_size, dwarf_version,
1628 debug_info_p, do_loc,
1629 section, this_set);
1630 case DW_FORM_GNU_addr_index:
1631 uvalue = read_uleb128 (data, & bytes_read, end);
1632 data += bytes_read;
1633 break;
1634 }
1635
1636 switch (form)
1637 {
1638 case DW_FORM_ref_addr:
1639 if (!do_loc)
1640 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue));
1641 break;
1642
1643 case DW_FORM_GNU_ref_alt:
1644 if (!do_loc)
1645 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue));
1646 break;
1647
1648 case DW_FORM_ref1:
1649 case DW_FORM_ref2:
1650 case DW_FORM_ref4:
1651 case DW_FORM_ref_udata:
1652 if (!do_loc)
1653 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset));
1654 break;
1655
1656 case DW_FORM_data4:
1657 case DW_FORM_addr:
1658 case DW_FORM_sec_offset:
1659 if (!do_loc)
1660 printf (" 0x%s", dwarf_vmatoa ("x", uvalue));
1661 break;
1662
1663 case DW_FORM_flag_present:
1664 case DW_FORM_flag:
1665 case DW_FORM_data1:
1666 case DW_FORM_data2:
1667 case DW_FORM_sdata:
1668 case DW_FORM_udata:
1669 if (!do_loc)
1670 printf (" %s", dwarf_vmatoa ("d", uvalue));
1671 break;
1672
1673 case DW_FORM_ref8:
1674 case DW_FORM_data8:
1675 if (!do_loc)
1676 {
1677 dwarf_vma high_bits;
1678 dwarf_vma utmp;
1679 char buf[64];
1680
1681 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1682 utmp = uvalue;
1683 if (form == DW_FORM_ref8)
1684 add64 (& high_bits, & utmp, cu_offset);
1685 printf (" 0x%s",
1686 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
1687 }
1688
1689 if ((do_loc || do_debug_loc || do_debug_ranges)
1690 && num_debug_info_entries == 0)
1691 {
1692 if (sizeof (uvalue) == 8)
1693 SAFE_BYTE_GET (uvalue, data, 8, end);
1694 else
1695 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1696 }
1697
1698 data += 8;
1699 break;
1700
1701 case DW_FORM_string:
1702 if (!do_loc)
1703 printf (" %.*s", (int) (end - data), data);
1704 data += strnlen ((char *) data, end - data) + 1;
1705 break;
1706
1707 case DW_FORM_block:
1708 case DW_FORM_exprloc:
1709 uvalue = read_uleb128 (data, & bytes_read, end);
1710 block_start = data + bytes_read;
1711 /* PR 17512: file: 008-103549-0.001:0.1. */
1712 if (block_start + uvalue > end)
1713 {
1714 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1715 uvalue = end - block_start;
1716 }
1717 if (do_loc)
1718 data = block_start + uvalue;
1719 else
1720 data = display_block (block_start, uvalue, end);
1721 break;
1722
1723 case DW_FORM_block1:
1724 SAFE_BYTE_GET (uvalue, data, 1, end);
1725 block_start = data + 1;
1726 if (block_start + uvalue > end)
1727 {
1728 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1729 uvalue = end - block_start;
1730 }
1731 if (do_loc)
1732 data = block_start + uvalue;
1733 else
1734 data = display_block (block_start, uvalue, end);
1735 break;
1736
1737 case DW_FORM_block2:
1738 SAFE_BYTE_GET (uvalue, data, 2, end);
1739 block_start = data + 2;
1740 if (block_start + uvalue > end)
1741 {
1742 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1743 uvalue = end - block_start;
1744 }
1745 if (do_loc)
1746 data = block_start + uvalue;
1747 else
1748 data = display_block (block_start, uvalue, end);
1749 break;
1750
1751 case DW_FORM_block4:
1752 SAFE_BYTE_GET (uvalue, data, 4, end);
1753 block_start = data + 4;
1754 if (block_start + uvalue > end)
1755 {
1756 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1757 uvalue = end - block_start;
1758 }
1759 if (do_loc)
1760 data = block_start + uvalue;
1761 else
1762 data = display_block (block_start, uvalue, end);
1763 break;
1764
1765 case DW_FORM_strp:
1766 if (!do_loc)
1767 printf (_(" (indirect string, offset: 0x%s): %s"),
1768 dwarf_vmatoa ("x", uvalue),
1769 fetch_indirect_string (uvalue));
1770 break;
1771
1772 case DW_FORM_GNU_str_index:
1773 if (!do_loc)
1774 {
1775 const char *suffix = strrchr (section->name, '.');
1776 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1777
1778 printf (_(" (indexed string: 0x%s): %s"),
1779 dwarf_vmatoa ("x", uvalue),
1780 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1781 }
1782 break;
1783
1784 case DW_FORM_GNU_strp_alt:
1785 if (!do_loc)
1786 printf (_(" (alt indirect string, offset: 0x%s)"),
1787 dwarf_vmatoa ("x", uvalue));
1788 break;
1789
1790 case DW_FORM_indirect:
1791 /* Handled above. */
1792 break;
1793
1794 case DW_FORM_ref_sig8:
1795 if (!do_loc)
1796 {
1797 dwarf_vma high_bits;
1798 char buf[64];
1799
1800 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
1801 printf (" signature: 0x%s",
1802 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
1803 }
1804 data += 8;
1805 break;
1806
1807 case DW_FORM_GNU_addr_index:
1808 if (!do_loc)
1809 printf (_(" (addr_index: 0x%s): %s"),
1810 dwarf_vmatoa ("x", uvalue),
1811 fetch_indexed_value (uvalue * pointer_size, pointer_size));
1812 break;
1813
1814 default:
1815 warn (_("Unrecognized form: %lu\n"), form);
1816 break;
1817 }
1818
1819 if ((do_loc || do_debug_loc || do_debug_ranges)
1820 && num_debug_info_entries == 0
1821 && debug_info_p != NULL)
1822 {
1823 switch (attribute)
1824 {
1825 case DW_AT_frame_base:
1826 have_frame_base = 1;
1827 case DW_AT_location:
1828 case DW_AT_string_length:
1829 case DW_AT_return_addr:
1830 case DW_AT_data_member_location:
1831 case DW_AT_vtable_elem_location:
1832 case DW_AT_segment:
1833 case DW_AT_static_link:
1834 case DW_AT_use_location:
1835 case DW_AT_GNU_call_site_value:
1836 case DW_AT_GNU_call_site_data_value:
1837 case DW_AT_GNU_call_site_target:
1838 case DW_AT_GNU_call_site_target_clobbered:
1839 if ((dwarf_version < 4
1840 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1841 || form == DW_FORM_sec_offset)
1842 {
1843 /* Process location list. */
1844 unsigned int lmax = debug_info_p->max_loc_offsets;
1845 unsigned int num = debug_info_p->num_loc_offsets;
1846
1847 if (lmax == 0 || num >= lmax)
1848 {
1849 lmax += 1024;
1850 debug_info_p->loc_offsets = (dwarf_vma *)
1851 xcrealloc (debug_info_p->loc_offsets,
1852 lmax, sizeof (*debug_info_p->loc_offsets));
1853 debug_info_p->have_frame_base = (int *)
1854 xcrealloc (debug_info_p->have_frame_base,
1855 lmax, sizeof (*debug_info_p->have_frame_base));
1856 debug_info_p->max_loc_offsets = lmax;
1857 }
1858 if (this_set != NULL)
1859 uvalue += this_set->section_offsets [DW_SECT_LOC];
1860 debug_info_p->loc_offsets [num] = uvalue;
1861 debug_info_p->have_frame_base [num] = have_frame_base;
1862 debug_info_p->num_loc_offsets++;
1863 }
1864 break;
1865
1866 case DW_AT_low_pc:
1867 if (need_base_address)
1868 debug_info_p->base_address = uvalue;
1869 break;
1870
1871 case DW_AT_GNU_addr_base:
1872 debug_info_p->addr_base = uvalue;
1873 break;
1874
1875 case DW_AT_GNU_ranges_base:
1876 debug_info_p->ranges_base = uvalue;
1877 break;
1878
1879 case DW_AT_ranges:
1880 if ((dwarf_version < 4
1881 && (form == DW_FORM_data4 || form == DW_FORM_data8))
1882 || form == DW_FORM_sec_offset)
1883 {
1884 /* Process range list. */
1885 unsigned int lmax = debug_info_p->max_range_lists;
1886 unsigned int num = debug_info_p->num_range_lists;
1887
1888 if (lmax == 0 || num >= lmax)
1889 {
1890 lmax += 1024;
1891 debug_info_p->range_lists = (dwarf_vma *)
1892 xcrealloc (debug_info_p->range_lists,
1893 lmax, sizeof (*debug_info_p->range_lists));
1894 debug_info_p->max_range_lists = lmax;
1895 }
1896 debug_info_p->range_lists [num] = uvalue;
1897 debug_info_p->num_range_lists++;
1898 }
1899 break;
1900
1901 default:
1902 break;
1903 }
1904 }
1905
1906 if (do_loc || attribute == 0)
1907 return data;
1908
1909 /* For some attributes we can display further information. */
1910 switch (attribute)
1911 {
1912 case DW_AT_inline:
1913 printf ("\t");
1914 switch (uvalue)
1915 {
1916 case DW_INL_not_inlined:
1917 printf (_("(not inlined)"));
1918 break;
1919 case DW_INL_inlined:
1920 printf (_("(inlined)"));
1921 break;
1922 case DW_INL_declared_not_inlined:
1923 printf (_("(declared as inline but ignored)"));
1924 break;
1925 case DW_INL_declared_inlined:
1926 printf (_("(declared as inline and inlined)"));
1927 break;
1928 default:
1929 printf (_(" (Unknown inline attribute value: %s)"),
1930 dwarf_vmatoa ("x", uvalue));
1931 break;
1932 }
1933 break;
1934
1935 case DW_AT_language:
1936 printf ("\t");
1937 switch (uvalue)
1938 {
1939 /* Ordered by the numeric value of these constants. */
1940 case DW_LANG_C89: printf ("(ANSI C)"); break;
1941 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1942 case DW_LANG_Ada83: printf ("(Ada)"); break;
1943 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1944 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1945 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1946 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1947 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1948 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1949 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1950 /* DWARF 2.1 values. */
1951 case DW_LANG_Java: printf ("(Java)"); break;
1952 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1953 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1954 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1955 /* DWARF 3 values. */
1956 case DW_LANG_PLI: printf ("(PLI)"); break;
1957 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1958 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1959 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1960 case DW_LANG_D: printf ("(D)"); break;
1961 /* DWARF 4 values. */
1962 case DW_LANG_Python: printf ("(Python)"); break;
1963 /* DWARF 5 values. */
1964 case DW_LANG_Go: printf ("(Go)"); break;
1965 /* MIPS extension. */
1966 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1967 /* UPC extension. */
1968 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1969 default:
1970 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1971 printf (_("(implementation defined: %s)"),
1972 dwarf_vmatoa ("x", uvalue));
1973 else
1974 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
1975 break;
1976 }
1977 break;
1978
1979 case DW_AT_encoding:
1980 printf ("\t");
1981 switch (uvalue)
1982 {
1983 case DW_ATE_void: printf ("(void)"); break;
1984 case DW_ATE_address: printf ("(machine address)"); break;
1985 case DW_ATE_boolean: printf ("(boolean)"); break;
1986 case DW_ATE_complex_float: printf ("(complex float)"); break;
1987 case DW_ATE_float: printf ("(float)"); break;
1988 case DW_ATE_signed: printf ("(signed)"); break;
1989 case DW_ATE_signed_char: printf ("(signed char)"); break;
1990 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1991 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1992 /* DWARF 2.1 values: */
1993 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1994 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1995 /* DWARF 3 values: */
1996 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1997 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1998 case DW_ATE_edited: printf ("(edited)"); break;
1999 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
2000 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
2001 /* HP extensions: */
2002 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
2003 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2004 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
2005 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2006 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
2007 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
2008 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
2009
2010 default:
2011 if (uvalue >= DW_ATE_lo_user
2012 && uvalue <= DW_ATE_hi_user)
2013 printf (_("(user defined type)"));
2014 else
2015 printf (_("(unknown type)"));
2016 break;
2017 }
2018 break;
2019
2020 case DW_AT_accessibility:
2021 printf ("\t");
2022 switch (uvalue)
2023 {
2024 case DW_ACCESS_public: printf ("(public)"); break;
2025 case DW_ACCESS_protected: printf ("(protected)"); break;
2026 case DW_ACCESS_private: printf ("(private)"); break;
2027 default:
2028 printf (_("(unknown accessibility)"));
2029 break;
2030 }
2031 break;
2032
2033 case DW_AT_visibility:
2034 printf ("\t");
2035 switch (uvalue)
2036 {
2037 case DW_VIS_local: printf ("(local)"); break;
2038 case DW_VIS_exported: printf ("(exported)"); break;
2039 case DW_VIS_qualified: printf ("(qualified)"); break;
2040 default: printf (_("(unknown visibility)")); break;
2041 }
2042 break;
2043
2044 case DW_AT_virtuality:
2045 printf ("\t");
2046 switch (uvalue)
2047 {
2048 case DW_VIRTUALITY_none: printf ("(none)"); break;
2049 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2050 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
2051 default: printf (_("(unknown virtuality)")); break;
2052 }
2053 break;
2054
2055 case DW_AT_identifier_case:
2056 printf ("\t");
2057 switch (uvalue)
2058 {
2059 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2060 case DW_ID_up_case: printf ("(up_case)"); break;
2061 case DW_ID_down_case: printf ("(down_case)"); break;
2062 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
2063 default: printf (_("(unknown case)")); break;
2064 }
2065 break;
2066
2067 case DW_AT_calling_convention:
2068 printf ("\t");
2069 switch (uvalue)
2070 {
2071 case DW_CC_normal: printf ("(normal)"); break;
2072 case DW_CC_program: printf ("(program)"); break;
2073 case DW_CC_nocall: printf ("(nocall)"); break;
2074 default:
2075 if (uvalue >= DW_CC_lo_user
2076 && uvalue <= DW_CC_hi_user)
2077 printf (_("(user defined)"));
2078 else
2079 printf (_("(unknown convention)"));
2080 }
2081 break;
2082
2083 case DW_AT_ordering:
2084 printf ("\t");
2085 switch (uvalue)
2086 {
2087 case -1: printf (_("(undefined)")); break;
2088 case 0: printf ("(row major)"); break;
2089 case 1: printf ("(column major)"); break;
2090 }
2091 break;
2092
2093 case DW_AT_frame_base:
2094 have_frame_base = 1;
2095 case DW_AT_location:
2096 case DW_AT_string_length:
2097 case DW_AT_return_addr:
2098 case DW_AT_data_member_location:
2099 case DW_AT_vtable_elem_location:
2100 case DW_AT_segment:
2101 case DW_AT_static_link:
2102 case DW_AT_use_location:
2103 case DW_AT_GNU_call_site_value:
2104 case DW_AT_GNU_call_site_data_value:
2105 case DW_AT_GNU_call_site_target:
2106 case DW_AT_GNU_call_site_target_clobbered:
2107 if ((dwarf_version < 4
2108 && (form == DW_FORM_data4 || form == DW_FORM_data8))
2109 || form == DW_FORM_sec_offset)
2110 printf (_(" (location list)"));
2111 /* Fall through. */
2112 case DW_AT_allocated:
2113 case DW_AT_associated:
2114 case DW_AT_data_location:
2115 case DW_AT_stride:
2116 case DW_AT_upper_bound:
2117 case DW_AT_lower_bound:
2118 if (block_start)
2119 {
2120 int need_frame_base;
2121
2122 printf ("\t(");
2123 need_frame_base = decode_location_expression (block_start,
2124 pointer_size,
2125 offset_size,
2126 dwarf_version,
2127 uvalue,
2128 cu_offset, section);
2129 printf (")");
2130 if (need_frame_base && !have_frame_base)
2131 printf (_(" [without DW_AT_frame_base]"));
2132 }
2133 break;
2134
2135 case DW_AT_import:
2136 {
2137 if (form == DW_FORM_ref_sig8
2138 || form == DW_FORM_GNU_ref_alt)
2139 break;
2140
2141 if (form == DW_FORM_ref1
2142 || form == DW_FORM_ref2
2143 || form == DW_FORM_ref4
2144 || form == DW_FORM_ref_udata)
2145 uvalue += cu_offset;
2146
2147 if (uvalue >= section->size)
2148 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2149 dwarf_vmatoa ("x", uvalue),
2150 (unsigned long) (orig_data - section->start));
2151 else
2152 {
2153 unsigned long abbrev_number;
2154 abbrev_entry * entry;
2155
2156 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
2157
2158 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
2159 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2160 use different abbrev table, and we don't track .debug_info chunks
2161 yet. */
2162 if (form != DW_FORM_ref_addr)
2163 {
2164 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2165 if (entry->entry == abbrev_number)
2166 break;
2167 if (entry != NULL)
2168 printf (" (%s)", get_TAG_name (entry->tag));
2169 }
2170 printf ("]");
2171 }
2172 }
2173 break;
2174
2175 default:
2176 break;
2177 }
2178
2179 return data;
2180 }
2181
2182 static const char *
get_AT_name(unsigned long attribute)2183 get_AT_name (unsigned long attribute)
2184 {
2185 const char *name;
2186
2187 if (attribute == 0)
2188 return "DW_AT value: 0";
2189
2190 /* One value is shared by the MIPS and HP extensions: */
2191 if (attribute == DW_AT_MIPS_fde)
2192 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2193
2194 name = get_DW_AT_name (attribute);
2195
2196 if (name == NULL)
2197 {
2198 static char buffer[100];
2199
2200 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2201 attribute);
2202 return buffer;
2203 }
2204
2205 return name;
2206 }
2207
2208 static unsigned char *
read_and_display_attr(unsigned long attribute,unsigned long form,unsigned char * data,unsigned char * end,dwarf_vma cu_offset,dwarf_vma pointer_size,dwarf_vma offset_size,int dwarf_version,debug_info * debug_info_p,int do_loc,struct dwarf_section * section,struct cu_tu_set * this_set)2209 read_and_display_attr (unsigned long attribute,
2210 unsigned long form,
2211 unsigned char * data,
2212 unsigned char * end,
2213 dwarf_vma cu_offset,
2214 dwarf_vma pointer_size,
2215 dwarf_vma offset_size,
2216 int dwarf_version,
2217 debug_info * debug_info_p,
2218 int do_loc,
2219 struct dwarf_section * section,
2220 struct cu_tu_set * this_set)
2221 {
2222 if (!do_loc)
2223 printf (" %-18s:", get_AT_name (attribute));
2224 data = read_and_display_attr_value (attribute, form, data, end,
2225 cu_offset, pointer_size, offset_size,
2226 dwarf_version, debug_info_p,
2227 do_loc, section, this_set);
2228 if (!do_loc)
2229 printf ("\n");
2230 return data;
2231 }
2232
2233 /* Process the contents of a .debug_info section. If do_loc is non-zero
2234 then we are scanning for location lists and we do not want to display
2235 anything to the user. If do_types is non-zero, we are processing
2236 a .debug_types section instead of a .debug_info section. */
2237
2238 static int
process_debug_info(struct dwarf_section * section,void * file,enum dwarf_section_display_enum abbrev_sec,int do_loc,int do_types)2239 process_debug_info (struct dwarf_section *section,
2240 void *file,
2241 enum dwarf_section_display_enum abbrev_sec,
2242 int do_loc,
2243 int do_types)
2244 {
2245 unsigned char *start = section->start;
2246 unsigned char *end = start + section->size;
2247 unsigned char *section_begin;
2248 unsigned int unit;
2249 unsigned int num_units = 0;
2250
2251 if ((do_loc || do_debug_loc || do_debug_ranges)
2252 && num_debug_info_entries == 0
2253 && ! do_types)
2254 {
2255 dwarf_vma length;
2256
2257 /* First scan the section to get the number of comp units. */
2258 for (section_begin = start, num_units = 0; section_begin < end;
2259 num_units ++)
2260 {
2261 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2262 will be the length. For a 64-bit DWARF section, it'll be
2263 the escape code 0xffffffff followed by an 8 byte length. */
2264 SAFE_BYTE_GET (length, section_begin, 4, end);
2265
2266 if (length == 0xffffffff)
2267 {
2268 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
2269 section_begin += length + 12;
2270 }
2271 else if (length >= 0xfffffff0 && length < 0xffffffff)
2272 {
2273 warn (_("Reserved length value (0x%s) found in section %s\n"),
2274 dwarf_vmatoa ("x", length), section->name);
2275 return 0;
2276 }
2277 else
2278 section_begin += length + 4;
2279
2280 /* Negative values are illegal, they may even cause infinite
2281 looping. This can happen if we can't accurately apply
2282 relocations to an object file. */
2283 if ((signed long) length <= 0)
2284 {
2285 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2286 dwarf_vmatoa ("x", length), section->name);
2287 return 0;
2288 }
2289 }
2290
2291 if (num_units == 0)
2292 {
2293 error (_("No comp units in %s section ?\n"), section->name);
2294 return 0;
2295 }
2296
2297 /* Then allocate an array to hold the information. */
2298 debug_information = (debug_info *) cmalloc (num_units,
2299 sizeof (* debug_information));
2300 if (debug_information == NULL)
2301 {
2302 error (_("Not enough memory for a debug info array of %u entries\n"),
2303 num_units);
2304 return 0;
2305 }
2306 }
2307
2308 if (!do_loc)
2309 {
2310 if (dwarf_start_die == 0)
2311 printf (_("Contents of the %s section:\n\n"), section->name);
2312
2313 load_debug_section (str, file);
2314 load_debug_section (str_dwo, file);
2315 load_debug_section (str_index, file);
2316 load_debug_section (str_index_dwo, file);
2317 load_debug_section (debug_addr, file);
2318 }
2319
2320 load_debug_section (abbrev_sec, file);
2321 if (debug_displays [abbrev_sec].section.start == NULL)
2322 {
2323 warn (_("Unable to locate %s section!\n"),
2324 debug_displays [abbrev_sec].section.name);
2325 return 0;
2326 }
2327
2328 for (section_begin = start, unit = 0; start < end; unit++)
2329 {
2330 DWARF2_Internal_CompUnit compunit;
2331 unsigned char *hdrptr;
2332 unsigned char *tags;
2333 int level, last_level, saved_level;
2334 dwarf_vma cu_offset;
2335 unsigned int offset_size;
2336 int initial_length_size;
2337 dwarf_vma signature_high = 0;
2338 dwarf_vma signature_low = 0;
2339 dwarf_vma type_offset = 0;
2340 struct cu_tu_set *this_set;
2341 dwarf_vma abbrev_base;
2342 size_t abbrev_size;
2343
2344 hdrptr = start;
2345
2346 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
2347
2348 if (compunit.cu_length == 0xffffffff)
2349 {
2350 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
2351 offset_size = 8;
2352 initial_length_size = 12;
2353 }
2354 else
2355 {
2356 offset_size = 4;
2357 initial_length_size = 4;
2358 }
2359
2360 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
2361
2362 cu_offset = start - section_begin;
2363
2364 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2365
2366 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
2367
2368 if (this_set == NULL)
2369 {
2370 abbrev_base = 0;
2371 abbrev_size = debug_displays [abbrev_sec].section.size;
2372 }
2373 else
2374 {
2375 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2376 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2377 }
2378
2379 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2380 /* PR 17512: file: 001-108546-0.001:0.1. */
2381 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2382 {
2383 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2384 compunit.cu_pointer_size, offset_size);
2385 compunit.cu_pointer_size = offset_size;
2386 }
2387
2388 if (do_types)
2389 {
2390 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
2391 hdrptr += 8;
2392 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2393 }
2394
2395 if ((do_loc || do_debug_loc || do_debug_ranges)
2396 && num_debug_info_entries == 0
2397 && ! do_types)
2398 {
2399 debug_information [unit].cu_offset = cu_offset;
2400 debug_information [unit].pointer_size
2401 = compunit.cu_pointer_size;
2402 debug_information [unit].offset_size = offset_size;
2403 debug_information [unit].dwarf_version = compunit.cu_version;
2404 debug_information [unit].base_address = 0;
2405 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2406 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
2407 debug_information [unit].loc_offsets = NULL;
2408 debug_information [unit].have_frame_base = NULL;
2409 debug_information [unit].max_loc_offsets = 0;
2410 debug_information [unit].num_loc_offsets = 0;
2411 debug_information [unit].range_lists = NULL;
2412 debug_information [unit].max_range_lists= 0;
2413 debug_information [unit].num_range_lists = 0;
2414 }
2415
2416 if (!do_loc && dwarf_start_die == 0)
2417 {
2418 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2419 dwarf_vmatoa ("x", cu_offset));
2420 printf (_(" Length: 0x%s (%s)\n"),
2421 dwarf_vmatoa ("x", compunit.cu_length),
2422 offset_size == 8 ? "64-bit" : "32-bit");
2423 printf (_(" Version: %d\n"), compunit.cu_version);
2424 printf (_(" Abbrev Offset: 0x%s\n"),
2425 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
2426 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2427 if (do_types)
2428 {
2429 char buf[64];
2430
2431 printf (_(" Signature: 0x%s\n"),
2432 dwarf_vmatoa64 (signature_high, signature_low,
2433 buf, sizeof (buf)));
2434 printf (_(" Type Offset: 0x%s\n"),
2435 dwarf_vmatoa ("x", type_offset));
2436 }
2437 if (this_set != NULL)
2438 {
2439 dwarf_vma *offsets = this_set->section_offsets;
2440 size_t *sizes = this_set->section_sizes;
2441
2442 printf (_(" Section contributions:\n"));
2443 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2444 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2445 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2446 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2447 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2448 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2449 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2450 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2451 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2452 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2453 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2454 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2455 }
2456 }
2457
2458 if (cu_offset + compunit.cu_length + initial_length_size
2459 > section->size)
2460 {
2461 warn (_("Debug info is corrupted, length of CU at %s"
2462 " extends beyond end of section (length = %s)\n"),
2463 dwarf_vmatoa ("x", cu_offset),
2464 dwarf_vmatoa ("x", compunit.cu_length));
2465 break;
2466 }
2467 tags = hdrptr;
2468 start += compunit.cu_length + initial_length_size;
2469
2470 if (compunit.cu_version != 2
2471 && compunit.cu_version != 3
2472 && compunit.cu_version != 4)
2473 {
2474 warn (_("CU at offset %s contains corrupt or "
2475 "unsupported version number: %d.\n"),
2476 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
2477 continue;
2478 }
2479
2480 free_abbrevs ();
2481
2482 /* Process the abbrevs used by this compilation unit. */
2483 if (compunit.cu_abbrev_offset >= abbrev_size)
2484 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2485 (unsigned long) compunit.cu_abbrev_offset,
2486 (unsigned long) abbrev_size);
2487 else
2488 process_abbrev_section
2489 (((unsigned char *) debug_displays [abbrev_sec].section.start
2490 + abbrev_base + compunit.cu_abbrev_offset),
2491 ((unsigned char *) debug_displays [abbrev_sec].section.start
2492 + abbrev_base + abbrev_size));
2493
2494 level = 0;
2495 last_level = level;
2496 saved_level = -1;
2497 while (tags < start)
2498 {
2499 unsigned int bytes_read;
2500 unsigned long abbrev_number;
2501 unsigned long die_offset;
2502 abbrev_entry *entry;
2503 abbrev_attr *attr;
2504 int do_printing = 1;
2505
2506 die_offset = tags - section_begin;
2507
2508 abbrev_number = read_uleb128 (tags, & bytes_read, start);
2509 tags += bytes_read;
2510
2511 /* A null DIE marks the end of a list of siblings or it may also be
2512 a section padding. */
2513 if (abbrev_number == 0)
2514 {
2515 /* Check if it can be a section padding for the last CU. */
2516 if (level == 0 && start == end)
2517 {
2518 unsigned char *chk;
2519
2520 for (chk = tags; chk < start; chk++)
2521 if (*chk != 0)
2522 break;
2523 if (chk == start)
2524 break;
2525 }
2526
2527 if (!do_loc && die_offset >= dwarf_start_die
2528 && (dwarf_cutoff_level == -1
2529 || level < dwarf_cutoff_level))
2530 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2531 level, die_offset);
2532
2533 --level;
2534 if (level < 0)
2535 {
2536 static unsigned num_bogus_warns = 0;
2537
2538 if (num_bogus_warns < 3)
2539 {
2540 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2541 die_offset, section->name);
2542 num_bogus_warns ++;
2543 if (num_bogus_warns == 3)
2544 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2545 }
2546 }
2547 if (dwarf_start_die != 0 && level < saved_level)
2548 return 1;
2549 continue;
2550 }
2551
2552 if (!do_loc)
2553 {
2554 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2555 do_printing = 0;
2556 else
2557 {
2558 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2559 saved_level = level;
2560 do_printing = (dwarf_cutoff_level == -1
2561 || level < dwarf_cutoff_level);
2562 if (do_printing)
2563 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2564 level, die_offset, abbrev_number);
2565 else if (dwarf_cutoff_level == -1
2566 || last_level < dwarf_cutoff_level)
2567 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2568 last_level = level;
2569 }
2570 }
2571
2572 /* Scan through the abbreviation list until we reach the
2573 correct entry. */
2574 for (entry = first_abbrev;
2575 entry && entry->entry != abbrev_number;
2576 entry = entry->next)
2577 continue;
2578
2579 if (entry == NULL)
2580 {
2581 if (!do_loc && do_printing)
2582 {
2583 printf ("\n");
2584 fflush (stdout);
2585 }
2586 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2587 die_offset, abbrev_number);
2588 return 0;
2589 }
2590
2591 if (!do_loc && do_printing)
2592 printf (" (%s)\n", get_TAG_name (entry->tag));
2593
2594 switch (entry->tag)
2595 {
2596 default:
2597 need_base_address = 0;
2598 break;
2599 case DW_TAG_compile_unit:
2600 need_base_address = 1;
2601 break;
2602 case DW_TAG_entry_point:
2603 case DW_TAG_subprogram:
2604 need_base_address = 0;
2605 /* Assuming that there is no DW_AT_frame_base. */
2606 have_frame_base = 0;
2607 break;
2608 }
2609
2610 for (attr = entry->first_attr;
2611 attr && attr->attribute;
2612 attr = attr->next)
2613 {
2614 debug_info *arg;
2615
2616 if (! do_loc && do_printing)
2617 /* Show the offset from where the tag was extracted. */
2618 printf (" <%lx>", (unsigned long)(tags - section_begin));
2619
2620 arg = debug_information;
2621 if (debug_information)
2622 arg += unit;
2623
2624 tags = read_and_display_attr (attr->attribute,
2625 attr->form,
2626 tags,
2627 end,
2628 cu_offset,
2629 compunit.cu_pointer_size,
2630 offset_size,
2631 compunit.cu_version,
2632 arg,
2633 do_loc || ! do_printing,
2634 section,
2635 this_set);
2636 }
2637
2638 if (entry->children)
2639 ++level;
2640 }
2641 }
2642
2643 /* Set num_debug_info_entries here so that it can be used to check if
2644 we need to process .debug_loc and .debug_ranges sections. */
2645 if ((do_loc || do_debug_loc || do_debug_ranges)
2646 && num_debug_info_entries == 0
2647 && ! do_types)
2648 num_debug_info_entries = num_units;
2649
2650 if (!do_loc)
2651 printf ("\n");
2652
2653 return 1;
2654 }
2655
2656 /* Locate and scan the .debug_info section in the file and record the pointer
2657 sizes and offsets for the compilation units in it. Usually an executable
2658 will have just one pointer size, but this is not guaranteed, and so we try
2659 not to make any assumptions. Returns zero upon failure, or the number of
2660 compilation units upon success. */
2661
2662 static unsigned int
load_debug_info(void * file)2663 load_debug_info (void * file)
2664 {
2665 /* Reset the last pointer size so that we can issue correct error
2666 messages if we are displaying the contents of more than one section. */
2667 last_pointer_size = 0;
2668 warned_about_missing_comp_units = FALSE;
2669
2670 /* If we have already tried and failed to load the .debug_info
2671 section then do not bother to repeat the task. */
2672 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2673 return 0;
2674
2675 /* If we already have the information there is nothing else to do. */
2676 if (num_debug_info_entries > 0)
2677 return num_debug_info_entries;
2678
2679 /* If this is a DWARF package file, load the CU and TU indexes. */
2680 load_cu_tu_indexes (file);
2681
2682 if (load_debug_section (info, file)
2683 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
2684 return num_debug_info_entries;
2685 else if (load_debug_section (info_dwo, file)
2686 && process_debug_info (&debug_displays [info_dwo].section, file,
2687 abbrev_dwo, 1, 0))
2688 return num_debug_info_entries;
2689
2690 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
2691 return 0;
2692 }
2693
2694 /* Experimental DWARF 5 extensions.
2695 See http://wiki.dwarfstd.org/index.php?title=TwoLevelLineTables. */
2696 #define DWARF2_LINE_EXPERIMENTAL_VERSION 0xf006
2697
2698 /* Read a DWARF .debug_line section header starting at DATA.
2699 Upon success returns an updated DATA pointer and the LINFO
2700 structure and the END_OF_SEQUENCE pointer will be filled in.
2701 Otherwise returns NULL. */
2702
2703 static unsigned char *
read_debug_line_header(struct dwarf_section * section,unsigned char * data,unsigned char * end,DWARF2_Internal_LineInfo * linfo,unsigned char ** end_of_sequence,unsigned int * pinitial_length_size,unsigned int * poffset_size)2704 read_debug_line_header (struct dwarf_section * section,
2705 unsigned char * data,
2706 unsigned char * end,
2707 DWARF2_Internal_LineInfo * linfo,
2708 unsigned char ** end_of_sequence,
2709 unsigned int * pinitial_length_size,
2710 unsigned int * poffset_size)
2711 {
2712 unsigned char *hdrptr;
2713 unsigned int offset_size;
2714 unsigned int initial_length_size;
2715
2716 /* Extract information from the Line Number Program Header.
2717 (section 6.2.4 in the Dwarf3 doc). */
2718 hdrptr = data;
2719
2720 /* Get and check the length of the block. */
2721 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
2722
2723 if (linfo->li_length == 0xffffffff)
2724 {
2725 /* This section is 64-bit DWARF 3. */
2726 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
2727 offset_size = 8;
2728 initial_length_size = 12;
2729 }
2730 else
2731 {
2732 offset_size = 4;
2733 initial_length_size = 4;
2734 }
2735 *pinitial_length_size = initial_length_size;
2736 *poffset_size = offset_size;
2737
2738 if (linfo->li_length + initial_length_size > section->size)
2739 {
2740 /* If the length is just a bias against the initial_length_size then
2741 this means that the field has a relocation against it which has not
2742 been applied. (Ie we are dealing with an object file, not a linked
2743 binary). Do not complain but instead assume that the rest of the
2744 section applies to this particular header. */
2745 if (linfo->li_length == - initial_length_size)
2746 {
2747 linfo->li_length = section->size - initial_length_size;
2748 }
2749 else
2750 {
2751 warn (_("The line info appears to be corrupt - the section is too small\n"));
2752 return NULL;
2753 }
2754 }
2755
2756 /* Get and check the version number. */
2757 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2758
2759 /* Version 0xf006 is for experimental two-level line tables. */
2760 if (linfo->li_version != 2
2761 && linfo->li_version != 3
2762 && linfo->li_version != 4
2763 && linfo->li_version != 5
2764 && linfo->li_version != DWARF2_LINE_EXPERIMENTAL_VERSION)
2765 {
2766 warn (_("Only DWARF versions 2-5 line info are currently supported.\n"));
2767 return NULL;
2768 }
2769
2770 if (linfo->li_version < 5)
2771 {
2772 linfo->li_address_size = 0;
2773 linfo->li_segment_size = 0;
2774 }
2775 else if (linfo->li_version != DWARF2_LINE_EXPERIMENTAL_VERSION)
2776 {
2777 SAFE_BYTE_GET_AND_INC (linfo->li_address_size, hdrptr, 1, end);
2778 SAFE_BYTE_GET_AND_INC (linfo->li_segment_size, hdrptr, 1, end);
2779 }
2780
2781 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2782
2783 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
2784
2785 if (linfo->li_version >= 4)
2786 {
2787 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
2788
2789 if (linfo->li_max_ops_per_insn == 0)
2790 {
2791 warn (_("Invalid maximum operations per insn.\n"));
2792 return NULL;
2793 }
2794 }
2795 else
2796 linfo->li_max_ops_per_insn = 1;
2797
2798 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
2799 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
2800 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2801 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
2802
2803 * end_of_sequence = data + linfo->li_length + initial_length_size;
2804 return hdrptr;
2805 }
2806
2807 static void
display_directory_table_v4(unsigned char * start,unsigned char * end,unsigned char ** pdata)2808 display_directory_table_v4 (unsigned char *start, unsigned char *end,
2809 unsigned char **pdata)
2810 {
2811 unsigned char *data = *pdata;
2812 unsigned int last_dir_entry = 0;
2813
2814 if (*data == 0)
2815 printf (_("\n The Directory Table is empty.\n"));
2816 else
2817 {
2818 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2819 (long)(data - start));
2820
2821 while (data < end && *data != 0)
2822 {
2823 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
2824
2825 data += strnlen ((char *) data, end - data) + 1;
2826 }
2827 }
2828
2829 /* Skip the NUL at the end of the table. */
2830 *pdata = data + 1;
2831 }
2832
2833 static void
display_file_name_table_v4(unsigned char * start,unsigned char * end,unsigned char ** pdata)2834 display_file_name_table_v4 (unsigned char *start, unsigned char *end,
2835 unsigned char **pdata)
2836 {
2837 unsigned char *data = *pdata;
2838
2839 if (*data == 0)
2840 printf (_("\n The File Name Table is empty.\n"));
2841 else
2842 {
2843 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2844 (long)(data - start));
2845 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2846
2847 while (data < end && *data != 0)
2848 {
2849 unsigned char *name;
2850 unsigned int bytes_read;
2851
2852 printf (" %d\t", ++state_machine_regs.last_file_entry);
2853 name = data;
2854 data += strnlen ((char *) data, end - data) + 1;
2855
2856 printf ("%s\t",
2857 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2858 data += bytes_read;
2859 printf ("%s\t",
2860 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2861 data += bytes_read;
2862 printf ("%s\t",
2863 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2864 data += bytes_read;
2865 printf ("%.*s\n", (int)(end - name), name);
2866
2867 if (data == end)
2868 {
2869 warn (_("Corrupt file name table entry\n"));
2870 break;
2871 }
2872 }
2873 }
2874
2875 /* Skip the NUL at the end of the table. */
2876 *pdata = data + 1;
2877 }
2878
2879 static int
display_dir_file_table_v5(unsigned char * start,unsigned char * end,unsigned char ** pdata,char * table_name,unsigned int offset_size)2880 display_dir_file_table_v5 (unsigned char *start, unsigned char *end,
2881 unsigned char **pdata, char *table_name,
2882 unsigned int offset_size)
2883 {
2884 unsigned char *data = *pdata;
2885 unsigned int bytes_read;
2886 unsigned int format_count;
2887 unsigned int *content_types;
2888 unsigned int *content_forms;
2889 unsigned int entry_count;
2890 unsigned int i, j;
2891 const unsigned char *name;
2892 dwarf_vma offset;
2893 unsigned int val;
2894
2895 format_count = read_uleb128 (data, & bytes_read, end);
2896 data += bytes_read;
2897 content_types = (unsigned int *) xmalloc (format_count *
2898 sizeof (unsigned int));
2899 content_forms = (unsigned int *) xmalloc (format_count *
2900 sizeof (unsigned int));
2901 for (j = 0; j < format_count; j++)
2902 {
2903 content_types[j] = read_uleb128 (data, & bytes_read, end);
2904 data += bytes_read;
2905 content_forms[j] = read_uleb128 (data, & bytes_read, end);
2906 data += bytes_read;
2907 }
2908
2909 entry_count = read_uleb128 (data, & bytes_read, end);
2910 data += bytes_read;
2911
2912 if (entry_count == 0)
2913 printf (_("\n The %s Table is empty.\n"), table_name);
2914 else
2915 {
2916 printf (_("\n The %s Table (offset 0x%lx):\n"),
2917 table_name, (long)(data - start));
2918
2919 printf (_(" Entry"));
2920 for (j = 0; j < format_count; j++)
2921 {
2922 printf ("\t");
2923 switch (content_types[j])
2924 {
2925 case DW_LNCT_path:
2926 printf (_("Path"));
2927 break;
2928 case DW_LNCT_subprogram_name:
2929 printf (_("Name"));
2930 break;
2931 case DW_LNCT_directory_index:
2932 printf (_("Dir"));
2933 break;
2934 case DW_LNCT_decl_file:
2935 printf (_("File"));
2936 break;
2937 case DW_LNCT_decl_line:
2938 printf (_("Line"));
2939 break;
2940 }
2941 }
2942 printf ("\n");
2943 }
2944
2945 for (i = 0; i < entry_count; i++)
2946 {
2947 printf (" %d", i + 1);
2948 for (j = 0; j < format_count; j++)
2949 {
2950 if (data >= end)
2951 break;
2952 switch (content_forms[j])
2953 {
2954 case DW_FORM_string:
2955 printf ("\t%.*s", (int) (end - data), data);
2956 data += strnlen ((char *) data, end - data) + 1;
2957 break;
2958 case DW_FORM_line_strp:
2959 SAFE_BYTE_GET_AND_INC (offset, data, offset_size, end);
2960 name = fetch_indirect_line_string (offset);
2961 printf ("\t%s", name);
2962 break;
2963 case DW_FORM_udata:
2964 val = read_uleb128 (data, & bytes_read, end);
2965 data += bytes_read;
2966 printf ("\t%u", val);
2967 break;
2968 default:
2969 printf ("\t%s", _("(unrecognized FORM code)"));
2970 data = end;
2971 break;
2972 }
2973 }
2974 printf ("\n");
2975
2976 /* PR 17512: file: 002-132094-0.004. */
2977 if (data >= end - 1)
2978 break;
2979 }
2980
2981 free (content_types);
2982 free (content_forms);
2983
2984 *pdata = data;
2985 return entry_count;
2986 }
2987
2988 static void
display_line_program(unsigned char * start,unsigned char * end,unsigned char ** pdata,char * table_name,DWARF2_Internal_LineInfo * linfo,unsigned char * standard_opcodes,int is_logical)2989 display_line_program (unsigned char *start, unsigned char *end,
2990 unsigned char **pdata, char *table_name,
2991 DWARF2_Internal_LineInfo *linfo,
2992 unsigned char *standard_opcodes,
2993 int is_logical)
2994 {
2995 unsigned char *data = *pdata;
2996
2997 if (data >= end)
2998 {
2999 printf (_(" No %s.\n"), table_name);
3000 return;
3001 }
3002
3003 printf (" %s:\n", table_name);
3004
3005 while (data < end)
3006 {
3007 unsigned char op_code;
3008 dwarf_signed_vma adv;
3009 dwarf_vma uladv;
3010 unsigned int bytes_read;
3011 unsigned int logical;
3012 int i;
3013
3014 printf (" [0x%08lx]", (long)(data - start));
3015
3016 op_code = *data++;
3017
3018 if (op_code >= linfo->li_opcode_base)
3019 {
3020 op_code -= linfo->li_opcode_base;
3021 uladv = (op_code / linfo->li_line_range);
3022 if (linfo->li_max_ops_per_insn == 1)
3023 {
3024 uladv *= linfo->li_min_insn_length;
3025 state_machine_regs.address += uladv;
3026 printf (_(" Special opcode %d: "
3027 "advance Address by %s to 0x%s"),
3028 op_code, dwarf_vmatoa ("u", uladv),
3029 dwarf_vmatoa ("x", state_machine_regs.address));
3030 }
3031 else
3032 {
3033 state_machine_regs.address
3034 += ((state_machine_regs.op_index + uladv)
3035 / linfo->li_max_ops_per_insn)
3036 * linfo->li_min_insn_length;
3037 state_machine_regs.op_index
3038 = (state_machine_regs.op_index + uladv)
3039 % linfo->li_max_ops_per_insn;
3040 printf (_(" Special opcode %d: "
3041 "advance Address by %s to 0x%s[%d]"),
3042 op_code, dwarf_vmatoa ("u", uladv),
3043 dwarf_vmatoa ("x", state_machine_regs.address),
3044 state_machine_regs.op_index);
3045 }
3046 adv = (op_code % linfo->li_line_range) + linfo->li_line_base;
3047 state_machine_regs.line += adv;
3048 printf (_(" and Line by %s to %d\n"),
3049 dwarf_vmatoa ("d", adv), state_machine_regs.line);
3050 if (is_logical)
3051 append_logical ();
3052 state_machine_regs.discriminator = 0;
3053 }
3054 else
3055 {
3056 switch (op_code)
3057 {
3058 case DW_LNS_extended_op:
3059 data += process_extended_line_op (data, linfo->li_default_is_stmt,
3060 end, is_logical);
3061 break;
3062
3063 case DW_LNS_copy:
3064 printf (_(" Copy\n"));
3065 if (is_logical)
3066 append_logical ();
3067 state_machine_regs.discriminator = 0;
3068 break;
3069
3070 case DW_LNS_advance_pc:
3071 uladv = read_uleb128 (data, & bytes_read, end);
3072 data += bytes_read;
3073 if (linfo->li_max_ops_per_insn == 1)
3074 {
3075 uladv *= linfo->li_min_insn_length;
3076 state_machine_regs.address += uladv;
3077 printf (_(" Advance PC by %s to 0x%s\n"),
3078 dwarf_vmatoa ("u", uladv),
3079 dwarf_vmatoa ("x", state_machine_regs.address));
3080 }
3081 else
3082 {
3083 state_machine_regs.address
3084 += ((state_machine_regs.op_index + uladv)
3085 / linfo->li_max_ops_per_insn)
3086 * linfo->li_min_insn_length;
3087 state_machine_regs.op_index
3088 = (state_machine_regs.op_index + uladv)
3089 % linfo->li_max_ops_per_insn;
3090 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3091 dwarf_vmatoa ("u", uladv),
3092 dwarf_vmatoa ("x", state_machine_regs.address),
3093 state_machine_regs.op_index);
3094 }
3095 break;
3096
3097 case DW_LNS_advance_line:
3098 adv = read_sleb128 (data, & bytes_read, end);
3099 data += bytes_read;
3100 state_machine_regs.line += adv;
3101 printf (_(" Advance Line by %s to %d\n"),
3102 dwarf_vmatoa ("d", adv),
3103 state_machine_regs.line);
3104 break;
3105
3106 case DW_LNS_set_file:
3107 adv = read_uleb128 (data, & bytes_read, end);
3108 data += bytes_read;
3109 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3110 dwarf_vmatoa ("d", adv));
3111 state_machine_regs.file = adv;
3112 break;
3113
3114 case DW_LNS_set_column:
3115 uladv = read_uleb128 (data, & bytes_read, end);
3116 data += bytes_read;
3117 printf (_(" Set column to %s\n"),
3118 dwarf_vmatoa ("u", uladv));
3119 state_machine_regs.column = uladv;
3120 break;
3121
3122 case DW_LNS_negate_stmt:
3123 adv = state_machine_regs.is_stmt;
3124 adv = ! adv;
3125 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3126 state_machine_regs.is_stmt = adv;
3127 break;
3128
3129 case DW_LNS_set_basic_block:
3130 printf (_(" Set basic block\n"));
3131 state_machine_regs.basic_block = 1;
3132 break;
3133
3134 case DW_LNS_const_add_pc:
3135 uladv = ((255 - linfo->li_opcode_base) / linfo->li_line_range);
3136 if (linfo->li_max_ops_per_insn)
3137 {
3138 uladv *= linfo->li_min_insn_length;
3139 state_machine_regs.address += uladv;
3140 printf (_(" Advance PC by constant %s to 0x%s\n"),
3141 dwarf_vmatoa ("u", uladv),
3142 dwarf_vmatoa ("x", state_machine_regs.address));
3143 }
3144 else
3145 {
3146 state_machine_regs.address
3147 += ((state_machine_regs.op_index + uladv)
3148 / linfo->li_max_ops_per_insn)
3149 * linfo->li_min_insn_length;
3150 state_machine_regs.op_index
3151 = (state_machine_regs.op_index + uladv)
3152 % linfo->li_max_ops_per_insn;
3153 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3154 dwarf_vmatoa ("u", uladv),
3155 dwarf_vmatoa ("x", state_machine_regs.address),
3156 state_machine_regs.op_index);
3157 }
3158 break;
3159
3160 case DW_LNS_fixed_advance_pc:
3161 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3162 state_machine_regs.address += uladv;
3163 state_machine_regs.op_index = 0;
3164 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3165 dwarf_vmatoa ("u", uladv),
3166 dwarf_vmatoa ("x", state_machine_regs.address));
3167 break;
3168
3169 case DW_LNS_set_prologue_end:
3170 printf (_(" Set prologue_end to true\n"));
3171 break;
3172
3173 case DW_LNS_set_epilogue_begin:
3174 printf (_(" Set epilogue_begin to true\n"));
3175 break;
3176
3177 case DW_LNS_set_isa:
3178 uladv = read_uleb128 (data, & bytes_read, end);
3179 data += bytes_read;
3180 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3181 break;
3182
3183 case DW_LNS_set_subprogram:
3184 /* This opcode is aliased with: */
3185 /* case DW_LNS_set_address_from_logical: */
3186 if (is_logical)
3187 {
3188 /* DW_LNS_set_subprogram */
3189 state_machine_regs.context = 0;
3190 state_machine_regs.subprogram = read_uleb128 (data, & bytes_read, end);
3191 data += bytes_read;
3192 printf (_(" Set subprogram to %u and reset context to 0\n"),
3193 state_machine_regs.subprogram);
3194 }
3195 else
3196 {
3197 /* DW_LNS_set_address_from_logical */
3198 adv = read_sleb128 (data, & bytes_read, end);
3199 data += bytes_read;
3200 state_machine_regs.line += adv;
3201 logical = state_machine_regs.line;
3202 if (logical - 1 < logicals_count)
3203 {
3204 state_machine_regs.address = logicals_table[logical - 1].address;
3205 state_machine_regs.op_index = logicals_table[logical - 1].op_index;
3206 }
3207 else
3208 warn (_("Logical row number outside range of logicals table\n"));
3209 printf (_(" Advance Line by %s to %u and set address from logical to 0x%s[%u]\n"),
3210 dwarf_vmatoa ("d", adv),
3211 logical,
3212 dwarf_vmatoa ("x", state_machine_regs.address),
3213 state_machine_regs.op_index);
3214 }
3215 break;
3216
3217 case DW_LNS_inlined_call:
3218 adv = read_sleb128 (data, & bytes_read, end);
3219 data += bytes_read;
3220 state_machine_regs.context = logicals_count + adv;
3221 state_machine_regs.subprogram = read_uleb128 (data, & bytes_read, end);
3222 data += bytes_read;
3223 printf (_(" Set context to %u and subprogram to %u\n"),
3224 state_machine_regs.context,
3225 state_machine_regs.subprogram);
3226 break;
3227
3228 case DW_LNS_pop_context:
3229 logical = state_machine_regs.context;
3230 printf (_(" Pop context to logical %u\n"), logical);
3231 if (logical - 1 < logicals_count)
3232 {
3233 state_machine_regs.file = logicals_table[logical - 1].file;
3234 state_machine_regs.line = logicals_table[logical - 1].line;
3235 state_machine_regs.column = logicals_table[logical - 1].column;
3236 state_machine_regs.discriminator = logicals_table[logical - 1].discriminator;
3237 state_machine_regs.is_stmt = logicals_table[logical - 1].is_stmt;
3238 state_machine_regs.context = logicals_table[logical - 1].context;
3239 state_machine_regs.subprogram = logicals_table[logical - 1].subprogram;
3240 }
3241 else
3242 warn (_("Context register outside range of logicals table\n"));
3243 break;
3244
3245 default:
3246 printf (_(" Unknown opcode %d with operands: "), op_code);
3247
3248 if (standard_opcodes != NULL)
3249 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3250 {
3251 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3252 &bytes_read, end)),
3253 i == 1 ? "" : ", ");
3254 data += bytes_read;
3255 }
3256 putchar ('\n');
3257 break;
3258 }
3259 }
3260 }
3261
3262 putchar ('\n');
3263 *pdata = data;
3264 }
3265
3266 static int
display_debug_lines_raw(struct dwarf_section * section,unsigned char * data,unsigned char * end)3267 display_debug_lines_raw (struct dwarf_section *section,
3268 unsigned char *data,
3269 unsigned char *end)
3270 {
3271 unsigned char *start = section->start;
3272 unsigned int initial_length_size;
3273 unsigned int offset_size;
3274
3275 printf (_("Raw dump of debug contents of section %s:\n\n"),
3276 section->name);
3277
3278 while (data < end)
3279 {
3280 static DWARF2_Internal_LineInfo saved_linfo;
3281 DWARF2_Internal_LineInfo linfo;
3282 unsigned int logicals_table_offset = 0;
3283 unsigned int actuals_table_offset = 0;
3284 unsigned char *end_of_header_length;
3285 unsigned char *standard_opcodes;
3286 unsigned char *start_of_line_program;
3287 unsigned char *end_of_logicals;
3288 unsigned char *end_of_sequence;
3289 int i;
3290 unsigned char *hdrptr = NULL;
3291
3292 if (const_strneq (section->name, ".debug_line.")
3293 /* Note: the following does not apply to .debug_line.dwo sections.
3294 These are full debug_line sections. */
3295 && strcmp (section->name, ".debug_line.dwo") != 0)
3296 {
3297 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3298 section containing just the Line Number Statements. They are
3299 created by the assembler and intended to be used alongside gcc's
3300 -ffunction-sections command line option. When the linker's
3301 garbage collection decides to discard a .text.<foo> section it
3302 can then also discard the line number information in .debug_line.<foo>.
3303
3304 Since the section is a fragment it does not have the details
3305 needed to fill out a LineInfo structure, so instead we use the
3306 details from the last full debug_line section that we processed. */
3307 start_of_line_program = data;
3308 end_of_sequence = end;
3309 end_of_logicals = end;
3310 standard_opcodes = NULL;
3311 linfo = saved_linfo;
3312 reset_state_machine (linfo.li_default_is_stmt);
3313 }
3314 else
3315 {
3316 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3317 & end_of_sequence,
3318 & initial_length_size,
3319 & offset_size)) == NULL)
3320 return 0;
3321
3322 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
3323 printf (_(" Length: %ld\n"), (long) linfo.li_length);
3324 printf (_(" DWARF Version: %d\n"), linfo.li_version);
3325 if (linfo.li_version >= 5
3326 && linfo.li_version != DWARF2_LINE_EXPERIMENTAL_VERSION)
3327 {
3328 printf (_(" Address Size: %u\n"), linfo.li_address_size);
3329 printf (_(" Segment Size: %u\n"), linfo.li_segment_size);
3330 }
3331 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
3332 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
3333 if (linfo.li_version >= 4)
3334 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
3335 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
3336 printf (_(" Line Base: %d\n"), linfo.li_line_base);
3337 printf (_(" Line Range: %d\n"), linfo.li_line_range);
3338 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
3339
3340 end_of_header_length = data + initial_length_size + 2 + offset_size;
3341 if (linfo.li_version >= 5
3342 && linfo.li_version != DWARF2_LINE_EXPERIMENTAL_VERSION)
3343 end_of_header_length += 2;
3344 start_of_line_program = end_of_header_length + linfo.li_prologue_length;
3345 end_of_logicals = end;
3346
3347 reset_state_machine (linfo.li_default_is_stmt);
3348
3349 /* Display the contents of the Opcodes table. */
3350 standard_opcodes = hdrptr;
3351
3352 printf (_("\n Opcodes:\n"));
3353
3354 for (i = 1; i < linfo.li_opcode_base; i++)
3355 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
3356
3357 data = standard_opcodes + linfo.li_opcode_base - 1;
3358
3359 if (linfo.li_version == DWARF2_LINE_EXPERIMENTAL_VERSION)
3360 {
3361 /* Skip the fake directory and filename table. */
3362 data += 2;
3363
3364 /* Skip the fake extended opcode that wraps the rest
3365 of the section. */
3366 data += 5;
3367
3368 /* Read the logicals table offset and actuals table offset. */
3369 SAFE_BYTE_GET_AND_INC (logicals_table_offset, data, offset_size, end);
3370 SAFE_BYTE_GET_AND_INC (actuals_table_offset, data, offset_size, end);
3371
3372 start_of_line_program = end_of_header_length + logicals_table_offset;
3373
3374 if (actuals_table_offset > 0)
3375 end_of_logicals = end_of_header_length + actuals_table_offset;
3376
3377 putchar ('\n');
3378 printf (_(" Logicals Table Offset: 0x%x\n"), logicals_table_offset);
3379 printf (_(" Actuals Table Offset: 0x%x\n"), actuals_table_offset);
3380 }
3381
3382 /* Display the contents of the Directory table. */
3383 if (linfo.li_version >= 5)
3384 display_dir_file_table_v5 (start, end, &data, _("Directory"),
3385 offset_size);
3386 else
3387 display_directory_table_v4 (start, end, &data);
3388
3389 /* PR 17512: file: 002-132094-0.004. */
3390 if (data >= end - 1)
3391 break;
3392
3393 /* Display the contents of the File Name table. */
3394 if (linfo.li_version >= 5)
3395 {
3396 unsigned int count;
3397
3398 count = display_dir_file_table_v5 (start, end, &data,
3399 _("File Name"), offset_size);
3400 state_machine_regs.last_file_entry = count - 1;
3401 }
3402 else
3403 display_file_name_table_v4 (start, end, &data);
3404
3405 /* Display the contents of the Subprogram table. */
3406 if (linfo.li_version == DWARF2_LINE_EXPERIMENTAL_VERSION)
3407 display_dir_file_table_v5 (start, end, &data, _("Subprogram"),
3408 offset_size);
3409
3410 putchar ('\n');
3411 saved_linfo = linfo;
3412 }
3413
3414 if (data > start_of_line_program)
3415 warn (_("Line table header is longer than header_length indicates\n"));
3416 else if (data < start_of_line_program)
3417 warn (_("Line table header is shorter than header_length indicates\n"));
3418 data = start_of_line_program;
3419
3420 if (linfo.li_version == DWARF2_LINE_EXPERIMENTAL_VERSION
3421 && hdrptr != NULL
3422 && actuals_table_offset > 0)
3423 {
3424 if (end_of_logicals > end)
3425 {
3426 warn (_("Actuals table offset %s extends beyond end of section\n"),
3427 dwarf_vmatoa ("u", actuals_table_offset));
3428 end_of_logicals = end;
3429 }
3430 display_line_program (start, end_of_logicals, &data,
3431 _("Logicals Statements"),
3432 &linfo, standard_opcodes, 1);
3433 if (data > end_of_logicals)
3434 warn (_("Logicals table is longer than actuals_table_offset indicates\n"));
3435 else if (data < end_of_logicals)
3436 warn (_("Line table header is shorter than actuals_table_offset indicates\n"));
3437 data = end_of_logicals;
3438 reset_state_machine (linfo.li_default_is_stmt);
3439 display_line_program (start, end_of_sequence, &data,
3440 _("Actuals Statements"),
3441 &linfo, standard_opcodes, 0);
3442 free_logicals ();
3443 }
3444 else
3445 {
3446 display_line_program (start, end_of_sequence, &data,
3447 _("Line Number Statements"),
3448 &linfo, standard_opcodes, 0);
3449 }
3450
3451 }
3452
3453 return 1;
3454 }
3455
3456 typedef struct
3457 {
3458 unsigned char *name;
3459 unsigned int directory_index;
3460 unsigned int modification_date;
3461 unsigned int length;
3462 } File_Entry;
3463
3464 /* Output a decoded representation of the .debug_line section. */
3465
3466 static int
display_debug_lines_decoded(struct dwarf_section * section,unsigned char * data,unsigned char * end)3467 display_debug_lines_decoded (struct dwarf_section *section,
3468 unsigned char *data,
3469 unsigned char *end)
3470 {
3471 static DWARF2_Internal_LineInfo saved_linfo;
3472 unsigned int initial_length_size;
3473 unsigned int offset_size;
3474
3475 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3476 section->name);
3477
3478 while (data < end)
3479 {
3480 /* This loop amounts to one iteration per compilation unit. */
3481 DWARF2_Internal_LineInfo linfo;
3482 unsigned char *standard_opcodes;
3483 unsigned char *end_of_sequence;
3484 int i;
3485 File_Entry *file_table = NULL;
3486 unsigned int n_files = 0;
3487 unsigned char **directory_table = NULL;
3488 unsigned int n_directories = 0;
3489
3490 if (const_strneq (section->name, ".debug_line.")
3491 /* Note: the following does not apply to .debug_line.dwo sections.
3492 These are full debug_line sections. */
3493 && strcmp (section->name, ".debug_line.dwo") != 0)
3494 {
3495 /* See comment in display_debug_lines_raw(). */
3496 end_of_sequence = end;
3497 standard_opcodes = NULL;
3498 linfo = saved_linfo;
3499 reset_state_machine (linfo.li_default_is_stmt);
3500 }
3501 else
3502 {
3503 unsigned char *hdrptr;
3504
3505 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3506 & end_of_sequence,
3507 & initial_length_size,
3508 & offset_size)) == NULL)
3509 return 0;
3510
3511 reset_state_machine (linfo.li_default_is_stmt);
3512
3513 /* Save a pointer to the contents of the Opcodes table. */
3514 standard_opcodes = hdrptr;
3515
3516 /* Traverse the Directory table just to count entries. */
3517 data = standard_opcodes + linfo.li_opcode_base - 1;
3518 if (*data != 0)
3519 {
3520 unsigned char *ptr_directory_table = data;
3521
3522 while (*data != 0)
3523 {
3524 data += strnlen ((char *) data, end - data) + 1;
3525 n_directories++;
3526 }
3527
3528 /* Go through the directory table again to save the directories. */
3529 directory_table = (unsigned char **)
3530 xmalloc (n_directories * sizeof (unsigned char *));
3531
3532 i = 0;
3533 while (*ptr_directory_table != 0)
3534 {
3535 directory_table[i] = ptr_directory_table;
3536 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3537 ptr_directory_table - end) + 1;
3538 i++;
3539 }
3540 }
3541 /* Skip the NUL at the end of the table. */
3542 data++;
3543
3544 /* Traverse the File Name table just to count the entries. */
3545 if (*data != 0)
3546 {
3547 unsigned char *ptr_file_name_table = data;
3548
3549 while (*data != 0)
3550 {
3551 unsigned int bytes_read;
3552
3553 /* Skip Name, directory index, last modification time and length
3554 of file. */
3555 data += strnlen ((char *) data, end - data) + 1;
3556 read_uleb128 (data, & bytes_read, end);
3557 data += bytes_read;
3558 read_uleb128 (data, & bytes_read, end);
3559 data += bytes_read;
3560 read_uleb128 (data, & bytes_read, end);
3561 data += bytes_read;
3562
3563 n_files++;
3564 }
3565
3566 /* Go through the file table again to save the strings. */
3567 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
3568
3569 i = 0;
3570 while (*ptr_file_name_table != 0)
3571 {
3572 unsigned int bytes_read;
3573
3574 file_table[i].name = ptr_file_name_table;
3575 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3576 end - ptr_file_name_table) + 1;
3577
3578 /* We are not interested in directory, time or size. */
3579 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3580 & bytes_read, end);
3581 ptr_file_name_table += bytes_read;
3582 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3583 & bytes_read, end);
3584 ptr_file_name_table += bytes_read;
3585 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3586 ptr_file_name_table += bytes_read;
3587 i++;
3588 }
3589 i = 0;
3590
3591 /* Print the Compilation Unit's name and a header. */
3592 if (directory_table == NULL)
3593 {
3594 printf (_("CU: %s:\n"), file_table[0].name);
3595 printf (_("File name Line number Starting address\n"));
3596 }
3597 else
3598 {
3599 unsigned int ix = file_table[0].directory_index;
3600 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
3601
3602 if (do_wide || strlen (directory) < 76)
3603 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3604 else
3605 printf ("%s:\n", file_table[0].name);
3606
3607 printf (_("File name Line number Starting address\n"));
3608 }
3609 }
3610
3611 /* Skip the NUL at the end of the table. */
3612 data++;
3613
3614 saved_linfo = linfo;
3615 }
3616
3617 /* This loop iterates through the Dwarf Line Number Program. */
3618 while (data < end_of_sequence)
3619 {
3620 unsigned char op_code;
3621 int adv;
3622 unsigned long int uladv;
3623 unsigned int bytes_read;
3624 int is_special_opcode = 0;
3625
3626 op_code = *data++;
3627
3628 if (op_code >= linfo.li_opcode_base)
3629 {
3630 op_code -= linfo.li_opcode_base;
3631 uladv = (op_code / linfo.li_line_range);
3632 if (linfo.li_max_ops_per_insn == 1)
3633 {
3634 uladv *= linfo.li_min_insn_length;
3635 state_machine_regs.address += uladv;
3636 }
3637 else
3638 {
3639 state_machine_regs.address
3640 += ((state_machine_regs.op_index + uladv)
3641 / linfo.li_max_ops_per_insn)
3642 * linfo.li_min_insn_length;
3643 state_machine_regs.op_index
3644 = (state_machine_regs.op_index + uladv)
3645 % linfo.li_max_ops_per_insn;
3646 }
3647
3648 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3649 state_machine_regs.line += adv;
3650 is_special_opcode = 1;
3651 }
3652 else switch (op_code)
3653 {
3654 case DW_LNS_extended_op:
3655 {
3656 unsigned int ext_op_code_len;
3657 unsigned char ext_op_code;
3658 unsigned char *op_code_data = data;
3659
3660 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3661 end_of_sequence);
3662 op_code_data += bytes_read;
3663
3664 if (ext_op_code_len == 0)
3665 {
3666 warn (_("Badly formed extended line op encountered!\n"));
3667 break;
3668 }
3669 ext_op_code_len += bytes_read;
3670 ext_op_code = *op_code_data++;
3671
3672 switch (ext_op_code)
3673 {
3674 case DW_LNE_end_sequence:
3675 reset_state_machine (linfo.li_default_is_stmt);
3676 break;
3677 case DW_LNE_set_address:
3678 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
3679 op_code_data,
3680 ext_op_code_len - bytes_read - 1,
3681 end);
3682 state_machine_regs.op_index = 0;
3683 break;
3684 case DW_LNE_define_file:
3685 {
3686 file_table = (File_Entry *) xrealloc
3687 (file_table, (n_files + 1) * sizeof (File_Entry));
3688
3689 ++state_machine_regs.last_file_entry;
3690 /* Source file name. */
3691 file_table[n_files].name = op_code_data;
3692 op_code_data += strlen ((char *) op_code_data) + 1;
3693 /* Directory index. */
3694 file_table[n_files].directory_index =
3695 read_uleb128 (op_code_data, & bytes_read,
3696 end_of_sequence);
3697 op_code_data += bytes_read;
3698 /* Last modification time. */
3699 file_table[n_files].modification_date =
3700 read_uleb128 (op_code_data, & bytes_read,
3701 end_of_sequence);
3702 op_code_data += bytes_read;
3703 /* File length. */
3704 file_table[n_files].length =
3705 read_uleb128 (op_code_data, & bytes_read,
3706 end_of_sequence);
3707
3708 n_files++;
3709 break;
3710 }
3711 case DW_LNE_set_discriminator:
3712 case DW_LNE_HP_set_sequence:
3713 /* Simply ignored. */
3714 break;
3715
3716 default:
3717 printf (_("UNKNOWN (%u): length %d\n"),
3718 ext_op_code, ext_op_code_len - bytes_read);
3719 break;
3720 }
3721 data += ext_op_code_len;
3722 break;
3723 }
3724 case DW_LNS_copy:
3725 break;
3726
3727 case DW_LNS_advance_pc:
3728 uladv = read_uleb128 (data, & bytes_read, end);
3729 data += bytes_read;
3730 if (linfo.li_max_ops_per_insn == 1)
3731 {
3732 uladv *= linfo.li_min_insn_length;
3733 state_machine_regs.address += uladv;
3734 }
3735 else
3736 {
3737 state_machine_regs.address
3738 += ((state_machine_regs.op_index + uladv)
3739 / linfo.li_max_ops_per_insn)
3740 * linfo.li_min_insn_length;
3741 state_machine_regs.op_index
3742 = (state_machine_regs.op_index + uladv)
3743 % linfo.li_max_ops_per_insn;
3744 }
3745 break;
3746
3747 case DW_LNS_advance_line:
3748 adv = read_sleb128 (data, & bytes_read, end);
3749 data += bytes_read;
3750 state_machine_regs.line += adv;
3751 break;
3752
3753 case DW_LNS_set_file:
3754 adv = read_uleb128 (data, & bytes_read, end);
3755 data += bytes_read;
3756 state_machine_regs.file = adv;
3757
3758 if (file_table == NULL)
3759 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3760 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3761 /* If directory index is 0, that means current directory. */
3762 printf ("\n./%s:[++]\n",
3763 file_table[state_machine_regs.file - 1].name);
3764 else if (directory_table == NULL)
3765 printf (_("\n [Use directory table entry %d]\n"),
3766 file_table[state_machine_regs.file - 1].directory_index - 1);
3767 else
3768 /* The directory index starts counting at 1. */
3769 printf ("\n%s/%s:\n",
3770 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3771 file_table[state_machine_regs.file - 1].name);
3772 break;
3773
3774 case DW_LNS_set_column:
3775 uladv = read_uleb128 (data, & bytes_read, end);
3776 data += bytes_read;
3777 state_machine_regs.column = uladv;
3778 break;
3779
3780 case DW_LNS_negate_stmt:
3781 adv = state_machine_regs.is_stmt;
3782 adv = ! adv;
3783 state_machine_regs.is_stmt = adv;
3784 break;
3785
3786 case DW_LNS_set_basic_block:
3787 state_machine_regs.basic_block = 1;
3788 break;
3789
3790 case DW_LNS_const_add_pc:
3791 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3792 if (linfo.li_max_ops_per_insn == 1)
3793 {
3794 uladv *= linfo.li_min_insn_length;
3795 state_machine_regs.address += uladv;
3796 }
3797 else
3798 {
3799 state_machine_regs.address
3800 += ((state_machine_regs.op_index + uladv)
3801 / linfo.li_max_ops_per_insn)
3802 * linfo.li_min_insn_length;
3803 state_machine_regs.op_index
3804 = (state_machine_regs.op_index + uladv)
3805 % linfo.li_max_ops_per_insn;
3806 }
3807 break;
3808
3809 case DW_LNS_fixed_advance_pc:
3810 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3811 state_machine_regs.address += uladv;
3812 state_machine_regs.op_index = 0;
3813 break;
3814
3815 case DW_LNS_set_prologue_end:
3816 break;
3817
3818 case DW_LNS_set_epilogue_begin:
3819 break;
3820
3821 case DW_LNS_set_isa:
3822 uladv = read_uleb128 (data, & bytes_read, end);
3823 data += bytes_read;
3824 printf (_(" Set ISA to %lu\n"), uladv);
3825 break;
3826
3827 default:
3828 printf (_(" Unknown opcode %d with operands: "), op_code);
3829
3830 if (standard_opcodes != NULL)
3831 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3832 {
3833 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3834 &bytes_read, end)),
3835 i == 1 ? "" : ", ");
3836 data += bytes_read;
3837 }
3838 putchar ('\n');
3839 break;
3840 }
3841
3842 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3843 to the DWARF address/line matrix. */
3844 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3845 || (op_code == DW_LNS_copy))
3846 {
3847 const unsigned int MAX_FILENAME_LENGTH = 35;
3848 char *fileName;
3849 char *newFileName = NULL;
3850 size_t fileNameLength;
3851
3852 if (file_table)
3853 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3854 else
3855 fileName = "<unknown>";
3856
3857 fileNameLength = strlen (fileName);
3858
3859 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3860 {
3861 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
3862 /* Truncate file name */
3863 strncpy (newFileName,
3864 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3865 MAX_FILENAME_LENGTH + 1);
3866 }
3867 else
3868 {
3869 newFileName = (char *) xmalloc (fileNameLength + 1);
3870 strncpy (newFileName, fileName, fileNameLength + 1);
3871 }
3872
3873 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3874 {
3875 if (linfo.li_max_ops_per_insn == 1)
3876 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3877 newFileName, state_machine_regs.line,
3878 state_machine_regs.address);
3879 else
3880 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3881 newFileName, state_machine_regs.line,
3882 state_machine_regs.address,
3883 state_machine_regs.op_index);
3884 }
3885 else
3886 {
3887 if (linfo.li_max_ops_per_insn == 1)
3888 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3889 newFileName, state_machine_regs.line,
3890 state_machine_regs.address);
3891 else
3892 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3893 newFileName, state_machine_regs.line,
3894 state_machine_regs.address,
3895 state_machine_regs.op_index);
3896 }
3897
3898 if (op_code == DW_LNE_end_sequence)
3899 printf ("\n");
3900
3901 free (newFileName);
3902 }
3903 }
3904
3905 if (file_table)
3906 {
3907 free (file_table);
3908 file_table = NULL;
3909 n_files = 0;
3910 }
3911
3912 if (directory_table)
3913 {
3914 free (directory_table);
3915 directory_table = NULL;
3916 n_directories = 0;
3917 }
3918
3919 putchar ('\n');
3920 }
3921
3922 return 1;
3923 }
3924
3925 static int
display_debug_lines(struct dwarf_section * section,void * file)3926 display_debug_lines (struct dwarf_section *section, void *file)
3927 {
3928 unsigned char *data = section->start;
3929 unsigned char *end = data + section->size;
3930 int retValRaw = 1;
3931 int retValDecoded = 1;
3932
3933 if (do_debug_lines == 0)
3934 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3935
3936 load_debug_section (line_str, file);
3937
3938 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
3939 retValRaw = display_debug_lines_raw (section, data, end);
3940
3941 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
3942 retValDecoded = display_debug_lines_decoded (section, data, end);
3943
3944 if (!retValRaw || !retValDecoded)
3945 return 0;
3946
3947 return 1;
3948 }
3949
3950 static debug_info *
find_debug_info_for_offset(unsigned long offset)3951 find_debug_info_for_offset (unsigned long offset)
3952 {
3953 unsigned int i;
3954
3955 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3956 return NULL;
3957
3958 for (i = 0; i < num_debug_info_entries; i++)
3959 if (debug_information[i].cu_offset == offset)
3960 return debug_information + i;
3961
3962 return NULL;
3963 }
3964
3965 static const char *
get_gdb_index_symbol_kind_name(gdb_index_symbol_kind kind)3966 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3967 {
3968 /* See gdb/gdb-index.h. */
3969 static const char * const kinds[] =
3970 {
3971 N_ ("no info"),
3972 N_ ("type"),
3973 N_ ("variable"),
3974 N_ ("function"),
3975 N_ ("other"),
3976 N_ ("unused5"),
3977 N_ ("unused6"),
3978 N_ ("unused7")
3979 };
3980
3981 return _ (kinds[kind]);
3982 }
3983
3984 static int
display_debug_pubnames_worker(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED,int is_gnu)3985 display_debug_pubnames_worker (struct dwarf_section *section,
3986 void *file ATTRIBUTE_UNUSED,
3987 int is_gnu)
3988 {
3989 DWARF2_Internal_PubNames names;
3990 unsigned char *start = section->start;
3991 unsigned char *end = start + section->size;
3992
3993 /* It does not matter if this load fails,
3994 we test for that later on. */
3995 load_debug_info (file);
3996
3997 printf (_("Contents of the %s section:\n\n"), section->name);
3998
3999 while (start < end)
4000 {
4001 unsigned char *data;
4002 unsigned long offset;
4003 unsigned int offset_size, initial_length_size;
4004
4005 data = start;
4006
4007 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
4008 if (names.pn_length == 0xffffffff)
4009 {
4010 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
4011 offset_size = 8;
4012 initial_length_size = 12;
4013 }
4014 else
4015 {
4016 offset_size = 4;
4017 initial_length_size = 4;
4018 }
4019
4020 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
4021 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
4022
4023 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4024 && num_debug_info_entries > 0
4025 && find_debug_info_for_offset (names.pn_offset) == NULL)
4026 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4027 (unsigned long) names.pn_offset, section->name);
4028
4029 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
4030
4031 start += names.pn_length + initial_length_size;
4032
4033 if (names.pn_version != 2 && names.pn_version != 3)
4034 {
4035 static int warned = 0;
4036
4037 if (! warned)
4038 {
4039 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4040 warned = 1;
4041 }
4042
4043 continue;
4044 }
4045
4046 printf (_(" Length: %ld\n"),
4047 (long) names.pn_length);
4048 printf (_(" Version: %d\n"),
4049 names.pn_version);
4050 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4051 (unsigned long) names.pn_offset);
4052 printf (_(" Size of area in .debug_info section: %ld\n"),
4053 (long) names.pn_size);
4054
4055 if (is_gnu)
4056 printf (_("\n Offset Kind Name\n"));
4057 else
4058 printf (_("\n Offset\tName\n"));
4059
4060 do
4061 {
4062 bfd_size_type maxprint;
4063
4064 SAFE_BYTE_GET (offset, data, offset_size, end);
4065
4066 if (offset != 0)
4067 {
4068 data += offset_size;
4069 if (data >= end)
4070 break;
4071 maxprint = (end - data) - 1;
4072
4073 if (is_gnu)
4074 {
4075 unsigned int kind_data;
4076 gdb_index_symbol_kind kind;
4077 const char *kind_name;
4078 int is_static;
4079
4080 SAFE_BYTE_GET (kind_data, data, 1, end);
4081 data++;
4082 maxprint --;
4083 /* GCC computes the kind as the upper byte in the CU index
4084 word, and then right shifts it by the CU index size.
4085 Left shift KIND to where the gdb-index.h accessor macros
4086 can use it. */
4087 kind_data <<= GDB_INDEX_CU_BITSIZE;
4088 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
4089 kind_name = get_gdb_index_symbol_kind_name (kind);
4090 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
4091 printf (" %-6lx %s,%-10s %.*s\n",
4092 offset, is_static ? _("s") : _("g"),
4093 kind_name, (int) maxprint, data);
4094 }
4095 else
4096 printf (" %-6lx\t%.*s\n", offset, (int) maxprint, data);
4097
4098 data += strnlen ((char *) data, maxprint) + 1;
4099 if (data >= end)
4100 break;
4101 }
4102 }
4103 while (offset != 0);
4104 }
4105
4106 printf ("\n");
4107 return 1;
4108 }
4109
4110 static int
display_debug_pubnames(struct dwarf_section * section,void * file)4111 display_debug_pubnames (struct dwarf_section *section, void *file)
4112 {
4113 return display_debug_pubnames_worker (section, file, 0);
4114 }
4115
4116 static int
display_debug_gnu_pubnames(struct dwarf_section * section,void * file)4117 display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
4118 {
4119 return display_debug_pubnames_worker (section, file, 1);
4120 }
4121
4122 static int
display_debug_macinfo(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)4123 display_debug_macinfo (struct dwarf_section *section,
4124 void *file ATTRIBUTE_UNUSED)
4125 {
4126 unsigned char *start = section->start;
4127 unsigned char *end = start + section->size;
4128 unsigned char *curr = start;
4129 unsigned int bytes_read;
4130 enum dwarf_macinfo_record_type op;
4131
4132 printf (_("Contents of the %s section:\n\n"), section->name);
4133
4134 while (curr < end)
4135 {
4136 unsigned int lineno;
4137 const unsigned char *string;
4138
4139 op = (enum dwarf_macinfo_record_type) *curr;
4140 curr++;
4141
4142 switch (op)
4143 {
4144 case DW_MACINFO_start_file:
4145 {
4146 unsigned int filenum;
4147
4148 lineno = read_uleb128 (curr, & bytes_read, end);
4149 curr += bytes_read;
4150 filenum = read_uleb128 (curr, & bytes_read, end);
4151 curr += bytes_read;
4152
4153 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4154 lineno, filenum);
4155 }
4156 break;
4157
4158 case DW_MACINFO_end_file:
4159 printf (_(" DW_MACINFO_end_file\n"));
4160 break;
4161
4162 case DW_MACINFO_define:
4163 lineno = read_uleb128 (curr, & bytes_read, end);
4164 curr += bytes_read;
4165 string = curr;
4166 curr += strnlen ((char *) string, end - string) + 1;
4167 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4168 lineno, string);
4169 break;
4170
4171 case DW_MACINFO_undef:
4172 lineno = read_uleb128 (curr, & bytes_read, end);
4173 curr += bytes_read;
4174 string = curr;
4175 curr += strnlen ((char *) string, end - string) + 1;
4176 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4177 lineno, string);
4178 break;
4179
4180 case DW_MACINFO_vendor_ext:
4181 {
4182 unsigned int constant;
4183
4184 constant = read_uleb128 (curr, & bytes_read, end);
4185 curr += bytes_read;
4186 string = curr;
4187 curr += strnlen ((char *) string, end - string) + 1;
4188 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4189 constant, string);
4190 }
4191 break;
4192 }
4193 }
4194
4195 return 1;
4196 }
4197
4198 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4199 filename and dirname corresponding to file name table entry with index
4200 FILEIDX. Return NULL on failure. */
4201
4202 static unsigned char *
get_line_filename_and_dirname(dwarf_vma line_offset,dwarf_vma fileidx,unsigned char ** dir_name)4203 get_line_filename_and_dirname (dwarf_vma line_offset,
4204 dwarf_vma fileidx,
4205 unsigned char **dir_name)
4206 {
4207 struct dwarf_section *section = &debug_displays [line].section;
4208 unsigned char *hdrptr, *dirtable, *file_name;
4209 unsigned int offset_size, initial_length_size;
4210 unsigned int version, opcode_base, bytes_read;
4211 dwarf_vma length, diridx;
4212 const unsigned char * end;
4213
4214 *dir_name = NULL;
4215 if (section->start == NULL
4216 || line_offset >= section->size
4217 || fileidx == 0)
4218 return NULL;
4219
4220 hdrptr = section->start + line_offset;
4221 end = section->start + section->size;
4222
4223 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4224 if (length == 0xffffffff)
4225 {
4226 /* This section is 64-bit DWARF 3. */
4227 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4228 offset_size = 8;
4229 initial_length_size = 12;
4230 }
4231 else
4232 {
4233 offset_size = 4;
4234 initial_length_size = 4;
4235 }
4236 if (length + initial_length_size > section->size)
4237 return NULL;
4238
4239 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4240 if (version != 2 && version != 3 && version != 4)
4241 return NULL;
4242 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
4243 if (version >= 4)
4244 hdrptr++; /* Skip max_ops_per_insn. */
4245 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
4246
4247 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4248 if (opcode_base == 0)
4249 return NULL;
4250
4251 hdrptr += opcode_base - 1;
4252 dirtable = hdrptr;
4253 /* Skip over dirname table. */
4254 while (*hdrptr != '\0')
4255 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4256 hdrptr++; /* Skip the NUL at the end of the table. */
4257 /* Now skip over preceding filename table entries. */
4258 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
4259 {
4260 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4261 read_uleb128 (hdrptr, &bytes_read, end);
4262 hdrptr += bytes_read;
4263 read_uleb128 (hdrptr, &bytes_read, end);
4264 hdrptr += bytes_read;
4265 read_uleb128 (hdrptr, &bytes_read, end);
4266 hdrptr += bytes_read;
4267 }
4268 if (hdrptr == end || *hdrptr == '\0')
4269 return NULL;
4270 file_name = hdrptr;
4271 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4272 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4273 if (diridx == 0)
4274 return file_name;
4275 for (; *dirtable != '\0' && diridx > 1; diridx--)
4276 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4277 if (*dirtable == '\0')
4278 return NULL;
4279 *dir_name = dirtable;
4280 return file_name;
4281 }
4282
4283 static int
display_debug_macro(struct dwarf_section * section,void * file)4284 display_debug_macro (struct dwarf_section *section,
4285 void *file)
4286 {
4287 unsigned char *start = section->start;
4288 unsigned char *end = start + section->size;
4289 unsigned char *curr = start;
4290 unsigned char *extended_op_buf[256];
4291 unsigned int bytes_read;
4292
4293 load_debug_section (str, file);
4294 load_debug_section (line, file);
4295
4296 printf (_("Contents of the %s section:\n\n"), section->name);
4297
4298 while (curr < end)
4299 {
4300 unsigned int lineno, version, flags;
4301 unsigned int offset_size = 4;
4302 const unsigned char *string;
4303 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4304 unsigned char **extended_ops = NULL;
4305
4306 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4307 if (version != 4)
4308 {
4309 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4310 section->name);
4311 return 0;
4312 }
4313
4314 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4315 if (flags & 1)
4316 offset_size = 8;
4317 printf (_(" Offset: 0x%lx\n"),
4318 (unsigned long) sec_offset);
4319 printf (_(" Version: %d\n"), version);
4320 printf (_(" Offset size: %d\n"), offset_size);
4321 if (flags & 2)
4322 {
4323 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4324 printf (_(" Offset into .debug_line: 0x%lx\n"),
4325 (unsigned long) line_offset);
4326 }
4327 if (flags & 4)
4328 {
4329 unsigned int i, count, op;
4330 dwarf_vma nargs, n;
4331
4332 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
4333
4334 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4335 extended_ops = extended_op_buf;
4336 if (count)
4337 {
4338 printf (_(" Extension opcode arguments:\n"));
4339 for (i = 0; i < count; i++)
4340 {
4341 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4342 extended_ops[op] = curr;
4343 nargs = read_uleb128 (curr, &bytes_read, end);
4344 curr += bytes_read;
4345 if (nargs == 0)
4346 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4347 else
4348 {
4349 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4350 for (n = 0; n < nargs; n++)
4351 {
4352 unsigned int form;
4353
4354 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4355 printf ("%s%s", get_FORM_name (form),
4356 n == nargs - 1 ? "\n" : ", ");
4357 switch (form)
4358 {
4359 case DW_FORM_data1:
4360 case DW_FORM_data2:
4361 case DW_FORM_data4:
4362 case DW_FORM_data8:
4363 case DW_FORM_sdata:
4364 case DW_FORM_udata:
4365 case DW_FORM_block:
4366 case DW_FORM_block1:
4367 case DW_FORM_block2:
4368 case DW_FORM_block4:
4369 case DW_FORM_flag:
4370 case DW_FORM_string:
4371 case DW_FORM_strp:
4372 case DW_FORM_sec_offset:
4373 break;
4374 default:
4375 error (_("Invalid extension opcode form %s\n"),
4376 get_FORM_name (form));
4377 return 0;
4378 }
4379 }
4380 }
4381 }
4382 }
4383 }
4384 printf ("\n");
4385
4386 while (1)
4387 {
4388 unsigned int op;
4389
4390 if (curr >= end)
4391 {
4392 error (_(".debug_macro section not zero terminated\n"));
4393 return 0;
4394 }
4395
4396 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4397 if (op == 0)
4398 break;
4399
4400 switch (op)
4401 {
4402 case DW_MACRO_GNU_start_file:
4403 {
4404 unsigned int filenum;
4405 unsigned char *file_name = NULL, *dir_name = NULL;
4406
4407 lineno = read_uleb128 (curr, &bytes_read, end);
4408 curr += bytes_read;
4409 filenum = read_uleb128 (curr, &bytes_read, end);
4410 curr += bytes_read;
4411
4412 if ((flags & 2) == 0)
4413 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4414 else
4415 file_name
4416 = get_line_filename_and_dirname (line_offset, filenum,
4417 &dir_name);
4418 if (file_name == NULL)
4419 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4420 lineno, filenum);
4421 else
4422 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4423 lineno, filenum,
4424 dir_name != NULL ? (const char *) dir_name : "",
4425 dir_name != NULL ? "/" : "", file_name);
4426 }
4427 break;
4428
4429 case DW_MACRO_GNU_end_file:
4430 printf (_(" DW_MACRO_GNU_end_file\n"));
4431 break;
4432
4433 case DW_MACRO_GNU_define:
4434 lineno = read_uleb128 (curr, &bytes_read, end);
4435 curr += bytes_read;
4436 string = curr;
4437 curr += strnlen ((char *) string, end - string) + 1;
4438 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4439 lineno, string);
4440 break;
4441
4442 case DW_MACRO_GNU_undef:
4443 lineno = read_uleb128 (curr, &bytes_read, end);
4444 curr += bytes_read;
4445 string = curr;
4446 curr += strnlen ((char *) string, end - string) + 1;
4447 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4448 lineno, string);
4449 break;
4450
4451 case DW_MACRO_GNU_define_indirect:
4452 lineno = read_uleb128 (curr, &bytes_read, end);
4453 curr += bytes_read;
4454 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4455 string = fetch_indirect_string (offset);
4456 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4457 lineno, string);
4458 break;
4459
4460 case DW_MACRO_GNU_undef_indirect:
4461 lineno = read_uleb128 (curr, &bytes_read, end);
4462 curr += bytes_read;
4463 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4464 string = fetch_indirect_string (offset);
4465 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4466 lineno, string);
4467 break;
4468
4469 case DW_MACRO_GNU_transparent_include:
4470 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4471 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4472 (unsigned long) offset);
4473 break;
4474
4475 case DW_MACRO_GNU_define_indirect_alt:
4476 lineno = read_uleb128 (curr, &bytes_read, end);
4477 curr += bytes_read;
4478 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4479 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4480 lineno, (unsigned long) offset);
4481 break;
4482
4483 case DW_MACRO_GNU_undef_indirect_alt:
4484 lineno = read_uleb128 (curr, &bytes_read, end);
4485 curr += bytes_read;
4486 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4487 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4488 lineno, (unsigned long) offset);
4489 break;
4490
4491 case DW_MACRO_GNU_transparent_include_alt:
4492 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4493 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4494 (unsigned long) offset);
4495 break;
4496
4497 default:
4498 if (extended_ops == NULL || extended_ops[op] == NULL)
4499 {
4500 error (_(" Unknown macro opcode %02x seen\n"), op);
4501 return 0;
4502 }
4503 else
4504 {
4505 /* Skip over unhandled opcodes. */
4506 dwarf_vma nargs, n;
4507 unsigned char *desc = extended_ops[op];
4508 nargs = read_uleb128 (desc, &bytes_read, end);
4509 desc += bytes_read;
4510 if (nargs == 0)
4511 {
4512 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4513 break;
4514 }
4515 printf (_(" DW_MACRO_GNU_%02x -"), op);
4516 for (n = 0; n < nargs; n++)
4517 {
4518 int val;
4519
4520 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4521 curr
4522 = read_and_display_attr_value (0, val,
4523 curr, end, 0, 0, offset_size,
4524 version, NULL, 0, NULL,
4525 NULL);
4526 if (n != nargs - 1)
4527 printf (",");
4528 }
4529 printf ("\n");
4530 }
4531 break;
4532 }
4533 }
4534
4535 printf ("\n");
4536 }
4537
4538 return 1;
4539 }
4540
4541 static int
display_debug_abbrev(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)4542 display_debug_abbrev (struct dwarf_section *section,
4543 void *file ATTRIBUTE_UNUSED)
4544 {
4545 abbrev_entry *entry;
4546 unsigned char *start = section->start;
4547 unsigned char *end = start + section->size;
4548
4549 printf (_("Contents of the %s section:\n\n"), section->name);
4550
4551 do
4552 {
4553 unsigned char *last;
4554
4555 free_abbrevs ();
4556
4557 last = start;
4558 start = process_abbrev_section (start, end);
4559
4560 if (first_abbrev == NULL)
4561 continue;
4562
4563 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
4564
4565 for (entry = first_abbrev; entry; entry = entry->next)
4566 {
4567 abbrev_attr *attr;
4568
4569 printf (" %ld %s [%s]\n",
4570 entry->entry,
4571 get_TAG_name (entry->tag),
4572 entry->children ? _("has children") : _("no children"));
4573
4574 for (attr = entry->first_attr; attr; attr = attr->next)
4575 printf (" %-18s %s\n",
4576 get_AT_name (attr->attribute),
4577 get_FORM_name (attr->form));
4578 }
4579 }
4580 while (start);
4581
4582 printf ("\n");
4583
4584 return 1;
4585 }
4586
4587 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4588
4589 static void
display_loc_list(struct dwarf_section * section,unsigned char ** start_ptr,int debug_info_entry,unsigned long offset,unsigned long base_address,int has_frame_base)4590 display_loc_list (struct dwarf_section *section,
4591 unsigned char **start_ptr,
4592 int debug_info_entry,
4593 unsigned long offset,
4594 unsigned long base_address,
4595 int has_frame_base)
4596 {
4597 unsigned char *start = *start_ptr;
4598 unsigned char *section_end = section->start + section->size;
4599 unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
4600 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
4601 unsigned int offset_size = debug_information [debug_info_entry].offset_size;
4602 int dwarf_version = debug_information [debug_info_entry].dwarf_version;
4603
4604 dwarf_vma begin;
4605 dwarf_vma end;
4606 unsigned short length;
4607 int need_frame_base;
4608
4609 if (pointer_size < 2 || pointer_size > 8)
4610 {
4611 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4612 pointer_size, debug_info_entry);
4613 return;
4614 }
4615
4616 while (1)
4617 {
4618 if (start + 2 * pointer_size > section_end)
4619 {
4620 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4621 offset);
4622 break;
4623 }
4624
4625 printf (" %8.8lx ", offset + (start - *start_ptr));
4626
4627 /* Note: we use sign extension here in order to be sure that we can detect
4628 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4629 address will not affect the values that we display since we always show
4630 hex values, and always the bottom 32-bits. */
4631 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4632 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4633
4634 if (begin == 0 && end == 0)
4635 {
4636 printf (_("<End of list>\n"));
4637 break;
4638 }
4639
4640 /* Check base address specifiers. */
4641 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4642 {
4643 base_address = end;
4644 print_dwarf_vma (begin, pointer_size);
4645 print_dwarf_vma (end, pointer_size);
4646 printf (_("(base address)\n"));
4647 continue;
4648 }
4649
4650 if (start + 2 > section_end)
4651 {
4652 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4653 offset);
4654 break;
4655 }
4656
4657 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4658
4659 if (start + length > section_end)
4660 {
4661 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4662 offset);
4663 break;
4664 }
4665
4666 print_dwarf_vma (begin + base_address, pointer_size);
4667 print_dwarf_vma (end + base_address, pointer_size);
4668
4669 putchar ('(');
4670 need_frame_base = decode_location_expression (start,
4671 pointer_size,
4672 offset_size,
4673 dwarf_version,
4674 length,
4675 cu_offset, section);
4676 putchar (')');
4677
4678 if (need_frame_base && !has_frame_base)
4679 printf (_(" [without DW_AT_frame_base]"));
4680
4681 if (begin == end)
4682 fputs (_(" (start == end)"), stdout);
4683 else if (begin > end)
4684 fputs (_(" (start > end)"), stdout);
4685
4686 putchar ('\n');
4687
4688 start += length;
4689 }
4690
4691 *start_ptr = start;
4692 }
4693
4694 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4695 right-adjusted in a field of length LEN, and followed by a space. */
4696
4697 static void
print_addr_index(unsigned int idx,unsigned int len)4698 print_addr_index (unsigned int idx, unsigned int len)
4699 {
4700 static char buf[15];
4701 snprintf (buf, sizeof (buf), "[%d]", idx);
4702 printf ("%*s ", len, buf);
4703 }
4704
4705 /* Display a location list from a .dwo section. It uses address indexes rather
4706 than embedded addresses. This code closely follows display_loc_list, but the
4707 two are sufficiently different that combining things is very ugly. */
4708
4709 static void
display_loc_list_dwo(struct dwarf_section * section,unsigned char ** start_ptr,int debug_info_entry,unsigned long offset,int has_frame_base)4710 display_loc_list_dwo (struct dwarf_section *section,
4711 unsigned char **start_ptr,
4712 int debug_info_entry,
4713 unsigned long offset,
4714 int has_frame_base)
4715 {
4716 unsigned char *start = *start_ptr;
4717 unsigned char *section_end = section->start + section->size;
4718 unsigned long cu_offset = debug_information [debug_info_entry].cu_offset;
4719 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
4720 unsigned int offset_size = debug_information [debug_info_entry].offset_size;
4721 int dwarf_version = debug_information [debug_info_entry].dwarf_version;
4722 int entry_type;
4723 unsigned short length;
4724 int need_frame_base;
4725 unsigned int idx;
4726 unsigned int bytes_read;
4727
4728 if (pointer_size < 2 || pointer_size > 8)
4729 {
4730 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4731 pointer_size, debug_info_entry);
4732 return;
4733 }
4734
4735 while (1)
4736 {
4737 printf (" %8.8lx ", offset + (start - *start_ptr));
4738
4739 if (start >= section_end)
4740 {
4741 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4742 offset);
4743 break;
4744 }
4745
4746 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4747 switch (entry_type)
4748 {
4749 case 0: /* A terminating entry. */
4750 *start_ptr = start;
4751 printf (_("<End of list>\n"));
4752 return;
4753 case 1: /* A base-address entry. */
4754 idx = read_uleb128 (start, &bytes_read, section_end);
4755 start += bytes_read;
4756 print_addr_index (idx, 8);
4757 printf (" ");
4758 printf (_("(base address selection entry)\n"));
4759 continue;
4760 case 2: /* A start/end entry. */
4761 idx = read_uleb128 (start, &bytes_read, section_end);
4762 start += bytes_read;
4763 print_addr_index (idx, 8);
4764 idx = read_uleb128 (start, &bytes_read, section_end);
4765 start += bytes_read;
4766 print_addr_index (idx, 8);
4767 break;
4768 case 3: /* A start/length entry. */
4769 idx = read_uleb128 (start, &bytes_read, section_end);
4770 start += bytes_read;
4771 print_addr_index (idx, 8);
4772 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4773 printf ("%08x ", idx);
4774 break;
4775 case 4: /* An offset pair entry. */
4776 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4777 printf ("%08x ", idx);
4778 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
4779 printf ("%08x ", idx);
4780 break;
4781 default:
4782 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4783 *start_ptr = start;
4784 return;
4785 }
4786
4787 if (start + 2 > section_end)
4788 {
4789 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4790 offset);
4791 break;
4792 }
4793
4794 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4795 if (start + length > section_end)
4796 {
4797 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4798 offset);
4799 break;
4800 }
4801
4802 putchar ('(');
4803 need_frame_base = decode_location_expression (start,
4804 pointer_size,
4805 offset_size,
4806 dwarf_version,
4807 length,
4808 cu_offset, section);
4809 putchar (')');
4810
4811 if (need_frame_base && !has_frame_base)
4812 printf (_(" [without DW_AT_frame_base]"));
4813
4814 putchar ('\n');
4815
4816 start += length;
4817 }
4818
4819 *start_ptr = start;
4820 }
4821
4822 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4823
4824 static dwarf_vma *loc_offsets;
4825
4826 static int
loc_offsets_compar(const void * ap,const void * bp)4827 loc_offsets_compar (const void *ap, const void *bp)
4828 {
4829 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4830 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4831
4832 return (a > b) - (b > a);
4833 }
4834
4835 static int
display_debug_loc(struct dwarf_section * section,void * file)4836 display_debug_loc (struct dwarf_section *section, void *file)
4837 {
4838 unsigned char *start = section->start;
4839 unsigned long bytes;
4840 unsigned char *section_begin = start;
4841 unsigned int num_loc_list = 0;
4842 unsigned long last_offset = 0;
4843 unsigned int first = 0;
4844 unsigned int i;
4845 unsigned int j;
4846 unsigned int k;
4847 int seen_first_offset = 0;
4848 int locs_sorted = 1;
4849 unsigned char *next;
4850 unsigned int *array = NULL;
4851 const char *suffix = strrchr (section->name, '.');
4852 int is_dwo = 0;
4853
4854 if (suffix && strcmp (suffix, ".dwo") == 0)
4855 is_dwo = 1;
4856
4857 bytes = section->size;
4858
4859 if (bytes == 0)
4860 {
4861 printf (_("\nThe %s section is empty.\n"), section->name);
4862 return 0;
4863 }
4864
4865 if (load_debug_info (file) == 0)
4866 {
4867 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4868 section->name);
4869 return 0;
4870 }
4871
4872 /* Check the order of location list in .debug_info section. If
4873 offsets of location lists are in the ascending order, we can
4874 use `debug_information' directly. */
4875 for (i = 0; i < num_debug_info_entries; i++)
4876 {
4877 unsigned int num;
4878
4879 num = debug_information [i].num_loc_offsets;
4880 if (num > num_loc_list)
4881 num_loc_list = num;
4882
4883 /* Check if we can use `debug_information' directly. */
4884 if (locs_sorted && num != 0)
4885 {
4886 if (!seen_first_offset)
4887 {
4888 /* This is the first location list. */
4889 last_offset = debug_information [i].loc_offsets [0];
4890 first = i;
4891 seen_first_offset = 1;
4892 j = 1;
4893 }
4894 else
4895 j = 0;
4896
4897 for (; j < num; j++)
4898 {
4899 if (last_offset >
4900 debug_information [i].loc_offsets [j])
4901 {
4902 locs_sorted = 0;
4903 break;
4904 }
4905 last_offset = debug_information [i].loc_offsets [j];
4906 }
4907 }
4908 }
4909
4910 if (!seen_first_offset)
4911 error (_("No location lists in .debug_info section!\n"));
4912
4913 if (debug_information [first].num_loc_offsets > 0
4914 && debug_information [first].loc_offsets [0] != 0)
4915 warn (_("Location lists in %s section start at 0x%s\n"),
4916 section->name,
4917 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
4918
4919 if (!locs_sorted)
4920 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
4921 printf (_("Contents of the %s section:\n\n"), section->name);
4922 printf (_(" Offset Begin End Expression\n"));
4923
4924 seen_first_offset = 0;
4925 for (i = first; i < num_debug_info_entries; i++)
4926 {
4927 unsigned long offset;
4928 unsigned long base_address;
4929 int has_frame_base;
4930
4931 if (!locs_sorted)
4932 {
4933 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4934 array[k] = k;
4935 loc_offsets = debug_information [i].loc_offsets;
4936 qsort (array, debug_information [i].num_loc_offsets,
4937 sizeof (*array), loc_offsets_compar);
4938 }
4939
4940 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4941 {
4942 j = locs_sorted ? k : array[k];
4943 if (k
4944 && debug_information [i].loc_offsets [locs_sorted
4945 ? k - 1 : array [k - 1]]
4946 == debug_information [i].loc_offsets [j])
4947 continue;
4948 has_frame_base = debug_information [i].have_frame_base [j];
4949 offset = debug_information [i].loc_offsets [j];
4950 next = section_begin + offset;
4951 base_address = debug_information [i].base_address;
4952
4953 if (!seen_first_offset)
4954 seen_first_offset = 1;
4955 else
4956 {
4957 if (start < next)
4958 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4959 (unsigned long) (start - section_begin),
4960 (unsigned long) (next - section_begin));
4961 else if (start > next)
4962 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4963 (unsigned long) (start - section_begin),
4964 (unsigned long) (next - section_begin));
4965 }
4966 start = next;
4967
4968 if (offset >= bytes)
4969 {
4970 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4971 offset);
4972 continue;
4973 }
4974
4975 if (is_dwo)
4976 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4977 else
4978 display_loc_list (section, &start, i, offset, base_address,
4979 has_frame_base);
4980 }
4981 }
4982
4983 if (start < section->start + section->size)
4984 warn (_("There are %ld unused bytes at the end of section %s\n"),
4985 (long) (section->start + section->size - start), section->name);
4986 putchar ('\n');
4987 free (array);
4988 return 1;
4989 }
4990
4991 static int
display_debug_str(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)4992 display_debug_str (struct dwarf_section *section,
4993 void *file ATTRIBUTE_UNUSED)
4994 {
4995 unsigned char *start = section->start;
4996 unsigned long bytes = section->size;
4997 dwarf_vma addr = section->address;
4998
4999 if (bytes == 0)
5000 {
5001 printf (_("\nThe %s section is empty.\n"), section->name);
5002 return 0;
5003 }
5004
5005 printf (_("Contents of the %s section:\n\n"), section->name);
5006
5007 while (bytes)
5008 {
5009 int j;
5010 int k;
5011 int lbytes;
5012
5013 lbytes = (bytes > 16 ? 16 : bytes);
5014
5015 printf (" 0x%8.8lx ", (unsigned long) addr);
5016
5017 for (j = 0; j < 16; j++)
5018 {
5019 if (j < lbytes)
5020 printf ("%2.2x", start[j]);
5021 else
5022 printf (" ");
5023
5024 if ((j & 3) == 3)
5025 printf (" ");
5026 }
5027
5028 for (j = 0; j < lbytes; j++)
5029 {
5030 k = start[j];
5031 if (k >= ' ' && k < 0x80)
5032 printf ("%c", k);
5033 else
5034 printf (".");
5035 }
5036
5037 putchar ('\n');
5038
5039 start += lbytes;
5040 addr += lbytes;
5041 bytes -= lbytes;
5042 }
5043
5044 putchar ('\n');
5045
5046 return 1;
5047 }
5048
5049 static int
display_debug_info(struct dwarf_section * section,void * file)5050 display_debug_info (struct dwarf_section *section, void *file)
5051 {
5052 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
5053 }
5054
5055 static int
display_debug_types(struct dwarf_section * section,void * file)5056 display_debug_types (struct dwarf_section *section, void *file)
5057 {
5058 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
5059 }
5060
5061 static int
display_trace_info(struct dwarf_section * section,void * file)5062 display_trace_info (struct dwarf_section *section, void *file)
5063 {
5064 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
5065 }
5066
5067 static int
display_debug_aranges(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)5068 display_debug_aranges (struct dwarf_section *section,
5069 void *file ATTRIBUTE_UNUSED)
5070 {
5071 unsigned char *start = section->start;
5072 unsigned char *end = start + section->size;
5073
5074 printf (_("Contents of the %s section:\n\n"), section->name);
5075
5076 /* It does not matter if this load fails,
5077 we test for that later on. */
5078 load_debug_info (file);
5079
5080 while (start < end)
5081 {
5082 unsigned char *hdrptr;
5083 DWARF2_Internal_ARange arange;
5084 unsigned char *addr_ranges;
5085 dwarf_vma length;
5086 dwarf_vma address;
5087 unsigned char address_size;
5088 int excess;
5089 unsigned int offset_size;
5090 unsigned int initial_length_size;
5091
5092 hdrptr = start;
5093
5094 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
5095 if (arange.ar_length == 0xffffffff)
5096 {
5097 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
5098 offset_size = 8;
5099 initial_length_size = 12;
5100 }
5101 else
5102 {
5103 offset_size = 4;
5104 initial_length_size = 4;
5105 }
5106
5107 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
5108 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
5109
5110 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
5111 && num_debug_info_entries > 0
5112 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
5113 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5114 (unsigned long) arange.ar_info_offset, section->name);
5115
5116 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
5117 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
5118
5119 if (arange.ar_version != 2 && arange.ar_version != 3)
5120 {
5121 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
5122 break;
5123 }
5124
5125 printf (_(" Length: %ld\n"),
5126 (long) arange.ar_length);
5127 printf (_(" Version: %d\n"), arange.ar_version);
5128 printf (_(" Offset into .debug_info: 0x%lx\n"),
5129 (unsigned long) arange.ar_info_offset);
5130 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
5131 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
5132
5133 address_size = arange.ar_pointer_size + arange.ar_segment_size;
5134
5135 /* PR 17512: file: 001-108546-0.001:0.1. */
5136 if (address_size == 0 || address_size > 8)
5137 {
5138 error (_("Invalid address size in %s section!\n"),
5139 section->name);
5140 break;
5141 }
5142
5143 /* The DWARF spec does not require that the address size be a power
5144 of two, but we do. This will have to change if we ever encounter
5145 an uneven architecture. */
5146 if ((address_size & (address_size - 1)) != 0)
5147 {
5148 warn (_("Pointer size + Segment size is not a power of two.\n"));
5149 break;
5150 }
5151
5152 if (address_size > 4)
5153 printf (_("\n Address Length\n"));
5154 else
5155 printf (_("\n Address Length\n"));
5156
5157 addr_ranges = hdrptr;
5158
5159 /* Must pad to an alignment boundary that is twice the address size. */
5160 excess = (hdrptr - start) % (2 * address_size);
5161 if (excess)
5162 addr_ranges += (2 * address_size) - excess;
5163
5164 start += arange.ar_length + initial_length_size;
5165
5166 while (addr_ranges + 2 * address_size <= start)
5167 {
5168 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
5169 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
5170
5171 printf (" ");
5172 print_dwarf_vma (address, address_size);
5173 print_dwarf_vma (length, address_size);
5174 putchar ('\n');
5175 }
5176 }
5177
5178 printf ("\n");
5179
5180 return 1;
5181 }
5182
5183 /* Comparison function for qsort. */
5184 static int
comp_addr_base(const void * v0,const void * v1)5185 comp_addr_base (const void * v0, const void * v1)
5186 {
5187 debug_info * info0 = (debug_info *) v0;
5188 debug_info * info1 = (debug_info *) v1;
5189 return info0->addr_base - info1->addr_base;
5190 }
5191
5192 /* Display the debug_addr section. */
5193 static int
display_debug_addr(struct dwarf_section * section,void * file)5194 display_debug_addr (struct dwarf_section *section,
5195 void *file)
5196 {
5197 debug_info **debug_addr_info;
5198 unsigned char *entry;
5199 unsigned char *end;
5200 unsigned int i;
5201 unsigned int count;
5202
5203 if (section->size == 0)
5204 {
5205 printf (_("\nThe %s section is empty.\n"), section->name);
5206 return 0;
5207 }
5208
5209 if (load_debug_info (file) == 0)
5210 {
5211 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5212 section->name);
5213 return 0;
5214 }
5215
5216 printf (_("Contents of the %s section:\n\n"), section->name);
5217
5218 debug_addr_info = (debug_info **) xmalloc ((num_debug_info_entries + 1)
5219 * sizeof (debug_info *));
5220
5221 count = 0;
5222 for (i = 0; i < num_debug_info_entries; i++)
5223 {
5224 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
5225 debug_addr_info [count++] = &debug_information [i];
5226 }
5227
5228 /* Add a sentinel to make iteration convenient. */
5229 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5230 debug_addr_info [count]->addr_base = section->size;
5231
5232 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
5233 for (i = 0; i < count; i++)
5234 {
5235 unsigned int idx;
5236 unsigned int address_size = debug_addr_info [i]->pointer_size;
5237
5238 printf (_(" For compilation unit at offset 0x%s:\n"),
5239 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5240
5241 printf (_("\tIndex\tAddress\n"));
5242 entry = section->start + debug_addr_info [i]->addr_base;
5243 end = section->start + debug_addr_info [i + 1]->addr_base;
5244 idx = 0;
5245 while (entry < end)
5246 {
5247 dwarf_vma base = byte_get (entry, address_size);
5248 printf (_("\t%d:\t"), idx);
5249 print_dwarf_vma (base, address_size);
5250 printf ("\n");
5251 entry += address_size;
5252 idx++;
5253 }
5254 }
5255 printf ("\n");
5256
5257 free (debug_addr_info);
5258 return 1;
5259 }
5260
5261 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5262 static int
display_debug_str_offsets(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)5263 display_debug_str_offsets (struct dwarf_section *section,
5264 void *file ATTRIBUTE_UNUSED)
5265 {
5266 if (section->size == 0)
5267 {
5268 printf (_("\nThe %s section is empty.\n"), section->name);
5269 return 0;
5270 }
5271 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5272 what the offset size is for this section. */
5273 return 1;
5274 }
5275
5276 /* Each debug_information[x].range_lists[y] gets this representation for
5277 sorting purposes. */
5278
5279 struct range_entry
5280 {
5281 /* The debug_information[x].range_lists[y] value. */
5282 unsigned long ranges_offset;
5283
5284 /* Original debug_information to find parameters of the data. */
5285 debug_info *debug_info_p;
5286 };
5287
5288 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5289
5290 static int
range_entry_compar(const void * ap,const void * bp)5291 range_entry_compar (const void *ap, const void *bp)
5292 {
5293 const struct range_entry *a_re = (const struct range_entry *) ap;
5294 const struct range_entry *b_re = (const struct range_entry *) bp;
5295 const unsigned long a = a_re->ranges_offset;
5296 const unsigned long b = b_re->ranges_offset;
5297
5298 return (a > b) - (b > a);
5299 }
5300
5301 static int
display_debug_ranges(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)5302 display_debug_ranges (struct dwarf_section *section,
5303 void *file ATTRIBUTE_UNUSED)
5304 {
5305 unsigned char *start = section->start;
5306 unsigned char *last_start = start;
5307 unsigned long bytes = section->size;
5308 unsigned char *section_begin = start;
5309 unsigned char *finish = start + bytes;
5310 unsigned int num_range_list, i;
5311 struct range_entry *range_entries, *range_entry_fill;
5312
5313 if (bytes == 0)
5314 {
5315 printf (_("\nThe %s section is empty.\n"), section->name);
5316 return 0;
5317 }
5318
5319 if (load_debug_info (file) == 0)
5320 {
5321 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5322 section->name);
5323 return 0;
5324 }
5325
5326 num_range_list = 0;
5327 for (i = 0; i < num_debug_info_entries; i++)
5328 num_range_list += debug_information [i].num_range_lists;
5329
5330 if (num_range_list == 0)
5331 {
5332 /* This can happen when the file was compiled with -gsplit-debug
5333 which removes references to range lists from the primary .o file. */
5334 printf (_("No range lists in .debug_info section.\n"));
5335 return 1;
5336 }
5337
5338 range_entries = (struct range_entry *)
5339 xmalloc (sizeof (*range_entries) * num_range_list);
5340 range_entry_fill = range_entries;
5341
5342 for (i = 0; i < num_debug_info_entries; i++)
5343 {
5344 debug_info *debug_info_p = &debug_information[i];
5345 unsigned int j;
5346
5347 for (j = 0; j < debug_info_p->num_range_lists; j++)
5348 {
5349 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5350 range_entry_fill->debug_info_p = debug_info_p;
5351 range_entry_fill++;
5352 }
5353 }
5354
5355 qsort (range_entries, num_range_list, sizeof (*range_entries),
5356 range_entry_compar);
5357
5358 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
5359 warn (_("Range lists in %s section start at 0x%lx\n"),
5360 section->name, range_entries[0].ranges_offset);
5361
5362 printf (_("Contents of the %s section:\n\n"), section->name);
5363 printf (_(" Offset Begin End\n"));
5364
5365 for (i = 0; i < num_range_list; i++)
5366 {
5367 struct range_entry *range_entry = &range_entries[i];
5368 debug_info *debug_info_p = range_entry->debug_info_p;
5369 unsigned int pointer_size;
5370 unsigned long offset;
5371 unsigned char *next;
5372 unsigned long base_address;
5373
5374 pointer_size = debug_info_p->pointer_size;
5375 offset = range_entry->ranges_offset;
5376 next = section_begin + offset;
5377 base_address = debug_info_p->base_address;
5378
5379 /* PR 17512: file: 001-101485-0.001:0.1. */
5380 if (pointer_size < 2 || pointer_size > 8)
5381 {
5382 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5383 pointer_size, offset);
5384 continue;
5385 }
5386
5387 if (dwarf_check != 0 && i > 0)
5388 {
5389 if (start < next)
5390 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5391 (unsigned long) (start - section_begin),
5392 (unsigned long) (next - section_begin), section->name);
5393 else if (start > next)
5394 {
5395 if (next == last_start)
5396 continue;
5397 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5398 (unsigned long) (start - section_begin),
5399 (unsigned long) (next - section_begin), section->name);
5400 }
5401 }
5402 start = next;
5403 last_start = next;
5404
5405 while (start < finish)
5406 {
5407 dwarf_vma begin;
5408 dwarf_vma end;
5409
5410 /* Note: we use sign extension here in order to be sure that
5411 we can detect the -1 escape value. Sign extension into the
5412 top 32 bits of a 32-bit address will not affect the values
5413 that we display since we always show hex values, and always
5414 the bottom 32-bits. */
5415 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
5416 if (start >= finish)
5417 break;
5418 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
5419
5420 printf (" %8.8lx ", offset);
5421
5422 if (begin == 0 && end == 0)
5423 {
5424 printf (_("<End of list>\n"));
5425 break;
5426 }
5427
5428 /* Check base address specifiers. */
5429 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
5430 {
5431 base_address = end;
5432 print_dwarf_vma (begin, pointer_size);
5433 print_dwarf_vma (end, pointer_size);
5434 printf ("(base address)\n");
5435 continue;
5436 }
5437
5438 print_dwarf_vma (begin + base_address, pointer_size);
5439 print_dwarf_vma (end + base_address, pointer_size);
5440
5441 if (begin == end)
5442 fputs (_("(start == end)"), stdout);
5443 else if (begin > end)
5444 fputs (_("(start > end)"), stdout);
5445
5446 putchar ('\n');
5447 }
5448 }
5449 putchar ('\n');
5450
5451 free (range_entries);
5452
5453 return 1;
5454 }
5455
5456 typedef struct Frame_Chunk
5457 {
5458 struct Frame_Chunk *next;
5459 unsigned char *chunk_start;
5460 int ncols;
5461 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5462 short int *col_type;
5463 int *col_offset;
5464 char *augmentation;
5465 unsigned int code_factor;
5466 int data_factor;
5467 dwarf_vma pc_begin;
5468 dwarf_vma pc_range;
5469 int cfa_reg;
5470 int cfa_offset;
5471 int ra;
5472 unsigned char fde_encoding;
5473 unsigned char cfa_exp;
5474 unsigned char ptr_size;
5475 unsigned char segment_size;
5476 }
5477 Frame_Chunk;
5478
5479 static const char *const *dwarf_regnames;
5480 static unsigned int dwarf_regnames_count;
5481
5482 /* A marker for a col_type that means this column was never referenced
5483 in the frame info. */
5484 #define DW_CFA_unreferenced (-1)
5485
5486 /* Return 0 if not more space is needed, 1 if more space is needed,
5487 -1 for invalid reg. */
5488
5489 static int
frame_need_space(Frame_Chunk * fc,unsigned int reg)5490 frame_need_space (Frame_Chunk *fc, unsigned int reg)
5491 {
5492 int prev = fc->ncols;
5493
5494 if (reg < (unsigned int) fc->ncols)
5495 return 0;
5496
5497 if (dwarf_regnames_count
5498 && reg > dwarf_regnames_count)
5499 return -1;
5500
5501 fc->ncols = reg + 1;
5502 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5503 sizeof (short int));
5504 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
5505 /* PR 17512: file:002-10025-0.005. */
5506 if (fc->col_type == NULL || fc->col_offset == NULL)
5507 {
5508 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5509 fc->ncols);
5510 fc->ncols = 0;
5511 return -1;
5512 }
5513
5514 while (prev < fc->ncols)
5515 {
5516 fc->col_type[prev] = DW_CFA_unreferenced;
5517 fc->col_offset[prev] = 0;
5518 prev++;
5519 }
5520 return 1;
5521 }
5522
5523 static const char *const dwarf_regnames_i386[] =
5524 {
5525 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5526 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5527 "eip", "eflags", NULL, /* 8 - 10 */
5528 "st0", "st1", "st2", "st3", /* 11 - 14 */
5529 "st4", "st5", "st6", "st7", /* 15 - 18 */
5530 NULL, NULL, /* 19 - 20 */
5531 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5532 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5533 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5534 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5535 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5536 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5537 "tr", "ldtr", /* 48 - 49 */
5538 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5539 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5540 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5541 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5542 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5543 NULL, NULL, NULL, /* 90 - 92 */
5544 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5545 };
5546
5547 void
init_dwarf_regnames_i386(void)5548 init_dwarf_regnames_i386 (void)
5549 {
5550 dwarf_regnames = dwarf_regnames_i386;
5551 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5552 }
5553
5554 static const char *const dwarf_regnames_x86_64[] =
5555 {
5556 "rax", "rdx", "rcx", "rbx",
5557 "rsi", "rdi", "rbp", "rsp",
5558 "r8", "r9", "r10", "r11",
5559 "r12", "r13", "r14", "r15",
5560 "rip",
5561 "xmm0", "xmm1", "xmm2", "xmm3",
5562 "xmm4", "xmm5", "xmm6", "xmm7",
5563 "xmm8", "xmm9", "xmm10", "xmm11",
5564 "xmm12", "xmm13", "xmm14", "xmm15",
5565 "st0", "st1", "st2", "st3",
5566 "st4", "st5", "st6", "st7",
5567 "mm0", "mm1", "mm2", "mm3",
5568 "mm4", "mm5", "mm6", "mm7",
5569 "rflags",
5570 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5571 "fs.base", "gs.base", NULL, NULL,
5572 "tr", "ldtr",
5573 "mxcsr", "fcw", "fsw",
5574 "xmm16", "xmm17", "xmm18", "xmm19",
5575 "xmm20", "xmm21", "xmm22", "xmm23",
5576 "xmm24", "xmm25", "xmm26", "xmm27",
5577 "xmm28", "xmm29", "xmm30", "xmm31",
5578 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5579 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5580 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5581 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5582 NULL, NULL, NULL, /* 115 - 117 */
5583 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5584 };
5585
5586 void
init_dwarf_regnames_x86_64(void)5587 init_dwarf_regnames_x86_64 (void)
5588 {
5589 dwarf_regnames = dwarf_regnames_x86_64;
5590 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5591 }
5592
5593 static const char *const dwarf_regnames_aarch64[] =
5594 {
5595 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5596 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5597 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5598 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5599 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5600 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5601 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5602 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5603 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5604 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5605 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5606 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5607 };
5608
5609 void
init_dwarf_regnames_aarch64(void)5610 init_dwarf_regnames_aarch64 (void)
5611 {
5612 dwarf_regnames = dwarf_regnames_aarch64;
5613 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5614 }
5615
5616 void
init_dwarf_regnames(unsigned int e_machine)5617 init_dwarf_regnames (unsigned int e_machine)
5618 {
5619 switch (e_machine)
5620 {
5621 case EM_386:
5622 case EM_486:
5623 init_dwarf_regnames_i386 ();
5624 break;
5625
5626 case EM_X86_64:
5627 case EM_L1OM:
5628 case EM_K1OM:
5629 init_dwarf_regnames_x86_64 ();
5630 break;
5631
5632 case EM_AARCH64:
5633 init_dwarf_regnames_aarch64 ();
5634 break;
5635
5636 default:
5637 break;
5638 }
5639 }
5640
5641 static const char *
regname(unsigned int regno,int row)5642 regname (unsigned int regno, int row)
5643 {
5644 static char reg[64];
5645 if (dwarf_regnames
5646 && regno < dwarf_regnames_count
5647 && dwarf_regnames [regno] != NULL)
5648 {
5649 if (row)
5650 return dwarf_regnames [regno];
5651 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5652 dwarf_regnames [regno]);
5653 }
5654 else
5655 snprintf (reg, sizeof (reg), "r%d", regno);
5656 return reg;
5657 }
5658
5659 static void
frame_display_row(Frame_Chunk * fc,int * need_col_headers,int * max_regs)5660 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
5661 {
5662 int r;
5663 char tmp[100];
5664
5665 if (*max_regs < fc->ncols)
5666 *max_regs = fc->ncols;
5667
5668 if (*need_col_headers)
5669 {
5670 static const char *sloc = " LOC";
5671
5672 *need_col_headers = 0;
5673
5674 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
5675
5676 for (r = 0; r < *max_regs; r++)
5677 if (fc->col_type[r] != DW_CFA_unreferenced)
5678 {
5679 if (r == fc->ra)
5680 printf ("ra ");
5681 else
5682 printf ("%-5s ", regname (r, 1));
5683 }
5684
5685 printf ("\n");
5686 }
5687
5688 print_dwarf_vma (fc->pc_begin, eh_addr_size);
5689 if (fc->cfa_exp)
5690 strcpy (tmp, "exp");
5691 else
5692 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
5693 printf ("%-8s ", tmp);
5694
5695 for (r = 0; r < fc->ncols; r++)
5696 {
5697 if (fc->col_type[r] != DW_CFA_unreferenced)
5698 {
5699 switch (fc->col_type[r])
5700 {
5701 case DW_CFA_undefined:
5702 strcpy (tmp, "u");
5703 break;
5704 case DW_CFA_same_value:
5705 strcpy (tmp, "s");
5706 break;
5707 case DW_CFA_offset:
5708 sprintf (tmp, "c%+d", fc->col_offset[r]);
5709 break;
5710 case DW_CFA_val_offset:
5711 sprintf (tmp, "v%+d", fc->col_offset[r]);
5712 break;
5713 case DW_CFA_register:
5714 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
5715 break;
5716 case DW_CFA_expression:
5717 strcpy (tmp, "exp");
5718 break;
5719 case DW_CFA_val_expression:
5720 strcpy (tmp, "vexp");
5721 break;
5722 default:
5723 strcpy (tmp, "n/a");
5724 break;
5725 }
5726 printf ("%-5s ", tmp);
5727 }
5728 }
5729 printf ("\n");
5730 }
5731
5732 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5733 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5734 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5735
5736 static unsigned char *
read_cie(unsigned char * start,unsigned char * end,Frame_Chunk ** p_cie,int * p_version,unsigned long * p_aug_len,unsigned char ** p_aug)5737 read_cie (unsigned char *start, unsigned char *end,
5738 Frame_Chunk **p_cie, int *p_version,
5739 unsigned long *p_aug_len, unsigned char **p_aug)
5740 {
5741 int version;
5742 Frame_Chunk *fc;
5743 unsigned int length_return;
5744 unsigned char *augmentation_data = NULL;
5745 unsigned long augmentation_data_len = 0;
5746
5747 * p_cie = NULL;
5748 /* PR 17512: file: 001-228113-0.004. */
5749 if (start >= end)
5750 return end;
5751
5752 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5753 memset (fc, 0, sizeof (Frame_Chunk));
5754
5755 fc->col_type = (short int *) xmalloc (sizeof (short int));
5756 fc->col_offset = (int *) xmalloc (sizeof (int));
5757
5758 version = *start++;
5759
5760 fc->augmentation = (char *) start;
5761 /* PR 17512: file: 001-228113-0.004.
5762 Skip past augmentation name, but avoid running off the end of the data. */
5763 while (start < end)
5764 if (* start ++ == '\0')
5765 break;
5766 if (start == end)
5767 {
5768 warn (_("No terminator for augmentation name\n"));
5769 return start;
5770 }
5771
5772 if (strcmp (fc->augmentation, "eh") == 0)
5773 start += eh_addr_size;
5774
5775 if (version >= 4)
5776 {
5777 GET (fc->ptr_size, 1);
5778 GET (fc->segment_size, 1);
5779 eh_addr_size = fc->ptr_size;
5780 }
5781 else
5782 {
5783 fc->ptr_size = eh_addr_size;
5784 fc->segment_size = 0;
5785 }
5786 fc->code_factor = LEB ();
5787 fc->data_factor = SLEB ();
5788 if (version == 1)
5789 {
5790 GET (fc->ra, 1);
5791 }
5792 else
5793 {
5794 fc->ra = LEB ();
5795 }
5796
5797 if (fc->augmentation[0] == 'z')
5798 {
5799 augmentation_data_len = LEB ();
5800 augmentation_data = start;
5801 start += augmentation_data_len;
5802 }
5803
5804 if (augmentation_data_len)
5805 {
5806 unsigned char *p, *q;
5807 p = (unsigned char *) fc->augmentation + 1;
5808 q = augmentation_data;
5809
5810 while (1)
5811 {
5812 if (*p == 'L')
5813 q++;
5814 else if (*p == 'P')
5815 q += 1 + size_of_encoded_value (*q);
5816 else if (*p == 'R')
5817 fc->fde_encoding = *q++;
5818 else if (*p == 'S')
5819 ;
5820 else
5821 break;
5822 p++;
5823 }
5824 }
5825
5826 *p_cie = fc;
5827 if (p_version)
5828 *p_version = version;
5829 if (p_aug_len)
5830 {
5831 *p_aug_len = augmentation_data_len;
5832 *p_aug = augmentation_data;
5833 }
5834 return start;
5835 }
5836
5837 static int
display_debug_frames(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)5838 display_debug_frames (struct dwarf_section *section,
5839 void *file ATTRIBUTE_UNUSED)
5840 {
5841 unsigned char *start = section->start;
5842 unsigned char *end = start + section->size;
5843 unsigned char *section_start = start;
5844 Frame_Chunk *chunks = 0, *forward_refs = 0;
5845 Frame_Chunk *remembered_state = 0;
5846 Frame_Chunk *rs;
5847 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5848 unsigned int length_return;
5849 int max_regs = 0;
5850 const char *bad_reg = _("bad register: ");
5851 int saved_eh_addr_size = eh_addr_size;
5852
5853 printf (_("Contents of the %s section:\n"), section->name);
5854
5855 while (start < end)
5856 {
5857 unsigned char *saved_start;
5858 unsigned char *block_end;
5859 dwarf_vma length;
5860 dwarf_vma cie_id;
5861 Frame_Chunk *fc;
5862 Frame_Chunk *cie;
5863 int need_col_headers = 1;
5864 unsigned char *augmentation_data = NULL;
5865 unsigned long augmentation_data_len = 0;
5866 unsigned int encoded_ptr_size = saved_eh_addr_size;
5867 unsigned int offset_size;
5868 unsigned int initial_length_size;
5869
5870 saved_start = start;
5871
5872 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
5873
5874 if (length == 0)
5875 {
5876 printf ("\n%08lx ZERO terminator\n\n",
5877 (unsigned long)(saved_start - section_start));
5878 continue;
5879 }
5880
5881 if (length == 0xffffffff)
5882 {
5883 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
5884 offset_size = 8;
5885 initial_length_size = 12;
5886 }
5887 else
5888 {
5889 offset_size = 4;
5890 initial_length_size = 4;
5891 }
5892
5893 block_end = saved_start + length + initial_length_size;
5894 if (block_end > end || block_end < start)
5895 {
5896 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5897 dwarf_vmatoa_1 (NULL, length, offset_size),
5898 (unsigned long) (saved_start - section_start));
5899 block_end = end;
5900 }
5901
5902 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
5903
5904 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5905 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
5906 {
5907 int version;
5908 int mreg;
5909
5910 start = read_cie (start, end, &cie, &version,
5911 &augmentation_data_len, &augmentation_data);
5912 /* PR 17512: file: 027-135133-0.005. */
5913 if (cie == NULL)
5914 break;
5915 fc = cie;
5916 fc->next = chunks;
5917 chunks = fc;
5918 fc->chunk_start = saved_start;
5919 mreg = max_regs - 1;
5920 if (mreg < fc->ra)
5921 mreg = fc->ra;
5922 frame_need_space (fc, mreg);
5923 if (fc->fde_encoding)
5924 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5925
5926 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5927 print_dwarf_vma (length, fc->ptr_size);
5928 print_dwarf_vma (cie_id, offset_size);
5929
5930 if (do_debug_frames_interp)
5931 {
5932 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5933 fc->code_factor, fc->data_factor, fc->ra);
5934 }
5935 else
5936 {
5937 printf ("CIE\n");
5938 printf (" Version: %d\n", version);
5939 printf (" Augmentation: \"%s\"\n", fc->augmentation);
5940 if (version >= 4)
5941 {
5942 printf (" Pointer Size: %u\n", fc->ptr_size);
5943 printf (" Segment Size: %u\n", fc->segment_size);
5944 }
5945 printf (" Code alignment factor: %u\n", fc->code_factor);
5946 printf (" Data alignment factor: %d\n", fc->data_factor);
5947 printf (" Return address column: %d\n", fc->ra);
5948
5949 if (augmentation_data_len)
5950 {
5951 unsigned long i;
5952 printf (" Augmentation data: ");
5953 for (i = 0; i < augmentation_data_len; ++i)
5954 printf (" %02x", augmentation_data[i]);
5955 putchar ('\n');
5956 }
5957 putchar ('\n');
5958 }
5959 }
5960 else
5961 {
5962 unsigned char *look_for;
5963 static Frame_Chunk fde_fc;
5964 unsigned long segment_selector;
5965
5966 if (is_eh)
5967 {
5968 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5969 look_for = start - 4 - ((cie_id ^ sign) - sign);
5970 }
5971 else
5972 look_for = section_start + cie_id;
5973
5974 if (look_for <= saved_start)
5975 {
5976 for (cie = chunks; cie ; cie = cie->next)
5977 if (cie->chunk_start == look_for)
5978 break;
5979 }
5980 else
5981 {
5982 for (cie = forward_refs; cie ; cie = cie->next)
5983 if (cie->chunk_start == look_for)
5984 break;
5985 if (!cie)
5986 {
5987 unsigned int off_size;
5988 unsigned char *cie_scan;
5989
5990 cie_scan = look_for;
5991 off_size = 4;
5992 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5993 if (length == 0xffffffff)
5994 {
5995 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5996 off_size = 8;
5997 }
5998 if (length != 0)
5999 {
6000 dwarf_vma c_id;
6001
6002 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
6003 if (is_eh
6004 ? c_id == 0
6005 : ((off_size == 4 && c_id == DW_CIE_ID)
6006 || (off_size == 8 && c_id == DW64_CIE_ID)))
6007 {
6008 int version;
6009 int mreg;
6010
6011 read_cie (cie_scan, end, &cie, &version,
6012 &augmentation_data_len, &augmentation_data);
6013 cie->next = forward_refs;
6014 forward_refs = cie;
6015 cie->chunk_start = look_for;
6016 mreg = max_regs - 1;
6017 if (mreg < cie->ra)
6018 mreg = cie->ra;
6019 frame_need_space (cie, mreg);
6020 if (cie->fde_encoding)
6021 encoded_ptr_size
6022 = size_of_encoded_value (cie->fde_encoding);
6023 }
6024 }
6025 }
6026 }
6027
6028 fc = &fde_fc;
6029 memset (fc, 0, sizeof (Frame_Chunk));
6030
6031 if (!cie)
6032 {
6033 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
6034 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
6035 (unsigned long) (saved_start - section_start));
6036 fc->ncols = 0;
6037 fc->col_type = (short int *) xmalloc (sizeof (short int));
6038 fc->col_offset = (int *) xmalloc (sizeof (int));
6039 frame_need_space (fc, max_regs - 1);
6040 cie = fc;
6041 fc->augmentation = "";
6042 fc->fde_encoding = 0;
6043 fc->ptr_size = eh_addr_size;
6044 fc->segment_size = 0;
6045 }
6046 else
6047 {
6048 fc->ncols = cie->ncols;
6049 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
6050 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
6051 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
6052 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
6053 fc->augmentation = cie->augmentation;
6054 fc->ptr_size = cie->ptr_size;
6055 eh_addr_size = cie->ptr_size;
6056 fc->segment_size = cie->segment_size;
6057 fc->code_factor = cie->code_factor;
6058 fc->data_factor = cie->data_factor;
6059 fc->cfa_reg = cie->cfa_reg;
6060 fc->cfa_offset = cie->cfa_offset;
6061 fc->ra = cie->ra;
6062 frame_need_space (fc, max_regs - 1);
6063 fc->fde_encoding = cie->fde_encoding;
6064 }
6065
6066 if (fc->fde_encoding)
6067 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
6068
6069 segment_selector = 0;
6070 if (fc->segment_size)
6071 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
6072
6073 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
6074
6075 /* FIXME: It appears that sometimes the final pc_range value is
6076 encoded in less than encoded_ptr_size bytes. See the x86_64
6077 run of the "objcopy on compressed debug sections" test for an
6078 example of this. */
6079 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
6080
6081 if (cie->augmentation[0] == 'z')
6082 {
6083 augmentation_data_len = LEB ();
6084 augmentation_data = start;
6085 start += augmentation_data_len;
6086 }
6087
6088 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6089 (unsigned long)(saved_start - section_start),
6090 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
6091 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
6092 (unsigned long)(cie->chunk_start - section_start));
6093
6094 if (fc->segment_size)
6095 printf ("%04lx:", segment_selector);
6096
6097 printf ("%s..%s\n",
6098 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
6099 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
6100
6101 if (! do_debug_frames_interp && augmentation_data_len)
6102 {
6103 unsigned long i;
6104
6105 printf (" Augmentation data: ");
6106 for (i = 0; i < augmentation_data_len; ++i)
6107 printf (" %02x", augmentation_data[i]);
6108 putchar ('\n');
6109 putchar ('\n');
6110 }
6111 }
6112
6113 /* At this point, fc is the current chunk, cie (if any) is set, and
6114 we're about to interpret instructions for the chunk. */
6115 /* ??? At present we need to do this always, since this sizes the
6116 fc->col_type and fc->col_offset arrays, which we write into always.
6117 We should probably split the interpreted and non-interpreted bits
6118 into two different routines, since there's so much that doesn't
6119 really overlap between them. */
6120 if (1 || do_debug_frames_interp)
6121 {
6122 /* Start by making a pass over the chunk, allocating storage
6123 and taking note of what registers are used. */
6124 unsigned char *tmp = start;
6125
6126 while (start < block_end)
6127 {
6128 unsigned int reg, op, opa;
6129 unsigned long temp;
6130
6131 op = *start++;
6132 opa = op & 0x3f;
6133 if (op & 0xc0)
6134 op &= 0xc0;
6135
6136 /* Warning: if you add any more cases to this switch, be
6137 sure to add them to the corresponding switch below. */
6138 switch (op)
6139 {
6140 case DW_CFA_advance_loc:
6141 break;
6142 case DW_CFA_offset:
6143 LEB ();
6144 if (frame_need_space (fc, opa) >= 0)
6145 fc->col_type[opa] = DW_CFA_undefined;
6146 break;
6147 case DW_CFA_restore:
6148 if (frame_need_space (fc, opa) >= 0)
6149 fc->col_type[opa] = DW_CFA_undefined;
6150 break;
6151 case DW_CFA_set_loc:
6152 start += encoded_ptr_size;
6153 break;
6154 case DW_CFA_advance_loc1:
6155 start += 1;
6156 break;
6157 case DW_CFA_advance_loc2:
6158 start += 2;
6159 break;
6160 case DW_CFA_advance_loc4:
6161 start += 4;
6162 break;
6163 case DW_CFA_offset_extended:
6164 case DW_CFA_val_offset:
6165 reg = LEB (); LEB ();
6166 if (frame_need_space (fc, reg) >= 0)
6167 fc->col_type[reg] = DW_CFA_undefined;
6168 break;
6169 case DW_CFA_restore_extended:
6170 reg = LEB ();
6171 frame_need_space (fc, reg);
6172 if (frame_need_space (fc, reg) >= 0)
6173 fc->col_type[reg] = DW_CFA_undefined;
6174 break;
6175 case DW_CFA_undefined:
6176 reg = LEB ();
6177 if (frame_need_space (fc, reg) >= 0)
6178 fc->col_type[reg] = DW_CFA_undefined;
6179 break;
6180 case DW_CFA_same_value:
6181 reg = LEB ();
6182 if (frame_need_space (fc, reg) >= 0)
6183 fc->col_type[reg] = DW_CFA_undefined;
6184 break;
6185 case DW_CFA_register:
6186 reg = LEB (); LEB ();
6187 if (frame_need_space (fc, reg) >= 0)
6188 fc->col_type[reg] = DW_CFA_undefined;
6189 break;
6190 case DW_CFA_def_cfa:
6191 LEB (); LEB ();
6192 break;
6193 case DW_CFA_def_cfa_register:
6194 LEB ();
6195 break;
6196 case DW_CFA_def_cfa_offset:
6197 LEB ();
6198 break;
6199 case DW_CFA_def_cfa_expression:
6200 temp = LEB ();
6201 if (start + temp < start)
6202 {
6203 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6204 start = block_end;
6205 }
6206 else
6207 start += temp;
6208 break;
6209 case DW_CFA_expression:
6210 case DW_CFA_val_expression:
6211 reg = LEB ();
6212 temp = LEB ();
6213 if (start + temp < start)
6214 {
6215 /* PR 17512: file:306-192417-0.005. */
6216 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6217 start = block_end;
6218 }
6219 else
6220 start += temp;
6221 if (frame_need_space (fc, reg) >= 0)
6222 fc->col_type[reg] = DW_CFA_undefined;
6223 break;
6224 case DW_CFA_offset_extended_sf:
6225 case DW_CFA_val_offset_sf:
6226 reg = LEB (); SLEB ();
6227 if (frame_need_space (fc, reg) >= 0)
6228 fc->col_type[reg] = DW_CFA_undefined;
6229 break;
6230 case DW_CFA_def_cfa_sf:
6231 LEB (); SLEB ();
6232 break;
6233 case DW_CFA_def_cfa_offset_sf:
6234 SLEB ();
6235 break;
6236 case DW_CFA_MIPS_advance_loc8:
6237 start += 8;
6238 break;
6239 case DW_CFA_GNU_args_size:
6240 LEB ();
6241 break;
6242 case DW_CFA_GNU_negative_offset_extended:
6243 reg = LEB (); LEB ();
6244 if (frame_need_space (fc, reg) >= 0)
6245 fc->col_type[reg] = DW_CFA_undefined;
6246 break;
6247 default:
6248 break;
6249 }
6250 }
6251 start = tmp;
6252 }
6253
6254 /* Now we know what registers are used, make a second pass over
6255 the chunk, this time actually printing out the info. */
6256
6257 while (start < block_end)
6258 {
6259 unsigned op, opa;
6260 unsigned long ul, reg, roffs;
6261 long l;
6262 dwarf_vma ofs;
6263 dwarf_vma vma;
6264 const char *reg_prefix = "";
6265
6266 op = *start++;
6267 opa = op & 0x3f;
6268 if (op & 0xc0)
6269 op &= 0xc0;
6270
6271 /* Warning: if you add any more cases to this switch, be
6272 sure to add them to the corresponding switch above. */
6273 switch (op)
6274 {
6275 case DW_CFA_advance_loc:
6276 if (do_debug_frames_interp)
6277 frame_display_row (fc, &need_col_headers, &max_regs);
6278 else
6279 printf (" DW_CFA_advance_loc: %d to %s\n",
6280 opa * fc->code_factor,
6281 dwarf_vmatoa_1 (NULL,
6282 fc->pc_begin + opa * fc->code_factor,
6283 fc->ptr_size));
6284 fc->pc_begin += opa * fc->code_factor;
6285 break;
6286
6287 case DW_CFA_offset:
6288 roffs = LEB ();
6289 if (opa >= (unsigned int) fc->ncols)
6290 reg_prefix = bad_reg;
6291 if (! do_debug_frames_interp || *reg_prefix != '\0')
6292 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6293 reg_prefix, regname (opa, 0),
6294 roffs * fc->data_factor);
6295 if (*reg_prefix == '\0')
6296 {
6297 fc->col_type[opa] = DW_CFA_offset;
6298 fc->col_offset[opa] = roffs * fc->data_factor;
6299 }
6300 break;
6301
6302 case DW_CFA_restore:
6303 if (opa >= (unsigned int) cie->ncols
6304 || opa >= (unsigned int) fc->ncols)
6305 reg_prefix = bad_reg;
6306 if (! do_debug_frames_interp || *reg_prefix != '\0')
6307 printf (" DW_CFA_restore: %s%s\n",
6308 reg_prefix, regname (opa, 0));
6309 if (*reg_prefix == '\0')
6310 {
6311 fc->col_type[opa] = cie->col_type[opa];
6312 fc->col_offset[opa] = cie->col_offset[opa];
6313 if (do_debug_frames_interp
6314 && fc->col_type[opa] == DW_CFA_unreferenced)
6315 fc->col_type[opa] = DW_CFA_undefined;
6316 }
6317 break;
6318
6319 case DW_CFA_set_loc:
6320 vma = get_encoded_value (&start, fc->fde_encoding, section, end);
6321 if (do_debug_frames_interp)
6322 frame_display_row (fc, &need_col_headers, &max_regs);
6323 else
6324 printf (" DW_CFA_set_loc: %s\n",
6325 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
6326 fc->pc_begin = vma;
6327 break;
6328
6329 case DW_CFA_advance_loc1:
6330 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
6331 if (do_debug_frames_interp)
6332 frame_display_row (fc, &need_col_headers, &max_regs);
6333 else
6334 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6335 (unsigned long) (ofs * fc->code_factor),
6336 dwarf_vmatoa_1 (NULL,
6337 fc->pc_begin + ofs * fc->code_factor,
6338 fc->ptr_size));
6339 fc->pc_begin += ofs * fc->code_factor;
6340 break;
6341
6342 case DW_CFA_advance_loc2:
6343 SAFE_BYTE_GET_AND_INC (ofs, start, 2, end);
6344 if (do_debug_frames_interp)
6345 frame_display_row (fc, &need_col_headers, &max_regs);
6346 else
6347 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6348 (unsigned long) (ofs * fc->code_factor),
6349 dwarf_vmatoa_1 (NULL,
6350 fc->pc_begin + ofs * fc->code_factor,
6351 fc->ptr_size));
6352 fc->pc_begin += ofs * fc->code_factor;
6353 break;
6354
6355 case DW_CFA_advance_loc4:
6356 SAFE_BYTE_GET_AND_INC (ofs, start, 4, end);
6357 if (do_debug_frames_interp)
6358 frame_display_row (fc, &need_col_headers, &max_regs);
6359 else
6360 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6361 (unsigned long) (ofs * fc->code_factor),
6362 dwarf_vmatoa_1 (NULL,
6363 fc->pc_begin + ofs * fc->code_factor,
6364 fc->ptr_size));
6365 fc->pc_begin += ofs * fc->code_factor;
6366 break;
6367
6368 case DW_CFA_offset_extended:
6369 reg = LEB ();
6370 roffs = LEB ();
6371 if (reg >= (unsigned int) fc->ncols)
6372 reg_prefix = bad_reg;
6373 if (! do_debug_frames_interp || *reg_prefix != '\0')
6374 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6375 reg_prefix, regname (reg, 0),
6376 roffs * fc->data_factor);
6377 if (*reg_prefix == '\0')
6378 {
6379 fc->col_type[reg] = DW_CFA_offset;
6380 fc->col_offset[reg] = roffs * fc->data_factor;
6381 }
6382 break;
6383
6384 case DW_CFA_val_offset:
6385 reg = LEB ();
6386 roffs = LEB ();
6387 if (reg >= (unsigned int) fc->ncols)
6388 reg_prefix = bad_reg;
6389 if (! do_debug_frames_interp || *reg_prefix != '\0')
6390 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6391 reg_prefix, regname (reg, 0),
6392 roffs * fc->data_factor);
6393 if (*reg_prefix == '\0')
6394 {
6395 fc->col_type[reg] = DW_CFA_val_offset;
6396 fc->col_offset[reg] = roffs * fc->data_factor;
6397 }
6398 break;
6399
6400 case DW_CFA_restore_extended:
6401 reg = LEB ();
6402 if (reg >= (unsigned int) cie->ncols
6403 || reg >= (unsigned int) fc->ncols)
6404 reg_prefix = bad_reg;
6405 if (! do_debug_frames_interp || *reg_prefix != '\0')
6406 printf (" DW_CFA_restore_extended: %s%s\n",
6407 reg_prefix, regname (reg, 0));
6408 if (*reg_prefix == '\0')
6409 {
6410 fc->col_type[reg] = cie->col_type[reg];
6411 fc->col_offset[reg] = cie->col_offset[reg];
6412 }
6413 break;
6414
6415 case DW_CFA_undefined:
6416 reg = LEB ();
6417 if (reg >= (unsigned int) fc->ncols)
6418 reg_prefix = bad_reg;
6419 if (! do_debug_frames_interp || *reg_prefix != '\0')
6420 printf (" DW_CFA_undefined: %s%s\n",
6421 reg_prefix, regname (reg, 0));
6422 if (*reg_prefix == '\0')
6423 {
6424 fc->col_type[reg] = DW_CFA_undefined;
6425 fc->col_offset[reg] = 0;
6426 }
6427 break;
6428
6429 case DW_CFA_same_value:
6430 reg = LEB ();
6431 if (reg >= (unsigned int) fc->ncols)
6432 reg_prefix = bad_reg;
6433 if (! do_debug_frames_interp || *reg_prefix != '\0')
6434 printf (" DW_CFA_same_value: %s%s\n",
6435 reg_prefix, regname (reg, 0));
6436 if (*reg_prefix == '\0')
6437 {
6438 fc->col_type[reg] = DW_CFA_same_value;
6439 fc->col_offset[reg] = 0;
6440 }
6441 break;
6442
6443 case DW_CFA_register:
6444 reg = LEB ();
6445 roffs = LEB ();
6446 if (reg >= (unsigned int) fc->ncols)
6447 reg_prefix = bad_reg;
6448 if (! do_debug_frames_interp || *reg_prefix != '\0')
6449 {
6450 printf (" DW_CFA_register: %s%s in ",
6451 reg_prefix, regname (reg, 0));
6452 puts (regname (roffs, 0));
6453 }
6454 if (*reg_prefix == '\0')
6455 {
6456 fc->col_type[reg] = DW_CFA_register;
6457 fc->col_offset[reg] = roffs;
6458 }
6459 break;
6460
6461 case DW_CFA_remember_state:
6462 if (! do_debug_frames_interp)
6463 printf (" DW_CFA_remember_state\n");
6464 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6465 rs->cfa_offset = fc->cfa_offset;
6466 rs->cfa_reg = fc->cfa_reg;
6467 rs->ra = fc->ra;
6468 rs->cfa_exp = fc->cfa_exp;
6469 rs->ncols = fc->ncols;
6470 rs->col_type = (short int *) xcmalloc (rs->ncols,
6471 sizeof (* rs->col_type));
6472 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6473 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6474 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
6475 rs->next = remembered_state;
6476 remembered_state = rs;
6477 break;
6478
6479 case DW_CFA_restore_state:
6480 if (! do_debug_frames_interp)
6481 printf (" DW_CFA_restore_state\n");
6482 rs = remembered_state;
6483 if (rs)
6484 {
6485 remembered_state = rs->next;
6486 fc->cfa_offset = rs->cfa_offset;
6487 fc->cfa_reg = rs->cfa_reg;
6488 fc->ra = rs->ra;
6489 fc->cfa_exp = rs->cfa_exp;
6490 frame_need_space (fc, rs->ncols - 1);
6491 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
6492 memcpy (fc->col_offset, rs->col_offset,
6493 rs->ncols * sizeof (* rs->col_offset));
6494 free (rs->col_type);
6495 free (rs->col_offset);
6496 free (rs);
6497 }
6498 else if (do_debug_frames_interp)
6499 printf ("Mismatched DW_CFA_restore_state\n");
6500 break;
6501
6502 case DW_CFA_def_cfa:
6503 fc->cfa_reg = LEB ();
6504 fc->cfa_offset = LEB ();
6505 fc->cfa_exp = 0;
6506 if (! do_debug_frames_interp)
6507 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6508 regname (fc->cfa_reg, 0), fc->cfa_offset);
6509 break;
6510
6511 case DW_CFA_def_cfa_register:
6512 fc->cfa_reg = LEB ();
6513 fc->cfa_exp = 0;
6514 if (! do_debug_frames_interp)
6515 printf (" DW_CFA_def_cfa_register: %s\n",
6516 regname (fc->cfa_reg, 0));
6517 break;
6518
6519 case DW_CFA_def_cfa_offset:
6520 fc->cfa_offset = LEB ();
6521 if (! do_debug_frames_interp)
6522 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6523 break;
6524
6525 case DW_CFA_nop:
6526 if (! do_debug_frames_interp)
6527 printf (" DW_CFA_nop\n");
6528 break;
6529
6530 case DW_CFA_def_cfa_expression:
6531 ul = LEB ();
6532 if (! do_debug_frames_interp)
6533 {
6534 printf (" DW_CFA_def_cfa_expression (");
6535 decode_location_expression (start, eh_addr_size, 0, -1,
6536 ul, 0, section);
6537 printf (")\n");
6538 }
6539 fc->cfa_exp = 1;
6540 start += ul;
6541 break;
6542
6543 case DW_CFA_expression:
6544 reg = LEB ();
6545 ul = LEB ();
6546 if (reg >= (unsigned int) fc->ncols)
6547 reg_prefix = bad_reg;
6548 if (! do_debug_frames_interp || *reg_prefix != '\0')
6549 {
6550 printf (" DW_CFA_expression: %s%s (",
6551 reg_prefix, regname (reg, 0));
6552 decode_location_expression (start, eh_addr_size, 0, -1,
6553 ul, 0, section);
6554 printf (")\n");
6555 }
6556 if (*reg_prefix == '\0')
6557 fc->col_type[reg] = DW_CFA_expression;
6558 start += ul;
6559 break;
6560
6561 case DW_CFA_val_expression:
6562 reg = LEB ();
6563 ul = LEB ();
6564 if (reg >= (unsigned int) fc->ncols)
6565 reg_prefix = bad_reg;
6566 if (! do_debug_frames_interp || *reg_prefix != '\0')
6567 {
6568 printf (" DW_CFA_val_expression: %s%s (",
6569 reg_prefix, regname (reg, 0));
6570 decode_location_expression (start, eh_addr_size, 0, -1,
6571 ul, 0, section);
6572 printf (")\n");
6573 }
6574 if (*reg_prefix == '\0')
6575 fc->col_type[reg] = DW_CFA_val_expression;
6576 start += ul;
6577 break;
6578
6579 case DW_CFA_offset_extended_sf:
6580 reg = LEB ();
6581 l = SLEB ();
6582 if (frame_need_space (fc, reg) < 0)
6583 reg_prefix = bad_reg;
6584 if (! do_debug_frames_interp || *reg_prefix != '\0')
6585 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6586 reg_prefix, regname (reg, 0),
6587 l * fc->data_factor);
6588 if (*reg_prefix == '\0')
6589 {
6590 fc->col_type[reg] = DW_CFA_offset;
6591 fc->col_offset[reg] = l * fc->data_factor;
6592 }
6593 break;
6594
6595 case DW_CFA_val_offset_sf:
6596 reg = LEB ();
6597 l = SLEB ();
6598 if (frame_need_space (fc, reg) < 0)
6599 reg_prefix = bad_reg;
6600 if (! do_debug_frames_interp || *reg_prefix != '\0')
6601 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6602 reg_prefix, regname (reg, 0),
6603 l * fc->data_factor);
6604 if (*reg_prefix == '\0')
6605 {
6606 fc->col_type[reg] = DW_CFA_val_offset;
6607 fc->col_offset[reg] = l * fc->data_factor;
6608 }
6609 break;
6610
6611 case DW_CFA_def_cfa_sf:
6612 fc->cfa_reg = LEB ();
6613 fc->cfa_offset = SLEB ();
6614 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6615 fc->cfa_exp = 0;
6616 if (! do_debug_frames_interp)
6617 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6618 regname (fc->cfa_reg, 0), fc->cfa_offset);
6619 break;
6620
6621 case DW_CFA_def_cfa_offset_sf:
6622 fc->cfa_offset = SLEB ();
6623 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6624 if (! do_debug_frames_interp)
6625 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6626 break;
6627
6628 case DW_CFA_MIPS_advance_loc8:
6629 SAFE_BYTE_GET_AND_INC (ofs, start, 8, end);
6630 if (do_debug_frames_interp)
6631 frame_display_row (fc, &need_col_headers, &max_regs);
6632 else
6633 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6634 (unsigned long) (ofs * fc->code_factor),
6635 dwarf_vmatoa_1 (NULL,
6636 fc->pc_begin + ofs * fc->code_factor,
6637 fc->ptr_size));
6638 fc->pc_begin += ofs * fc->code_factor;
6639 break;
6640
6641 case DW_CFA_GNU_window_save:
6642 if (! do_debug_frames_interp)
6643 printf (" DW_CFA_GNU_window_save\n");
6644 break;
6645
6646 case DW_CFA_GNU_args_size:
6647 ul = LEB ();
6648 if (! do_debug_frames_interp)
6649 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6650 break;
6651
6652 case DW_CFA_GNU_negative_offset_extended:
6653 reg = LEB ();
6654 l = - LEB ();
6655 if (frame_need_space (fc, reg) < 0)
6656 reg_prefix = bad_reg;
6657 if (! do_debug_frames_interp || *reg_prefix != '\0')
6658 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6659 reg_prefix, regname (reg, 0),
6660 l * fc->data_factor);
6661 if (*reg_prefix == '\0')
6662 {
6663 fc->col_type[reg] = DW_CFA_offset;
6664 fc->col_offset[reg] = l * fc->data_factor;
6665 }
6666 break;
6667
6668 default:
6669 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6670 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6671 else
6672 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
6673 start = block_end;
6674 }
6675 }
6676
6677 if (do_debug_frames_interp)
6678 frame_display_row (fc, &need_col_headers, &max_regs);
6679
6680 start = block_end;
6681 eh_addr_size = saved_eh_addr_size;
6682 }
6683
6684 printf ("\n");
6685
6686 return 1;
6687 }
6688
6689 #undef GET
6690 #undef LEB
6691 #undef SLEB
6692
6693 static int
display_gdb_index(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)6694 display_gdb_index (struct dwarf_section *section,
6695 void *file ATTRIBUTE_UNUSED)
6696 {
6697 unsigned char *start = section->start;
6698 uint32_t version;
6699 uint32_t cu_list_offset, tu_list_offset;
6700 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6701 unsigned int cu_list_elements, tu_list_elements;
6702 unsigned int address_table_size, symbol_table_slots;
6703 unsigned char *cu_list, *tu_list;
6704 unsigned char *address_table, *symbol_table, *constant_pool;
6705 unsigned int i;
6706
6707 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6708
6709 printf (_("Contents of the %s section:\n"), section->name);
6710
6711 if (section->size < 6 * sizeof (uint32_t))
6712 {
6713 warn (_("Truncated header in the %s section.\n"), section->name);
6714 return 0;
6715 }
6716
6717 version = byte_get_little_endian (start, 4);
6718 printf (_("Version %ld\n"), (long) version);
6719
6720 /* Prior versions are obsolete, and future versions may not be
6721 backwards compatible. */
6722 if (version < 3 || version > 8)
6723 {
6724 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
6725 return 0;
6726 }
6727 if (version < 4)
6728 warn (_("The address table data in version 3 may be wrong.\n"));
6729 if (version < 5)
6730 warn (_("Version 4 does not support case insensitive lookups.\n"));
6731 if (version < 6)
6732 warn (_("Version 5 does not include inlined functions.\n"));
6733 if (version < 7)
6734 warn (_("Version 6 does not include symbol attributes.\n"));
6735 /* Version 7 indices generated by Gold have bad type unit references,
6736 PR binutils/15021. But we don't know if the index was generated by
6737 Gold or not, so to avoid worrying users with gdb-generated indices
6738 we say nothing for version 7 here. */
6739
6740 cu_list_offset = byte_get_little_endian (start + 4, 4);
6741 tu_list_offset = byte_get_little_endian (start + 8, 4);
6742 address_table_offset = byte_get_little_endian (start + 12, 4);
6743 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6744 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6745
6746 if (cu_list_offset > section->size
6747 || tu_list_offset > section->size
6748 || address_table_offset > section->size
6749 || symbol_table_offset > section->size
6750 || constant_pool_offset > section->size)
6751 {
6752 warn (_("Corrupt header in the %s section.\n"), section->name);
6753 return 0;
6754 }
6755
6756 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
6757 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
6758 address_table_size = symbol_table_offset - address_table_offset;
6759 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6760
6761 cu_list = start + cu_list_offset;
6762 tu_list = start + tu_list_offset;
6763 address_table = start + address_table_offset;
6764 symbol_table = start + symbol_table_offset;
6765 constant_pool = start + constant_pool_offset;
6766
6767 printf (_("\nCU table:\n"));
6768 for (i = 0; i < cu_list_elements; i += 2)
6769 {
6770 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6771 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6772
6773 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6774 (unsigned long) cu_offset,
6775 (unsigned long) (cu_offset + cu_length - 1));
6776 }
6777
6778 printf (_("\nTU table:\n"));
6779 for (i = 0; i < tu_list_elements; i += 3)
6780 {
6781 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6782 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6783 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6784
6785 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6786 (unsigned long) tu_offset,
6787 (unsigned long) type_offset);
6788 print_dwarf_vma (signature, 8);
6789 printf ("\n");
6790 }
6791
6792 printf (_("\nAddress table:\n"));
6793 for (i = 0; i < address_table_size; i += 2 * 8 + 4)
6794 {
6795 uint64_t low = byte_get_little_endian (address_table + i, 8);
6796 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6797 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6798
6799 print_dwarf_vma (low, 8);
6800 print_dwarf_vma (high, 8);
6801 printf (_("%lu\n"), (unsigned long) cu_index);
6802 }
6803
6804 printf (_("\nSymbol table:\n"));
6805 for (i = 0; i < symbol_table_slots; ++i)
6806 {
6807 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6808 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6809 uint32_t num_cus, cu;
6810
6811 if (name_offset != 0
6812 || cu_vector_offset != 0)
6813 {
6814 unsigned int j;
6815
6816 printf ("[%3u] %s:", i, constant_pool + name_offset);
6817 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
6818 if (num_cus > 1)
6819 printf ("\n");
6820 for (j = 0; j < num_cus; ++j)
6821 {
6822 int is_static;
6823 gdb_index_symbol_kind kind;
6824
6825 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
6826 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
6827 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6828 cu = GDB_INDEX_CU_VALUE (cu);
6829 /* Convert to TU number if it's for a type unit. */
6830 if (cu >= cu_list_elements / 2)
6831 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6832 (unsigned long) (cu - cu_list_elements / 2));
6833 else
6834 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6835
6836 printf (" [%s, %s]",
6837 is_static ? _("static") : _("global"),
6838 get_gdb_index_symbol_kind_name (kind));
6839 if (num_cus > 1)
6840 printf ("\n");
6841 }
6842 if (num_cus <= 1)
6843 printf ("\n");
6844 }
6845 }
6846
6847 return 1;
6848 }
6849
6850 /* Pre-allocate enough space for the CU/TU sets needed. */
6851
6852 static void
prealloc_cu_tu_list(unsigned int nshndx)6853 prealloc_cu_tu_list (unsigned int nshndx)
6854 {
6855 if (shndx_pool == NULL)
6856 {
6857 shndx_pool_size = nshndx;
6858 shndx_pool_used = 0;
6859 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6860 sizeof (unsigned int));
6861 }
6862 else
6863 {
6864 shndx_pool_size = shndx_pool_used + nshndx;
6865 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6866 sizeof (unsigned int));
6867 }
6868 }
6869
6870 static void
add_shndx_to_cu_tu_entry(unsigned int shndx)6871 add_shndx_to_cu_tu_entry (unsigned int shndx)
6872 {
6873 if (shndx_pool_used >= shndx_pool_size)
6874 {
6875 error (_("Internal error: out of space in the shndx pool.\n"));
6876 return;
6877 }
6878 shndx_pool [shndx_pool_used++] = shndx;
6879 }
6880
6881 static void
end_cu_tu_entry(void)6882 end_cu_tu_entry (void)
6883 {
6884 if (shndx_pool_used >= shndx_pool_size)
6885 {
6886 error (_("Internal error: out of space in the shndx pool.\n"));
6887 return;
6888 }
6889 shndx_pool [shndx_pool_used++] = 0;
6890 }
6891
6892 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6893
6894 static const char *
get_DW_SECT_short_name(unsigned int dw_sect)6895 get_DW_SECT_short_name (unsigned int dw_sect)
6896 {
6897 static char buf[16];
6898
6899 switch (dw_sect)
6900 {
6901 case DW_SECT_INFO:
6902 return "info";
6903 case DW_SECT_TYPES:
6904 return "types";
6905 case DW_SECT_ABBREV:
6906 return "abbrev";
6907 case DW_SECT_LINE:
6908 return "line";
6909 case DW_SECT_LOC:
6910 return "loc";
6911 case DW_SECT_STR_OFFSETS:
6912 return "str_off";
6913 case DW_SECT_MACINFO:
6914 return "macinfo";
6915 case DW_SECT_MACRO:
6916 return "macro";
6917 default:
6918 break;
6919 }
6920
6921 snprintf (buf, sizeof (buf), "%d", dw_sect);
6922 return buf;
6923 }
6924
6925 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6926 These sections are extensions for Fission.
6927 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6928
6929 static int
process_cu_tu_index(struct dwarf_section * section,int do_display)6930 process_cu_tu_index (struct dwarf_section *section, int do_display)
6931 {
6932 unsigned char *phdr = section->start;
6933 unsigned char *limit = phdr + section->size;
6934 unsigned char *phash;
6935 unsigned char *pindex;
6936 unsigned char *ppool;
6937 unsigned int version;
6938 unsigned int ncols = 0;
6939 unsigned int nused;
6940 unsigned int nslots;
6941 unsigned int i;
6942 unsigned int j;
6943 dwarf_vma signature_high;
6944 dwarf_vma signature_low;
6945 char buf[64];
6946
6947 version = byte_get (phdr, 4);
6948 if (version >= 2)
6949 ncols = byte_get (phdr + 4, 4);
6950 nused = byte_get (phdr + 8, 4);
6951 nslots = byte_get (phdr + 12, 4);
6952 phash = phdr + 16;
6953 pindex = phash + nslots * 8;
6954 ppool = pindex + nslots * 4;
6955
6956 if (do_display)
6957 {
6958 printf (_("Contents of the %s section:\n\n"), section->name);
6959 printf (_(" Version: %d\n"), version);
6960 if (version >= 2)
6961 printf (_(" Number of columns: %d\n"), ncols);
6962 printf (_(" Number of used entries: %d\n"), nused);
6963 printf (_(" Number of slots: %d\n\n"), nslots);
6964 }
6965
6966 if (ppool > limit)
6967 {
6968 warn (_("Section %s too small for %d hash table entries\n"),
6969 section->name, nslots);
6970 return 0;
6971 }
6972
6973 if (version == 1)
6974 {
6975 if (!do_display)
6976 prealloc_cu_tu_list ((limit - ppool) / 4);
6977 for (i = 0; i < nslots; i++)
6978 {
6979 unsigned char *shndx_list;
6980 unsigned int shndx;
6981
6982 byte_get_64 (phash, &signature_high, &signature_low);
6983 if (signature_high != 0 || signature_low != 0)
6984 {
6985 j = byte_get (pindex, 4);
6986 shndx_list = ppool + j * 4;
6987 if (do_display)
6988 printf (_(" [%3d] Signature: 0x%s Sections: "),
6989 i, dwarf_vmatoa64 (signature_high, signature_low,
6990 buf, sizeof (buf)));
6991 for (;;)
6992 {
6993 if (shndx_list >= limit)
6994 {
6995 warn (_("Section %s too small for shndx pool\n"),
6996 section->name);
6997 return 0;
6998 }
6999 shndx = byte_get (shndx_list, 4);
7000 if (shndx == 0)
7001 break;
7002 if (do_display)
7003 printf (" %d", shndx);
7004 else
7005 add_shndx_to_cu_tu_entry (shndx);
7006 shndx_list += 4;
7007 }
7008 if (do_display)
7009 printf ("\n");
7010 else
7011 end_cu_tu_entry ();
7012 }
7013 phash += 8;
7014 pindex += 4;
7015 }
7016 }
7017 else if (version == 2)
7018 {
7019 unsigned int val;
7020 unsigned int dw_sect;
7021 unsigned char *ph = phash;
7022 unsigned char *pi = pindex;
7023 unsigned char *poffsets = ppool + ncols * 4;
7024 unsigned char *psizes = poffsets + nused * ncols * 4;
7025 unsigned char *pend = psizes + nused * ncols * 4;
7026 bfd_boolean is_tu_index;
7027 struct cu_tu_set *this_set = NULL;
7028 unsigned int row;
7029 unsigned char *prow;
7030
7031 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7032
7033 if (pend > limit)
7034 {
7035 warn (_("Section %s too small for offset and size tables\n"),
7036 section->name);
7037 return 0;
7038 }
7039
7040 if (do_display)
7041 {
7042 printf (_(" Offset table\n"));
7043 printf (" slot %-16s ",
7044 is_tu_index ? _("signature") : _("dwo_id"));
7045 }
7046 else
7047 {
7048 if (is_tu_index)
7049 {
7050 tu_count = nused;
7051 tu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
7052 this_set = tu_sets;
7053 }
7054 else
7055 {
7056 cu_count = nused;
7057 cu_sets = xcmalloc (nused, sizeof (struct cu_tu_set));
7058 this_set = cu_sets;
7059 }
7060 }
7061 if (do_display)
7062 {
7063 for (j = 0; j < ncols; j++)
7064 {
7065 dw_sect = byte_get (ppool + j * 4, 4);
7066 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7067 }
7068 printf ("\n");
7069 }
7070 for (i = 0; i < nslots; i++)
7071 {
7072 byte_get_64 (ph, &signature_high, &signature_low);
7073 row = byte_get (pi, 4);
7074 if (row != 0)
7075 {
7076 if (!do_display)
7077 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
7078 prow = poffsets + (row - 1) * ncols * 4;
7079 if (do_display)
7080 printf (_(" [%3d] 0x%s"),
7081 i, dwarf_vmatoa64 (signature_high, signature_low,
7082 buf, sizeof (buf)));
7083 for (j = 0; j < ncols; j++)
7084 {
7085 val = byte_get (prow + j * 4, 4);
7086 if (do_display)
7087 printf (" %8d", val);
7088 else
7089 {
7090 dw_sect = byte_get (ppool + j * 4, 4);
7091 this_set [row - 1].section_offsets [dw_sect] = val;
7092 }
7093 }
7094 if (do_display)
7095 printf ("\n");
7096 }
7097 ph += 8;
7098 pi += 4;
7099 }
7100
7101 ph = phash;
7102 pi = pindex;
7103 if (do_display)
7104 {
7105 printf ("\n");
7106 printf (_(" Size table\n"));
7107 printf (" slot %-16s ",
7108 is_tu_index ? _("signature") : _("dwo_id"));
7109 }
7110 for (j = 0; j < ncols; j++)
7111 {
7112 val = byte_get (ppool + j * 4, 4);
7113 if (do_display)
7114 printf (" %8s", get_DW_SECT_short_name (val));
7115 }
7116 if (do_display)
7117 printf ("\n");
7118 for (i = 0; i < nslots; i++)
7119 {
7120 byte_get_64 (ph, &signature_high, &signature_low);
7121 row = byte_get (pi, 4);
7122 if (row != 0)
7123 {
7124 prow = psizes + (row - 1) * ncols * 4;
7125 if (do_display)
7126 printf (_(" [%3d] 0x%s"),
7127 i, dwarf_vmatoa64 (signature_high, signature_low,
7128 buf, sizeof (buf)));
7129 for (j = 0; j < ncols; j++)
7130 {
7131 val = byte_get (prow + j * 4, 4);
7132 if (do_display)
7133 printf (" %8d", val);
7134 else
7135 {
7136 dw_sect = byte_get (ppool + j * 4, 4);
7137 this_set [row - 1].section_sizes [dw_sect] = val;
7138 }
7139 }
7140 if (do_display)
7141 printf ("\n");
7142 }
7143 ph += 8;
7144 pi += 4;
7145 }
7146 }
7147 else if (do_display)
7148 printf (_(" Unsupported version\n"));
7149
7150 if (do_display)
7151 printf ("\n");
7152
7153 return 1;
7154 }
7155
7156 /* Load the CU and TU indexes if present. This will build a list of
7157 section sets that we can use to associate a .debug_info.dwo section
7158 with its associated .debug_abbrev.dwo section in a .dwp file. */
7159
7160 static void
load_cu_tu_indexes(void * file)7161 load_cu_tu_indexes (void *file)
7162 {
7163 /* If we have already loaded (or tried to load) the CU and TU indexes
7164 then do not bother to repeat the task. */
7165 if (cu_tu_indexes_read)
7166 return;
7167
7168 if (load_debug_section (dwp_cu_index, file))
7169 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7170
7171 if (load_debug_section (dwp_tu_index, file))
7172 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7173
7174 cu_tu_indexes_read = 1;
7175 }
7176
7177 /* Find the set of sections that includes section SHNDX. */
7178
7179 unsigned int *
find_cu_tu_set(void * file,unsigned int shndx)7180 find_cu_tu_set (void *file, unsigned int shndx)
7181 {
7182 unsigned int i;
7183
7184 load_cu_tu_indexes (file);
7185
7186 /* Find SHNDX in the shndx pool. */
7187 for (i = 0; i < shndx_pool_used; i++)
7188 if (shndx_pool [i] == shndx)
7189 break;
7190
7191 if (i >= shndx_pool_used)
7192 return NULL;
7193
7194 /* Now backup to find the first entry in the set. */
7195 while (i > 0 && shndx_pool [i - 1] != 0)
7196 i--;
7197
7198 return shndx_pool + i;
7199 }
7200
7201 /* Display a .debug_cu_index or .debug_tu_index section. */
7202
7203 static int
display_cu_index(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)7204 display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7205 {
7206 return process_cu_tu_index (section, 1);
7207 }
7208
7209 static int
display_debug_not_supported(struct dwarf_section * section,void * file ATTRIBUTE_UNUSED)7210 display_debug_not_supported (struct dwarf_section *section,
7211 void *file ATTRIBUTE_UNUSED)
7212 {
7213 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7214 section->name);
7215
7216 return 1;
7217 }
7218
7219 void *
cmalloc(size_t nmemb,size_t size)7220 cmalloc (size_t nmemb, size_t size)
7221 {
7222 /* Check for overflow. */
7223 if (nmemb >= ~(size_t) 0 / size)
7224 return NULL;
7225 else
7226 return malloc (nmemb * size);
7227 }
7228
7229 void *
xcmalloc(size_t nmemb,size_t size)7230 xcmalloc (size_t nmemb, size_t size)
7231 {
7232 /* Check for overflow. */
7233 if (nmemb >= ~(size_t) 0 / size)
7234 return NULL;
7235 else
7236 return xmalloc (nmemb * size);
7237 }
7238
7239 void *
xcrealloc(void * ptr,size_t nmemb,size_t size)7240 xcrealloc (void *ptr, size_t nmemb, size_t size)
7241 {
7242 /* Check for overflow. */
7243 if (nmemb >= ~(size_t) 0 / size)
7244 return NULL;
7245 else
7246 return xrealloc (ptr, nmemb * size);
7247 }
7248
7249 void
free_debug_memory(void)7250 free_debug_memory (void)
7251 {
7252 unsigned int i;
7253
7254 free_abbrevs ();
7255
7256 for (i = 0; i < max; i++)
7257 free_debug_section ((enum dwarf_section_display_enum) i);
7258
7259 if (debug_information != NULL)
7260 {
7261 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
7262 {
7263 for (i = 0; i < num_debug_info_entries; i++)
7264 {
7265 if (!debug_information [i].max_loc_offsets)
7266 {
7267 free (debug_information [i].loc_offsets);
7268 free (debug_information [i].have_frame_base);
7269 }
7270 if (!debug_information [i].max_range_lists)
7271 free (debug_information [i].range_lists);
7272 }
7273 }
7274
7275 free (debug_information);
7276 debug_information = NULL;
7277 num_debug_info_entries = 0;
7278 }
7279 }
7280
7281 void
dwarf_select_sections_by_names(const char * names)7282 dwarf_select_sections_by_names (const char *names)
7283 {
7284 typedef struct
7285 {
7286 const char * option;
7287 int * variable;
7288 int val;
7289 }
7290 debug_dump_long_opts;
7291
7292 static const debug_dump_long_opts opts_table [] =
7293 {
7294 /* Please keep this table alpha- sorted. */
7295 { "Ranges", & do_debug_ranges, 1 },
7296 { "abbrev", & do_debug_abbrevs, 1 },
7297 { "addr", & do_debug_addr, 1 },
7298 { "aranges", & do_debug_aranges, 1 },
7299 { "cu_index", & do_debug_cu_index, 1 },
7300 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
7301 { "frames", & do_debug_frames, 1 },
7302 { "frames-interp", & do_debug_frames_interp, 1 },
7303 /* The special .gdb_index section. */
7304 { "gdb_index", & do_gdb_index, 1 },
7305 { "info", & do_debug_info, 1 },
7306 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
7307 { "loc", & do_debug_loc, 1 },
7308 { "macro", & do_debug_macinfo, 1 },
7309 { "pubnames", & do_debug_pubnames, 1 },
7310 { "pubtypes", & do_debug_pubtypes, 1 },
7311 /* This entry is for compatability
7312 with earlier versions of readelf. */
7313 { "ranges", & do_debug_aranges, 1 },
7314 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
7315 { "str", & do_debug_str, 1 },
7316 /* These trace_* sections are used by Itanium VMS. */
7317 { "trace_abbrev", & do_trace_abbrevs, 1 },
7318 { "trace_aranges", & do_trace_aranges, 1 },
7319 { "trace_info", & do_trace_info, 1 },
7320 { NULL, NULL, 0 }
7321 };
7322
7323 const char *p;
7324
7325 p = names;
7326 while (*p)
7327 {
7328 const debug_dump_long_opts * entry;
7329
7330 for (entry = opts_table; entry->option; entry++)
7331 {
7332 size_t len = strlen (entry->option);
7333
7334 if (strncmp (p, entry->option, len) == 0
7335 && (p[len] == ',' || p[len] == '\0'))
7336 {
7337 * entry->variable |= entry->val;
7338
7339 /* The --debug-dump=frames-interp option also
7340 enables the --debug-dump=frames option. */
7341 if (do_debug_frames_interp)
7342 do_debug_frames = 1;
7343
7344 p += len;
7345 break;
7346 }
7347 }
7348
7349 if (entry->option == NULL)
7350 {
7351 warn (_("Unrecognized debug option '%s'\n"), p);
7352 p = strchr (p, ',');
7353 if (p == NULL)
7354 break;
7355 }
7356
7357 if (*p == ',')
7358 p++;
7359 }
7360 }
7361
7362 void
dwarf_select_sections_by_letters(const char * letters)7363 dwarf_select_sections_by_letters (const char *letters)
7364 {
7365 unsigned int lindex = 0;
7366
7367 while (letters[lindex])
7368 switch (letters[lindex++])
7369 {
7370 case 'i':
7371 do_debug_info = 1;
7372 break;
7373
7374 case 'a':
7375 do_debug_abbrevs = 1;
7376 break;
7377
7378 case 'l':
7379 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7380 break;
7381
7382 case 'L':
7383 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7384 break;
7385
7386 case 'p':
7387 do_debug_pubnames = 1;
7388 break;
7389
7390 case 't':
7391 do_debug_pubtypes = 1;
7392 break;
7393
7394 case 'r':
7395 do_debug_aranges = 1;
7396 break;
7397
7398 case 'R':
7399 do_debug_ranges = 1;
7400 break;
7401
7402 case 'F':
7403 do_debug_frames_interp = 1;
7404 case 'f':
7405 do_debug_frames = 1;
7406 break;
7407
7408 case 'm':
7409 do_debug_macinfo = 1;
7410 break;
7411
7412 case 's':
7413 do_debug_str = 1;
7414 break;
7415
7416 case 'o':
7417 do_debug_loc = 1;
7418 break;
7419
7420 default:
7421 warn (_("Unrecognized debug option '%s'\n"), optarg);
7422 break;
7423 }
7424 }
7425
7426 void
dwarf_select_sections_all(void)7427 dwarf_select_sections_all (void)
7428 {
7429 do_debug_info = 1;
7430 do_debug_abbrevs = 1;
7431 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7432 do_debug_pubnames = 1;
7433 do_debug_pubtypes = 1;
7434 do_debug_aranges = 1;
7435 do_debug_ranges = 1;
7436 do_debug_frames = 1;
7437 do_debug_macinfo = 1;
7438 do_debug_str = 1;
7439 do_debug_loc = 1;
7440 do_gdb_index = 1;
7441 do_trace_info = 1;
7442 do_trace_abbrevs = 1;
7443 do_trace_aranges = 1;
7444 do_debug_addr = 1;
7445 do_debug_cu_index = 1;
7446 }
7447
7448 struct dwarf_section_display debug_displays[] =
7449 {
7450 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0 },
7451 display_debug_abbrev, &do_debug_abbrevs, 0 },
7452 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0 },
7453 display_debug_aranges, &do_debug_aranges, 1 },
7454 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0 },
7455 display_debug_frames, &do_debug_frames, 1 },
7456 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev },
7457 display_debug_info, &do_debug_info, 1 },
7458 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0 },
7459 display_debug_lines, &do_debug_lines, 1 },
7460 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0 },
7461 display_debug_pubnames, &do_debug_pubnames, 0 },
7462 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0 },
7463 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
7464 { { ".eh_frame", "", NULL, NULL, 0, 0, 0 },
7465 display_debug_frames, &do_debug_frames, 1 },
7466 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0 },
7467 display_debug_macinfo, &do_debug_macinfo, 0 },
7468 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0 },
7469 display_debug_macro, &do_debug_macinfo, 1 },
7470 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0 },
7471 display_debug_str, &do_debug_str, 0 },
7472 { { ".debug_line_str", ".zdebug_line_str", NULL, NULL, 0, 0, 0 },
7473 display_debug_str, &do_debug_str, 0 },
7474 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0 },
7475 display_debug_loc, &do_debug_loc, 1 },
7476 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0 },
7477 display_debug_pubnames, &do_debug_pubtypes, 0 },
7478 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0 },
7479 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
7480 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0 },
7481 display_debug_ranges, &do_debug_ranges, 1 },
7482 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0 },
7483 display_debug_not_supported, NULL, 0 },
7484 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0 },
7485 display_debug_not_supported, NULL, 0 },
7486 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev },
7487 display_debug_types, &do_debug_info, 1 },
7488 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0 },
7489 display_debug_not_supported, NULL, 0 },
7490 { { ".gdb_index", "", NULL, NULL, 0, 0, 0 },
7491 display_gdb_index, &do_gdb_index, 0 },
7492 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev },
7493 display_trace_info, &do_trace_info, 1 },
7494 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0 },
7495 display_debug_abbrev, &do_trace_abbrevs, 0 },
7496 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0 },
7497 display_debug_aranges, &do_trace_aranges, 0 },
7498 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo },
7499 display_debug_info, &do_debug_info, 1 },
7500 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0 },
7501 display_debug_abbrev, &do_debug_abbrevs, 0 },
7502 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo },
7503 display_debug_types, &do_debug_info, 1 },
7504 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0 },
7505 display_debug_lines, &do_debug_lines, 1 },
7506 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0 },
7507 display_debug_loc, &do_debug_loc, 1 },
7508 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0 },
7509 display_debug_macro, &do_debug_macinfo, 1 },
7510 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0 },
7511 display_debug_macinfo, &do_debug_macinfo, 0 },
7512 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0 },
7513 display_debug_str, &do_debug_str, 1 },
7514 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0 },
7515 display_debug_str_offsets, NULL, 0 },
7516 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0 },
7517 display_debug_str_offsets, NULL, 0 },
7518 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0 },
7519 display_debug_addr, &do_debug_addr, 1 },
7520 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0 },
7521 display_cu_index, &do_debug_cu_index, 0 },
7522 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0 },
7523 display_cu_index, &do_debug_cu_index, 0 },
7524 };
7525