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