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