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