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