?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* configure.in: Update version to 2.17.90.
[binutils.git] / binutils / dwarf.c
blob9cfb158aa30c95cabb2113a66e77fbb10e2518a3
1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005, 2006, 2007
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "libiberty.h"
24 #include "bfd.h"
25 #include "bucomm.h"
26 #include "elf/dwarf2.h"
27 #include "dwarf.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 case DW_OP_form_tls_address:
899 printf ("DW_OP_form_tls_address");
900 break;
901
902 /* GNU extensions. */
903 case DW_OP_GNU_push_tls_address:
904 printf ("DW_OP_GNU_push_tls_address");
905 break;
906
907 default:
908 if (op >= DW_OP_lo_user
909 && op <= DW_OP_hi_user)
910 printf (_("(User defined location op)"));
911 else
912 printf (_("(Unknown location op)"));
913 /* No way to tell where the next op is, so just bail. */
914 return need_frame_base;
915 }
916
917 /* Separate the ops. */
918 if (data < end)
919 printf ("; ");
920 }
921
922 return need_frame_base;
923 }
924
925 static unsigned char *
926 read_and_display_attr_value (unsigned long attribute,
927 unsigned long form,
928 unsigned char *data,
929 unsigned long cu_offset,
930 unsigned long pointer_size,
931 unsigned long offset_size,
932 int dwarf_version,
933 debug_info *debug_info_p,
934 int do_loc)
935 {
936 unsigned long uvalue = 0;
937 unsigned char *block_start = NULL;
938 unsigned int bytes_read;
939
940 switch (form)
941 {
942 default:
943 break;
944
945 case DW_FORM_ref_addr:
946 if (dwarf_version == 2)
947 {
948 uvalue = byte_get (data, pointer_size);
949 data += pointer_size;
950 }
951 else if (dwarf_version == 3)
952 {
953 uvalue = byte_get (data, offset_size);
954 data += offset_size;
955 }
956 else
957 {
958 error (_("Internal error: DWARF version is not 2 or 3.\n"));
959 }
960 break;
961
962 case DW_FORM_addr:
963 uvalue = byte_get (data, pointer_size);
964 data += pointer_size;
965 break;
966
967 case DW_FORM_strp:
968 uvalue = byte_get (data, offset_size);
969 data += offset_size;
970 break;
971
972 case DW_FORM_ref1:
973 case DW_FORM_flag:
974 case DW_FORM_data1:
975 uvalue = byte_get (data++, 1);
976 break;
977
978 case DW_FORM_ref2:
979 case DW_FORM_data2:
980 uvalue = byte_get (data, 2);
981 data += 2;
982 break;
983
984 case DW_FORM_ref4:
985 case DW_FORM_data4:
986 uvalue = byte_get (data, 4);
987 data += 4;
988 break;
989
990 case DW_FORM_sdata:
991 uvalue = read_leb128 (data, & bytes_read, 1);
992 data += bytes_read;
993 break;
994
995 case DW_FORM_ref_udata:
996 case DW_FORM_udata:
997 uvalue = read_leb128 (data, & bytes_read, 0);
998 data += bytes_read;
999 break;
1000
1001 case DW_FORM_indirect:
1002 form = read_leb128 (data, & bytes_read, 0);
1003 data += bytes_read;
1004 if (!do_loc)
1005 printf (" %s", get_FORM_name (form));
1006 return read_and_display_attr_value (attribute, form, data,
1007 cu_offset, pointer_size,
1008 offset_size, dwarf_version,
1009 debug_info_p, do_loc);
1010 }
1011
1012 switch (form)
1013 {
1014 case DW_FORM_ref_addr:
1015 if (!do_loc)
1016 printf (" <#%lx>", uvalue);
1017 break;
1018
1019 case DW_FORM_ref1:
1020 case DW_FORM_ref2:
1021 case DW_FORM_ref4:
1022 case DW_FORM_ref_udata:
1023 if (!do_loc)
1024 printf (" <%lx>", uvalue + cu_offset);
1025 break;
1026
1027 case DW_FORM_data4:
1028 case DW_FORM_addr:
1029 if (!do_loc)
1030 printf (" %#lx", uvalue);
1031 break;
1032
1033 case DW_FORM_flag:
1034 case DW_FORM_data1:
1035 case DW_FORM_data2:
1036 case DW_FORM_sdata:
1037 case DW_FORM_udata:
1038 if (!do_loc)
1039 printf (" %ld", uvalue);
1040 break;
1041
1042 case DW_FORM_ref8:
1043 case DW_FORM_data8:
1044 if (!do_loc)
1045 {
1046 uvalue = byte_get (data, 4);
1047 printf (" %lx", uvalue);
1048 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
1049 }
1050 if ((do_loc || do_debug_loc || do_debug_ranges)
1051 && num_debug_info_entries == 0)
1052 {
1053 if (sizeof (uvalue) == 8)
1054 uvalue = byte_get (data, 8);
1055 else
1056 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1057 }
1058 data += 8;
1059 break;
1060
1061 case DW_FORM_string:
1062 if (!do_loc)
1063 printf (" %s", data);
1064 data += strlen ((char *) data) + 1;
1065 break;
1066
1067 case DW_FORM_block:
1068 uvalue = read_leb128 (data, & bytes_read, 0);
1069 block_start = data + bytes_read;
1070 if (do_loc)
1071 data = block_start + uvalue;
1072 else
1073 data = display_block (block_start, uvalue);
1074 break;
1075
1076 case DW_FORM_block1:
1077 uvalue = byte_get (data, 1);
1078 block_start = data + 1;
1079 if (do_loc)
1080 data = block_start + uvalue;
1081 else
1082 data = display_block (block_start, uvalue);
1083 break;
1084
1085 case DW_FORM_block2:
1086 uvalue = byte_get (data, 2);
1087 block_start = data + 2;
1088 if (do_loc)
1089 data = block_start + uvalue;
1090 else
1091 data = display_block (block_start, uvalue);
1092 break;
1093
1094 case DW_FORM_block4:
1095 uvalue = byte_get (data, 4);
1096 block_start = data + 4;
1097 if (do_loc)
1098 data = block_start + uvalue;
1099 else
1100 data = display_block (block_start, uvalue);
1101 break;
1102
1103 case DW_FORM_strp:
1104 if (!do_loc)
1105 printf (_(" (indirect string, offset: 0x%lx): %s"),
1106 uvalue, fetch_indirect_string (uvalue));
1107 break;
1108
1109 case DW_FORM_indirect:
1110 /* Handled above. */
1111 break;
1112
1113 default:
1114 warn (_("Unrecognized form: %lu\n"), form);
1115 break;
1116 }
1117
1118 /* For some attributes we can display further information. */
1119 if ((do_loc || do_debug_loc || do_debug_ranges)
1120 && num_debug_info_entries == 0)
1121 {
1122 switch (attribute)
1123 {
1124 case DW_AT_frame_base:
1125 have_frame_base = 1;
1126 case DW_AT_location:
1127 case DW_AT_data_member_location:
1128 case DW_AT_vtable_elem_location:
1129 case DW_AT_allocated:
1130 case DW_AT_associated:
1131 case DW_AT_data_location:
1132 case DW_AT_stride:
1133 case DW_AT_upper_bound:
1134 case DW_AT_lower_bound:
1135 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1136 {
1137 /* Process location list. */
1138 unsigned int max = debug_info_p->max_loc_offsets;
1139 unsigned int num = debug_info_p->num_loc_offsets;
1140
1141 if (max == 0 || num >= max)
1142 {
1143 max += 1024;
1144 debug_info_p->loc_offsets
1145 = xcrealloc (debug_info_p->loc_offsets,
1146 max, sizeof (*debug_info_p->loc_offsets));
1147 debug_info_p->have_frame_base
1148 = xcrealloc (debug_info_p->have_frame_base,
1149 max, sizeof (*debug_info_p->have_frame_base));
1150 debug_info_p->max_loc_offsets = max;
1151 }
1152 debug_info_p->loc_offsets [num] = uvalue;
1153 debug_info_p->have_frame_base [num] = have_frame_base;
1154 debug_info_p->num_loc_offsets++;
1155 }
1156 break;
1157
1158 case DW_AT_low_pc:
1159 if (need_base_address)
1160 debug_info_p->base_address = uvalue;
1161 break;
1162
1163 case DW_AT_ranges:
1164 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1165 {
1166 /* Process range list. */
1167 unsigned int max = debug_info_p->max_range_lists;
1168 unsigned int num = debug_info_p->num_range_lists;
1169
1170 if (max == 0 || num >= max)
1171 {
1172 max += 1024;
1173 debug_info_p->range_lists
1174 = xcrealloc (debug_info_p->range_lists,
1175 max, sizeof (*debug_info_p->range_lists));
1176 debug_info_p->max_range_lists = max;
1177 }
1178 debug_info_p->range_lists [num] = uvalue;
1179 debug_info_p->num_range_lists++;
1180 }
1181 break;
1182
1183 default:
1184 break;
1185 }
1186 }
1187
1188 if (do_loc)
1189 return data;
1190
1191 printf ("\t");
1192
1193 switch (attribute)
1194 {
1195 case DW_AT_inline:
1196 switch (uvalue)
1197 {
1198 case DW_INL_not_inlined:
1199 printf (_("(not inlined)"));
1200 break;
1201 case DW_INL_inlined:
1202 printf (_("(inlined)"));
1203 break;
1204 case DW_INL_declared_not_inlined:
1205 printf (_("(declared as inline but ignored)"));
1206 break;
1207 case DW_INL_declared_inlined:
1208 printf (_("(declared as inline and inlined)"));
1209 break;
1210 default:
1211 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1212 break;
1213 }
1214 break;
1215
1216 case DW_AT_language:
1217 switch (uvalue)
1218 {
1219 /* Ordered by the numeric value of these constants. */
1220 case DW_LANG_C89: printf ("(ANSI C)"); break;
1221 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1222 case DW_LANG_Ada83: printf ("(Ada)"); break;
1223 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
1224 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1225 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
1226 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1227 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
1228 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
1229 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
1230 /* DWARF 2.1 values. */
1231 case DW_LANG_Java: printf ("(Java)"); break;
1232 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1233 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1234 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
1235 /* DWARF 3 values. */
1236 case DW_LANG_PLI: printf ("(PLI)"); break;
1237 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1238 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1239 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1240 case DW_LANG_D: printf ("(D)"); break;
1241 /* MIPS extension. */
1242 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1243 /* UPC extension. */
1244 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1245 default:
1246 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1247 printf ("(implementation defined: %lx)", uvalue);
1248 else
1249 printf ("(Unknown: %lx)", uvalue);
1250 break;
1251 }
1252 break;
1253
1254 case DW_AT_encoding:
1255 switch (uvalue)
1256 {
1257 case DW_ATE_void: printf ("(void)"); break;
1258 case DW_ATE_address: printf ("(machine address)"); break;
1259 case DW_ATE_boolean: printf ("(boolean)"); break;
1260 case DW_ATE_complex_float: printf ("(complex float)"); break;
1261 case DW_ATE_float: printf ("(float)"); break;
1262 case DW_ATE_signed: printf ("(signed)"); break;
1263 case DW_ATE_signed_char: printf ("(signed char)"); break;
1264 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1265 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
1266 /* DWARF 2.1 value. */
1267 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1268 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
1269 default:
1270 if (uvalue >= DW_ATE_lo_user
1271 && uvalue <= DW_ATE_hi_user)
1272 printf ("(user defined type)");
1273 else
1274 printf ("(unknown type)");
1275 break;
1276 }
1277 break;
1278
1279 case DW_AT_accessibility:
1280 switch (uvalue)
1281 {
1282 case DW_ACCESS_public: printf ("(public)"); break;
1283 case DW_ACCESS_protected: printf ("(protected)"); break;
1284 case DW_ACCESS_private: printf ("(private)"); break;
1285 default:
1286 printf ("(unknown accessibility)");
1287 break;
1288 }
1289 break;
1290
1291 case DW_AT_visibility:
1292 switch (uvalue)
1293 {
1294 case DW_VIS_local: printf ("(local)"); break;
1295 case DW_VIS_exported: printf ("(exported)"); break;
1296 case DW_VIS_qualified: printf ("(qualified)"); break;
1297 default: printf ("(unknown visibility)"); break;
1298 }
1299 break;
1300
1301 case DW_AT_virtuality:
1302 switch (uvalue)
1303 {
1304 case DW_VIRTUALITY_none: printf ("(none)"); break;
1305 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1306 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1307 default: printf ("(unknown virtuality)"); break;
1308 }
1309 break;
1310
1311 case DW_AT_identifier_case:
1312 switch (uvalue)
1313 {
1314 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1315 case DW_ID_up_case: printf ("(up_case)"); break;
1316 case DW_ID_down_case: printf ("(down_case)"); break;
1317 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1318 default: printf ("(unknown case)"); break;
1319 }
1320 break;
1321
1322 case DW_AT_calling_convention:
1323 switch (uvalue)
1324 {
1325 case DW_CC_normal: printf ("(normal)"); break;
1326 case DW_CC_program: printf ("(program)"); break;
1327 case DW_CC_nocall: printf ("(nocall)"); break;
1328 default:
1329 if (uvalue >= DW_CC_lo_user
1330 && uvalue <= DW_CC_hi_user)
1331 printf ("(user defined)");
1332 else
1333 printf ("(unknown convention)");
1334 }
1335 break;
1336
1337 case DW_AT_ordering:
1338 switch (uvalue)
1339 {
1340 case -1: printf ("(undefined)"); break;
1341 case 0: printf ("(row major)"); break;
1342 case 1: printf ("(column major)"); break;
1343 }
1344 break;
1345
1346 case DW_AT_frame_base:
1347 have_frame_base = 1;
1348 case DW_AT_location:
1349 case DW_AT_data_member_location:
1350 case DW_AT_vtable_elem_location:
1351 case DW_AT_allocated:
1352 case DW_AT_associated:
1353 case DW_AT_data_location:
1354 case DW_AT_stride:
1355 case DW_AT_upper_bound:
1356 case DW_AT_lower_bound:
1357 if (block_start)
1358 {
1359 int need_frame_base;
1360
1361 printf ("(");
1362 need_frame_base = decode_location_expression (block_start,
1363 pointer_size,
1364 uvalue,
1365 cu_offset);
1366 printf (")");
1367 if (need_frame_base && !have_frame_base)
1368 printf (_(" [without DW_AT_frame_base]"));
1369 }
1370 else if (form == DW_FORM_data4 || form == DW_FORM_data8)
1371 printf (_("(location list)"));
1372
1373 break;
1374
1375 default:
1376 break;
1377 }
1378
1379 return data;
1380 }
1381
1382 static char *
1383 get_AT_name (unsigned long attribute)
1384 {
1385 switch (attribute)
1386 {
1387 case DW_AT_sibling: return "DW_AT_sibling";
1388 case DW_AT_location: return "DW_AT_location";
1389 case DW_AT_name: return "DW_AT_name";
1390 case DW_AT_ordering: return "DW_AT_ordering";
1391 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1392 case DW_AT_byte_size: return "DW_AT_byte_size";
1393 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1394 case DW_AT_bit_size: return "DW_AT_bit_size";
1395 case DW_AT_element_list: return "DW_AT_element_list";
1396 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1397 case DW_AT_low_pc: return "DW_AT_low_pc";
1398 case DW_AT_high_pc: return "DW_AT_high_pc";
1399 case DW_AT_language: return "DW_AT_language";
1400 case DW_AT_member: return "DW_AT_member";
1401 case DW_AT_discr: return "DW_AT_discr";
1402 case DW_AT_discr_value: return "DW_AT_discr_value";
1403 case DW_AT_visibility: return "DW_AT_visibility";
1404 case DW_AT_import: return "DW_AT_import";
1405 case DW_AT_string_length: return "DW_AT_string_length";
1406 case DW_AT_common_reference: return "DW_AT_common_reference";
1407 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1408 case DW_AT_const_value: return "DW_AT_const_value";
1409 case DW_AT_containing_type: return "DW_AT_containing_type";
1410 case DW_AT_default_value: return "DW_AT_default_value";
1411 case DW_AT_inline: return "DW_AT_inline";
1412 case DW_AT_is_optional: return "DW_AT_is_optional";
1413 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1414 case DW_AT_producer: return "DW_AT_producer";
1415 case DW_AT_prototyped: return "DW_AT_prototyped";
1416 case DW_AT_return_addr: return "DW_AT_return_addr";
1417 case DW_AT_start_scope: return "DW_AT_start_scope";
1418 case DW_AT_stride_size: return "DW_AT_stride_size";
1419 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1420 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1421 case DW_AT_accessibility: return "DW_AT_accessibility";
1422 case DW_AT_address_class: return "DW_AT_address_class";
1423 case DW_AT_artificial: return "DW_AT_artificial";
1424 case DW_AT_base_types: return "DW_AT_base_types";
1425 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1426 case DW_AT_count: return "DW_AT_count";
1427 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1428 case DW_AT_decl_column: return "DW_AT_decl_column";
1429 case DW_AT_decl_file: return "DW_AT_decl_file";
1430 case DW_AT_decl_line: return "DW_AT_decl_line";
1431 case DW_AT_declaration: return "DW_AT_declaration";
1432 case DW_AT_discr_list: return "DW_AT_discr_list";
1433 case DW_AT_encoding: return "DW_AT_encoding";
1434 case DW_AT_external: return "DW_AT_external";
1435 case DW_AT_frame_base: return "DW_AT_frame_base";
1436 case DW_AT_friend: return "DW_AT_friend";
1437 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1438 case DW_AT_macro_info: return "DW_AT_macro_info";
1439 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1440 case DW_AT_priority: return "DW_AT_priority";
1441 case DW_AT_segment: return "DW_AT_segment";
1442 case DW_AT_specification: return "DW_AT_specification";
1443 case DW_AT_static_link: return "DW_AT_static_link";
1444 case DW_AT_type: return "DW_AT_type";
1445 case DW_AT_use_location: return "DW_AT_use_location";
1446 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1447 case DW_AT_virtuality: return "DW_AT_virtuality";
1448 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1449 /* DWARF 2.1 values. */
1450 case DW_AT_allocated: return "DW_AT_allocated";
1451 case DW_AT_associated: return "DW_AT_associated";
1452 case DW_AT_data_location: return "DW_AT_data_location";
1453 case DW_AT_stride: return "DW_AT_stride";
1454 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1455 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1456 case DW_AT_extension: return "DW_AT_extension";
1457 case DW_AT_ranges: return "DW_AT_ranges";
1458 case DW_AT_trampoline: return "DW_AT_trampoline";
1459 case DW_AT_call_column: return "DW_AT_call_column";
1460 case DW_AT_call_file: return "DW_AT_call_file";
1461 case DW_AT_call_line: return "DW_AT_call_line";
1462 /* SGI/MIPS extensions. */
1463 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
1464 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1465 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1466 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1467 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1468 case DW_AT_MIPS_software_pipeline_depth:
1469 return "DW_AT_MIPS_software_pipeline_depth";
1470 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1471 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1472 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1473 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1474 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1475 /* GNU extensions. */
1476 case DW_AT_sf_names: return "DW_AT_sf_names";
1477 case DW_AT_src_info: return "DW_AT_src_info";
1478 case DW_AT_mac_info: return "DW_AT_mac_info";
1479 case DW_AT_src_coords: return "DW_AT_src_coords";
1480 case DW_AT_body_begin: return "DW_AT_body_begin";
1481 case DW_AT_body_end: return "DW_AT_body_end";
1482 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1483 /* UPC extension. */
1484 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
1485 default:
1486 {
1487 static char buffer[100];
1488
1489 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1490 attribute);
1491 return buffer;
1492 }
1493 }
1494 }
1495
1496 static unsigned char *
1497 read_and_display_attr (unsigned long attribute,
1498 unsigned long form,
1499 unsigned char *data,
1500 unsigned long cu_offset,
1501 unsigned long pointer_size,
1502 unsigned long offset_size,
1503 int dwarf_version,
1504 debug_info *debug_info_p,
1505 int do_loc)
1506 {
1507 if (!do_loc)
1508 printf (" %-18s:", get_AT_name (attribute));
1509 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1510 pointer_size, offset_size,
1511 dwarf_version, debug_info_p,
1512 do_loc);
1513 if (!do_loc)
1514 printf ("\n");
1515 return data;
1516 }
1517
1518
1519 /* Process the contents of a .debug_info section. If do_loc is non-zero
1520 then we are scanning for location lists and we do not want to display
1521 anything to the user. */
1522
1523 static int
1524 process_debug_info (struct dwarf_section *section, void *file,
1525 int do_loc)
1526 {
1527 unsigned char *start = section->start;
1528 unsigned char *end = start + section->size;
1529 unsigned char *section_begin;
1530 unsigned int unit;
1531 unsigned int num_units = 0;
1532
1533 if ((do_loc || do_debug_loc || do_debug_ranges)
1534 && num_debug_info_entries == 0)
1535 {
1536 unsigned long length;
1537
1538 /* First scan the section to get the number of comp units. */
1539 for (section_begin = start, num_units = 0; section_begin < end;
1540 num_units ++)
1541 {
1542 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1543 will be the length. For a 64-bit DWARF section, it'll be
1544 the escape code 0xffffffff followed by an 8 byte length. */
1545 length = byte_get (section_begin, 4);
1546
1547 if (length == 0xffffffff)
1548 {
1549 length = byte_get (section_begin + 4, 8);
1550 section_begin += length + 12;
1551 }
1552 else
1553 section_begin += length + 4;
1554 }
1555
1556 if (num_units == 0)
1557 {
1558 error (_("No comp units in %s section ?"), section->name);
1559 return 0;
1560 }
1561
1562 /* Then allocate an array to hold the information. */
1563 debug_information = cmalloc (num_units,
1564 sizeof (* debug_information));
1565 if (debug_information == NULL)
1566 {
1567 error (_("Not enough memory for a debug info array of %u entries"),
1568 num_units);
1569 return 0;
1570 }
1571 }
1572
1573 if (!do_loc)
1574 {
1575 printf (_("The section %s contains:\n\n"), section->name);
1576
1577 load_debug_section (str, file);
1578 }
1579
1580 load_debug_section (abbrev, file);
1581 if (debug_displays [abbrev].section.start == NULL)
1582 {
1583 warn (_("Unable to locate %s section!\n"),
1584 debug_displays [abbrev].section.name);
1585 return 0;
1586 }
1587
1588 for (section_begin = start, unit = 0; start < end; unit++)
1589 {
1590 DWARF2_Internal_CompUnit compunit;
1591 unsigned char *hdrptr;
1592 unsigned char *cu_abbrev_offset_ptr;
1593 unsigned char *tags;
1594 int level;
1595 unsigned long cu_offset;
1596 int offset_size;
1597 int initial_length_size;
1598
1599 hdrptr = start;
1600
1601 compunit.cu_length = byte_get (hdrptr, 4);
1602 hdrptr += 4;
1603
1604 if (compunit.cu_length == 0xffffffff)
1605 {
1606 compunit.cu_length = byte_get (hdrptr, 8);
1607 hdrptr += 8;
1608 offset_size = 8;
1609 initial_length_size = 12;
1610 }
1611 else
1612 {
1613 offset_size = 4;
1614 initial_length_size = 4;
1615 }
1616
1617 compunit.cu_version = byte_get (hdrptr, 2);
1618 hdrptr += 2;
1619
1620 cu_offset = start - section_begin;
1621
1622 cu_abbrev_offset_ptr = hdrptr;
1623 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1624 hdrptr += offset_size;
1625
1626 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1627 hdrptr += 1;
1628 if ((do_loc || do_debug_loc || do_debug_ranges)
1629 && num_debug_info_entries == 0)
1630 {
1631 debug_information [unit].cu_offset = cu_offset;
1632 debug_information [unit].pointer_size
1633 = compunit.cu_pointer_size;
1634 debug_information [unit].base_address = 0;
1635 debug_information [unit].loc_offsets = NULL;
1636 debug_information [unit].have_frame_base = NULL;
1637 debug_information [unit].max_loc_offsets = 0;
1638 debug_information [unit].num_loc_offsets = 0;
1639 debug_information [unit].range_lists = NULL;
1640 debug_information [unit].max_range_lists= 0;
1641 debug_information [unit].num_range_lists = 0;
1642 }
1643
1644 if (!do_loc)
1645 {
1646 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
1647 printf (_(" Length: %ld\n"), compunit.cu_length);
1648 printf (_(" Version: %d\n"), compunit.cu_version);
1649 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1650 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1651 }
1652
1653 if (cu_offset + compunit.cu_length + initial_length_size
1654 > section->size)
1655 {
1656 warn (_("Debug info is corrupted, length is invalid (section is %lu bytes)\n"),
1657 (unsigned long)section->size);
1658 break;
1659 }
1660 tags = hdrptr;
1661 start += compunit.cu_length + initial_length_size;
1662
1663 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1664 {
1665 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
1666 continue;
1667 }
1668
1669 free_abbrevs ();
1670
1671 /* Process the abbrevs used by this compilation unit. DWARF
1672 sections under Mach-O have non-zero addresses. */
1673 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
1674 warn (_("Debug info is corrupted, abbrev offset is invalid (section is %lu bytes)\n"),
1675 (unsigned long)debug_displays [abbrev].section.size);
1676 else
1677 process_abbrev_section
1678 ((unsigned char *) debug_displays [abbrev].section.start
1679 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1680 (unsigned char *) debug_displays [abbrev].section.start
1681 + debug_displays [abbrev].section.size);
1682
1683 level = 0;
1684 while (tags < start)
1685 {
1686 unsigned int bytes_read;
1687 unsigned long abbrev_number;
1688 abbrev_entry *entry;
1689 abbrev_attr *attr;
1690
1691 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1692 tags += bytes_read;
1693
1694 /* A null DIE marks the end of a list of children. */
1695 if (abbrev_number == 0)
1696 {
1697 --level;
1698 continue;
1699 }
1700
1701 if (!do_loc)
1702 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
1703 level,
1704 (unsigned long) (tags - section_begin
1705 - bytes_read),
1706 abbrev_number);
1707
1708 /* Scan through the abbreviation list until we reach the
1709 correct entry. */
1710 for (entry = first_abbrev;
1711 entry && entry->entry != abbrev_number;
1712 entry = entry->next)
1713 continue;
1714
1715 if (entry == NULL)
1716 {
1717 if (!do_loc)
1718 {
1719 printf ("\n");
1720 fflush (stdout);
1721 }
1722 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
1723 abbrev_number);
1724 return 0;
1725 }
1726
1727 if (!do_loc)
1728 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
1729
1730 switch (entry->tag)
1731 {
1732 default:
1733 need_base_address = 0;
1734 break;
1735 case DW_TAG_compile_unit:
1736 need_base_address = 1;
1737 break;
1738 case DW_TAG_entry_point:
1739 case DW_TAG_subprogram:
1740 need_base_address = 0;
1741 /* Assuming that there is no DW_AT_frame_base. */
1742 have_frame_base = 0;
1743 break;
1744 }
1745
1746 for (attr = entry->first_attr; attr; attr = attr->next)
1747 {
1748 if (! do_loc)
1749 /* Show the offset from where the tag was extracted. */
1750 printf (" <%2lx>", (unsigned long)(tags - section_begin));
1751
1752 tags = read_and_display_attr (attr->attribute,
1753 attr->form,
1754 tags, cu_offset,
1755 compunit.cu_pointer_size,
1756 offset_size,
1757 compunit.cu_version,
1758 &debug_information [unit],
1759 do_loc);
1760 }
1761
1762 if (entry->children)
1763 ++level;
1764 }
1765 }
1766
1767 /* Set num_debug_info_entries here so that it can be used to check if
1768 we need to process .debug_loc and .debug_ranges sections. */
1769 if ((do_loc || do_debug_loc || do_debug_ranges)
1770 && num_debug_info_entries == 0)
1771 num_debug_info_entries = num_units;
1772
1773 if (!do_loc)
1774 {
1775 printf ("\n");
1776 }
1777
1778 return 1;
1779 }
1780
1781 /* Locate and scan the .debug_info section in the file and record the pointer
1782 sizes and offsets for the compilation units in it. Usually an executable
1783 will have just one pointer size, but this is not guaranteed, and so we try
1784 not to make any assumptions. Returns zero upon failure, or the number of
1785 compilation units upon success. */
1786
1787 static unsigned int
1788 load_debug_info (void * file)
1789 {
1790 /* Reset the last pointer size so that we can issue correct error
1791 messages if we are displaying the contents of more than one section. */
1792 last_pointer_size = 0;
1793 warned_about_missing_comp_units = FALSE;
1794
1795 /* If we already have the information there is nothing else to do. */
1796 if (num_debug_info_entries > 0)
1797 return num_debug_info_entries;
1798
1799 if (load_debug_section (info, file)
1800 && process_debug_info (&debug_displays [info].section, file, 1))
1801 return num_debug_info_entries;
1802 else
1803 return 0;
1804 }
1805
1806 static int
1807 display_debug_lines (struct dwarf_section *section, void *file)
1808 {
1809 unsigned char *start = section->start;
1810 unsigned char *data = start;
1811 unsigned char *end = start + section->size;
1812
1813 printf (_("\nDump of debug contents of section %s:\n\n"),
1814 section->name);
1815
1816 load_debug_info (file);
1817
1818 while (data < end)
1819 {
1820 DWARF2_Internal_LineInfo info;
1821 unsigned char *standard_opcodes;
1822 unsigned char *end_of_sequence;
1823 unsigned char *hdrptr;
1824 int initial_length_size;
1825 int offset_size;
1826 int i;
1827
1828 hdrptr = data;
1829
1830 /* Check the length of the block. */
1831 info.li_length = byte_get (hdrptr, 4);
1832 hdrptr += 4;
1833
1834 if (info.li_length == 0xffffffff)
1835 {
1836 /* This section is 64-bit DWARF 3. */
1837 info.li_length = byte_get (hdrptr, 8);
1838 hdrptr += 8;
1839 offset_size = 8;
1840 initial_length_size = 12;
1841 }
1842 else
1843 {
1844 offset_size = 4;
1845 initial_length_size = 4;
1846 }
1847
1848 if (info.li_length + initial_length_size > section->size)
1849 {
1850 warn
1851 (_("The line info appears to be corrupt - the section is too small\n"));
1852 return 0;
1853 }
1854
1855 /* Check its version number. */
1856 info.li_version = byte_get (hdrptr, 2);
1857 hdrptr += 2;
1858 if (info.li_version != 2 && info.li_version != 3)
1859 {
1860 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
1861 return 0;
1862 }
1863
1864 info.li_prologue_length = byte_get (hdrptr, offset_size);
1865 hdrptr += offset_size;
1866 info.li_min_insn_length = byte_get (hdrptr, 1);
1867 hdrptr++;
1868 info.li_default_is_stmt = byte_get (hdrptr, 1);
1869 hdrptr++;
1870 info.li_line_base = byte_get (hdrptr, 1);
1871 hdrptr++;
1872 info.li_line_range = byte_get (hdrptr, 1);
1873 hdrptr++;
1874 info.li_opcode_base = byte_get (hdrptr, 1);
1875 hdrptr++;
1876
1877 /* Sign extend the line base field. */
1878 info.li_line_base <<= 24;
1879 info.li_line_base >>= 24;
1880
1881 printf (_(" Length: %ld\n"), info.li_length);
1882 printf (_(" DWARF Version: %d\n"), info.li_version);
1883 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
1884 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
1885 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
1886 printf (_(" Line Base: %d\n"), info.li_line_base);
1887 printf (_(" Line Range: %d\n"), info.li_line_range);
1888 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
1889
1890 end_of_sequence = data + info.li_length + initial_length_size;
1891
1892 reset_state_machine (info.li_default_is_stmt);
1893
1894 /* Display the contents of the Opcodes table. */
1895 standard_opcodes = hdrptr;
1896
1897 printf (_("\n Opcodes:\n"));
1898
1899 for (i = 1; i < info.li_opcode_base; i++)
1900 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
1901
1902 /* Display the contents of the Directory table. */
1903 data = standard_opcodes + info.li_opcode_base - 1;
1904
1905 if (*data == 0)
1906 printf (_("\n The Directory Table is empty.\n"));
1907 else
1908 {
1909 printf (_("\n The Directory Table:\n"));
1910
1911 while (*data != 0)
1912 {
1913 printf (_(" %s\n"), data);
1914
1915 data += strlen ((char *) data) + 1;
1916 }
1917 }
1918
1919 /* Skip the NUL at the end of the table. */
1920 data++;
1921
1922 /* Display the contents of the File Name table. */
1923 if (*data == 0)
1924 printf (_("\n The File Name Table is empty.\n"));
1925 else
1926 {
1927 printf (_("\n The File Name Table:\n"));
1928 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
1929
1930 while (*data != 0)
1931 {
1932 unsigned char *name;
1933 unsigned int bytes_read;
1934
1935 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
1936 name = data;
1937
1938 data += strlen ((char *) data) + 1;
1939
1940 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1941 data += bytes_read;
1942 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1943 data += bytes_read;
1944 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
1945 data += bytes_read;
1946 printf (_("%s\n"), name);
1947 }
1948 }
1949
1950 /* Skip the NUL at the end of the table. */
1951 data++;
1952
1953 /* Now display the statements. */
1954 printf (_("\n Line Number Statements:\n"));
1955
1956 while (data < end_of_sequence)
1957 {
1958 unsigned char op_code;
1959 int adv;
1960 unsigned long int uladv;
1961 unsigned int bytes_read;
1962
1963 op_code = *data++;
1964
1965 if (op_code >= info.li_opcode_base)
1966 {
1967 op_code -= info.li_opcode_base;
1968 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
1969 state_machine_regs.address += uladv;
1970 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
1971 op_code, uladv, state_machine_regs.address);
1972 adv = (op_code % info.li_line_range) + info.li_line_base;
1973 state_machine_regs.line += adv;
1974 printf (_(" and Line by %d to %d\n"),
1975 adv, state_machine_regs.line);
1976 }
1977 else switch (op_code)
1978 {
1979 case DW_LNS_extended_op:
1980 data += process_extended_line_op (data, info.li_default_is_stmt);
1981 break;
1982
1983 case DW_LNS_copy:
1984 printf (_(" Copy\n"));
1985 break;
1986
1987 case DW_LNS_advance_pc:
1988 uladv = read_leb128 (data, & bytes_read, 0);
1989 uladv *= info.li_min_insn_length;
1990 data += bytes_read;
1991 state_machine_regs.address += uladv;
1992 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
1993 state_machine_regs.address);
1994 break;
1995
1996 case DW_LNS_advance_line:
1997 adv = read_leb128 (data, & bytes_read, 1);
1998 data += bytes_read;
1999 state_machine_regs.line += adv;
2000 printf (_(" Advance Line by %d to %d\n"), adv,
2001 state_machine_regs.line);
2002 break;
2003
2004 case DW_LNS_set_file:
2005 adv = read_leb128 (data, & bytes_read, 0);
2006 data += bytes_read;
2007 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2008 adv);
2009 state_machine_regs.file = adv;
2010 break;
2011
2012 case DW_LNS_set_column:
2013 uladv = read_leb128 (data, & bytes_read, 0);
2014 data += bytes_read;
2015 printf (_(" Set column to %lu\n"), uladv);
2016 state_machine_regs.column = uladv;
2017 break;
2018
2019 case DW_LNS_negate_stmt:
2020 adv = state_machine_regs.is_stmt;
2021 adv = ! adv;
2022 printf (_(" Set is_stmt to %d\n"), adv);
2023 state_machine_regs.is_stmt = adv;
2024 break;
2025
2026 case DW_LNS_set_basic_block:
2027 printf (_(" Set basic block\n"));
2028 state_machine_regs.basic_block = 1;
2029 break;
2030
2031 case DW_LNS_const_add_pc:
2032 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2033 * info.li_min_insn_length);
2034 state_machine_regs.address += uladv;
2035 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2036 state_machine_regs.address);
2037 break;
2038
2039 case DW_LNS_fixed_advance_pc:
2040 uladv = byte_get (data, 2);
2041 data += 2;
2042 state_machine_regs.address += uladv;
2043 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2044 uladv, state_machine_regs.address);
2045 break;
2046
2047 case DW_LNS_set_prologue_end:
2048 printf (_(" Set prologue_end to true\n"));
2049 break;
2050
2051 case DW_LNS_set_epilogue_begin:
2052 printf (_(" Set epilogue_begin to true\n"));
2053 break;
2054
2055 case DW_LNS_set_isa:
2056 uladv = read_leb128 (data, & bytes_read, 0);
2057 data += bytes_read;
2058 printf (_(" Set ISA to %lu\n"), uladv);
2059 break;
2060
2061 default:
2062 printf (_(" Unknown opcode %d with operands: "), op_code);
2063
2064 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2065 {
2066 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2067 i == 1 ? "" : ", ");
2068 data += bytes_read;
2069 }
2070 putchar ('\n');
2071 break;
2072 }
2073 }
2074 putchar ('\n');
2075 }
2076
2077 return 1;
2078 }
2079
2080 static int
2081 display_debug_pubnames (struct dwarf_section *section,
2082 void *file ATTRIBUTE_UNUSED)
2083 {
2084 DWARF2_Internal_PubNames pubnames;
2085 unsigned char *start = section->start;
2086 unsigned char *end = start + section->size;
2087
2088 printf (_("Contents of the %s section:\n\n"), section->name);
2089
2090 while (start < end)
2091 {
2092 unsigned char *data;
2093 unsigned long offset;
2094 int offset_size, initial_length_size;
2095
2096 data = start;
2097
2098 pubnames.pn_length = byte_get (data, 4);
2099 data += 4;
2100 if (pubnames.pn_length == 0xffffffff)
2101 {
2102 pubnames.pn_length = byte_get (data, 8);
2103 data += 8;
2104 offset_size = 8;
2105 initial_length_size = 12;
2106 }
2107 else
2108 {
2109 offset_size = 4;
2110 initial_length_size = 4;
2111 }
2112
2113 pubnames.pn_version = byte_get (data, 2);
2114 data += 2;
2115 pubnames.pn_offset = byte_get (data, offset_size);
2116 data += offset_size;
2117 pubnames.pn_size = byte_get (data, offset_size);
2118 data += offset_size;
2119
2120 start += pubnames.pn_length + initial_length_size;
2121
2122 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2123 {
2124 static int warned = 0;
2125
2126 if (! warned)
2127 {
2128 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2129 warned = 1;
2130 }
2131
2132 continue;
2133 }
2134
2135 printf (_(" Length: %ld\n"),
2136 pubnames.pn_length);
2137 printf (_(" Version: %d\n"),
2138 pubnames.pn_version);
2139 printf (_(" Offset into .debug_info section: %ld\n"),
2140 pubnames.pn_offset);
2141 printf (_(" Size of area in .debug_info section: %ld\n"),
2142 pubnames.pn_size);
2143
2144 printf (_("\n Offset\tName\n"));
2145
2146 do
2147 {
2148 offset = byte_get (data, offset_size);
2149
2150 if (offset != 0)
2151 {
2152 data += offset_size;
2153 printf (" %-6ld\t\t%s\n", offset, data);
2154 data += strlen ((char *) data) + 1;
2155 }
2156 }
2157 while (offset != 0);
2158 }
2159
2160 printf ("\n");
2161 return 1;
2162 }
2163
2164 static int
2165 display_debug_macinfo (struct dwarf_section *section,
2166 void *file ATTRIBUTE_UNUSED)
2167 {
2168 unsigned char *start = section->start;
2169 unsigned char *end = start + section->size;
2170 unsigned char *curr = start;
2171 unsigned int bytes_read;
2172 enum dwarf_macinfo_record_type op;
2173
2174 printf (_("Contents of the %s section:\n\n"), section->name);
2175
2176 while (curr < end)
2177 {
2178 unsigned int lineno;
2179 const char *string;
2180
2181 op = *curr;
2182 curr++;
2183
2184 switch (op)
2185 {
2186 case DW_MACINFO_start_file:
2187 {
2188 unsigned int filenum;
2189
2190 lineno = read_leb128 (curr, & bytes_read, 0);
2191 curr += bytes_read;
2192 filenum = read_leb128 (curr, & bytes_read, 0);
2193 curr += bytes_read;
2194
2195 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2196 lineno, filenum);
2197 }
2198 break;
2199
2200 case DW_MACINFO_end_file:
2201 printf (_(" DW_MACINFO_end_file\n"));
2202 break;
2203
2204 case DW_MACINFO_define:
2205 lineno = read_leb128 (curr, & bytes_read, 0);
2206 curr += bytes_read;
2207 string = (char *) curr;
2208 curr += strlen (string) + 1;
2209 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2210 lineno, string);
2211 break;
2212
2213 case DW_MACINFO_undef:
2214 lineno = read_leb128 (curr, & bytes_read, 0);
2215 curr += bytes_read;
2216 string = (char *) curr;
2217 curr += strlen (string) + 1;
2218 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2219 lineno, string);
2220 break;
2221
2222 case DW_MACINFO_vendor_ext:
2223 {
2224 unsigned int constant;
2225
2226 constant = read_leb128 (curr, & bytes_read, 0);
2227 curr += bytes_read;
2228 string = (char *) curr;
2229 curr += strlen (string) + 1;
2230 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2231 constant, string);
2232 }
2233 break;
2234 }
2235 }
2236
2237 return 1;
2238 }
2239
2240 static int
2241 display_debug_abbrev (struct dwarf_section *section,
2242 void *file ATTRIBUTE_UNUSED)
2243 {
2244 abbrev_entry *entry;
2245 unsigned char *start = section->start;
2246 unsigned char *end = start + section->size;
2247
2248 printf (_("Contents of the %s section:\n\n"), section->name);
2249
2250 do
2251 {
2252 free_abbrevs ();
2253
2254 start = process_abbrev_section (start, end);
2255
2256 if (first_abbrev == NULL)
2257 continue;
2258
2259 printf (_(" Number TAG\n"));
2260
2261 for (entry = first_abbrev; entry; entry = entry->next)
2262 {
2263 abbrev_attr *attr;
2264
2265 printf (_(" %ld %s [%s]\n"),
2266 entry->entry,
2267 get_TAG_name (entry->tag),
2268 entry->children ? _("has children") : _("no children"));
2269
2270 for (attr = entry->first_attr; attr; attr = attr->next)
2271 printf (_(" %-18s %s\n"),
2272 get_AT_name (attr->attribute),
2273 get_FORM_name (attr->form));
2274 }
2275 }
2276 while (start);
2277
2278 printf ("\n");
2279
2280 return 1;
2281 }
2282
2283 static int
2284 display_debug_loc (struct dwarf_section *section, void *file)
2285 {
2286 unsigned char *start = section->start;
2287 unsigned char *section_end;
2288 unsigned long bytes;
2289 unsigned char *section_begin = start;
2290 unsigned int num_loc_list = 0;
2291 unsigned long last_offset = 0;
2292 unsigned int first = 0;
2293 unsigned int i;
2294 unsigned int j;
2295 int seen_first_offset = 0;
2296 int use_debug_info = 1;
2297 unsigned char *next;
2298
2299 bytes = section->size;
2300 section_end = start + bytes;
2301
2302 if (bytes == 0)
2303 {
2304 printf (_("\nThe %s section is empty.\n"), section->name);
2305 return 0;
2306 }
2307
2308 load_debug_info (file);
2309
2310 /* Check the order of location list in .debug_info section. If
2311 offsets of location lists are in the ascending order, we can
2312 use `debug_information' directly. */
2313 for (i = 0; i < num_debug_info_entries; i++)
2314 {
2315 unsigned int num;
2316
2317 num = debug_information [i].num_loc_offsets;
2318 num_loc_list += num;
2319
2320 /* Check if we can use `debug_information' directly. */
2321 if (use_debug_info && num != 0)
2322 {
2323 if (!seen_first_offset)
2324 {
2325 /* This is the first location list. */
2326 last_offset = debug_information [i].loc_offsets [0];
2327 first = i;
2328 seen_first_offset = 1;
2329 j = 1;
2330 }
2331 else
2332 j = 0;
2333
2334 for (; j < num; j++)
2335 {
2336 if (last_offset >
2337 debug_information [i].loc_offsets [j])
2338 {
2339 use_debug_info = 0;
2340 break;
2341 }
2342 last_offset = debug_information [i].loc_offsets [j];
2343 }
2344 }
2345 }
2346
2347 if (!use_debug_info)
2348 /* FIXME: Should we handle this case? */
2349 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2350
2351 if (!seen_first_offset)
2352 error (_("No location lists in .debug_info section!\n"));
2353
2354 /* DWARF sections under Mach-O have non-zero addresses. */
2355 if (debug_information [first].num_loc_offsets > 0
2356 && debug_information [first].loc_offsets [0] != section->address)
2357 warn (_("Location lists in %s section start at 0x%lx\n"),
2358 section->name, debug_information [first].loc_offsets [0]);
2359
2360 printf (_("Contents of the %s section:\n\n"), section->name);
2361 printf (_(" Offset Begin End Expression\n"));
2362
2363 seen_first_offset = 0;
2364 for (i = first; i < num_debug_info_entries; i++)
2365 {
2366 unsigned long begin;
2367 unsigned long end;
2368 unsigned short length;
2369 unsigned long offset;
2370 unsigned int pointer_size;
2371 unsigned long cu_offset;
2372 unsigned long base_address;
2373 int need_frame_base;
2374 int has_frame_base;
2375
2376 pointer_size = debug_information [i].pointer_size;
2377 cu_offset = debug_information [i].cu_offset;
2378
2379 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2380 {
2381 has_frame_base = debug_information [i].have_frame_base [j];
2382 /* DWARF sections under Mach-O have non-zero addresses. */
2383 offset = debug_information [i].loc_offsets [j] - section->address;
2384 next = section_begin + offset;
2385 base_address = debug_information [i].base_address;
2386
2387 if (!seen_first_offset)
2388 seen_first_offset = 1;
2389 else
2390 {
2391 if (start < next)
2392 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2393 (long)(start - section_begin), (long)(next - section_begin));
2394 else if (start > next)
2395 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2396 (long)(start - section_begin), (long)(next - section_begin));
2397 }
2398 start = next;
2399
2400 if (offset >= bytes)
2401 {
2402 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2403 offset);
2404 continue;
2405 }
2406
2407 while (1)
2408 {
2409 if (start + 2 * pointer_size > section_end)
2410 {
2411 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2412 offset);
2413 break;
2414 }
2415
2416 begin = byte_get (start, pointer_size);
2417 start += pointer_size;
2418 end = byte_get (start, pointer_size);
2419 start += pointer_size;
2420
2421 if (begin == 0 && end == 0)
2422 {
2423 printf (_(" %8.8lx <End of list>\n"), offset);
2424 break;
2425 }
2426
2427 /* Check base address specifiers. */
2428 if (begin == -1UL && end != -1UL)
2429 {
2430 base_address = end;
2431 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2432 offset, begin, end);
2433 continue;
2434 }
2435
2436 if (start + 2 > section_end)
2437 {
2438 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2439 offset);
2440 break;
2441 }
2442
2443 length = byte_get (start, 2);
2444 start += 2;
2445
2446 if (start + length > section_end)
2447 {
2448 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2449 offset);
2450 break;
2451 }
2452
2453 printf (" %8.8lx %8.8lx %8.8lx (",
2454 offset, begin + base_address, end + base_address);
2455 need_frame_base = decode_location_expression (start,
2456 pointer_size,
2457 length,
2458 cu_offset);
2459 putchar (')');
2460
2461 if (need_frame_base && !has_frame_base)
2462 printf (_(" [without DW_AT_frame_base]"));
2463
2464 if (begin == end)
2465 fputs (_(" (start == end)"), stdout);
2466 else if (begin > end)
2467 fputs (_(" (start > end)"), stdout);
2468
2469 putchar ('\n');
2470
2471 start += length;
2472 }
2473 }
2474 }
2475 return 1;
2476 }
2477
2478 static int
2479 display_debug_str (struct dwarf_section *section,
2480 void *file ATTRIBUTE_UNUSED)
2481 {
2482 unsigned char *start = section->start;
2483 unsigned long bytes = section->size;
2484 dwarf_vma addr = section->address;
2485
2486 if (bytes == 0)
2487 {
2488 printf (_("\nThe %s section is empty.\n"), section->name);
2489 return 0;
2490 }
2491
2492 printf (_("Contents of the %s section:\n\n"), section->name);
2493
2494 while (bytes)
2495 {
2496 int j;
2497 int k;
2498 int lbytes;
2499
2500 lbytes = (bytes > 16 ? 16 : bytes);
2501
2502 printf (" 0x%8.8lx ", (unsigned long) addr);
2503
2504 for (j = 0; j < 16; j++)
2505 {
2506 if (j < lbytes)
2507 printf ("%2.2x", start[j]);
2508 else
2509 printf (" ");
2510
2511 if ((j & 3) == 3)
2512 printf (" ");
2513 }
2514
2515 for (j = 0; j < lbytes; j++)
2516 {
2517 k = start[j];
2518 if (k >= ' ' && k < 0x80)
2519 printf ("%c", k);
2520 else
2521 printf (".");
2522 }
2523
2524 putchar ('\n');
2525
2526 start += lbytes;
2527 addr += lbytes;
2528 bytes -= lbytes;
2529 }
2530
2531 putchar ('\n');
2532
2533 return 1;
2534 }
2535
2536 static int
2537 display_debug_info (struct dwarf_section *section, void *file)
2538 {
2539 return process_debug_info (section, file, 0);
2540 }
2541
2542
2543 static int
2544 display_debug_aranges (struct dwarf_section *section,
2545 void *file ATTRIBUTE_UNUSED)
2546 {
2547 unsigned char *start = section->start;
2548 unsigned char *end = start + section->size;
2549
2550 printf (_("The section %s contains:\n\n"), section->name);
2551
2552 while (start < end)
2553 {
2554 unsigned char *hdrptr;
2555 DWARF2_Internal_ARange arange;
2556 unsigned char *ranges;
2557 unsigned long length;
2558 unsigned long address;
2559 unsigned char address_size;
2560 int excess;
2561 int offset_size;
2562 int initial_length_size;
2563
2564 hdrptr = start;
2565
2566 arange.ar_length = byte_get (hdrptr, 4);
2567 hdrptr += 4;
2568
2569 if (arange.ar_length == 0xffffffff)
2570 {
2571 arange.ar_length = byte_get (hdrptr, 8);
2572 hdrptr += 8;
2573 offset_size = 8;
2574 initial_length_size = 12;
2575 }
2576 else
2577 {
2578 offset_size = 4;
2579 initial_length_size = 4;
2580 }
2581
2582 arange.ar_version = byte_get (hdrptr, 2);
2583 hdrptr += 2;
2584
2585 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2586 hdrptr += offset_size;
2587
2588 arange.ar_pointer_size = byte_get (hdrptr, 1);
2589 hdrptr += 1;
2590
2591 arange.ar_segment_size = byte_get (hdrptr, 1);
2592 hdrptr += 1;
2593
2594 if (arange.ar_version != 2 && arange.ar_version != 3)
2595 {
2596 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2597 break;
2598 }
2599
2600 printf (_(" Length: %ld\n"), arange.ar_length);
2601 printf (_(" Version: %d\n"), arange.ar_version);
2602 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
2603 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2604 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2605
2606 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2607
2608 /* The DWARF spec does not require that the address size be a power
2609 of two, but we do. This will have to change if we ever encounter
2610 an uneven architecture. */
2611 if ((address_size & (address_size - 1)) != 0)
2612 {
2613 warn (_("Pointer size + Segment size is not a power of two.\n"));
2614 break;
2615 }
2616
2617 if (address_size > 4)
2618 printf (_("\n Address Length\n"));
2619 else
2620 printf (_("\n Address Length\n"));
2621
2622 ranges = hdrptr;
2623
2624 /* Must pad to an alignment boundary that is twice the address size. */
2625 excess = (hdrptr - start) % (2 * address_size);
2626 if (excess)
2627 ranges += (2 * address_size) - excess;
2628
2629 start += arange.ar_length + initial_length_size;
2630
2631 while (ranges + 2 * address_size <= start)
2632 {
2633 address = byte_get (ranges, address_size);
2634
2635 ranges += address_size;
2636
2637 length = byte_get (ranges, address_size);
2638
2639 ranges += address_size;
2640
2641 if (address_size > 4)
2642 printf (" 0x%16.16lx 0x%lx\n", address, length);
2643 else
2644 printf (" 0x%8.8lx 0x%lx\n", address, length);
2645 }
2646 }
2647
2648 printf ("\n");
2649
2650 return 1;
2651 }
2652
2653 static int
2654 display_debug_ranges (struct dwarf_section *section,
2655 void *file ATTRIBUTE_UNUSED)
2656 {
2657 unsigned char *start = section->start;
2658 unsigned char *section_end;
2659 unsigned long bytes;
2660 unsigned char *section_begin = start;
2661 unsigned int num_range_list = 0;
2662 unsigned long last_offset = 0;
2663 unsigned int first = 0;
2664 unsigned int i;
2665 unsigned int j;
2666 int seen_first_offset = 0;
2667 int use_debug_info = 1;
2668 unsigned char *next;
2669
2670 bytes = section->size;
2671 section_end = start + bytes;
2672
2673 if (bytes == 0)
2674 {
2675 printf (_("\nThe %s section is empty.\n"), section->name);
2676 return 0;
2677 }
2678
2679 load_debug_info (file);
2680
2681 /* Check the order of range list in .debug_info section. If
2682 offsets of range lists are in the ascending order, we can
2683 use `debug_information' directly. */
2684 for (i = 0; i < num_debug_info_entries; i++)
2685 {
2686 unsigned int num;
2687
2688 num = debug_information [i].num_range_lists;
2689 num_range_list += num;
2690
2691 /* Check if we can use `debug_information' directly. */
2692 if (use_debug_info && num != 0)
2693 {
2694 if (!seen_first_offset)
2695 {
2696 /* This is the first range list. */
2697 last_offset = debug_information [i].range_lists [0];
2698 first = i;
2699 seen_first_offset = 1;
2700 j = 1;
2701 }
2702 else
2703 j = 0;
2704
2705 for (; j < num; j++)
2706 {
2707 if (last_offset >
2708 debug_information [i].range_lists [j])
2709 {
2710 use_debug_info = 0;
2711 break;
2712 }
2713 last_offset = debug_information [i].range_lists [j];
2714 }
2715 }
2716 }
2717
2718 if (!use_debug_info)
2719 /* FIXME: Should we handle this case? */
2720 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2721
2722 if (!seen_first_offset)
2723 error (_("No range lists in .debug_info section!\n"));
2724
2725 /* DWARF sections under Mach-O have non-zero addresses. */
2726 if (debug_information [first].num_range_lists > 0
2727 && debug_information [first].range_lists [0] != section->address)
2728 warn (_("Range lists in %s section start at 0x%lx\n"),
2729 section->name, debug_information [first].range_lists [0]);
2730
2731 printf (_("Contents of the %s section:\n\n"), section->name);
2732 printf (_(" Offset Begin End\n"));
2733
2734 seen_first_offset = 0;
2735 for (i = first; i < num_debug_info_entries; i++)
2736 {
2737 unsigned long begin;
2738 unsigned long end;
2739 unsigned long offset;
2740 unsigned int pointer_size;
2741 unsigned long base_address;
2742
2743 pointer_size = debug_information [i].pointer_size;
2744
2745 for (j = 0; j < debug_information [i].num_range_lists; j++)
2746 {
2747 /* DWARF sections under Mach-O have non-zero addresses. */
2748 offset = debug_information [i].range_lists [j] - section->address;
2749 next = section_begin + offset;
2750 base_address = debug_information [i].base_address;
2751
2752 if (!seen_first_offset)
2753 seen_first_offset = 1;
2754 else
2755 {
2756 if (start < next)
2757 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
2758 (long)(start - section_begin),
2759 (long)(next - section_begin), section->name);
2760 else if (start > next)
2761 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
2762 (long)(start - section_begin),
2763 (long)(next - section_begin), section->name);
2764 }
2765 start = next;
2766
2767 while (1)
2768 {
2769 begin = byte_get (start, pointer_size);
2770 start += pointer_size;
2771 end = byte_get (start, pointer_size);
2772 start += pointer_size;
2773
2774 if (begin == 0 && end == 0)
2775 {
2776 printf (_(" %8.8lx <End of list>\n"), offset);
2777 break;
2778 }
2779
2780 /* Check base address specifiers. */
2781 if (begin == -1UL && end != -1UL)
2782 {
2783 base_address = end;
2784 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
2785 offset, begin, end);
2786 continue;
2787 }
2788
2789 printf (" %8.8lx %8.8lx %8.8lx",
2790 offset, begin + base_address, end + base_address);
2791
2792 if (begin == end)
2793 fputs (_(" (start == end)"), stdout);
2794 else if (begin > end)
2795 fputs (_(" (start > end)"), stdout);
2796
2797 putchar ('\n');
2798 }
2799 }
2800 }
2801 putchar ('\n');
2802 return 1;
2803 }
2804
2805 typedef struct Frame_Chunk
2806 {
2807 struct Frame_Chunk *next;
2808 unsigned char *chunk_start;
2809 int ncols;
2810 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
2811 short int *col_type;
2812 int *col_offset;
2813 char *augmentation;
2814 unsigned int code_factor;
2815 int data_factor;
2816 unsigned long pc_begin;
2817 unsigned long pc_range;
2818 int cfa_reg;
2819 int cfa_offset;
2820 int ra;
2821 unsigned char fde_encoding;
2822 unsigned char cfa_exp;
2823 }
2824 Frame_Chunk;
2825
2826 /* A marker for a col_type that means this column was never referenced
2827 in the frame info. */
2828 #define DW_CFA_unreferenced (-1)
2829
2830 static void
2831 frame_need_space (Frame_Chunk *fc, int reg)
2832 {
2833 int prev = fc->ncols;
2834
2835 if (reg < fc->ncols)
2836 return;
2837
2838 fc->ncols = reg + 1;
2839 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
2840 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
2841
2842 while (prev < fc->ncols)
2843 {
2844 fc->col_type[prev] = DW_CFA_unreferenced;
2845 fc->col_offset[prev] = 0;
2846 prev++;
2847 }
2848 }
2849
2850 static void
2851 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
2852 {
2853 int r;
2854 char tmp[100];
2855
2856 if (*max_regs < fc->ncols)
2857 *max_regs = fc->ncols;
2858
2859 if (*need_col_headers)
2860 {
2861 *need_col_headers = 0;
2862
2863 printf (" LOC CFA ");
2864
2865 for (r = 0; r < *max_regs; r++)
2866 if (fc->col_type[r] != DW_CFA_unreferenced)
2867 {
2868 if (r == fc->ra)
2869 printf ("ra ");
2870 else
2871 printf ("r%-4d", r);
2872 }
2873
2874 printf ("\n");
2875 }
2876
2877 printf ("%08lx ", fc->pc_begin);
2878 if (fc->cfa_exp)
2879 strcpy (tmp, "exp");
2880 else
2881 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
2882 printf ("%-8s ", tmp);
2883
2884 for (r = 0; r < fc->ncols; r++)
2885 {
2886 if (fc->col_type[r] != DW_CFA_unreferenced)
2887 {
2888 switch (fc->col_type[r])
2889 {
2890 case DW_CFA_undefined:
2891 strcpy (tmp, "u");
2892 break;
2893 case DW_CFA_same_value:
2894 strcpy (tmp, "s");
2895 break;
2896 case DW_CFA_offset:
2897 sprintf (tmp, "c%+d", fc->col_offset[r]);
2898 break;
2899 case DW_CFA_val_offset:
2900 sprintf (tmp, "v%+d", fc->col_offset[r]);
2901 break;
2902 case DW_CFA_register:
2903 sprintf (tmp, "r%d", fc->col_offset[r]);
2904 break;
2905 case DW_CFA_expression:
2906 strcpy (tmp, "exp");
2907 break;
2908 case DW_CFA_val_expression:
2909 strcpy (tmp, "vexp");
2910 break;
2911 default:
2912 strcpy (tmp, "n/a");
2913 break;
2914 }
2915 printf ("%-5s", tmp);
2916 }
2917 }
2918 printf ("\n");
2919 }
2920
2921 static int
2922 size_of_encoded_value (int encoding)
2923 {
2924 switch (encoding & 0x7)
2925 {
2926 default: /* ??? */
2927 case 0: return eh_addr_size;
2928 case 2: return 2;
2929 case 3: return 4;
2930 case 4: return 8;
2931 }
2932 }
2933
2934 static dwarf_vma
2935 get_encoded_value (unsigned char *data, int encoding)
2936 {
2937 int size = size_of_encoded_value (encoding);
2938
2939 if (encoding & DW_EH_PE_signed)
2940 return byte_get_signed (data, size);
2941 else
2942 return byte_get (data, size);
2943 }
2944
2945 #define GET(N) byte_get (start, N); start += N
2946 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
2947 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
2948
2949 static int
2950 display_debug_frames (struct dwarf_section *section,
2951 void *file ATTRIBUTE_UNUSED)
2952 {
2953 unsigned char *start = section->start;
2954 unsigned char *end = start + section->size;
2955 unsigned char *section_start = start;
2956 Frame_Chunk *chunks = 0;
2957 Frame_Chunk *remembered_state = 0;
2958 Frame_Chunk *rs;
2959 int is_eh = strcmp (section->name, ".eh_frame") == 0;
2960 unsigned int length_return;
2961 int max_regs = 0;
2962
2963 printf (_("The section %s contains:\n"), section->name);
2964
2965 while (start < end)
2966 {
2967 unsigned char *saved_start;
2968 unsigned char *block_end;
2969 unsigned long length;
2970 unsigned long cie_id;
2971 Frame_Chunk *fc;
2972 Frame_Chunk *cie;
2973 int need_col_headers = 1;
2974 unsigned char *augmentation_data = NULL;
2975 unsigned long augmentation_data_len = 0;
2976 int encoded_ptr_size = eh_addr_size;
2977 int offset_size;
2978 int initial_length_size;
2979
2980 saved_start = start;
2981 length = byte_get (start, 4); start += 4;
2982
2983 if (length == 0)
2984 {
2985 printf ("\n%08lx ZERO terminator\n\n",
2986 (unsigned long)(saved_start - section_start));
2987 continue;
2988 }
2989
2990 if (length == 0xffffffff)
2991 {
2992 length = byte_get (start, 8);
2993 start += 8;
2994 offset_size = 8;
2995 initial_length_size = 12;
2996 }
2997 else
2998 {
2999 offset_size = 4;
3000 initial_length_size = 4;
3001 }
3002
3003 block_end = saved_start + length + initial_length_size;
3004 if (block_end > end)
3005 {
3006 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3007 length, (unsigned long)(saved_start - section_start));
3008 block_end = end;
3009 }
3010 cie_id = byte_get (start, offset_size); start += offset_size;
3011
3012 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3013 {
3014 int version;
3015
3016 fc = xmalloc (sizeof (Frame_Chunk));
3017 memset (fc, 0, sizeof (Frame_Chunk));
3018
3019 fc->next = chunks;
3020 chunks = fc;
3021 fc->chunk_start = saved_start;
3022 fc->ncols = 0;
3023 fc->col_type = xmalloc (sizeof (short int));
3024 fc->col_offset = xmalloc (sizeof (int));
3025 frame_need_space (fc, max_regs-1);
3026
3027 version = *start++;
3028
3029 fc->augmentation = (char *) start;
3030 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3031
3032 if (fc->augmentation[0] == 'z')
3033 {
3034 fc->code_factor = LEB ();
3035 fc->data_factor = SLEB ();
3036 if (version == 1)
3037 {
3038 fc->ra = GET (1);
3039 }
3040 else
3041 {
3042 fc->ra = LEB ();
3043 }
3044 augmentation_data_len = LEB ();
3045 augmentation_data = start;
3046 start += augmentation_data_len;
3047 }
3048 else if (strcmp (fc->augmentation, "eh") == 0)
3049 {
3050 start += eh_addr_size;
3051 fc->code_factor = LEB ();
3052 fc->data_factor = SLEB ();
3053 if (version == 1)
3054 {
3055 fc->ra = GET (1);
3056 }
3057 else
3058 {
3059 fc->ra = LEB ();
3060 }
3061 }
3062 else
3063 {
3064 fc->code_factor = LEB ();
3065 fc->data_factor = SLEB ();
3066 if (version == 1)
3067 {
3068 fc->ra = GET (1);
3069 }
3070 else
3071 {
3072 fc->ra = LEB ();
3073 }
3074 }
3075 cie = fc;
3076
3077 if (do_debug_frames_interp)
3078 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3079 (unsigned long)(saved_start - section_start), length, cie_id,
3080 fc->augmentation, fc->code_factor, fc->data_factor,
3081 fc->ra);
3082 else
3083 {
3084 printf ("\n%08lx %08lx %08lx CIE\n",
3085 (unsigned long)(saved_start - section_start), length, cie_id);
3086 printf (" Version: %d\n", version);
3087 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3088 printf (" Code alignment factor: %u\n", fc->code_factor);
3089 printf (" Data alignment factor: %d\n", fc->data_factor);
3090 printf (" Return address column: %d\n", fc->ra);
3091
3092 if (augmentation_data_len)
3093 {
3094 unsigned long i;
3095 printf (" Augmentation data: ");
3096 for (i = 0; i < augmentation_data_len; ++i)
3097 printf (" %02x", augmentation_data[i]);
3098 putchar ('\n');
3099 }
3100 putchar ('\n');
3101 }
3102
3103 if (augmentation_data_len)
3104 {
3105 unsigned char *p, *q;
3106 p = (unsigned char *) fc->augmentation + 1;
3107 q = augmentation_data;
3108
3109 while (1)
3110 {
3111 if (*p == 'L')
3112 q++;
3113 else if (*p == 'P')
3114 q += 1 + size_of_encoded_value (*q);
3115 else if (*p == 'R')
3116 fc->fde_encoding = *q++;
3117 else
3118 break;
3119 p++;
3120 }
3121
3122 if (fc->fde_encoding)
3123 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3124 }
3125
3126 frame_need_space (fc, fc->ra);
3127 }
3128 else
3129 {
3130 unsigned char *look_for;
3131 static Frame_Chunk fde_fc;
3132
3133 fc = & fde_fc;
3134 memset (fc, 0, sizeof (Frame_Chunk));
3135
3136 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3137
3138 for (cie = chunks; cie ; cie = cie->next)
3139 if (cie->chunk_start == look_for)
3140 break;
3141
3142 if (!cie)
3143 {
3144 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
3145 cie_id, (unsigned long)(saved_start - section_start));
3146 fc->ncols = 0;
3147 fc->col_type = xmalloc (sizeof (short int));
3148 fc->col_offset = xmalloc (sizeof (int));
3149 frame_need_space (fc, max_regs - 1);
3150 cie = fc;
3151 fc->augmentation = "";
3152 fc->fde_encoding = 0;
3153 }
3154 else
3155 {
3156 fc->ncols = cie->ncols;
3157 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3158 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3159 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3160 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3161 fc->augmentation = cie->augmentation;
3162 fc->code_factor = cie->code_factor;
3163 fc->data_factor = cie->data_factor;
3164 fc->cfa_reg = cie->cfa_reg;
3165 fc->cfa_offset = cie->cfa_offset;
3166 fc->ra = cie->ra;
3167 frame_need_space (fc, max_regs-1);
3168 fc->fde_encoding = cie->fde_encoding;
3169 }
3170
3171 if (fc->fde_encoding)
3172 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3173
3174 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
3175 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3176 /* Don't adjust for relocatable file since there's
3177 invariably a pcrel reloc here, which we haven't
3178 applied. */
3179 && !is_relocatable)
3180 fc->pc_begin += section->address + (start - section_start);
3181 start += encoded_ptr_size;
3182 fc->pc_range = byte_get (start, encoded_ptr_size);
3183 start += encoded_ptr_size;
3184
3185 if (cie->augmentation[0] == 'z')
3186 {
3187 augmentation_data_len = LEB ();
3188 augmentation_data = start;
3189 start += augmentation_data_len;
3190 }
3191
3192 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3193 (unsigned long)(saved_start - section_start), length, cie_id,
3194 (unsigned long)(cie->chunk_start - section_start),
3195 fc->pc_begin, fc->pc_begin + fc->pc_range);
3196 if (! do_debug_frames_interp && augmentation_data_len)
3197 {
3198 unsigned long i;
3199
3200 printf (" Augmentation data: ");
3201 for (i = 0; i < augmentation_data_len; ++i)
3202 printf (" %02x", augmentation_data[i]);
3203 putchar ('\n');
3204 putchar ('\n');
3205 }
3206 }
3207
3208 /* At this point, fc is the current chunk, cie (if any) is set, and
3209 we're about to interpret instructions for the chunk. */
3210 /* ??? At present we need to do this always, since this sizes the
3211 fc->col_type and fc->col_offset arrays, which we write into always.
3212 We should probably split the interpreted and non-interpreted bits
3213 into two different routines, since there's so much that doesn't
3214 really overlap between them. */
3215 if (1 || do_debug_frames_interp)
3216 {
3217 /* Start by making a pass over the chunk, allocating storage
3218 and taking note of what registers are used. */
3219 unsigned char *tmp = start;
3220
3221 while (start < block_end)
3222 {
3223 unsigned op, opa;
3224 unsigned long reg, tmp;
3225
3226 op = *start++;
3227 opa = op & 0x3f;
3228 if (op & 0xc0)
3229 op &= 0xc0;
3230
3231 /* Warning: if you add any more cases to this switch, be
3232 sure to add them to the corresponding switch below. */
3233 switch (op)
3234 {
3235 case DW_CFA_advance_loc:
3236 break;
3237 case DW_CFA_offset:
3238 LEB ();
3239 frame_need_space (fc, opa);
3240 fc->col_type[opa] = DW_CFA_undefined;
3241 break;
3242 case DW_CFA_restore:
3243 frame_need_space (fc, opa);
3244 fc->col_type[opa] = DW_CFA_undefined;
3245 break;
3246 case DW_CFA_set_loc:
3247 start += encoded_ptr_size;
3248 break;
3249 case DW_CFA_advance_loc1:
3250 start += 1;
3251 break;
3252 case DW_CFA_advance_loc2:
3253 start += 2;
3254 break;
3255 case DW_CFA_advance_loc4:
3256 start += 4;
3257 break;
3258 case DW_CFA_offset_extended:
3259 case DW_CFA_val_offset:
3260 reg = LEB (); LEB ();
3261 frame_need_space (fc, reg);
3262 fc->col_type[reg] = DW_CFA_undefined;
3263 break;
3264 case DW_CFA_restore_extended:
3265 reg = LEB ();
3266 frame_need_space (fc, reg);
3267 fc->col_type[reg] = DW_CFA_undefined;
3268 break;
3269 case DW_CFA_undefined:
3270 reg = LEB ();
3271 frame_need_space (fc, reg);
3272 fc->col_type[reg] = DW_CFA_undefined;
3273 break;
3274 case DW_CFA_same_value:
3275 reg = LEB ();
3276 frame_need_space (fc, reg);
3277 fc->col_type[reg] = DW_CFA_undefined;
3278 break;
3279 case DW_CFA_register:
3280 reg = LEB (); LEB ();
3281 frame_need_space (fc, reg);
3282 fc->col_type[reg] = DW_CFA_undefined;
3283 break;
3284 case DW_CFA_def_cfa:
3285 LEB (); LEB ();
3286 break;
3287 case DW_CFA_def_cfa_register:
3288 LEB ();
3289 break;
3290 case DW_CFA_def_cfa_offset:
3291 LEB ();
3292 break;
3293 case DW_CFA_def_cfa_expression:
3294 tmp = LEB ();
3295 start += tmp;
3296 break;
3297 case DW_CFA_expression:
3298 case DW_CFA_val_expression:
3299 reg = LEB ();
3300 tmp = LEB ();
3301 start += tmp;
3302 frame_need_space (fc, reg);
3303 fc->col_type[reg] = DW_CFA_undefined;
3304 break;
3305 case DW_CFA_offset_extended_sf:
3306 case DW_CFA_val_offset_sf:
3307 reg = LEB (); SLEB ();
3308 frame_need_space (fc, reg);
3309 fc->col_type[reg] = DW_CFA_undefined;
3310 break;
3311 case DW_CFA_def_cfa_sf:
3312 LEB (); SLEB ();
3313 break;
3314 case DW_CFA_def_cfa_offset_sf:
3315 SLEB ();
3316 break;
3317 case DW_CFA_MIPS_advance_loc8:
3318 start += 8;
3319 break;
3320 case DW_CFA_GNU_args_size:
3321 LEB ();
3322 break;
3323 case DW_CFA_GNU_negative_offset_extended:
3324 reg = LEB (); LEB ();
3325 frame_need_space (fc, reg);
3326 fc->col_type[reg] = DW_CFA_undefined;
3327
3328 default:
3329 break;
3330 }
3331 }
3332 start = tmp;
3333 }
3334
3335 /* Now we know what registers are used, make a second pass over
3336 the chunk, this time actually printing out the info. */
3337
3338 while (start < block_end)
3339 {
3340 unsigned op, opa;
3341 unsigned long ul, reg, roffs;
3342 long l, ofs;
3343 dwarf_vma vma;
3344
3345 op = *start++;
3346 opa = op & 0x3f;
3347 if (op & 0xc0)
3348 op &= 0xc0;
3349
3350 /* Warning: if you add any more cases to this switch, be
3351 sure to add them to the corresponding switch above. */
3352 switch (op)
3353 {
3354 case DW_CFA_advance_loc:
3355 if (do_debug_frames_interp)
3356 frame_display_row (fc, &need_col_headers, &max_regs);
3357 else
3358 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3359 opa * fc->code_factor,
3360 fc->pc_begin + opa * fc->code_factor);
3361 fc->pc_begin += opa * fc->code_factor;
3362 break;
3363
3364 case DW_CFA_offset:
3365 roffs = LEB ();
3366 if (! do_debug_frames_interp)
3367 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3368 opa, roffs * fc->data_factor);
3369 fc->col_type[opa] = DW_CFA_offset;
3370 fc->col_offset[opa] = roffs * fc->data_factor;
3371 break;
3372
3373 case DW_CFA_restore:
3374 if (! do_debug_frames_interp)
3375 printf (" DW_CFA_restore: r%d\n", opa);
3376 fc->col_type[opa] = cie->col_type[opa];
3377 fc->col_offset[opa] = cie->col_offset[opa];
3378 break;
3379
3380 case DW_CFA_set_loc:
3381 vma = get_encoded_value (start, fc->fde_encoding);
3382 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel
3383 && !is_relocatable)
3384 vma += section->address + (start - section_start);
3385 start += encoded_ptr_size;
3386 if (do_debug_frames_interp)
3387 frame_display_row (fc, &need_col_headers, &max_regs);
3388 else
3389 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3390 fc->pc_begin = vma;
3391 break;
3392
3393 case DW_CFA_advance_loc1:
3394 ofs = byte_get (start, 1); start += 1;
3395 if (do_debug_frames_interp)
3396 frame_display_row (fc, &need_col_headers, &max_regs);
3397 else
3398 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3399 ofs * fc->code_factor,
3400 fc->pc_begin + ofs * fc->code_factor);
3401 fc->pc_begin += ofs * fc->code_factor;
3402 break;
3403
3404 case DW_CFA_advance_loc2:
3405 ofs = byte_get (start, 2); start += 2;
3406 if (do_debug_frames_interp)
3407 frame_display_row (fc, &need_col_headers, &max_regs);
3408 else
3409 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3410 ofs * fc->code_factor,
3411 fc->pc_begin + ofs * fc->code_factor);
3412 fc->pc_begin += ofs * fc->code_factor;
3413 break;
3414
3415 case DW_CFA_advance_loc4:
3416 ofs = byte_get (start, 4); start += 4;
3417 if (do_debug_frames_interp)
3418 frame_display_row (fc, &need_col_headers, &max_regs);
3419 else
3420 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3421 ofs * fc->code_factor,
3422 fc->pc_begin + ofs * fc->code_factor);
3423 fc->pc_begin += ofs * fc->code_factor;
3424 break;
3425
3426 case DW_CFA_offset_extended:
3427 reg = LEB ();
3428 roffs = LEB ();
3429 if (! do_debug_frames_interp)
3430 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3431 reg, roffs * fc->data_factor);
3432 fc->col_type[reg] = DW_CFA_offset;
3433 fc->col_offset[reg] = roffs * fc->data_factor;
3434 break;
3435
3436 case DW_CFA_val_offset:
3437 reg = LEB ();
3438 roffs = LEB ();
3439 if (! do_debug_frames_interp)
3440 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3441 reg, roffs * fc->data_factor);
3442 fc->col_type[reg] = DW_CFA_val_offset;
3443 fc->col_offset[reg] = roffs * fc->data_factor;
3444 break;
3445
3446 case DW_CFA_restore_extended:
3447 reg = LEB ();
3448 if (! do_debug_frames_interp)
3449 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3450 fc->col_type[reg] = cie->col_type[reg];
3451 fc->col_offset[reg] = cie->col_offset[reg];
3452 break;
3453
3454 case DW_CFA_undefined:
3455 reg = LEB ();
3456 if (! do_debug_frames_interp)
3457 printf (" DW_CFA_undefined: r%ld\n", reg);
3458 fc->col_type[reg] = DW_CFA_undefined;
3459 fc->col_offset[reg] = 0;
3460 break;
3461
3462 case DW_CFA_same_value:
3463 reg = LEB ();
3464 if (! do_debug_frames_interp)
3465 printf (" DW_CFA_same_value: r%ld\n", reg);
3466 fc->col_type[reg] = DW_CFA_same_value;
3467 fc->col_offset[reg] = 0;
3468 break;
3469
3470 case DW_CFA_register:
3471 reg = LEB ();
3472 roffs = LEB ();
3473 if (! do_debug_frames_interp)
3474 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3475 fc->col_type[reg] = DW_CFA_register;
3476 fc->col_offset[reg] = roffs;
3477 break;
3478
3479 case DW_CFA_remember_state:
3480 if (! do_debug_frames_interp)
3481 printf (" DW_CFA_remember_state\n");
3482 rs = xmalloc (sizeof (Frame_Chunk));
3483 rs->ncols = fc->ncols;
3484 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3485 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3486 memcpy (rs->col_type, fc->col_type, rs->ncols);
3487 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3488 rs->next = remembered_state;
3489 remembered_state = rs;
3490 break;
3491
3492 case DW_CFA_restore_state:
3493 if (! do_debug_frames_interp)
3494 printf (" DW_CFA_restore_state\n");
3495 rs = remembered_state;
3496 if (rs)
3497 {
3498 remembered_state = rs->next;
3499 frame_need_space (fc, rs->ncols-1);
3500 memcpy (fc->col_type, rs->col_type, rs->ncols);
3501 memcpy (fc->col_offset, rs->col_offset,
3502 rs->ncols * sizeof (int));
3503 free (rs->col_type);
3504 free (rs->col_offset);
3505 free (rs);
3506 }
3507 else if (do_debug_frames_interp)
3508 printf ("Mismatched DW_CFA_restore_state\n");
3509 break;
3510
3511 case DW_CFA_def_cfa:
3512 fc->cfa_reg = LEB ();
3513 fc->cfa_offset = LEB ();
3514 fc->cfa_exp = 0;
3515 if (! do_debug_frames_interp)
3516 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3517 fc->cfa_reg, fc->cfa_offset);
3518 break;
3519
3520 case DW_CFA_def_cfa_register:
3521 fc->cfa_reg = LEB ();
3522 fc->cfa_exp = 0;
3523 if (! do_debug_frames_interp)
3524 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3525 break;
3526
3527 case DW_CFA_def_cfa_offset:
3528 fc->cfa_offset = LEB ();
3529 if (! do_debug_frames_interp)
3530 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3531 break;
3532
3533 case DW_CFA_nop:
3534 if (! do_debug_frames_interp)
3535 printf (" DW_CFA_nop\n");
3536 break;
3537
3538 case DW_CFA_def_cfa_expression:
3539 ul = LEB ();
3540 if (! do_debug_frames_interp)
3541 {
3542 printf (" DW_CFA_def_cfa_expression (");
3543 decode_location_expression (start, eh_addr_size, ul, 0);
3544 printf (")\n");
3545 }
3546 fc->cfa_exp = 1;
3547 start += ul;
3548 break;
3549
3550 case DW_CFA_expression:
3551 reg = LEB ();
3552 ul = LEB ();
3553 if (! do_debug_frames_interp)
3554 {
3555 printf (" DW_CFA_expression: r%ld (", reg);
3556 decode_location_expression (start, eh_addr_size, ul, 0);
3557 printf (")\n");
3558 }
3559 fc->col_type[reg] = DW_CFA_expression;
3560 start += ul;
3561 break;
3562
3563 case DW_CFA_val_expression:
3564 reg = LEB ();
3565 ul = LEB ();
3566 if (! do_debug_frames_interp)
3567 {
3568 printf (" DW_CFA_val_expression: r%ld (", reg);
3569 decode_location_expression (start, eh_addr_size, ul, 0);
3570 printf (")\n");
3571 }
3572 fc->col_type[reg] = DW_CFA_val_expression;
3573 start += ul;
3574 break;
3575
3576 case DW_CFA_offset_extended_sf:
3577 reg = LEB ();
3578 l = SLEB ();
3579 frame_need_space (fc, reg);
3580 if (! do_debug_frames_interp)
3581 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3582 reg, l * fc->data_factor);
3583 fc->col_type[reg] = DW_CFA_offset;
3584 fc->col_offset[reg] = l * fc->data_factor;
3585 break;
3586
3587 case DW_CFA_val_offset_sf:
3588 reg = LEB ();
3589 l = SLEB ();
3590 frame_need_space (fc, reg);
3591 if (! do_debug_frames_interp)
3592 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3593 reg, l * fc->data_factor);
3594 fc->col_type[reg] = DW_CFA_val_offset;
3595 fc->col_offset[reg] = l * fc->data_factor;
3596 break;
3597
3598 case DW_CFA_def_cfa_sf:
3599 fc->cfa_reg = LEB ();
3600 fc->cfa_offset = SLEB ();
3601 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3602 fc->cfa_exp = 0;
3603 if (! do_debug_frames_interp)
3604 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3605 fc->cfa_reg, fc->cfa_offset);
3606 break;
3607
3608 case DW_CFA_def_cfa_offset_sf:
3609 fc->cfa_offset = SLEB ();
3610 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3611 if (! do_debug_frames_interp)
3612 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3613 break;
3614
3615 case DW_CFA_MIPS_advance_loc8:
3616 ofs = byte_get (start, 8); start += 8;
3617 if (do_debug_frames_interp)
3618 frame_display_row (fc, &need_col_headers, &max_regs);
3619 else
3620 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3621 ofs * fc->code_factor,
3622 fc->pc_begin + ofs * fc->code_factor);
3623 fc->pc_begin += ofs * fc->code_factor;
3624 break;
3625
3626 case DW_CFA_GNU_window_save:
3627 if (! do_debug_frames_interp)
3628 printf (" DW_CFA_GNU_window_save\n");
3629 break;
3630
3631 case DW_CFA_GNU_args_size:
3632 ul = LEB ();
3633 if (! do_debug_frames_interp)
3634 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3635 break;
3636
3637 case DW_CFA_GNU_negative_offset_extended:
3638 reg = LEB ();
3639 l = - LEB ();
3640 frame_need_space (fc, reg);
3641 if (! do_debug_frames_interp)
3642 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3643 reg, l * fc->data_factor);
3644 fc->col_type[reg] = DW_CFA_offset;
3645 fc->col_offset[reg] = l * fc->data_factor;
3646 break;
3647
3648 default:
3649 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3650 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3651 else
3652 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
3653 start = block_end;
3654 }
3655 }
3656
3657 if (do_debug_frames_interp)
3658 frame_display_row (fc, &need_col_headers, &max_regs);
3659
3660 start = block_end;
3661 }
3662
3663 printf ("\n");
3664
3665 return 1;
3666 }
3667
3668 #undef GET
3669 #undef LEB
3670 #undef SLEB
3671
3672 static int
3673 display_debug_not_supported (struct dwarf_section *section,
3674 void *file ATTRIBUTE_UNUSED)
3675 {
3676 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3677 section->name);
3678
3679 return 1;
3680 }
3681
3682 void *
3683 cmalloc (size_t nmemb, size_t size)
3684 {
3685 /* Check for overflow. */
3686 if (nmemb >= ~(size_t) 0 / size)
3687 return NULL;
3688 else
3689 return malloc (nmemb * size);
3690 }
3691
3692 void *
3693 xcmalloc (size_t nmemb, size_t size)
3694 {
3695 /* Check for overflow. */
3696 if (nmemb >= ~(size_t) 0 / size)
3697 return NULL;
3698 else
3699 return xmalloc (nmemb * size);
3700 }
3701
3702 void *
3703 xcrealloc (void *ptr, size_t nmemb, size_t size)
3704 {
3705 /* Check for overflow. */
3706 if (nmemb >= ~(size_t) 0 / size)
3707 return NULL;
3708 else
3709 return xrealloc (ptr, nmemb * size);
3710 }
3711
3712 void
3713 error (const char *message, ...)
3714 {
3715 va_list args;
3716
3717 va_start (args, message);
3718 fprintf (stderr, _("%s: Error: "), program_name);
3719 vfprintf (stderr, message, args);
3720 va_end (args);
3721 }
3722
3723 void
3724 warn (const char *message, ...)
3725 {
3726 va_list args;
3727
3728 va_start (args, message);
3729 fprintf (stderr, _("%s: Warning: "), program_name);
3730 vfprintf (stderr, message, args);
3731 va_end (args);
3732 }
3733
3734 void
3735 free_debug_memory (void)
3736 {
3737 enum dwarf_section_display_enum i;
3738
3739 free_abbrevs ();
3740
3741 for (i = 0; i < max; i++)
3742 free_debug_section (i);
3743
3744 if (debug_information)
3745 {
3746 for (i = 0; i < num_debug_info_entries; i++)
3747 {
3748 if (!debug_information [i].max_loc_offsets)
3749 {
3750 free (debug_information [i].loc_offsets);
3751 free (debug_information [i].have_frame_base);
3752 }
3753 if (!debug_information [i].max_range_lists)
3754 free (debug_information [i].range_lists);
3755 }
3756 free (debug_information);
3757 debug_information = NULL;
3758 num_debug_info_entries = 0;
3759 }
3760
3761 }
3762
3763 struct dwarf_section_display debug_displays[] =
3764 {
3765 { { ".debug_abbrev", NULL, 0, 0 },
3766 display_debug_abbrev, 0, 0 },
3767 { { ".debug_aranges", NULL, 0, 0 },
3768 display_debug_aranges, 0, 0 },
3769 { { ".debug_frame", NULL, 0, 0 },
3770 display_debug_frames, 1, 0 },
3771 { { ".debug_info", NULL, 0, 0 },
3772 display_debug_info, 1, 0 },
3773 { { ".debug_line", NULL, 0, 0 },
3774 display_debug_lines, 0, 0 },
3775 { { ".debug_pubnames", NULL, 0, 0 },
3776 display_debug_pubnames, 0, 0 },
3777 { { ".eh_frame", NULL, 0, 0 },
3778 display_debug_frames, 1, 1 },
3779 { { ".debug_macinfo", NULL, 0, 0 },
3780 display_debug_macinfo, 0, 0 },
3781 { { ".debug_str", NULL, 0, 0 },
3782 display_debug_str, 0, 0 },
3783 { { ".debug_loc", NULL, 0, 0 },
3784 display_debug_loc, 0, 0 },
3785 { { ".debug_pubtypes", NULL, 0, 0 },
3786 display_debug_pubnames, 0, 0 },
3787 { { ".debug_ranges", NULL, 0, 0 },
3788 display_debug_ranges, 0, 0 },
3789 { { ".debug_static_func", NULL, 0, 0 },
3790 display_debug_not_supported, 0, 0 },
3791 { { ".debug_static_vars", NULL, 0, 0 },
3792 display_debug_not_supported, 0, 0 },
3793 { { ".debug_types", NULL, 0, 0 },
3794 display_debug_not_supported, 0, 0 },
3795 { { ".debug_weaknames", NULL, 0, 0 },
3796 display_debug_not_supported, 0, 0 }
3797 };
git-cvsimport of binutils cvsroot