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