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