projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* readelf.c (target_specific_reloc_handling): New function:
[deliverable/binutils-gdb.git] / binutils / dwarf.c
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 putchar ('\n');
3258 return 1;
3259 }
3260
3261 static int
3262 display_debug_str (struct dwarf_section *section,
3263 void *file ATTRIBUTE_UNUSED)
3264 {
3265 unsigned char *start = section->start;
3266 unsigned long bytes = section->size;
3267 dwarf_vma addr = section->address;
3268
3269 if (bytes == 0)
3270 {
3271 printf (_("\nThe %s section is empty.\n"), section->name);
3272 return 0;
3273 }
3274
3275 printf (_("Contents of the %s section:\n\n"), section->name);
3276
3277 while (bytes)
3278 {
3279 int j;
3280 int k;
3281 int lbytes;
3282
3283 lbytes = (bytes > 16 ? 16 : bytes);
3284
3285 printf (" 0x%8.8lx ", (unsigned long) addr);
3286
3287 for (j = 0; j < 16; j++)
3288 {
3289 if (j < lbytes)
3290 printf ("%2.2x", start[j]);
3291 else
3292 printf (" ");
3293
3294 if ((j & 3) == 3)
3295 printf (" ");
3296 }
3297
3298 for (j = 0; j < lbytes; j++)
3299 {
3300 k = start[j];
3301 if (k >= ' ' && k < 0x80)
3302 printf ("%c", k);
3303 else
3304 printf (".");
3305 }
3306
3307 putchar ('\n');
3308
3309 start += lbytes;
3310 addr += lbytes;
3311 bytes -= lbytes;
3312 }
3313
3314 putchar ('\n');
3315
3316 return 1;
3317 }
3318
3319 static int
3320 display_debug_info (struct dwarf_section *section, void *file)
3321 {
3322 return process_debug_info (section, file, 0);
3323 }
3324
3325
3326 static int
3327 display_debug_aranges (struct dwarf_section *section,
3328 void *file ATTRIBUTE_UNUSED)
3329 {
3330 unsigned char *start = section->start;
3331 unsigned char *end = start + section->size;
3332
3333 printf (_("Contents of the %s section:\n\n"), section->name);
3334
3335 /* It does not matter if this load fails,
3336 we test for that later on. */
3337 load_debug_info (file);
3338
3339 while (start < end)
3340 {
3341 unsigned char *hdrptr;
3342 DWARF2_Internal_ARange arange;
3343 unsigned char *ranges;
3344 dwarf_vma length;
3345 dwarf_vma address;
3346 unsigned char address_size;
3347 int excess;
3348 int offset_size;
3349 int initial_length_size;
3350
3351 hdrptr = start;
3352
3353 arange.ar_length = byte_get (hdrptr, 4);
3354 hdrptr += 4;
3355
3356 if (arange.ar_length == 0xffffffff)
3357 {
3358 arange.ar_length = byte_get (hdrptr, 8);
3359 hdrptr += 8;
3360 offset_size = 8;
3361 initial_length_size = 12;
3362 }
3363 else
3364 {
3365 offset_size = 4;
3366 initial_length_size = 4;
3367 }
3368
3369 arange.ar_version = byte_get (hdrptr, 2);
3370 hdrptr += 2;
3371
3372 arange.ar_info_offset = byte_get (hdrptr, offset_size);
3373 hdrptr += offset_size;
3374
3375 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3376 && num_debug_info_entries > 0
3377 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
3378 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3379 arange.ar_info_offset, section->name);
3380
3381 arange.ar_pointer_size = byte_get (hdrptr, 1);
3382 hdrptr += 1;
3383
3384 arange.ar_segment_size = byte_get (hdrptr, 1);
3385 hdrptr += 1;
3386
3387 if (arange.ar_version != 2 && arange.ar_version != 3)
3388 {
3389 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
3390 break;
3391 }
3392
3393 printf (_(" Length: %ld\n"), arange.ar_length);
3394 printf (_(" Version: %d\n"), arange.ar_version);
3395 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
3396 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
3397 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
3398
3399 address_size = arange.ar_pointer_size + arange.ar_segment_size;
3400
3401 /* The DWARF spec does not require that the address size be a power
3402 of two, but we do. This will have to change if we ever encounter
3403 an uneven architecture. */
3404 if ((address_size & (address_size - 1)) != 0)
3405 {
3406 warn (_("Pointer size + Segment size is not a power of two.\n"));
3407 break;
3408 }
3409
3410 if (address_size > 4)
3411 printf (_("\n Address Length\n"));
3412 else
3413 printf (_("\n Address Length\n"));
3414
3415 ranges = hdrptr;
3416
3417 /* Must pad to an alignment boundary that is twice the address size. */
3418 excess = (hdrptr - start) % (2 * address_size);
3419 if (excess)
3420 ranges += (2 * address_size) - excess;
3421
3422 start += arange.ar_length + initial_length_size;
3423
3424 while (ranges + 2 * address_size <= start)
3425 {
3426 address = byte_get (ranges, address_size);
3427
3428 ranges += address_size;
3429
3430 length = byte_get (ranges, address_size);
3431
3432 ranges += address_size;
3433
3434 printf (" ");
3435 print_dwarf_vma (address, address_size);
3436 print_dwarf_vma (length, address_size);
3437 putchar ('\n');
3438 }
3439 }
3440
3441 printf ("\n");
3442
3443 return 1;
3444 }
3445
3446 static int
3447 display_debug_ranges (struct dwarf_section *section,
3448 void *file ATTRIBUTE_UNUSED)
3449 {
3450 unsigned char *start = section->start;
3451 unsigned char *section_end;
3452 unsigned long bytes;
3453 unsigned char *section_begin = start;
3454 unsigned int num_range_list = 0;
3455 unsigned long last_offset = 0;
3456 unsigned int first = 0;
3457 unsigned int i;
3458 unsigned int j;
3459 int seen_first_offset = 0;
3460 int use_debug_info = 1;
3461 unsigned char *next;
3462
3463 bytes = section->size;
3464 section_end = start + bytes;
3465
3466 if (bytes == 0)
3467 {
3468 printf (_("\nThe %s section is empty.\n"), section->name);
3469 return 0;
3470 }
3471
3472 if (load_debug_info (file) == 0)
3473 {
3474 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3475 section->name);
3476 return 0;
3477 }
3478
3479 /* Check the order of range list in .debug_info section. If
3480 offsets of range lists are in the ascending order, we can
3481 use `debug_information' directly. */
3482 for (i = 0; i < num_debug_info_entries; i++)
3483 {
3484 unsigned int num;
3485
3486 num = debug_information [i].num_range_lists;
3487 num_range_list += num;
3488
3489 /* Check if we can use `debug_information' directly. */
3490 if (use_debug_info && num != 0)
3491 {
3492 if (!seen_first_offset)
3493 {
3494 /* This is the first range list. */
3495 last_offset = debug_information [i].range_lists [0];
3496 first = i;
3497 seen_first_offset = 1;
3498 j = 1;
3499 }
3500 else
3501 j = 0;
3502
3503 for (; j < num; j++)
3504 {
3505 if (last_offset >
3506 debug_information [i].range_lists [j])
3507 {
3508 use_debug_info = 0;
3509 break;
3510 }
3511 last_offset = debug_information [i].range_lists [j];
3512 }
3513 }
3514 }
3515
3516 if (!use_debug_info)
3517 /* FIXME: Should we handle this case? */
3518 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
3519
3520 if (!seen_first_offset)
3521 error (_("No range lists in .debug_info section!\n"));
3522
3523 /* DWARF sections under Mach-O have non-zero addresses. */
3524 if (debug_information [first].num_range_lists > 0
3525 && debug_information [first].range_lists [0] != section->address)
3526 warn (_("Range lists in %s section start at 0x%lx\n"),
3527 section->name, debug_information [first].range_lists [0]);
3528
3529 printf (_("Contents of the %s section:\n\n"), section->name);
3530 printf (_(" Offset Begin End\n"));
3531
3532 seen_first_offset = 0;
3533 for (i = first; i < num_debug_info_entries; i++)
3534 {
3535 dwarf_vma begin;
3536 dwarf_vma end;
3537 unsigned long offset;
3538 unsigned int pointer_size;
3539 unsigned long base_address;
3540
3541 pointer_size = debug_information [i].pointer_size;
3542
3543 for (j = 0; j < debug_information [i].num_range_lists; j++)
3544 {
3545 /* DWARF sections under Mach-O have non-zero addresses. */
3546 offset = debug_information [i].range_lists [j] - section->address;
3547 next = section_begin + offset;
3548 base_address = debug_information [i].base_address;
3549
3550 if (!seen_first_offset)
3551 seen_first_offset = 1;
3552 else
3553 {
3554 if (start < next)
3555 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3556 (unsigned long) (start - section_begin),
3557 (unsigned long) (next - section_begin), section->name);
3558 else if (start > next)
3559 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3560 (unsigned long) (start - section_begin),
3561 (unsigned long) (next - section_begin), section->name);
3562 }
3563 start = next;
3564
3565 while (1)
3566 {
3567 /* Note: we use sign extension here in order to be sure that
3568 we can detect the -1 escape value. Sign extension into the
3569 top 32 bits of a 32-bit address will not affect the values
3570 that we display since we always show hex values, and always
3571 the bottom 32-bits. */
3572 begin = byte_get_signed (start, pointer_size);
3573 start += pointer_size;
3574 end = byte_get_signed (start, pointer_size);
3575 start += pointer_size;
3576
3577 printf (" %8.8lx ", offset);
3578
3579 if (begin == 0 && end == 0)
3580 {
3581 printf (_("<End of list>\n"));
3582 break;
3583 }
3584
3585 /* Check base address specifiers. */
3586 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
3587 {
3588 base_address = end;
3589 print_dwarf_vma (begin, pointer_size);
3590 print_dwarf_vma (end, pointer_size);
3591 printf ("(base address)\n");
3592 continue;
3593 }
3594
3595 print_dwarf_vma (begin + base_address, pointer_size);
3596 print_dwarf_vma (end + base_address, pointer_size);
3597
3598 if (begin == end)
3599 fputs (_("(start == end)"), stdout);
3600 else if (begin > end)
3601 fputs (_("(start > end)"), stdout);
3602
3603 putchar ('\n');
3604 }
3605 }
3606 }
3607 putchar ('\n');
3608 return 1;
3609 }
3610
3611 typedef struct Frame_Chunk
3612 {
3613 struct Frame_Chunk *next;
3614 unsigned char *chunk_start;
3615 int ncols;
3616 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3617 short int *col_type;
3618 int *col_offset;
3619 char *augmentation;
3620 unsigned int code_factor;
3621 int data_factor;
3622 unsigned long pc_begin;
3623 unsigned long pc_range;
3624 int cfa_reg;
3625 int cfa_offset;
3626 int ra;
3627 unsigned char fde_encoding;
3628 unsigned char cfa_exp;
3629 }
3630 Frame_Chunk;
3631
3632 static const char *const *dwarf_regnames;
3633 static unsigned int dwarf_regnames_count;
3634
3635 /* A marker for a col_type that means this column was never referenced
3636 in the frame info. */
3637 #define DW_CFA_unreferenced (-1)
3638
3639 /* Return 0 if not more space is needed, 1 if more space is needed,
3640 -1 for invalid reg. */
3641
3642 static int
3643 frame_need_space (Frame_Chunk *fc, unsigned int reg)
3644 {
3645 int prev = fc->ncols;
3646
3647 if (reg < (unsigned int) fc->ncols)
3648 return 0;
3649
3650 if (dwarf_regnames_count
3651 && reg > dwarf_regnames_count)
3652 return -1;
3653
3654 fc->ncols = reg + 1;
3655 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3656 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3657
3658 while (prev < fc->ncols)
3659 {
3660 fc->col_type[prev] = DW_CFA_unreferenced;
3661 fc->col_offset[prev] = 0;
3662 prev++;
3663 }
3664 return 1;
3665 }
3666
3667 static const char *const dwarf_regnames_i386[] =
3668 {
3669 "eax", "ecx", "edx", "ebx",
3670 "esp", "ebp", "esi", "edi",
3671 "eip", "eflags", NULL,
3672 "st0", "st1", "st2", "st3",
3673 "st4", "st5", "st6", "st7",
3674 NULL, NULL,
3675 "xmm0", "xmm1", "xmm2", "xmm3",
3676 "xmm4", "xmm5", "xmm6", "xmm7",
3677 "mm0", "mm1", "mm2", "mm3",
3678 "mm4", "mm5", "mm6", "mm7",
3679 "fcw", "fsw", "mxcsr",
3680 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3681 "tr", "ldtr"
3682 };
3683
3684 static const char *const dwarf_regnames_x86_64[] =
3685 {
3686 "rax", "rdx", "rcx", "rbx",
3687 "rsi", "rdi", "rbp", "rsp",
3688 "r8", "r9", "r10", "r11",
3689 "r12", "r13", "r14", "r15",
3690 "rip",
3691 "xmm0", "xmm1", "xmm2", "xmm3",
3692 "xmm4", "xmm5", "xmm6", "xmm7",
3693 "xmm8", "xmm9", "xmm10", "xmm11",
3694 "xmm12", "xmm13", "xmm14", "xmm15",
3695 "st0", "st1", "st2", "st3",
3696 "st4", "st5", "st6", "st7",
3697 "mm0", "mm1", "mm2", "mm3",
3698 "mm4", "mm5", "mm6", "mm7",
3699 "rflags",
3700 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
3701 "fs.base", "gs.base", NULL, NULL,
3702 "tr", "ldtr",
3703 "mxcsr", "fcw", "fsw"
3704 };
3705
3706 void
3707 init_dwarf_regnames (unsigned int e_machine)
3708 {
3709 switch (e_machine)
3710 {
3711 case EM_386:
3712 case EM_486:
3713 dwarf_regnames = dwarf_regnames_i386;
3714 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
3715 break;
3716
3717 case EM_X86_64:
3718 dwarf_regnames = dwarf_regnames_x86_64;
3719 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
3720 break;
3721
3722 default:
3723 break;
3724 }
3725 }
3726
3727 static const char *
3728 regname (unsigned int regno, int row)
3729 {
3730 static char reg[64];
3731 if (dwarf_regnames
3732 && regno < dwarf_regnames_count
3733 && dwarf_regnames [regno] != NULL)
3734 {
3735 if (row)
3736 return dwarf_regnames [regno];
3737 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
3738 dwarf_regnames [regno]);
3739 }
3740 else
3741 snprintf (reg, sizeof (reg), "r%d", regno);
3742 return reg;
3743 }
3744
3745 static void
3746 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3747 {
3748 int r;
3749 char tmp[100];
3750
3751 if (*max_regs < fc->ncols)
3752 *max_regs = fc->ncols;
3753
3754 if (*need_col_headers)
3755 {
3756 static const char *loc = " LOC";
3757
3758 *need_col_headers = 0;
3759
3760 printf ("%-*s CFA ", eh_addr_size * 2, loc);
3761
3762 for (r = 0; r < *max_regs; r++)
3763 if (fc->col_type[r] != DW_CFA_unreferenced)
3764 {
3765 if (r == fc->ra)
3766 printf ("ra ");
3767 else
3768 printf ("%-5s ", regname (r, 1));
3769 }
3770
3771 printf ("\n");
3772 }
3773
3774 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
3775 if (fc->cfa_exp)
3776 strcpy (tmp, "exp");
3777 else
3778 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
3779 printf ("%-8s ", tmp);
3780
3781 for (r = 0; r < fc->ncols; r++)
3782 {
3783 if (fc->col_type[r] != DW_CFA_unreferenced)
3784 {
3785 switch (fc->col_type[r])
3786 {
3787 case DW_CFA_undefined:
3788 strcpy (tmp, "u");
3789 break;
3790 case DW_CFA_same_value:
3791 strcpy (tmp, "s");
3792 break;
3793 case DW_CFA_offset:
3794 sprintf (tmp, "c%+d", fc->col_offset[r]);
3795 break;
3796 case DW_CFA_val_offset:
3797 sprintf (tmp, "v%+d", fc->col_offset[r]);
3798 break;
3799 case DW_CFA_register:
3800 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
3801 break;
3802 case DW_CFA_expression:
3803 strcpy (tmp, "exp");
3804 break;
3805 case DW_CFA_val_expression:
3806 strcpy (tmp, "vexp");
3807 break;
3808 default:
3809 strcpy (tmp, "n/a");
3810 break;
3811 }
3812 printf ("%-5s ", tmp);
3813 }
3814 }
3815 printf ("\n");
3816 }
3817
3818 #define GET(N) byte_get (start, N); start += N
3819 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
3820 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3821
3822 static int
3823 display_debug_frames (struct dwarf_section *section,
3824 void *file ATTRIBUTE_UNUSED)
3825 {
3826 unsigned char *start = section->start;
3827 unsigned char *end = start + section->size;
3828 unsigned char *section_start = start;
3829 Frame_Chunk *chunks = 0;
3830 Frame_Chunk *remembered_state = 0;
3831 Frame_Chunk *rs;
3832 int is_eh = strcmp (section->name, ".eh_frame") == 0;
3833 unsigned int length_return;
3834 int max_regs = 0;
3835 const char *bad_reg = _("bad register: ");
3836
3837 printf (_("Contents of the %s section:\n"), section->name);
3838
3839 while (start < end)
3840 {
3841 unsigned char *saved_start;
3842 unsigned char *block_end;
3843 unsigned long length;
3844 unsigned long cie_id;
3845 Frame_Chunk *fc;
3846 Frame_Chunk *cie;
3847 int need_col_headers = 1;
3848 unsigned char *augmentation_data = NULL;
3849 unsigned long augmentation_data_len = 0;
3850 int encoded_ptr_size = eh_addr_size;
3851 int offset_size;
3852 int initial_length_size;
3853
3854 saved_start = start;
3855 length = byte_get (start, 4); start += 4;
3856
3857 if (length == 0)
3858 {
3859 printf ("\n%08lx ZERO terminator\n\n",
3860 (unsigned long)(saved_start - section_start));
3861 continue;
3862 }
3863
3864 if (length == 0xffffffff)
3865 {
3866 length = byte_get (start, 8);
3867 start += 8;
3868 offset_size = 8;
3869 initial_length_size = 12;
3870 }
3871 else
3872 {
3873 offset_size = 4;
3874 initial_length_size = 4;
3875 }
3876
3877 block_end = saved_start + length + initial_length_size;
3878 if (block_end > end)
3879 {
3880 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3881 length, (unsigned long)(saved_start - section_start));
3882 block_end = end;
3883 }
3884 cie_id = byte_get (start, offset_size); start += offset_size;
3885
3886 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3887 {
3888 int version;
3889
3890 fc = xmalloc (sizeof (Frame_Chunk));
3891 memset (fc, 0, sizeof (Frame_Chunk));
3892
3893 fc->next = chunks;
3894 chunks = fc;
3895 fc->chunk_start = saved_start;
3896 fc->ncols = 0;
3897 fc->col_type = xmalloc (sizeof (short int));
3898 fc->col_offset = xmalloc (sizeof (int));
3899 frame_need_space (fc, max_regs - 1);
3900
3901 version = *start++;
3902
3903 fc->augmentation = (char *) start;
3904 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3905
3906 if (fc->augmentation[0] == 'z')
3907 {
3908 fc->code_factor = LEB ();
3909 fc->data_factor = SLEB ();
3910 if (version == 1)
3911 {
3912 fc->ra = GET (1);
3913 }
3914 else
3915 {
3916 fc->ra = LEB ();
3917 }
3918 augmentation_data_len = LEB ();
3919 augmentation_data = start;
3920 start += augmentation_data_len;
3921 }
3922 else if (strcmp (fc->augmentation, "eh") == 0)
3923 {
3924 start += eh_addr_size;
3925 fc->code_factor = LEB ();
3926 fc->data_factor = SLEB ();
3927 if (version == 1)
3928 {
3929 fc->ra = GET (1);
3930 }
3931 else
3932 {
3933 fc->ra = LEB ();
3934 }
3935 }
3936 else
3937 {
3938 fc->code_factor = LEB ();
3939 fc->data_factor = SLEB ();
3940 if (version == 1)
3941 {
3942 fc->ra = GET (1);
3943 }
3944 else
3945 {
3946 fc->ra = LEB ();
3947 }
3948 }
3949 cie = fc;
3950
3951 if (do_debug_frames_interp)
3952 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3953 (unsigned long)(saved_start - section_start), length, cie_id,
3954 fc->augmentation, fc->code_factor, fc->data_factor,
3955 fc->ra);
3956 else
3957 {
3958 printf ("\n%08lx %08lx %08lx CIE\n",
3959 (unsigned long)(saved_start - section_start), length, cie_id);
3960 printf (" Version: %d\n", version);
3961 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3962 printf (" Code alignment factor: %u\n", fc->code_factor);
3963 printf (" Data alignment factor: %d\n", fc->data_factor);
3964 printf (" Return address column: %d\n", fc->ra);
3965
3966 if (augmentation_data_len)
3967 {
3968 unsigned long i;
3969 printf (" Augmentation data: ");
3970 for (i = 0; i < augmentation_data_len; ++i)
3971 printf (" %02x", augmentation_data[i]);
3972 putchar ('\n');
3973 }
3974 putchar ('\n');
3975 }
3976
3977 if (augmentation_data_len)
3978 {
3979 unsigned char *p, *q;
3980 p = (unsigned char *) fc->augmentation + 1;
3981 q = augmentation_data;
3982
3983 while (1)
3984 {
3985 if (*p == 'L')
3986 q++;
3987 else if (*p == 'P')
3988 q += 1 + size_of_encoded_value (*q);
3989 else if (*p == 'R')
3990 fc->fde_encoding = *q++;
3991 else
3992 break;
3993 p++;
3994 }
3995
3996 if (fc->fde_encoding)
3997 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3998 }
3999
4000 frame_need_space (fc, fc->ra);
4001 }
4002 else
4003 {
4004 unsigned char *look_for;
4005 static Frame_Chunk fde_fc;
4006
4007 fc = & fde_fc;
4008 memset (fc, 0, sizeof (Frame_Chunk));
4009
4010 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4011
4012 for (cie = chunks; cie ; cie = cie->next)
4013 if (cie->chunk_start == look_for)
4014 break;
4015
4016 if (!cie)
4017 {
4018 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
4019 cie_id, (unsigned long)(saved_start - section_start));
4020 fc->ncols = 0;
4021 fc->col_type = xmalloc (sizeof (short int));
4022 fc->col_offset = xmalloc (sizeof (int));
4023 frame_need_space (fc, max_regs - 1);
4024 cie = fc;
4025 fc->augmentation = "";
4026 fc->fde_encoding = 0;
4027 }
4028 else
4029 {
4030 fc->ncols = cie->ncols;
4031 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
4032 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
4033 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4034 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4035 fc->augmentation = cie->augmentation;
4036 fc->code_factor = cie->code_factor;
4037 fc->data_factor = cie->data_factor;
4038 fc->cfa_reg = cie->cfa_reg;
4039 fc->cfa_offset = cie->cfa_offset;
4040 fc->ra = cie->ra;
4041 frame_need_space (fc, max_regs - 1);
4042 fc->fde_encoding = cie->fde_encoding;
4043 }
4044
4045 if (fc->fde_encoding)
4046 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4047
4048 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
4049 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4050 fc->pc_begin += section->address + (start - section_start);
4051 start += encoded_ptr_size;
4052 fc->pc_range = byte_get (start, encoded_ptr_size);
4053 start += encoded_ptr_size;
4054
4055 if (cie->augmentation[0] == 'z')
4056 {
4057 augmentation_data_len = LEB ();
4058 augmentation_data = start;
4059 start += augmentation_data_len;
4060 }
4061
4062 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
4063 (unsigned long)(saved_start - section_start), length, cie_id,
4064 (unsigned long)(cie->chunk_start - section_start),
4065 fc->pc_begin, fc->pc_begin + fc->pc_range);
4066 if (! do_debug_frames_interp && augmentation_data_len)
4067 {
4068 unsigned long i;
4069
4070 printf (" Augmentation data: ");
4071 for (i = 0; i < augmentation_data_len; ++i)
4072 printf (" %02x", augmentation_data[i]);
4073 putchar ('\n');
4074 putchar ('\n');
4075 }
4076 }
4077
4078 /* At this point, fc is the current chunk, cie (if any) is set, and
4079 we're about to interpret instructions for the chunk. */
4080 /* ??? At present we need to do this always, since this sizes the
4081 fc->col_type and fc->col_offset arrays, which we write into always.
4082 We should probably split the interpreted and non-interpreted bits
4083 into two different routines, since there's so much that doesn't
4084 really overlap between them. */
4085 if (1 || do_debug_frames_interp)
4086 {
4087 /* Start by making a pass over the chunk, allocating storage
4088 and taking note of what registers are used. */
4089 unsigned char *tmp = start;
4090
4091 while (start < block_end)
4092 {
4093 unsigned op, opa;
4094 unsigned long reg, tmp;
4095
4096 op = *start++;
4097 opa = op & 0x3f;
4098 if (op & 0xc0)
4099 op &= 0xc0;
4100
4101 /* Warning: if you add any more cases to this switch, be
4102 sure to add them to the corresponding switch below. */
4103 switch (op)
4104 {
4105 case DW_CFA_advance_loc:
4106 break;
4107 case DW_CFA_offset:
4108 LEB ();
4109 if (frame_need_space (fc, opa) >= 0)
4110 fc->col_type[opa] = DW_CFA_undefined;
4111 break;
4112 case DW_CFA_restore:
4113 if (frame_need_space (fc, opa) >= 0)
4114 fc->col_type[opa] = DW_CFA_undefined;
4115 break;
4116 case DW_CFA_set_loc:
4117 start += encoded_ptr_size;
4118 break;
4119 case DW_CFA_advance_loc1:
4120 start += 1;
4121 break;
4122 case DW_CFA_advance_loc2:
4123 start += 2;
4124 break;
4125 case DW_CFA_advance_loc4:
4126 start += 4;
4127 break;
4128 case DW_CFA_offset_extended:
4129 case DW_CFA_val_offset:
4130 reg = LEB (); LEB ();
4131 if (frame_need_space (fc, reg) >= 0)
4132 fc->col_type[reg] = DW_CFA_undefined;
4133 break;
4134 case DW_CFA_restore_extended:
4135 reg = LEB ();
4136 frame_need_space (fc, reg);
4137 if (frame_need_space (fc, reg) >= 0)
4138 fc->col_type[reg] = DW_CFA_undefined;
4139 break;
4140 case DW_CFA_undefined:
4141 reg = LEB ();
4142 if (frame_need_space (fc, reg) >= 0)
4143 fc->col_type[reg] = DW_CFA_undefined;
4144 break;
4145 case DW_CFA_same_value:
4146 reg = LEB ();
4147 if (frame_need_space (fc, reg) >= 0)
4148 fc->col_type[reg] = DW_CFA_undefined;
4149 break;
4150 case DW_CFA_register:
4151 reg = LEB (); LEB ();
4152 if (frame_need_space (fc, reg) >= 0)
4153 fc->col_type[reg] = DW_CFA_undefined;
4154 break;
4155 case DW_CFA_def_cfa:
4156 LEB (); LEB ();
4157 break;
4158 case DW_CFA_def_cfa_register:
4159 LEB ();
4160 break;
4161 case DW_CFA_def_cfa_offset:
4162 LEB ();
4163 break;
4164 case DW_CFA_def_cfa_expression:
4165 tmp = LEB ();
4166 start += tmp;
4167 break;
4168 case DW_CFA_expression:
4169 case DW_CFA_val_expression:
4170 reg = LEB ();
4171 tmp = LEB ();
4172 start += tmp;
4173 if (frame_need_space (fc, reg) >= 0)
4174 fc->col_type[reg] = DW_CFA_undefined;
4175 break;
4176 case DW_CFA_offset_extended_sf:
4177 case DW_CFA_val_offset_sf:
4178 reg = LEB (); SLEB ();
4179 if (frame_need_space (fc, reg) >= 0)
4180 fc->col_type[reg] = DW_CFA_undefined;
4181 break;
4182 case DW_CFA_def_cfa_sf:
4183 LEB (); SLEB ();
4184 break;
4185 case DW_CFA_def_cfa_offset_sf:
4186 SLEB ();
4187 break;
4188 case DW_CFA_MIPS_advance_loc8:
4189 start += 8;
4190 break;
4191 case DW_CFA_GNU_args_size:
4192 LEB ();
4193 break;
4194 case DW_CFA_GNU_negative_offset_extended:
4195 reg = LEB (); LEB ();
4196 if (frame_need_space (fc, reg) >= 0)
4197 fc->col_type[reg] = DW_CFA_undefined;
4198 break;
4199 default:
4200 break;
4201 }
4202 }
4203 start = tmp;
4204 }
4205
4206 /* Now we know what registers are used, make a second pass over
4207 the chunk, this time actually printing out the info. */
4208
4209 while (start < block_end)
4210 {
4211 unsigned op, opa;
4212 unsigned long ul, reg, roffs;
4213 long l, ofs;
4214 dwarf_vma vma;
4215 const char *reg_prefix = "";
4216
4217 op = *start++;
4218 opa = op & 0x3f;
4219 if (op & 0xc0)
4220 op &= 0xc0;
4221
4222 /* Warning: if you add any more cases to this switch, be
4223 sure to add them to the corresponding switch above. */
4224 switch (op)
4225 {
4226 case DW_CFA_advance_loc:
4227 if (do_debug_frames_interp)
4228 frame_display_row (fc, &need_col_headers, &max_regs);
4229 else
4230 printf (" DW_CFA_advance_loc: %d to %08lx\n",
4231 opa * fc->code_factor,
4232 fc->pc_begin + opa * fc->code_factor);
4233 fc->pc_begin += opa * fc->code_factor;
4234 break;
4235
4236 case DW_CFA_offset:
4237 roffs = LEB ();
4238 if (opa >= (unsigned int) fc->ncols)
4239 reg_prefix = bad_reg;
4240 if (! do_debug_frames_interp || *reg_prefix != '\0')
4241 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
4242 reg_prefix, regname (opa, 0),
4243 roffs * fc->data_factor);
4244 if (*reg_prefix == '\0')
4245 {
4246 fc->col_type[opa] = DW_CFA_offset;
4247 fc->col_offset[opa] = roffs * fc->data_factor;
4248 }
4249 break;
4250
4251 case DW_CFA_restore:
4252 if (opa >= (unsigned int) cie->ncols
4253 || opa >= (unsigned int) fc->ncols)
4254 reg_prefix = bad_reg;
4255 if (! do_debug_frames_interp || *reg_prefix != '\0')
4256 printf (" DW_CFA_restore: %s%s\n",
4257 reg_prefix, regname (opa, 0));
4258 if (*reg_prefix == '\0')
4259 {
4260 fc->col_type[opa] = cie->col_type[opa];
4261 fc->col_offset[opa] = cie->col_offset[opa];
4262 }
4263 break;
4264
4265 case DW_CFA_set_loc:
4266 vma = get_encoded_value (start, fc->fde_encoding);
4267 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
4268 vma += section->address + (start - section_start);
4269 start += encoded_ptr_size;
4270 if (do_debug_frames_interp)
4271 frame_display_row (fc, &need_col_headers, &max_regs);
4272 else
4273 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
4274 fc->pc_begin = vma;
4275 break;
4276
4277 case DW_CFA_advance_loc1:
4278 ofs = byte_get (start, 1); start += 1;
4279 if (do_debug_frames_interp)
4280 frame_display_row (fc, &need_col_headers, &max_regs);
4281 else
4282 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
4283 ofs * fc->code_factor,
4284 fc->pc_begin + ofs * fc->code_factor);
4285 fc->pc_begin += ofs * fc->code_factor;
4286 break;
4287
4288 case DW_CFA_advance_loc2:
4289 ofs = byte_get (start, 2); start += 2;
4290 if (do_debug_frames_interp)
4291 frame_display_row (fc, &need_col_headers, &max_regs);
4292 else
4293 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
4294 ofs * fc->code_factor,
4295 fc->pc_begin + ofs * fc->code_factor);
4296 fc->pc_begin += ofs * fc->code_factor;
4297 break;
4298
4299 case DW_CFA_advance_loc4:
4300 ofs = byte_get (start, 4); start += 4;
4301 if (do_debug_frames_interp)
4302 frame_display_row (fc, &need_col_headers, &max_regs);
4303 else
4304 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
4305 ofs * fc->code_factor,
4306 fc->pc_begin + ofs * fc->code_factor);
4307 fc->pc_begin += ofs * fc->code_factor;
4308 break;
4309
4310 case DW_CFA_offset_extended:
4311 reg = LEB ();
4312 roffs = LEB ();
4313 if (reg >= (unsigned int) fc->ncols)
4314 reg_prefix = bad_reg;
4315 if (! do_debug_frames_interp || *reg_prefix != '\0')
4316 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
4317 reg_prefix, regname (reg, 0),
4318 roffs * fc->data_factor);
4319 if (*reg_prefix == '\0')
4320 {
4321 fc->col_type[reg] = DW_CFA_offset;
4322 fc->col_offset[reg] = roffs * fc->data_factor;
4323 }
4324 break;
4325
4326 case DW_CFA_val_offset:
4327 reg = LEB ();
4328 roffs = LEB ();
4329 if (reg >= (unsigned int) fc->ncols)
4330 reg_prefix = bad_reg;
4331 if (! do_debug_frames_interp || *reg_prefix != '\0')
4332 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
4333 reg_prefix, regname (reg, 0),
4334 roffs * fc->data_factor);
4335 if (*reg_prefix == '\0')
4336 {
4337 fc->col_type[reg] = DW_CFA_val_offset;
4338 fc->col_offset[reg] = roffs * fc->data_factor;
4339 }
4340 break;
4341
4342 case DW_CFA_restore_extended:
4343 reg = LEB ();
4344 if (reg >= (unsigned int) cie->ncols
4345 || reg >= (unsigned int) fc->ncols)
4346 reg_prefix = bad_reg;
4347 if (! do_debug_frames_interp || *reg_prefix != '\0')
4348 printf (" DW_CFA_restore_extended: %s%s\n",
4349 reg_prefix, regname (reg, 0));
4350 if (*reg_prefix == '\0')
4351 {
4352 fc->col_type[reg] = cie->col_type[reg];
4353 fc->col_offset[reg] = cie->col_offset[reg];
4354 }
4355 break;
4356
4357 case DW_CFA_undefined:
4358 reg = LEB ();
4359 if (reg >= (unsigned int) fc->ncols)
4360 reg_prefix = bad_reg;
4361 if (! do_debug_frames_interp || *reg_prefix != '\0')
4362 printf (" DW_CFA_undefined: %s%s\n",
4363 reg_prefix, regname (reg, 0));
4364 if (*reg_prefix == '\0')
4365 {
4366 fc->col_type[reg] = DW_CFA_undefined;
4367 fc->col_offset[reg] = 0;
4368 }
4369 break;
4370
4371 case DW_CFA_same_value:
4372 reg = LEB ();
4373 if (reg >= (unsigned int) fc->ncols)
4374 reg_prefix = bad_reg;
4375 if (! do_debug_frames_interp || *reg_prefix != '\0')
4376 printf (" DW_CFA_same_value: %s%s\n",
4377 reg_prefix, regname (reg, 0));
4378 if (*reg_prefix == '\0')
4379 {
4380 fc->col_type[reg] = DW_CFA_same_value;
4381 fc->col_offset[reg] = 0;
4382 }
4383 break;
4384
4385 case DW_CFA_register:
4386 reg = LEB ();
4387 roffs = LEB ();
4388 if (reg >= (unsigned int) fc->ncols)
4389 reg_prefix = bad_reg;
4390 if (! do_debug_frames_interp || *reg_prefix != '\0')
4391 {
4392 printf (" DW_CFA_register: %s%s in ",
4393 reg_prefix, regname (reg, 0));
4394 puts (regname (roffs, 0));
4395 }
4396 if (*reg_prefix == '\0')
4397 {
4398 fc->col_type[reg] = DW_CFA_register;
4399 fc->col_offset[reg] = roffs;
4400 }
4401 break;
4402
4403 case DW_CFA_remember_state:
4404 if (! do_debug_frames_interp)
4405 printf (" DW_CFA_remember_state\n");
4406 rs = xmalloc (sizeof (Frame_Chunk));
4407 rs->ncols = fc->ncols;
4408 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
4409 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
4410 memcpy (rs->col_type, fc->col_type, rs->ncols);
4411 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
4412 rs->next = remembered_state;
4413 remembered_state = rs;
4414 break;
4415
4416 case DW_CFA_restore_state:
4417 if (! do_debug_frames_interp)
4418 printf (" DW_CFA_restore_state\n");
4419 rs = remembered_state;
4420 if (rs)
4421 {
4422 remembered_state = rs->next;
4423 frame_need_space (fc, rs->ncols - 1);
4424 memcpy (fc->col_type, rs->col_type, rs->ncols);
4425 memcpy (fc->col_offset, rs->col_offset,
4426 rs->ncols * sizeof (int));
4427 free (rs->col_type);
4428 free (rs->col_offset);
4429 free (rs);
4430 }
4431 else if (do_debug_frames_interp)
4432 printf ("Mismatched DW_CFA_restore_state\n");
4433 break;
4434
4435 case DW_CFA_def_cfa:
4436 fc->cfa_reg = LEB ();
4437 fc->cfa_offset = LEB ();
4438 fc->cfa_exp = 0;
4439 if (! do_debug_frames_interp)
4440 printf (" DW_CFA_def_cfa: %s ofs %d\n",
4441 regname (fc->cfa_reg, 0), fc->cfa_offset);
4442 break;
4443
4444 case DW_CFA_def_cfa_register:
4445 fc->cfa_reg = LEB ();
4446 fc->cfa_exp = 0;
4447 if (! do_debug_frames_interp)
4448 printf (" DW_CFA_def_cfa_register: %s\n",
4449 regname (fc->cfa_reg, 0));
4450 break;
4451
4452 case DW_CFA_def_cfa_offset:
4453 fc->cfa_offset = LEB ();
4454 if (! do_debug_frames_interp)
4455 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
4456 break;
4457
4458 case DW_CFA_nop:
4459 if (! do_debug_frames_interp)
4460 printf (" DW_CFA_nop\n");
4461 break;
4462
4463 case DW_CFA_def_cfa_expression:
4464 ul = LEB ();
4465 if (! do_debug_frames_interp)
4466 {
4467 printf (" DW_CFA_def_cfa_expression (");
4468 decode_location_expression (start, eh_addr_size, ul, 0,
4469 section);
4470 printf (")\n");
4471 }
4472 fc->cfa_exp = 1;
4473 start += ul;
4474 break;
4475
4476 case DW_CFA_expression:
4477 reg = LEB ();
4478 ul = LEB ();
4479 if (reg >= (unsigned int) fc->ncols)
4480 reg_prefix = bad_reg;
4481 if (! do_debug_frames_interp || *reg_prefix != '\0')
4482 {
4483 printf (" DW_CFA_expression: %s%s (",
4484 reg_prefix, regname (reg, 0));
4485 decode_location_expression (start, eh_addr_size,
4486 ul, 0, section);
4487 printf (")\n");
4488 }
4489 if (*reg_prefix == '\0')
4490 fc->col_type[reg] = DW_CFA_expression;
4491 start += ul;
4492 break;
4493
4494 case DW_CFA_val_expression:
4495 reg = LEB ();
4496 ul = LEB ();
4497 if (reg >= (unsigned int) fc->ncols)
4498 reg_prefix = bad_reg;
4499 if (! do_debug_frames_interp || *reg_prefix != '\0')
4500 {
4501 printf (" DW_CFA_val_expression: %s%s (",
4502 reg_prefix, regname (reg, 0));
4503 decode_location_expression (start, eh_addr_size, ul, 0,
4504 section);
4505 printf (")\n");
4506 }
4507 if (*reg_prefix == '\0')
4508 fc->col_type[reg] = DW_CFA_val_expression;
4509 start += ul;
4510 break;
4511
4512 case DW_CFA_offset_extended_sf:
4513 reg = LEB ();
4514 l = SLEB ();
4515 if (frame_need_space (fc, reg) < 0)
4516 reg_prefix = bad_reg;
4517 if (! do_debug_frames_interp || *reg_prefix != '\0')
4518 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
4519 reg_prefix, regname (reg, 0),
4520 l * fc->data_factor);
4521 if (*reg_prefix == '\0')
4522 {
4523 fc->col_type[reg] = DW_CFA_offset;
4524 fc->col_offset[reg] = l * fc->data_factor;
4525 }
4526 break;
4527
4528 case DW_CFA_val_offset_sf:
4529 reg = LEB ();
4530 l = SLEB ();
4531 if (frame_need_space (fc, reg) < 0)
4532 reg_prefix = bad_reg;
4533 if (! do_debug_frames_interp || *reg_prefix != '\0')
4534 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
4535 reg_prefix, regname (reg, 0),
4536 l * fc->data_factor);
4537 if (*reg_prefix == '\0')
4538 {
4539 fc->col_type[reg] = DW_CFA_val_offset;
4540 fc->col_offset[reg] = l * fc->data_factor;
4541 }
4542 break;
4543
4544 case DW_CFA_def_cfa_sf:
4545 fc->cfa_reg = LEB ();
4546 fc->cfa_offset = SLEB ();
4547 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4548 fc->cfa_exp = 0;
4549 if (! do_debug_frames_interp)
4550 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
4551 regname (fc->cfa_reg, 0), fc->cfa_offset);
4552 break;
4553
4554 case DW_CFA_def_cfa_offset_sf:
4555 fc->cfa_offset = SLEB ();
4556 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
4557 if (! do_debug_frames_interp)
4558 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
4559 break;
4560
4561 case DW_CFA_MIPS_advance_loc8:
4562 ofs = byte_get (start, 8); start += 8;
4563 if (do_debug_frames_interp)
4564 frame_display_row (fc, &need_col_headers, &max_regs);
4565 else
4566 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
4567 ofs * fc->code_factor,
4568 fc->pc_begin + ofs * fc->code_factor);
4569 fc->pc_begin += ofs * fc->code_factor;
4570 break;
4571
4572 case DW_CFA_GNU_window_save:
4573 if (! do_debug_frames_interp)
4574 printf (" DW_CFA_GNU_window_save\n");
4575 break;
4576
4577 case DW_CFA_GNU_args_size:
4578 ul = LEB ();
4579 if (! do_debug_frames_interp)
4580 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
4581 break;
4582
4583 case DW_CFA_GNU_negative_offset_extended:
4584 reg = LEB ();
4585 l = - LEB ();
4586 if (frame_need_space (fc, reg) < 0)
4587 reg_prefix = bad_reg;
4588 if (! do_debug_frames_interp || *reg_prefix != '\0')
4589 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
4590 reg_prefix, regname (reg, 0),
4591 l * fc->data_factor);
4592 if (*reg_prefix == '\0')
4593 {
4594 fc->col_type[reg] = DW_CFA_offset;
4595 fc->col_offset[reg] = l * fc->data_factor;
4596 }
4597 break;
4598
4599 default:
4600 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
4601 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
4602 else
4603 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
4604 start = block_end;
4605 }
4606 }
4607
4608 if (do_debug_frames_interp)
4609 frame_display_row (fc, &need_col_headers, &max_regs);
4610
4611 start = block_end;
4612 }
4613
4614 printf ("\n");
4615
4616 return 1;
4617 }
4618
4619 #undef GET
4620 #undef LEB
4621 #undef SLEB
4622
4623 static int
4624 display_debug_not_supported (struct dwarf_section *section,
4625 void *file ATTRIBUTE_UNUSED)
4626 {
4627 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
4628 section->name);
4629
4630 return 1;
4631 }
4632
4633 void *
4634 cmalloc (size_t nmemb, size_t size)
4635 {
4636 /* Check for overflow. */
4637 if (nmemb >= ~(size_t) 0 / size)
4638 return NULL;
4639 else
4640 return malloc (nmemb * size);
4641 }
4642
4643 void *
4644 xcmalloc (size_t nmemb, size_t size)
4645 {
4646 /* Check for overflow. */
4647 if (nmemb >= ~(size_t) 0 / size)
4648 return NULL;
4649 else
4650 return xmalloc (nmemb * size);
4651 }
4652
4653 void *
4654 xcrealloc (void *ptr, size_t nmemb, size_t size)
4655 {
4656 /* Check for overflow. */
4657 if (nmemb >= ~(size_t) 0 / size)
4658 return NULL;
4659 else
4660 return xrealloc (ptr, nmemb * size);
4661 }
4662
4663 void
4664 error (const char *message, ...)
4665 {
4666 va_list args;
4667
4668 va_start (args, message);
4669 fprintf (stderr, _("%s: Error: "), program_name);
4670 vfprintf (stderr, message, args);
4671 va_end (args);
4672 }
4673
4674 void
4675 warn (const char *message, ...)
4676 {
4677 va_list args;
4678
4679 va_start (args, message);
4680 fprintf (stderr, _("%s: Warning: "), program_name);
4681 vfprintf (stderr, message, args);
4682 va_end (args);
4683 }
4684
4685 void
4686 free_debug_memory (void)
4687 {
4688 enum dwarf_section_display_enum i;
4689
4690 free_abbrevs ();
4691
4692 for (i = 0; i < max; i++)
4693 free_debug_section (i);
4694
4695 if (debug_information != NULL)
4696 {
4697 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
4698 {
4699 for (i = 0; i < num_debug_info_entries; i++)
4700 {
4701 if (!debug_information [i].max_loc_offsets)
4702 {
4703 free (debug_information [i].loc_offsets);
4704 free (debug_information [i].have_frame_base);
4705 }
4706 if (!debug_information [i].max_range_lists)
4707 free (debug_information [i].range_lists);
4708 }
4709 }
4710
4711 free (debug_information);
4712 debug_information = NULL;
4713 num_debug_info_entries = 0;
4714 }
4715 }
4716
4717 void
4718 dwarf_select_sections_by_names (const char *names)
4719 {
4720 typedef struct
4721 {
4722 const char * option;
4723 int * variable;
4724 int val;
4725 }
4726 debug_dump_long_opts;
4727
4728 static const debug_dump_long_opts opts_table [] =
4729 {
4730 /* Please keep this table alpha- sorted. */
4731 { "Ranges", & do_debug_ranges, 1 },
4732 { "abbrev", & do_debug_abbrevs, 1 },
4733 { "aranges", & do_debug_aranges, 1 },
4734 { "frames", & do_debug_frames, 1 },
4735 { "frames-interp", & do_debug_frames_interp, 1 },
4736 { "info", & do_debug_info, 1 },
4737 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
4738 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4739 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4740 { "loc", & do_debug_loc, 1 },
4741 { "macro", & do_debug_macinfo, 1 },
4742 { "pubnames", & do_debug_pubnames, 1 },
4743 /* This entry is for compatability
4744 with earlier versions of readelf. */
4745 { "ranges", & do_debug_aranges, 1 },
4746 { "str", & do_debug_str, 1 },
4747 { NULL, NULL, 0 }
4748 };
4749
4750 const char *p;
4751
4752 p = names;
4753 while (*p)
4754 {
4755 const debug_dump_long_opts * entry;
4756
4757 for (entry = opts_table; entry->option; entry++)
4758 {
4759 size_t len = strlen (entry->option);
4760
4761 if (strncmp (p, entry->option, len) == 0
4762 && (p[len] == ',' || p[len] == '\0'))
4763 {
4764 * entry->variable |= entry->val;
4765
4766 /* The --debug-dump=frames-interp option also
4767 enables the --debug-dump=frames option. */
4768 if (do_debug_frames_interp)
4769 do_debug_frames = 1;
4770
4771 p += len;
4772 break;
4773 }
4774 }
4775
4776 if (entry->option == NULL)
4777 {
4778 warn (_("Unrecognized debug option '%s'\n"), p);
4779 p = strchr (p, ',');
4780 if (p == NULL)
4781 break;
4782 }
4783
4784 if (*p == ',')
4785 p++;
4786 }
4787 }
4788
4789 void
4790 dwarf_select_sections_by_letters (const char *letters)
4791 {
4792 unsigned int index = 0;
4793
4794 while (letters[index])
4795 switch (letters[index++])
4796 {
4797 case 'i':
4798 do_debug_info = 1;
4799 break;
4800
4801 case 'a':
4802 do_debug_abbrevs = 1;
4803 break;
4804
4805 case 'l':
4806 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4807 break;
4808
4809 case 'L':
4810 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
4811 break;
4812
4813 case 'p':
4814 do_debug_pubnames = 1;
4815 break;
4816
4817 case 'r':
4818 do_debug_aranges = 1;
4819 break;
4820
4821 case 'R':
4822 do_debug_ranges = 1;
4823 break;
4824
4825 case 'F':
4826 do_debug_frames_interp = 1;
4827 case 'f':
4828 do_debug_frames = 1;
4829 break;
4830
4831 case 'm':
4832 do_debug_macinfo = 1;
4833 break;
4834
4835 case 's':
4836 do_debug_str = 1;
4837 break;
4838
4839 case 'o':
4840 do_debug_loc = 1;
4841 break;
4842
4843 default:
4844 warn (_("Unrecognized debug option '%s'\n"), optarg);
4845 break;
4846 }
4847 }
4848
4849 void
4850 dwarf_select_sections_all (void)
4851 {
4852 do_debug_info = 1;
4853 do_debug_abbrevs = 1;
4854 do_debug_lines = FLAG_DEBUG_LINES_RAW;
4855 do_debug_pubnames = 1;
4856 do_debug_aranges = 1;
4857 do_debug_ranges = 1;
4858 do_debug_frames = 1;
4859 do_debug_macinfo = 1;
4860 do_debug_str = 1;
4861 do_debug_loc = 1;
4862 }
4863
4864 struct dwarf_section_display debug_displays[] =
4865 {
4866 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
4867 display_debug_abbrev, &do_debug_abbrevs, 0, 0 },
4868 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
4869 display_debug_aranges, &do_debug_aranges, 1, 0 },
4870 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
4871 display_debug_frames, &do_debug_frames, 1, 0 },
4872 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
4873 display_debug_info, &do_debug_info, 1, 0 },
4874 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
4875 display_debug_lines, &do_debug_lines, 0, 0 },
4876 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
4877 display_debug_pubnames, &do_debug_pubnames, 0, 0 },
4878 { { ".eh_frame", "", NULL, NULL, 0, 0 },
4879 display_debug_frames, &do_debug_frames, 1, 1 },
4880 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
4881 display_debug_macinfo, &do_debug_macinfo, 0, 0 },
4882 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
4883 display_debug_str, &do_debug_str, 0, 0 },
4884 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
4885 display_debug_loc, &do_debug_loc, 1, 0 },
4886 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
4887 display_debug_pubnames, &do_debug_pubnames, 0, 0 },
4888 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
4889 display_debug_ranges, &do_debug_ranges, 0, 0 },
4890 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
4891 display_debug_not_supported, NULL, 0, 0 },
4892 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
4893 display_debug_not_supported, NULL, 0, 0 },
4894 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
4895 display_debug_not_supported, NULL, 0, 0 },
4896 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
4897 display_debug_not_supported, NULL, 0, 0 }
4898 };
GDB Binutils - Deliverables
This page took 0.217649 seconds and 5 git commands to generate.