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