?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
opcodes/
[binutils.git] / binutils / dwarf.c
blob117d2a573e5e806c3b7a21adf1b1f36efc814374
1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006
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
29 static int have_frame_base;
30 static int need_base_address;
31
32 static unsigned int last_pointer_size = 0;
33 static int warned_about_missing_comp_units = FALSE;
34
35 static unsigned int num_debug_info_entries = 0;
36 static debug_info *debug_information = NULL;
37
38 dwarf_vma eh_addr_size;
39 int is_relocatable;
40
41 int do_debug_info;
42 int do_debug_abbrevs;
43 int do_debug_lines;
44 int do_debug_pubnames;
45 int do_debug_aranges;
46 int do_debug_ranges;
47 int do_debug_frames;
48 int do_debug_frames_interp;
49 int do_debug_macinfo;
50 int do_debug_str;
51 int do_debug_loc;
52
53 dwarf_vma (*byte_get) (unsigned char *, int);
54
55 dwarf_vma
56 byte_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
98 dwarf_vma
99 byte_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
142 static dwarf_vma
143 byte_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
162 static unsigned long int
163 read_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
191 typedef 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
205 static SMR state_machine_regs;
206
207 static void
208 reset_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
223 static int
224 process_extended_line_op (unsigned char *data, int is_stmt)
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:
254 adr = byte_get (data, len - bytes_read - 1);
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
282 static const char *
283 fetch_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
290 /* DWARF sections under Mach-O have non-zero addresses. */
291 offset -= section->address;
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. */
304 typedef struct abbrev_attr
305 {
306 unsigned long attribute;
307 unsigned long form;
308 struct abbrev_attr *next;
309 }
310 abbrev_attr;
311
312 typedef 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 }
321 abbrev_entry;
322
323 static abbrev_entry *first_abbrev = NULL;
324 static abbrev_entry *last_abbrev = NULL;
325
326 static void
327 free_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
351 static void
352 add_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
377 static void
378 add_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
405 static unsigned char *
406 process_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
454 static char *
455 get_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
534 static char *
535 get_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
570 static unsigned char *
571 display_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
581 static int
582 decode_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
922 static unsigned char *
923 read_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
1368 static char *
1369 get_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
1482 static unsigned char *
1483 read_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
1509 static int
1510 process_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;
1607 start += compunit.cu_length + initial_length_size;
1608
1609 cu_abbrev_offset_ptr = hdrptr;
1610 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1611 hdrptr += offset_size;
1612
1613 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1614 hdrptr += 1;
1615 if ((do_loc || do_debug_loc || do_debug_ranges)
1616 && num_debug_info_entries == 0)
1617 {
1618 debug_information [unit].cu_offset = cu_offset;
1619 debug_information [unit].pointer_size
1620 = compunit.cu_pointer_size;
1621 debug_information [unit].base_address = 0;
1622 debug_information [unit].loc_offsets = NULL;
1623 debug_information [unit].have_frame_base = NULL;
1624 debug_information [unit].max_loc_offsets = 0;
1625 debug_information [unit].num_loc_offsets = 0;
1626 debug_information [unit].range_lists = NULL;
1627 debug_information [unit].max_range_lists= 0;
1628 debug_information [unit].num_range_lists = 0;
1629 }
1630
1631 tags = hdrptr;
1632
1633 if (!do_loc)
1634 {
1635 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1636 printf (_(" Length: %ld\n"), compunit.cu_length);
1637 printf (_(" Version: %d\n"), compunit.cu_version);
1638 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1639 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1640 }
1641
1642 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1643 {
1644 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1645 continue;
1646 }
1647
1648 free_abbrevs ();
1649
1650 /* Process the abbrevs used by this compilation unit. DWARF
1651 sections under Mach-O have non-zero addresses. */
1652 process_abbrev_section
1653 ((unsigned char *) debug_displays [abbrev].section.start
1654 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1655 (unsigned char *) debug_displays [abbrev].section.start
1656 + debug_displays [abbrev].section.size);
1657
1658 level = 0;
1659 while (tags < start)
1660 {
1661 unsigned int bytes_read;
1662 unsigned long abbrev_number;
1663 abbrev_entry *entry;
1664 abbrev_attr *attr;
1665
1666 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1667 tags += bytes_read;
1668
1669 /* A null DIE marks the end of a list of children. */
1670 if (abbrev_number == 0)
1671 {
1672 --level;
1673 continue;
1674 }
1675
1676 /* Scan through the abbreviation list until we reach the
1677 correct entry. */
1678 for (entry = first_abbrev;
1679 entry && entry->entry != abbrev_number;
1680 entry = entry->next)
1681 continue;
1682
1683 if (entry == NULL)
1684 {
1685 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1686 abbrev_number);
1687 return 0;
1688 }
1689
1690 if (!do_loc)
1691 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
1692 level,
1693 (unsigned long) (tags - section_begin
1694 - bytes_read),
1695 abbrev_number,
1696 get_TAG_name (entry->tag));
1697
1698 switch (entry->tag)
1699 {
1700 default:
1701 need_base_address = 0;
1702 break;
1703 case DW_TAG_compile_unit:
1704 need_base_address = 1;
1705 break;
1706 case DW_TAG_entry_point:
1707 case DW_TAG_inlined_subroutine:
1708 case DW_TAG_subprogram:
1709 need_base_address = 0;
1710 /* Assuming that there is no DW_AT_frame_base. */
1711 have_frame_base = 0;
1712 break;
1713 }
1714
1715 for (attr = entry->first_attr; attr; attr = attr->next)
1716 tags = read_and_display_attr (attr->attribute,
1717 attr->form,
1718 tags, cu_offset,
1719 compunit.cu_pointer_size,
1720 offset_size,
1721 compunit.cu_version,
1722 &debug_information [unit],
1723 do_loc);
1724
1725 if (entry->children)
1726 ++level;
1727 }
1728 }
1729
1730 /* Set num_debug_info_entries here so that it can be used to check if
1731 we need to process .debug_loc and .debug_ranges sections. */
1732 if ((do_loc || do_debug_loc || do_debug_ranges)
1733 && num_debug_info_entries == 0)
1734 num_debug_info_entries = num_units;
1735
1736 if (!do_loc)
1737 {
1738 printf ("\n");
1739 }
1740
1741 return 1;
1742 }
1743
1744 /* Locate and scan the .debug_info section in the file and record the pointer
1745 sizes and offsets for the compilation units in it. Usually an executable
1746 will have just one pointer size, but this is not guaranteed, and so we try
1747 not to make any assumptions. Returns zero upon failure, or the number of
1748 compilation units upon success. */
1749
1750 static unsigned int
1751 load_debug_info (void * file)
1752 {
1753 /* Reset the last pointer size so that we can issue correct error
1754 messages if we are displaying the contents of more than one section. */
1755 last_pointer_size = 0;
1756 warned_about_missing_comp_units = FALSE;
1757
1758 /* If we already have the information there is nothing else to do. */
1759 if (num_debug_info_entries > 0)
1760 return num_debug_info_entries;
1761
1762 if (load_debug_section (info, file)
1763 && process_debug_info (&debug_displays [info].section, file, 1))
1764 return num_debug_info_entries;
1765 else
1766 return 0;
1767 }
1768
1769 static int
1770 display_debug_lines (struct dwarf_section *section, void *file)
1771 {
1772 unsigned char *start = section->start;
1773 unsigned char *data = start;
1774 unsigned char *end = start + section->size;
1775
1776 printf (_("\nDump of debug contents of section %s:\n\n"),
1777 section->name);
1778
1779 load_debug_info (file);
1780
1781 while (data < end)
1782 {
1783 DWARF2_Internal_LineInfo info;
1784 unsigned char *standard_opcodes;
1785 unsigned char *end_of_sequence;
1786 unsigned char *hdrptr;
1787 int initial_length_size;
1788 int offset_size;
1789 int i;
1790
1791 hdrptr = data;
1792
1793 /* Check the length of the block. */
1794 info.li_length = byte_get (hdrptr, 4);
1795 hdrptr += 4;
1796
1797 if (info.li_length == 0xffffffff)
1798 {
1799 /* This section is 64-bit DWARF 3. */
1800 info.li_length = byte_get (hdrptr, 8);
1801 hdrptr += 8;
1802 offset_size = 8;
1803 initial_length_size = 12;
1804 }
1805 else
1806 {
1807 offset_size = 4;
1808 initial_length_size = 4;
1809 }
1810
1811 if (info.li_length + initial_length_size > section->size)
1812 {
1813 warn
1814 (_("The line info appears to be corrupt - the section is too small\n"));
1815 return 0;
1816 }
1817
1818 /* Check its version number. */
1819 info.li_version = byte_get (hdrptr, 2);
1820 hdrptr += 2;
1821 if (info.li_version != 2 && info.li_version != 3)
1822 {
1823 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1824 return 0;
1825 }
1826
1827 info.li_prologue_length = byte_get (hdrptr, offset_size);
1828 hdrptr += offset_size;
1829 info.li_min_insn_length = byte_get (hdrptr, 1);
1830 hdrptr++;
1831 info.li_default_is_stmt = byte_get (hdrptr, 1);
1832 hdrptr++;
1833 info.li_line_base = byte_get (hdrptr, 1);
1834 hdrptr++;
1835 info.li_line_range = byte_get (hdrptr, 1);
1836 hdrptr++;
1837 info.li_opcode_base = byte_get (hdrptr, 1);
1838 hdrptr++;
1839
1840 /* Sign extend the line base field. */
1841 info.li_line_base <<= 24;
1842 info.li_line_base >>= 24;
1843
1844 printf (_(" Length: %ld\n"), info.li_length);
1845 printf (_(" DWARF Version: %d\n"), info.li_version);
1846 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
1847 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
1848 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
1849 printf (_(" Line Base: %d\n"), info.li_line_base);
1850 printf (_(" Line Range: %d\n"), info.li_line_range);
1851 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
1852
1853 end_of_sequence = data + info.li_length + initial_length_size;
1854
1855 reset_state_machine (info.li_default_is_stmt);
1856
1857 /* Display the contents of the Opcodes table. */
1858 standard_opcodes = hdrptr;
1859
1860 printf (_("\n Opcodes:\n"));
1861
1862 for (i = 1; i < info.li_opcode_base; i++)
1863 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
1864
1865 /* Display the contents of the Directory table. */
1866 data = standard_opcodes + info.li_opcode_base - 1;
1867
1868 if (*data == 0)
1869 printf (_("\n The Directory Table is empty.\n"));
1870 else
1871 {
1872 printf (_("\n The Directory Table:\n"));
1873
1874 while (*data != 0)
1875 {
1876 printf (_(" %s\n"), data);
1877
1878 data += strlen ((char *) data) + 1;
1879 }
1880 }
1881
1882 /* Skip the NUL at the end of the table. */
1883 data++;
1884
1885 /* Display the contents of the File Name table. */
1886 if (*data == 0)
1887 printf (_("\n The File Name Table is empty.\n"));
1888 else
1889 {
1890 printf (_("\n The File Name Table:\n"));
1891 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
1892
1893 while (*data != 0)
1894 {
1895 unsigned char *name;
1896 unsigned int bytes_read;
1897
1898 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
1899 name = data;
1900
1901 data += strlen ((char *) data) + 1;
1902
1903 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1904 data += bytes_read;
1905 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1906 data += bytes_read;
1907 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1908 data += bytes_read;
1909 printf (_("%s\n"), name);
1910 }
1911 }
1912
1913 /* Skip the NUL at the end of the table. */
1914 data++;
1915
1916 /* Now display the statements. */
1917 printf (_("\n Line Number Statements:\n"));
1918
1919 while (data < end_of_sequence)
1920 {
1921 unsigned char op_code;
1922 int adv;
1923 unsigned long int uladv;
1924 unsigned int bytes_read;
1925
1926 op_code = *data++;
1927
1928 if (op_code >= info.li_opcode_base)
1929 {
1930 op_code -= info.li_opcode_base;
1931 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
1932 state_machine_regs.address += uladv;
1933 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
1934 op_code, uladv, state_machine_regs.address);
1935 adv = (op_code % info.li_line_range) + info.li_line_base;
1936 state_machine_regs.line += adv;
1937 printf (_(" and Line by %d to %d\n"),
1938 adv, state_machine_regs.line);
1939 }
1940 else switch (op_code)
1941 {
1942 case DW_LNS_extended_op:
1943 data += process_extended_line_op (data, info.li_default_is_stmt);
1944 break;
1945
1946 case DW_LNS_copy:
1947 printf (_(" Copy\n"));
1948 break;
1949
1950 case DW_LNS_advance_pc:
1951 uladv = read_leb128 (data, & bytes_read, 0);
1952 uladv *= info.li_min_insn_length;
1953 data += bytes_read;
1954 state_machine_regs.address += uladv;
1955 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
1956 state_machine_regs.address);
1957 break;
1958
1959 case DW_LNS_advance_line:
1960 adv = read_leb128 (data, & bytes_read, 1);
1961 data += bytes_read;
1962 state_machine_regs.line += adv;
1963 printf (_(" Advance Line by %d to %d\n"), adv,
1964 state_machine_regs.line);
1965 break;
1966
1967 case DW_LNS_set_file:
1968 adv = read_leb128 (data, & bytes_read, 0);
1969 data += bytes_read;
1970 printf (_(" Set File Name to entry %d in the File Name Table\n"),
1971 adv);
1972 state_machine_regs.file = adv;
1973 break;
1974
1975 case DW_LNS_set_column:
1976 uladv = read_leb128 (data, & bytes_read, 0);
1977 data += bytes_read;
1978 printf (_(" Set column to %lu\n"), uladv);
1979 state_machine_regs.column = uladv;
1980 break;
1981
1982 case DW_LNS_negate_stmt:
1983 adv = state_machine_regs.is_stmt;
1984 adv = ! adv;
1985 printf (_(" Set is_stmt to %d\n"), adv);
1986 state_machine_regs.is_stmt = adv;
1987 break;
1988
1989 case DW_LNS_set_basic_block:
1990 printf (_(" Set basic block\n"));
1991 state_machine_regs.basic_block = 1;
1992 break;
1993
1994 case DW_LNS_const_add_pc:
1995 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
1996 * info.li_min_insn_length);
1997 state_machine_regs.address += uladv;
1998 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
1999 state_machine_regs.address);
2000 break;
2001
2002 case DW_LNS_fixed_advance_pc:
2003 uladv = byte_get (data, 2);
2004 data += 2;
2005 state_machine_regs.address += uladv;
2006 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2007 uladv, state_machine_regs.address);
2008 break;
2009
2010 case DW_LNS_set_prologue_end:
2011 printf (_(" Set prologue_end to true\n"));
2012 break;
2013
2014 case DW_LNS_set_epilogue_begin:
2015 printf (_(" Set epilogue_begin to true\n"));
2016 break;
2017
2018 case DW_LNS_set_isa:
2019 uladv = read_leb128 (data, & bytes_read, 0);
2020 data += bytes_read;
2021 printf (_(" Set ISA to %lu\n"), uladv);
2022 break;
2023
2024 default:
2025 printf (_(" Unknown opcode %d with operands: "), op_code);
2026
2027 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2028 {
2029 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2030 i == 1 ? "" : ", ");
2031 data += bytes_read;
2032 }
2033 putchar ('\n');
2034 break;
2035 }
2036 }
2037 putchar ('\n');
2038 }
2039
2040 return 1;
2041 }
2042
2043 static int
2044 display_debug_pubnames (struct dwarf_section *section,
2045 void *file ATTRIBUTE_UNUSED)
2046 {
2047 DWARF2_Internal_PubNames pubnames;
2048 unsigned char *start = section->start;
2049 unsigned char *end = start + section->size;
2050
2051 printf (_("Contents of the %s section:\n\n"), section->name);
2052
2053 while (start < end)
2054 {
2055 unsigned char *data;
2056 unsigned long offset;
2057 int offset_size, initial_length_size;
2058
2059 data = start;
2060
2061 pubnames.pn_length = byte_get (data, 4);
2062 data += 4;
2063 if (pubnames.pn_length == 0xffffffff)
2064 {
2065 pubnames.pn_length = byte_get (data, 8);
2066 data += 8;
2067 offset_size = 8;
2068 initial_length_size = 12;
2069 }
2070 else
2071 {
2072 offset_size = 4;
2073 initial_length_size = 4;
2074 }
2075
2076 pubnames.pn_version = byte_get (data, 2);
2077 data += 2;
2078 pubnames.pn_offset = byte_get (data, offset_size);
2079 data += offset_size;
2080 pubnames.pn_size = byte_get (data, offset_size);
2081 data += offset_size;
2082
2083 start += pubnames.pn_length + initial_length_size;
2084
2085 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2086 {
2087 static int warned = 0;
2088
2089 if (! warned)
2090 {
2091 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2092 warned = 1;
2093 }
2094
2095 continue;
2096 }
2097
2098 printf (_(" Length: %ld\n"),
2099 pubnames.pn_length);
2100 printf (_(" Version: %d\n"),
2101 pubnames.pn_version);
2102 printf (_(" Offset into .debug_info section: %ld\n"),
2103 pubnames.pn_offset);
2104 printf (_(" Size of area in .debug_info section: %ld\n"),
2105 pubnames.pn_size);
2106
2107 printf (_("\n Offset\tName\n"));
2108
2109 do
2110 {
2111 offset = byte_get (data, offset_size);
2112
2113 if (offset != 0)
2114 {
2115 data += offset_size;
2116 printf (" %-6ld\t\t%s\n", offset, data);
2117 data += strlen ((char *) data) + 1;
2118 }
2119 }
2120 while (offset != 0);
2121 }
2122
2123 printf ("\n");
2124 return 1;
2125 }
2126
2127 static int
2128 display_debug_macinfo (struct dwarf_section *section,
2129 void *file ATTRIBUTE_UNUSED)
2130 {
2131 unsigned char *start = section->start;
2132 unsigned char *end = start + section->size;
2133 unsigned char *curr = start;
2134 unsigned int bytes_read;
2135 enum dwarf_macinfo_record_type op;
2136
2137 printf (_("Contents of the %s section:\n\n"), section->name);
2138
2139 while (curr < end)
2140 {
2141 unsigned int lineno;
2142 const char *string;
2143
2144 op = *curr;
2145 curr++;
2146
2147 switch (op)
2148 {
2149 case DW_MACINFO_start_file:
2150 {
2151 unsigned int filenum;
2152
2153 lineno = read_leb128 (curr, & bytes_read, 0);
2154 curr += bytes_read;
2155 filenum = read_leb128 (curr, & bytes_read, 0);
2156 curr += bytes_read;
2157
2158 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2159 lineno, filenum);
2160 }
2161 break;
2162
2163 case DW_MACINFO_end_file:
2164 printf (_(" DW_MACINFO_end_file\n"));
2165 break;
2166
2167 case DW_MACINFO_define:
2168 lineno = read_leb128 (curr, & bytes_read, 0);
2169 curr += bytes_read;
2170 string = (char *) curr;
2171 curr += strlen (string) + 1;
2172 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2173 lineno, string);
2174 break;
2175
2176 case DW_MACINFO_undef:
2177 lineno = read_leb128 (curr, & bytes_read, 0);
2178 curr += bytes_read;
2179 string = (char *) curr;
2180 curr += strlen (string) + 1;
2181 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2182 lineno, string);
2183 break;
2184
2185 case DW_MACINFO_vendor_ext:
2186 {
2187 unsigned int constant;
2188
2189 constant = read_leb128 (curr, & bytes_read, 0);
2190 curr += bytes_read;
2191 string = (char *) curr;
2192 curr += strlen (string) + 1;
2193 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2194 constant, string);
2195 }
2196 break;
2197 }
2198 }
2199
2200 return 1;
2201 }
2202
2203 static int
2204 display_debug_abbrev (struct dwarf_section *section,
2205 void *file ATTRIBUTE_UNUSED)
2206 {
2207 abbrev_entry *entry;
2208 unsigned char *start = section->start;
2209 unsigned char *end = start + section->size;
2210
2211 printf (_("Contents of the %s section:\n\n"), section->name);
2212
2213 do
2214 {
2215 free_abbrevs ();
2216
2217 start = process_abbrev_section (start, end);
2218
2219 if (first_abbrev == NULL)
2220 continue;
2221
2222 printf (_(" Number TAG\n"));
2223
2224 for (entry = first_abbrev; entry; entry = entry->next)
2225 {
2226 abbrev_attr *attr;
2227
2228 printf (_(" %ld %s [%s]\n"),
2229 entry->entry,
2230 get_TAG_name (entry->tag),
2231 entry->children ? _("has children") : _("no children"));
2232
2233 for (attr = entry->first_attr; attr; attr = attr->next)
2234 printf (_(" %-18s %s\n"),
2235 get_AT_name (attr->attribute),
2236 get_FORM_name (attr->form));
2237 }
2238 }
2239 while (start);
2240
2241 printf ("\n");
2242
2243 return 1;
2244 }
2245
2246 static int
2247 display_debug_loc (struct dwarf_section *section, void *file)
2248 {
2249 unsigned char *start = section->start;
2250 unsigned char *section_end;
2251 unsigned long bytes;
2252 unsigned char *section_begin = start;
2253 unsigned int num_loc_list = 0;
2254 unsigned long last_offset = 0;
2255 unsigned int first = 0;
2256 unsigned int i;
2257 unsigned int j;
2258 int seen_first_offset = 0;
2259 int use_debug_info = 1;
2260 unsigned char *next;
2261
2262 bytes = section->size;
2263 section_end = start + bytes;
2264
2265 if (bytes == 0)
2266 {
2267 printf (_("\nThe %s section is empty.\n"), section->name);
2268 return 0;
2269 }
2270
2271 load_debug_info (file);
2272
2273 /* Check the order of location list in .debug_info section. If
2274 offsets of location lists are in the ascending order, we can
2275 use `debug_information' directly. */
2276 for (i = 0; i < num_debug_info_entries; i++)
2277 {
2278 unsigned int num;
2279
2280 num = debug_information [i].num_loc_offsets;
2281 num_loc_list += num;
2282
2283 /* Check if we can use `debug_information' directly. */
2284 if (use_debug_info && num != 0)
2285 {
2286 if (!seen_first_offset)
2287 {
2288 /* This is the first location list. */
2289 last_offset = debug_information [i].loc_offsets [0];
2290 first = i;
2291 seen_first_offset = 1;
2292 j = 1;
2293 }
2294 else
2295 j = 0;
2296
2297 for (; j < num; j++)
2298 {
2299 if (last_offset >
2300 debug_information [i].loc_offsets [j])
2301 {
2302 use_debug_info = 0;
2303 break;
2304 }
2305 last_offset = debug_information [i].loc_offsets [j];
2306 }
2307 }
2308 }
2309
2310 if (!use_debug_info)
2311 /* FIXME: Should we handle this case? */
2312 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2313
2314 if (!seen_first_offset)
2315 error (_("No location lists in .debug_info section!\n"));
2316
2317 /* DWARF sections under Mach-O have non-zero addresses. */
2318 if (debug_information [first].num_loc_offsets > 0
2319 && debug_information [first].loc_offsets [0] != section->address)
2320 warn (_("Location lists in %s section start at 0x%lx\n"),
2321 section->name, debug_information [first].loc_offsets [0]);
2322
2323 printf (_("Contents of the %s section:\n\n"), section->name);
2324 printf (_(" Offset Begin End Expression\n"));
2325
2326 seen_first_offset = 0;
2327 for (i = first; i < num_debug_info_entries; i++)
2328 {
2329 unsigned long begin;
2330 unsigned long end;
2331 unsigned short length;
2332 unsigned long offset;
2333 unsigned int pointer_size;
2334 unsigned long cu_offset;
2335 unsigned long base_address;
2336 int need_frame_base;
2337 int has_frame_base;
2338
2339 pointer_size = debug_information [i].pointer_size;
2340 cu_offset = debug_information [i].cu_offset;
2341
2342 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2343 {
2344 has_frame_base = debug_information [i].have_frame_base [j];
2345 /* DWARF sections under Mach-O have non-zero addresses. */
2346 offset = debug_information [i].loc_offsets [j] - section->address;
2347 next = section_begin + offset;
2348 base_address = debug_information [i].base_address;
2349
2350 if (!seen_first_offset)
2351 seen_first_offset = 1;
2352 else
2353 {
2354 if (start < next)
2355 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2356 (long)(start - section_begin), (long)(next - section_begin));
2357 else if (start > next)
2358 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2359 (long)(start - section_begin), (long)(next - section_begin));
2360 }
2361 start = next;
2362
2363 if (offset >= bytes)
2364 {
2365 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2366 offset);
2367 continue;
2368 }
2369
2370 while (1)
2371 {
2372 if (start + 2 * pointer_size > section_end)
2373 {
2374 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2375 offset);
2376 break;
2377 }
2378
2379 begin = byte_get (start, pointer_size);
2380 start += pointer_size;
2381 end = byte_get (start, pointer_size);
2382 start += pointer_size;
2383
2384 if (begin == 0 && end == 0)
2385 {
2386 printf (_(" %8.8lx <End of list>\n"), offset);
2387 break;
2388 }
2389
2390 /* Check base address specifiers. */
2391 if (begin == -1UL && end != -1UL)
2392 {
2393 base_address = end;
2394 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2395 offset, begin, end);
2396 continue;
2397 }
2398
2399 if (start + 2 > section_end)
2400 {
2401 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2402 offset);
2403 break;
2404 }
2405
2406 length = byte_get (start, 2);
2407 start += 2;
2408
2409 if (start + length > section_end)
2410 {
2411 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2412 offset);
2413 break;
2414 }
2415
2416 printf (" %8.8lx %8.8lx %8.8lx (",
2417 offset, begin + base_address, end + base_address);
2418 need_frame_base = decode_location_expression (start,
2419 pointer_size,
2420 length,
2421 cu_offset);
2422 putchar (')');
2423
2424 if (need_frame_base && !has_frame_base)
2425 printf (_(" [without DW_AT_frame_base]"));
2426
2427 if (begin == end)
2428 fputs (_(" (start == end)"), stdout);
2429 else if (begin > end)
2430 fputs (_(" (start > end)"), stdout);
2431
2432 putchar ('\n');
2433
2434 start += length;
2435 }
2436 }
2437 }
2438 return 1;
2439 }
2440
2441 static int
2442 display_debug_str (struct dwarf_section *section,
2443 void *file ATTRIBUTE_UNUSED)
2444 {
2445 unsigned char *start = section->start;
2446 unsigned long bytes = section->size;
2447 dwarf_vma addr = section->address;
2448
2449 if (bytes == 0)
2450 {
2451 printf (_("\nThe %s section is empty.\n"), section->name);
2452 return 0;
2453 }
2454
2455 printf (_("Contents of the %s section:\n\n"), section->name);
2456
2457 while (bytes)
2458 {
2459 int j;
2460 int k;
2461 int lbytes;
2462
2463 lbytes = (bytes > 16 ? 16 : bytes);
2464
2465 printf (" 0x%8.8lx ", (unsigned long) addr);
2466
2467 for (j = 0; j < 16; j++)
2468 {
2469 if (j < lbytes)
2470 printf ("%2.2x", start[j]);
2471 else
2472 printf (" ");
2473
2474 if ((j & 3) == 3)
2475 printf (" ");
2476 }
2477
2478 for (j = 0; j < lbytes; j++)
2479 {
2480 k = start[j];
2481 if (k >= ' ' && k < 0x80)
2482 printf ("%c", k);
2483 else
2484 printf (".");
2485 }
2486
2487 putchar ('\n');
2488
2489 start += lbytes;
2490 addr += lbytes;
2491 bytes -= lbytes;
2492 }
2493
2494 putchar ('\n');
2495
2496 return 1;
2497 }
2498
2499
2500 static int
2501 display_debug_info (struct dwarf_section *section, void *file)
2502 {
2503 return process_debug_info (section, file, 0);
2504 }
2505
2506
2507 static int
2508 display_debug_aranges (struct dwarf_section *section,
2509 void *file ATTRIBUTE_UNUSED)
2510 {
2511 unsigned char *start = section->start;
2512 unsigned char *end = start + section->size;
2513
2514 printf (_("The section %s contains:\n\n"), section->name);
2515
2516 while (start < end)
2517 {
2518 unsigned char *hdrptr;
2519 DWARF2_Internal_ARange arange;
2520 unsigned char *ranges;
2521 unsigned long length;
2522 unsigned long address;
2523 unsigned char address_size;
2524 int excess;
2525 int offset_size;
2526 int initial_length_size;
2527
2528 hdrptr = start;
2529
2530 arange.ar_length = byte_get (hdrptr, 4);
2531 hdrptr += 4;
2532
2533 if (arange.ar_length == 0xffffffff)
2534 {
2535 arange.ar_length = byte_get (hdrptr, 8);
2536 hdrptr += 8;
2537 offset_size = 8;
2538 initial_length_size = 12;
2539 }
2540 else
2541 {
2542 offset_size = 4;
2543 initial_length_size = 4;
2544 }
2545
2546 arange.ar_version = byte_get (hdrptr, 2);
2547 hdrptr += 2;
2548
2549 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2550 hdrptr += offset_size;
2551
2552 arange.ar_pointer_size = byte_get (hdrptr, 1);
2553 hdrptr += 1;
2554
2555 arange.ar_segment_size = byte_get (hdrptr, 1);
2556 hdrptr += 1;
2557
2558 if (arange.ar_version != 2 && arange.ar_version != 3)
2559 {
2560 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2561 break;
2562 }
2563
2564 printf (_(" Length: %ld\n"), arange.ar_length);
2565 printf (_(" Version: %d\n"), arange.ar_version);
2566 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
2567 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2568 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2569
2570 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2571
2572 /* The DWARF spec does not require that the address size be a power
2573 of two, but we do. This will have to change if we ever encounter
2574 an uneven architecture. */
2575 if ((address_size & (address_size - 1)) != 0)
2576 {
2577 warn (_("Pointer size + Segment size is not a power of two.\n"));
2578 break;
2579 }
2580
2581 if (address_size > 4)
2582 printf (_("\n Address Length\n"));
2583 else
2584 printf (_("\n Address Length\n"));
2585
2586 ranges = hdrptr;
2587
2588 /* Must pad to an alignment boundary that is twice the address size. */
2589 excess = (hdrptr - start) % (2 * address_size);
2590 if (excess)
2591 ranges += (2 * address_size) - excess;
2592
2593 start += arange.ar_length + initial_length_size;
2594
2595 while (ranges + 2 * address_size <= start)
2596 {
2597 address = byte_get (ranges, address_size);
2598
2599 ranges += address_size;
2600
2601 length = byte_get (ranges, address_size);
2602
2603 ranges += address_size;
2604
2605 if (address_size > 4)
2606 printf (" 0x%16.16lx 0x%lx\n", address, length);
2607 else
2608 printf (" 0x%8.8lx 0x%lx\n", address, length);
2609 }
2610 }
2611
2612 printf ("\n");
2613
2614 return 1;
2615 }
2616
2617 static int
2618 display_debug_ranges (struct dwarf_section *section,
2619 void *file ATTRIBUTE_UNUSED)
2620 {
2621 unsigned char *start = section->start;
2622 unsigned char *section_end;
2623 unsigned long bytes;
2624 unsigned char *section_begin = start;
2625 unsigned int num_range_list = 0;
2626 unsigned long last_offset = 0;
2627 unsigned int first = 0;
2628 unsigned int i;
2629 unsigned int j;
2630 int seen_first_offset = 0;
2631 int use_debug_info = 1;
2632 unsigned char *next;
2633
2634 bytes = section->size;
2635 section_end = start + bytes;
2636
2637 if (bytes == 0)
2638 {
2639 printf (_("\nThe %s section is empty.\n"), section->name);
2640 return 0;
2641 }
2642
2643 load_debug_info (file);
2644
2645 /* Check the order of range list in .debug_info section. If
2646 offsets of range lists are in the ascending order, we can
2647 use `debug_information' directly. */
2648 for (i = 0; i < num_debug_info_entries; i++)
2649 {
2650 unsigned int num;
2651
2652 num = debug_information [i].num_range_lists;
2653 num_range_list += num;
2654
2655 /* Check if we can use `debug_information' directly. */
2656 if (use_debug_info && num != 0)
2657 {
2658 if (!seen_first_offset)
2659 {
2660 /* This is the first range list. */
2661 last_offset = debug_information [i].range_lists [0];
2662 first = i;
2663 seen_first_offset = 1;
2664 j = 1;
2665 }
2666 else
2667 j = 0;
2668
2669 for (; j < num; j++)
2670 {
2671 if (last_offset >
2672 debug_information [i].range_lists [j])
2673 {
2674 use_debug_info = 0;
2675 break;
2676 }
2677 last_offset = debug_information [i].range_lists [j];
2678 }
2679 }
2680 }
2681
2682 if (!use_debug_info)
2683 /* FIXME: Should we handle this case? */
2684 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2685
2686 if (!seen_first_offset)
2687 error (_("No range lists in .debug_info section!\n"));
2688
2689 /* DWARF sections under Mach-O have non-zero addresses. */
2690 if (debug_information [first].num_range_lists > 0
2691 && debug_information [first].range_lists [0] != section->address)
2692 warn (_("Range lists in %s section start at 0x%lx\n"),
2693 section->name, debug_information [first].range_lists [0]);
2694
2695 printf (_("Contents of the %s section:\n\n"), section->name);
2696 printf (_(" Offset Begin End\n"));
2697
2698 seen_first_offset = 0;
2699 for (i = first; i < num_debug_info_entries; i++)
2700 {
2701 unsigned long begin;
2702 unsigned long end;
2703 unsigned long offset;
2704 unsigned int pointer_size;
2705 unsigned long base_address;
2706
2707 pointer_size = debug_information [i].pointer_size;
2708
2709 for (j = 0; j < debug_information [i].num_range_lists; j++)
2710 {
2711 /* DWARF sections under Mach-O have non-zero addresses. */
2712 offset = debug_information [i].range_lists [j] - section->address;
2713 next = section_begin + offset;
2714 base_address = debug_information [i].base_address;
2715
2716 if (!seen_first_offset)
2717 seen_first_offset = 1;
2718 else
2719 {
2720 if (start < next)
2721 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2722 (long)(start - section_begin),
2723 (long)(next - section_begin), section->name);
2724 else if (start > next)
2725 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2726 (long)(start - section_begin),
2727 (long)(next - section_begin), section->name);
2728 }
2729 start = next;
2730
2731 while (1)
2732 {
2733 begin = byte_get (start, pointer_size);
2734 start += pointer_size;
2735 end = byte_get (start, pointer_size);
2736 start += pointer_size;
2737
2738 if (begin == 0 && end == 0)
2739 {
2740 printf (_(" %8.8lx <End of list>\n"), offset);
2741 break;
2742 }
2743
2744 /* Check base address specifiers. */
2745 if (begin == -1UL && end != -1UL)
2746 {
2747 base_address = end;
2748 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2749 offset, begin, end);
2750 continue;
2751 }
2752
2753 printf (" %8.8lx %8.8lx %8.8lx",
2754 offset, begin + base_address, end + base_address);
2755
2756 if (begin == end)
2757 fputs (_(" (start == end)"), stdout);
2758 else if (begin > end)
2759 fputs (_(" (start > end)"), stdout);
2760
2761 putchar ('\n');
2762 }
2763 }
2764 }
2765 putchar ('\n');
2766 return 1;
2767 }
2768
2769 typedef struct Frame_Chunk
2770 {
2771 struct Frame_Chunk *next;
2772 unsigned char *chunk_start;
2773 int ncols;
2774 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2775 short int *col_type;
2776 int *col_offset;
2777 char *augmentation;
2778 unsigned int code_factor;
2779 int data_factor;
2780 unsigned long pc_begin;
2781 unsigned long pc_range;
2782 int cfa_reg;
2783 int cfa_offset;
2784 int ra;
2785 unsigned char fde_encoding;
2786 unsigned char cfa_exp;
2787 }
2788 Frame_Chunk;
2789
2790 /* A marker for a col_type that means this column was never referenced
2791 in the frame info. */
2792 #define DW_CFA_unreferenced (-1)
2793
2794 static void
2795 frame_need_space (Frame_Chunk *fc, int reg)
2796 {
2797 int prev = fc->ncols;
2798
2799 if (reg < fc->ncols)
2800 return;
2801
2802 fc->ncols = reg + 1;
2803 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2804 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2805
2806 while (prev < fc->ncols)
2807 {
2808 fc->col_type[prev] = DW_CFA_unreferenced;
2809 fc->col_offset[prev] = 0;
2810 prev++;
2811 }
2812 }
2813
2814 static void
2815 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
2816 {
2817 int r;
2818 char tmp[100];
2819
2820 if (*max_regs < fc->ncols)
2821 *max_regs = fc->ncols;
2822
2823 if (*need_col_headers)
2824 {
2825 *need_col_headers = 0;
2826
2827 printf (" LOC CFA ");
2828
2829 for (r = 0; r < *max_regs; r++)
2830 if (fc->col_type[r] != DW_CFA_unreferenced)
2831 {
2832 if (r == fc->ra)
2833 printf ("ra ");
2834 else
2835 printf ("r%-4d", r);
2836 }
2837
2838 printf ("\n");
2839 }
2840
2841 printf ("%08lx ", fc->pc_begin);
2842 if (fc->cfa_exp)
2843 strcpy (tmp, "exp");
2844 else
2845 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
2846 printf ("%-8s ", tmp);
2847
2848 for (r = 0; r < fc->ncols; r++)
2849 {
2850 if (fc->col_type[r] != DW_CFA_unreferenced)
2851 {
2852 switch (fc->col_type[r])
2853 {
2854 case DW_CFA_undefined:
2855 strcpy (tmp, "u");
2856 break;
2857 case DW_CFA_same_value:
2858 strcpy (tmp, "s");
2859 break;
2860 case DW_CFA_offset:
2861 sprintf (tmp, "c%+d", fc->col_offset[r]);
2862 break;
2863 case DW_CFA_val_offset:
2864 sprintf (tmp, "v%+d", fc->col_offset[r]);
2865 break;
2866 case DW_CFA_register:
2867 sprintf (tmp, "r%d", fc->col_offset[r]);
2868 break;
2869 case DW_CFA_expression:
2870 strcpy (tmp, "exp");
2871 break;
2872 case DW_CFA_val_expression:
2873 strcpy (tmp, "vexp");
2874 break;
2875 default:
2876 strcpy (tmp, "n/a");
2877 break;
2878 }
2879 printf ("%-5s", tmp);
2880 }
2881 }
2882 printf ("\n");
2883 }
2884
2885 static int
2886 size_of_encoded_value (int encoding)
2887 {
2888 switch (encoding & 0x7)
2889 {
2890 default: /* ??? */
2891 case 0: return eh_addr_size;
2892 case 2: return 2;
2893 case 3: return 4;
2894 case 4: return 8;
2895 }
2896 }
2897
2898 static dwarf_vma
2899 get_encoded_value (unsigned char *data, int encoding)
2900 {
2901 int size = size_of_encoded_value (encoding);
2902
2903 if (encoding & DW_EH_PE_signed)
2904 return byte_get_signed (data, size);
2905 else
2906 return byte_get (data, size);
2907 }
2908
2909 #define GET(N) byte_get (start, N); start += N
2910 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
2911 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
2912
2913 static int
2914 display_debug_frames (struct dwarf_section *section,
2915 void *file ATTRIBUTE_UNUSED)
2916 {
2917 unsigned char *start = section->start;
2918 unsigned char *end = start + section->size;
2919 unsigned char *section_start = start;
2920 Frame_Chunk *chunks = 0;
2921 Frame_Chunk *remembered_state = 0;
2922 Frame_Chunk *rs;
2923 int is_eh = strcmp (section->name, ".eh_frame") == 0;
2924 unsigned int length_return;
2925 int max_regs = 0;
2926
2927 printf (_("The section %s contains:\n"), section->name);
2928
2929 while (start < end)
2930 {
2931 unsigned char *saved_start;
2932 unsigned char *block_end;
2933 unsigned long length;
2934 unsigned long cie_id;
2935 Frame_Chunk *fc;
2936 Frame_Chunk *cie;
2937 int need_col_headers = 1;
2938 unsigned char *augmentation_data = NULL;
2939 unsigned long augmentation_data_len = 0;
2940 int encoded_ptr_size = eh_addr_size;
2941 int offset_size;
2942 int initial_length_size;
2943
2944 saved_start = start;
2945 length = byte_get (start, 4); start += 4;
2946
2947 if (length == 0)
2948 {
2949 printf ("\n%08lx ZERO terminator\n\n",
2950 (unsigned long)(saved_start - section_start));
2951 continue;
2952 }
2953
2954 if (length == 0xffffffff)
2955 {
2956 length = byte_get (start, 8);
2957 start += 8;
2958 offset_size = 8;
2959 initial_length_size = 12;
2960 }
2961 else
2962 {
2963 offset_size = 4;
2964 initial_length_size = 4;
2965 }
2966
2967 block_end = saved_start + length + initial_length_size;
2968 if (block_end > end)
2969 {
2970 warn ("Invalid length %#08lx in FDE at %#08lx\n",
2971 length, (unsigned long)(saved_start - section_start));
2972 block_end = end;
2973 }
2974 cie_id = byte_get (start, offset_size); start += offset_size;
2975
2976 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
2977 {
2978 int version;
2979
2980 fc = xmalloc (sizeof (Frame_Chunk));
2981 memset (fc, 0, sizeof (Frame_Chunk));
2982
2983 fc->next = chunks;
2984 chunks = fc;
2985 fc->chunk_start = saved_start;
2986 fc->ncols = 0;
2987 fc->col_type = xmalloc (sizeof (short int));
2988 fc->col_offset = xmalloc (sizeof (int));
2989 frame_need_space (fc, max_regs-1);
2990
2991 version = *start++;
2992
2993 fc->augmentation = (char *) start;
2994 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
2995
2996 if (fc->augmentation[0] == 'z')
2997 {
2998 fc->code_factor = LEB ();
2999 fc->data_factor = SLEB ();
3000 if (version == 1)
3001 {
3002 fc->ra = GET (1);
3003 }
3004 else
3005 {
3006 fc->ra = LEB ();
3007 }
3008 augmentation_data_len = LEB ();
3009 augmentation_data = start;
3010 start += augmentation_data_len;
3011 }
3012 else if (strcmp (fc->augmentation, "eh") == 0)
3013 {
3014 start += eh_addr_size;
3015 fc->code_factor = LEB ();
3016 fc->data_factor = SLEB ();
3017 if (version == 1)
3018 {
3019 fc->ra = GET (1);
3020 }
3021 else
3022 {
3023 fc->ra = LEB ();
3024 }
3025 }
3026 else
3027 {
3028 fc->code_factor = LEB ();
3029 fc->data_factor = SLEB ();
3030 if (version == 1)
3031 {
3032 fc->ra = GET (1);
3033 }
3034 else
3035 {
3036 fc->ra = LEB ();
3037 }
3038 }
3039 cie = fc;
3040
3041 if (do_debug_frames_interp)
3042 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3043 (unsigned long)(saved_start - section_start), length, cie_id,
3044 fc->augmentation, fc->code_factor, fc->data_factor,
3045 fc->ra);
3046 else
3047 {
3048 printf ("\n%08lx %08lx %08lx CIE\n",
3049 (unsigned long)(saved_start - section_start), length, cie_id);
3050 printf (" Version: %d\n", version);
3051 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3052 printf (" Code alignment factor: %u\n", fc->code_factor);
3053 printf (" Data alignment factor: %d\n", fc->data_factor);
3054 printf (" Return address column: %d\n", fc->ra);
3055
3056 if (augmentation_data_len)
3057 {
3058 unsigned long i;
3059 printf (" Augmentation data: ");
3060 for (i = 0; i < augmentation_data_len; ++i)
3061 printf (" %02x", augmentation_data[i]);
3062 putchar ('\n');
3063 }
3064 putchar ('\n');
3065 }
3066
3067 if (augmentation_data_len)
3068 {
3069 unsigned char *p, *q;
3070 p = (unsigned char *) fc->augmentation + 1;
3071 q = augmentation_data;
3072
3073 while (1)
3074 {
3075 if (*p == 'L')
3076 q++;
3077 else if (*p == 'P')
3078 q += 1 + size_of_encoded_value (*q);
3079 else if (*p == 'R')
3080 fc->fde_encoding = *q++;
3081 else
3082 break;
3083 p++;
3084 }
3085
3086 if (fc->fde_encoding)
3087 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3088 }
3089
3090 frame_need_space (fc, fc->ra);
3091 }
3092 else
3093 {
3094 unsigned char *look_for;
3095 static Frame_Chunk fde_fc;
3096
3097 fc = & fde_fc;
3098 memset (fc, 0, sizeof (Frame_Chunk));
3099
3100 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3101
3102 for (cie = chunks; cie ; cie = cie->next)
3103 if (cie->chunk_start == look_for)
3104 break;
3105
3106 if (!cie)
3107 {
3108 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3109 cie_id, (unsigned long)(saved_start - section_start));
3110 fc->ncols = 0;
3111 fc->col_type = xmalloc (sizeof (short int));
3112 fc->col_offset = xmalloc (sizeof (int));
3113 frame_need_space (fc, max_regs - 1);
3114 cie = fc;
3115 fc->augmentation = "";
3116 fc->fde_encoding = 0;
3117 }
3118 else
3119 {
3120 fc->ncols = cie->ncols;
3121 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3122 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3123 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3124 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3125 fc->augmentation = cie->augmentation;
3126 fc->code_factor = cie->code_factor;
3127 fc->data_factor = cie->data_factor;
3128 fc->cfa_reg = cie->cfa_reg;
3129 fc->cfa_offset = cie->cfa_offset;
3130 fc->ra = cie->ra;
3131 frame_need_space (fc, max_regs-1);
3132 fc->fde_encoding = cie->fde_encoding;
3133 }
3134
3135 if (fc->fde_encoding)
3136 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3137
3138 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3139 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3140 /* Don't adjust for relocatable file since there's
3141 invariably a pcrel reloc here, which we haven't
3142 applied. */
3143 && !is_relocatable)
3144 fc->pc_begin += section->address + (start - section_start);
3145 start += encoded_ptr_size;
3146 fc->pc_range = byte_get (start, encoded_ptr_size);
3147 start += encoded_ptr_size;
3148
3149 if (cie->augmentation[0] == 'z')
3150 {
3151 augmentation_data_len = LEB ();
3152 augmentation_data = start;
3153 start += augmentation_data_len;
3154 }
3155
3156 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3157 (unsigned long)(saved_start - section_start), length, cie_id,
3158 (unsigned long)(cie->chunk_start - section_start),
3159 fc->pc_begin, fc->pc_begin + fc->pc_range);
3160 if (! do_debug_frames_interp && augmentation_data_len)
3161 {
3162 unsigned long i;
3163
3164 printf (" Augmentation data: ");
3165 for (i = 0; i < augmentation_data_len; ++i)
3166 printf (" %02x", augmentation_data[i]);
3167 putchar ('\n');
3168 putchar ('\n');
3169 }
3170 }
3171
3172 /* At this point, fc is the current chunk, cie (if any) is set, and
3173 we're about to interpret instructions for the chunk. */
3174 /* ??? At present we need to do this always, since this sizes the
3175 fc->col_type and fc->col_offset arrays, which we write into always.
3176 We should probably split the interpreted and non-interpreted bits
3177 into two different routines, since there's so much that doesn't
3178 really overlap between them. */
3179 if (1 || do_debug_frames_interp)
3180 {
3181 /* Start by making a pass over the chunk, allocating storage
3182 and taking note of what registers are used. */
3183 unsigned char *tmp = start;
3184
3185 while (start < block_end)
3186 {
3187 unsigned op, opa;
3188 unsigned long reg, tmp;
3189
3190 op = *start++;
3191 opa = op & 0x3f;
3192 if (op & 0xc0)
3193 op &= 0xc0;
3194
3195 /* Warning: if you add any more cases to this switch, be
3196 sure to add them to the corresponding switch below. */
3197 switch (op)
3198 {
3199 case DW_CFA_advance_loc:
3200 break;
3201 case DW_CFA_offset:
3202 LEB ();
3203 frame_need_space (fc, opa);
3204 fc->col_type[opa] = DW_CFA_undefined;
3205 break;
3206 case DW_CFA_restore:
3207 frame_need_space (fc, opa);
3208 fc->col_type[opa] = DW_CFA_undefined;
3209 break;
3210 case DW_CFA_set_loc:
3211 start += encoded_ptr_size;
3212 break;
3213 case DW_CFA_advance_loc1:
3214 start += 1;
3215 break;
3216 case DW_CFA_advance_loc2:
3217 start += 2;
3218 break;
3219 case DW_CFA_advance_loc4:
3220 start += 4;
3221 break;
3222 case DW_CFA_offset_extended:
3223 case DW_CFA_val_offset:
3224 reg = LEB (); LEB ();
3225 frame_need_space (fc, reg);
3226 fc->col_type[reg] = DW_CFA_undefined;
3227 break;
3228 case DW_CFA_restore_extended:
3229 reg = LEB ();
3230 frame_need_space (fc, reg);
3231 fc->col_type[reg] = DW_CFA_undefined;
3232 break;
3233 case DW_CFA_undefined:
3234 reg = LEB ();
3235 frame_need_space (fc, reg);
3236 fc->col_type[reg] = DW_CFA_undefined;
3237 break;
3238 case DW_CFA_same_value:
3239 reg = LEB ();
3240 frame_need_space (fc, reg);
3241 fc->col_type[reg] = DW_CFA_undefined;
3242 break;
3243 case DW_CFA_register:
3244 reg = LEB (); LEB ();
3245 frame_need_space (fc, reg);
3246 fc->col_type[reg] = DW_CFA_undefined;
3247 break;
3248 case DW_CFA_def_cfa:
3249 LEB (); LEB ();
3250 break;
3251 case DW_CFA_def_cfa_register:
3252 LEB ();
3253 break;
3254 case DW_CFA_def_cfa_offset:
3255 LEB ();
3256 break;
3257 case DW_CFA_def_cfa_expression:
3258 tmp = LEB ();
3259 start += tmp;
3260 break;
3261 case DW_CFA_expression:
3262 case DW_CFA_val_expression:
3263 reg = LEB ();
3264 tmp = LEB ();
3265 start += tmp;
3266 frame_need_space (fc, reg);
3267 fc->col_type[reg] = DW_CFA_undefined;
3268 break;
3269 case DW_CFA_offset_extended_sf:
3270 case DW_CFA_val_offset_sf:
3271 reg = LEB (); SLEB ();
3272 frame_need_space (fc, reg);
3273 fc->col_type[reg] = DW_CFA_undefined;
3274 break;
3275 case DW_CFA_def_cfa_sf:
3276 LEB (); SLEB ();
3277 break;
3278 case DW_CFA_def_cfa_offset_sf:
3279 SLEB ();
3280 break;
3281 case DW_CFA_MIPS_advance_loc8:
3282 start += 8;
3283 break;
3284 case DW_CFA_GNU_args_size:
3285 LEB ();
3286 break;
3287 case DW_CFA_GNU_negative_offset_extended:
3288 reg = LEB (); LEB ();
3289 frame_need_space (fc, reg);
3290 fc->col_type[reg] = DW_CFA_undefined;
3291
3292 default:
3293 break;
3294 }
3295 }
3296 start = tmp;
3297 }
3298
3299 /* Now we know what registers are used, make a second pass over
3300 the chunk, this time actually printing out the info. */
3301
3302 while (start < block_end)
3303 {
3304 unsigned op, opa;
3305 unsigned long ul, reg, roffs;
3306 long l, ofs;
3307 dwarf_vma vma;
3308
3309 op = *start++;
3310 opa = op & 0x3f;
3311 if (op & 0xc0)
3312 op &= 0xc0;
3313
3314 /* Warning: if you add any more cases to this switch, be
3315 sure to add them to the corresponding switch above. */
3316 switch (op)
3317 {
3318 case DW_CFA_advance_loc:
3319 if (do_debug_frames_interp)
3320 frame_display_row (fc, &need_col_headers, &max_regs);
3321 else
3322 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3323 opa * fc->code_factor,
3324 fc->pc_begin + opa * fc->code_factor);
3325 fc->pc_begin += opa * fc->code_factor;
3326 break;
3327
3328 case DW_CFA_offset:
3329 roffs = LEB ();
3330 if (! do_debug_frames_interp)
3331 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3332 opa, roffs * fc->data_factor);
3333 fc->col_type[opa] = DW_CFA_offset;
3334 fc->col_offset[opa] = roffs * fc->data_factor;
3335 break;
3336
3337 case DW_CFA_restore:
3338 if (! do_debug_frames_interp)
3339 printf (" DW_CFA_restore: r%d\n", opa);
3340 fc->col_type[opa] = cie->col_type[opa];
3341 fc->col_offset[opa] = cie->col_offset[opa];
3342 break;
3343
3344 case DW_CFA_set_loc:
3345 vma = get_encoded_value (start, fc->fde_encoding);
3346 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3347 && !is_relocatable)
3348 vma += section->address + (start - section_start);
3349 start += encoded_ptr_size;
3350 if (do_debug_frames_interp)
3351 frame_display_row (fc, &need_col_headers, &max_regs);
3352 else
3353 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3354 fc->pc_begin = vma;
3355 break;
3356
3357 case DW_CFA_advance_loc1:
3358 ofs = byte_get (start, 1); start += 1;
3359 if (do_debug_frames_interp)
3360 frame_display_row (fc, &need_col_headers, &max_regs);
3361 else
3362 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3363 ofs * fc->code_factor,
3364 fc->pc_begin + ofs * fc->code_factor);
3365 fc->pc_begin += ofs * fc->code_factor;
3366 break;
3367
3368 case DW_CFA_advance_loc2:
3369 ofs = byte_get (start, 2); start += 2;
3370 if (do_debug_frames_interp)
3371 frame_display_row (fc, &need_col_headers, &max_regs);
3372 else
3373 printf (" DW_CFA_advance_loc2: %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_loc4:
3380 ofs = byte_get (start, 4); start += 4;
3381 if (do_debug_frames_interp)
3382 frame_display_row (fc, &need_col_headers, &max_regs);
3383 else
3384 printf (" DW_CFA_advance_loc4: %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_offset_extended:
3391 reg = LEB ();
3392 roffs = LEB ();
3393 if (! do_debug_frames_interp)
3394 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3395 reg, roffs * fc->data_factor);
3396 fc->col_type[reg] = DW_CFA_offset;
3397 fc->col_offset[reg] = roffs * fc->data_factor;
3398 break;
3399
3400 case DW_CFA_val_offset:
3401 reg = LEB ();
3402 roffs = LEB ();
3403 if (! do_debug_frames_interp)
3404 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3405 reg, roffs * fc->data_factor);
3406 fc->col_type[reg] = DW_CFA_val_offset;
3407 fc->col_offset[reg] = roffs * fc->data_factor;
3408 break;
3409
3410 case DW_CFA_restore_extended:
3411 reg = LEB ();
3412 if (! do_debug_frames_interp)
3413 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3414 fc->col_type[reg] = cie->col_type[reg];
3415 fc->col_offset[reg] = cie->col_offset[reg];
3416 break;
3417
3418 case DW_CFA_undefined:
3419 reg = LEB ();
3420 if (! do_debug_frames_interp)
3421 printf (" DW_CFA_undefined: r%ld\n", reg);
3422 fc->col_type[reg] = DW_CFA_undefined;
3423 fc->col_offset[reg] = 0;
3424 break;
3425
3426 case DW_CFA_same_value:
3427 reg = LEB ();
3428 if (! do_debug_frames_interp)
3429 printf (" DW_CFA_same_value: r%ld\n", reg);
3430 fc->col_type[reg] = DW_CFA_same_value;
3431 fc->col_offset[reg] = 0;
3432 break;
3433
3434 case DW_CFA_register:
3435 reg = LEB ();
3436 roffs = LEB ();
3437 if (! do_debug_frames_interp)
3438 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3439 fc->col_type[reg] = DW_CFA_register;
3440 fc->col_offset[reg] = roffs;
3441 break;
3442
3443 case DW_CFA_remember_state:
3444 if (! do_debug_frames_interp)
3445 printf (" DW_CFA_remember_state\n");
3446 rs = xmalloc (sizeof (Frame_Chunk));
3447 rs->ncols = fc->ncols;
3448 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3449 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3450 memcpy (rs->col_type, fc->col_type, rs->ncols);
3451 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3452 rs->next = remembered_state;
3453 remembered_state = rs;
3454 break;
3455
3456 case DW_CFA_restore_state:
3457 if (! do_debug_frames_interp)
3458 printf (" DW_CFA_restore_state\n");
3459 rs = remembered_state;
3460 if (rs)
3461 {
3462 remembered_state = rs->next;
3463 frame_need_space (fc, rs->ncols-1);
3464 memcpy (fc->col_type, rs->col_type, rs->ncols);
3465 memcpy (fc->col_offset, rs->col_offset,
3466 rs->ncols * sizeof (int));
3467 free (rs->col_type);
3468 free (rs->col_offset);
3469 free (rs);
3470 }
3471 else if (do_debug_frames_interp)
3472 printf ("Mismatched DW_CFA_restore_state\n");
3473 break;
3474
3475 case DW_CFA_def_cfa:
3476 fc->cfa_reg = LEB ();
3477 fc->cfa_offset = LEB ();
3478 fc->cfa_exp = 0;
3479 if (! do_debug_frames_interp)
3480 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3481 fc->cfa_reg, fc->cfa_offset);
3482 break;
3483
3484 case DW_CFA_def_cfa_register:
3485 fc->cfa_reg = LEB ();
3486 fc->cfa_exp = 0;
3487 if (! do_debug_frames_interp)
3488 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3489 break;
3490
3491 case DW_CFA_def_cfa_offset:
3492 fc->cfa_offset = LEB ();
3493 if (! do_debug_frames_interp)
3494 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3495 break;
3496
3497 case DW_CFA_nop:
3498 if (! do_debug_frames_interp)
3499 printf (" DW_CFA_nop\n");
3500 break;
3501
3502 case DW_CFA_def_cfa_expression:
3503 ul = LEB ();
3504 if (! do_debug_frames_interp)
3505 {
3506 printf (" DW_CFA_def_cfa_expression (");
3507 decode_location_expression (start, eh_addr_size, ul, 0);
3508 printf (")\n");
3509 }
3510 fc->cfa_exp = 1;
3511 start += ul;
3512 break;
3513
3514 case DW_CFA_expression:
3515 reg = LEB ();
3516 ul = LEB ();
3517 if (! do_debug_frames_interp)
3518 {
3519 printf (" DW_CFA_expression: r%ld (", reg);
3520 decode_location_expression (start, eh_addr_size, ul, 0);
3521 printf (")\n");
3522 }
3523 fc->col_type[reg] = DW_CFA_expression;
3524 start += ul;
3525 break;
3526
3527 case DW_CFA_val_expression:
3528 reg = LEB ();
3529 ul = LEB ();
3530 if (! do_debug_frames_interp)
3531 {
3532 printf (" DW_CFA_val_expression: r%ld (", reg);
3533 decode_location_expression (start, eh_addr_size, ul, 0);
3534 printf (")\n");
3535 }
3536 fc->col_type[reg] = DW_CFA_val_expression;
3537 start += ul;
3538 break;
3539
3540 case DW_CFA_offset_extended_sf:
3541 reg = LEB ();
3542 l = SLEB ();
3543 frame_need_space (fc, reg);
3544 if (! do_debug_frames_interp)
3545 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3546 reg, l * fc->data_factor);
3547 fc->col_type[reg] = DW_CFA_offset;
3548 fc->col_offset[reg] = l * fc->data_factor;
3549 break;
3550
3551 case DW_CFA_val_offset_sf:
3552 reg = LEB ();
3553 l = SLEB ();
3554 frame_need_space (fc, reg);
3555 if (! do_debug_frames_interp)
3556 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3557 reg, l * fc->data_factor);
3558 fc->col_type[reg] = DW_CFA_val_offset;
3559 fc->col_offset[reg] = l * fc->data_factor;
3560 break;
3561
3562 case DW_CFA_def_cfa_sf:
3563 fc->cfa_reg = LEB ();
3564 fc->cfa_offset = SLEB ();
3565 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3566 fc->cfa_exp = 0;
3567 if (! do_debug_frames_interp)
3568 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3569 fc->cfa_reg, fc->cfa_offset);
3570 break;
3571
3572 case DW_CFA_def_cfa_offset_sf:
3573 fc->cfa_offset = SLEB ();
3574 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3575 if (! do_debug_frames_interp)
3576 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3577 break;
3578
3579 case DW_CFA_MIPS_advance_loc8:
3580 ofs = byte_get (start, 8); start += 8;
3581 if (do_debug_frames_interp)
3582 frame_display_row (fc, &need_col_headers, &max_regs);
3583 else
3584 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3585 ofs * fc->code_factor,
3586 fc->pc_begin + ofs * fc->code_factor);
3587 fc->pc_begin += ofs * fc->code_factor;
3588 break;
3589
3590 case DW_CFA_GNU_window_save:
3591 if (! do_debug_frames_interp)
3592 printf (" DW_CFA_GNU_window_save\n");
3593 break;
3594
3595 case DW_CFA_GNU_args_size:
3596 ul = LEB ();
3597 if (! do_debug_frames_interp)
3598 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3599 break;
3600
3601 case DW_CFA_GNU_negative_offset_extended:
3602 reg = LEB ();
3603 l = - LEB ();
3604 frame_need_space (fc, reg);
3605 if (! do_debug_frames_interp)
3606 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3607 reg, l * fc->data_factor);
3608 fc->col_type[reg] = DW_CFA_offset;
3609 fc->col_offset[reg] = l * fc->data_factor;
3610 break;
3611
3612 default:
3613 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3614 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3615 else
3616 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3617 start = block_end;
3618 }
3619 }
3620
3621 if (do_debug_frames_interp)
3622 frame_display_row (fc, &need_col_headers, &max_regs);
3623
3624 start = block_end;
3625 }
3626
3627 printf ("\n");
3628
3629 return 1;
3630 }
3631
3632 #undef GET
3633 #undef LEB
3634 #undef SLEB
3635
3636 static int
3637 display_debug_not_supported (struct dwarf_section *section,
3638 void *file ATTRIBUTE_UNUSED)
3639 {
3640 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3641 section->name);
3642
3643 return 1;
3644 }
3645
3646 void *
3647 cmalloc (size_t nmemb, size_t size)
3648 {
3649 /* Check for overflow. */
3650 if (nmemb >= ~(size_t) 0 / size)
3651 return NULL;
3652 else
3653 return malloc (nmemb * size);
3654 }
3655
3656 void *
3657 xcmalloc (size_t nmemb, size_t size)
3658 {
3659 /* Check for overflow. */
3660 if (nmemb >= ~(size_t) 0 / size)
3661 return NULL;
3662 else
3663 return xmalloc (nmemb * size);
3664 }
3665
3666 void *
3667 xcrealloc (void *ptr, size_t nmemb, size_t size)
3668 {
3669 /* Check for overflow. */
3670 if (nmemb >= ~(size_t) 0 / size)
3671 return NULL;
3672 else
3673 return xrealloc (ptr, nmemb * size);
3674 }
3675
3676 void
3677 error (const char *message, ...)
3678 {
3679 va_list args;
3680
3681 va_start (args, message);
3682 fprintf (stderr, _("%s: Error: "), program_name);
3683 vfprintf (stderr, message, args);
3684 va_end (args);
3685 }
3686
3687 void
3688 warn (const char *message, ...)
3689 {
3690 va_list args;
3691
3692 va_start (args, message);
3693 fprintf (stderr, _("%s: Warning: "), program_name);
3694 vfprintf (stderr, message, args);
3695 va_end (args);
3696 }
3697
3698 void
3699 free_debug_memory (void)
3700 {
3701 enum dwarf_section_display_enum i;
3702
3703 free_abbrevs ();
3704
3705 for (i = 0; i < max; i++)
3706 free_debug_section (i);
3707
3708 if (debug_information)
3709 {
3710 for (i = 0; i < num_debug_info_entries; i++)
3711 {
3712 if (!debug_information [i].max_loc_offsets)
3713 {
3714 free (debug_information [i].loc_offsets);
3715 free (debug_information [i].have_frame_base);
3716 }
3717 if (!debug_information [i].max_range_lists)
3718 free (debug_information [i].range_lists);
3719 }
3720 free (debug_information);
3721 debug_information = NULL;
3722 num_debug_info_entries = 0;
3723 }
3724
3725 }
3726
3727 struct dwarf_section_display debug_displays[] =
3728 {
3729 { { ".debug_abbrev", NULL, 0, 0 },
3730 display_debug_abbrev, 0, 0 },
3731 { { ".debug_aranges", NULL, 0, 0 },
3732 display_debug_aranges, 0, 0 },
3733 { { ".debug_frame", NULL, 0, 0 },
3734 display_debug_frames, 1, 0 },
3735 { { ".debug_info", NULL, 0, 0 },
3736 display_debug_info, 1, 0 },
3737 { { ".debug_line", NULL, 0, 0 },
3738 display_debug_lines, 0, 0 },
3739 { { ".debug_pubnames", NULL, 0, 0 },
3740 display_debug_pubnames, 0, 0 },
3741 { { ".eh_frame", NULL, 0, 0 },
3742 display_debug_frames, 1, 1 },
3743 { { ".debug_macinfo", NULL, 0, 0 },
3744 display_debug_macinfo, 0, 0 },
3745 { { ".debug_str", NULL, 0, 0 },
3746 display_debug_str, 0, 0 },
3747 { { ".debug_loc", NULL, 0, 0 },
3748 display_debug_loc, 0, 0 },
3749 { { ".debug_pubtypes", NULL, 0, 0 },
3750 display_debug_pubnames, 0, 0 },
3751 { { ".debug_ranges", NULL, 0, 0 },
3752 display_debug_ranges, 0, 0 },
3753 { { ".debug_static_func", NULL, 0, 0 },
3754 display_debug_not_supported, 0, 0 },
3755 { { ".debug_static_vars", NULL, 0, 0 },
3756 display_debug_not_supported, 0, 0 },
3757 { { ".debug_types", NULL, 0, 0 },
3758 display_debug_not_supported, 0, 0 },
3759 { { ".debug_weaknames", NULL, 0, 0 },
3760 display_debug_not_supported, 0, 0 }
3761 };
git-cvsimport of binutils cvsroot