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