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