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