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