projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* readelf.c (process_section_headers): Add m16c handler.
[deliverable/binutils-gdb.git] / binutils / dwarf.c
CommitLineData
19e6b90e 1/* dwarf.c -- display DWARF contents of a BFD binary file
4b78141a 2 Copyright 2005, 2006, 2007
19e6b90e
L		 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
32866df7 9 the Free Software Foundation; either version 3 of the License, or
19e6b90e
L		 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
3db64b00 22#include "sysdep.h"
19e6b90e 23#include "libiberty.h"
3db64b00
AM		 24#include "bfd.h"
25#include "bucomm.h"
26#include "elf/dwarf2.h"
27#include "dwarf.h"
19e6b90e
L		 28
29static int have_frame_base;
30static int need_base_address;
31
32static unsigned int last_pointer_size = 0;
33static int warned_about_missing_comp_units = FALSE;
34
35static unsigned int num_debug_info_entries = 0;
36static debug_info *debug_information = NULL;
cc86f28f
NC		 37/* Special value for num_debug_info_entries to indicate
38 that the .debug_info section could not be loaded/parsed. */
39#define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
19e6b90e
L		 40
41dwarf_vma eh_addr_size;
19e6b90e
L		 42
43int do_debug_info;
44int do_debug_abbrevs;
45int do_debug_lines;
46int do_debug_pubnames;
47int do_debug_aranges;
48int do_debug_ranges;
49int do_debug_frames;
50int do_debug_frames_interp;
51int do_debug_macinfo;
52int do_debug_str;
53int do_debug_loc;
54
55dwarf_vma (*byte_get) (unsigned char *, int);
56
57dwarf_vma
58byte_get_little_endian (unsigned char *field, int size)
59{
60 switch (size)
61 {
62 case 1:
63 return *field;
64
65 case 2:
66 return ((unsigned int) (field[0]))
67 | (((unsigned int) (field[1])) << 8);
68
69 case 4:
70 return ((unsigned long) (field[0]))
71 | (((unsigned long) (field[1])) << 8)
72 | (((unsigned long) (field[2])) << 16)
73 | (((unsigned long) (field[3])) << 24);
74
75 case 8:
76 if (sizeof (dwarf_vma) == 8)
77 return ((dwarf_vma) (field[0]))
78 | (((dwarf_vma) (field[1])) << 8)
79 | (((dwarf_vma) (field[2])) << 16)
80 | (((dwarf_vma) (field[3])) << 24)
81 | (((dwarf_vma) (field[4])) << 32)
82 | (((dwarf_vma) (field[5])) << 40)
83 | (((dwarf_vma) (field[6])) << 48)
84 | (((dwarf_vma) (field[7])) << 56);
85 else if (sizeof (dwarf_vma) == 4)
86 /* We want to extract data from an 8 byte wide field and
87 place it into a 4 byte wide field. Since this is a little
88 endian source we can just use the 4 byte extraction code. */
89 return ((unsigned long) (field[0]))
90 | (((unsigned long) (field[1])) << 8)
91 | (((unsigned long) (field[2])) << 16)
92 | (((unsigned long) (field[3])) << 24);
93
94 default:
95 error (_("Unhandled data length: %d\n"), size);
96 abort ();
97 }
98}
99
100dwarf_vma
101byte_get_big_endian (unsigned char *field, int size)
102{
103 switch (size)
104 {
105 case 1:
106 return *field;
107
108 case 2:
109 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
110
111 case 4:
112 return ((unsigned long) (field[3]))
113 | (((unsigned long) (field[2])) << 8)
114 | (((unsigned long) (field[1])) << 16)
115 | (((unsigned long) (field[0])) << 24);
116
117 case 8:
118 if (sizeof (dwarf_vma) == 8)
119 return ((dwarf_vma) (field[7]))
120 | (((dwarf_vma) (field[6])) << 8)
121 | (((dwarf_vma) (field[5])) << 16)
122 | (((dwarf_vma) (field[4])) << 24)
123 | (((dwarf_vma) (field[3])) << 32)
124 | (((dwarf_vma) (field[2])) << 40)
125 | (((dwarf_vma) (field[1])) << 48)
126 | (((dwarf_vma) (field[0])) << 56);
127 else if (sizeof (dwarf_vma) == 4)
128 {
129 /* Although we are extracing data from an 8 byte wide field,
130 we are returning only 4 bytes of data. */
131 field += 4;
132 return ((unsigned long) (field[3]))
133 | (((unsigned long) (field[2])) << 8)
134 | (((unsigned long) (field[1])) << 16)
135 | (((unsigned long) (field[0])) << 24);
136 }
137
138 default:
139 error (_("Unhandled data length: %d\n"), size);
140 abort ();
141 }
142}
143
144static dwarf_vma
145byte_get_signed (unsigned char *field, int size)
146{
147 dwarf_vma x = byte_get (field, size);
148
149 switch (size)
150 {
151 case 1:
152 return (x ^ 0x80) - 0x80;
153 case 2:
154 return (x ^ 0x8000) - 0x8000;
155 case 4:
156 return (x ^ 0x80000000) - 0x80000000;
157 case 8:
158 return x;
159 default:
160 abort ();
161 }
162}
163
164static unsigned long int
165read_leb128 (unsigned char *data, unsigned int *length_return, int sign)
166{
167 unsigned long int result = 0;
168 unsigned int num_read = 0;
169 unsigned int shift = 0;
170 unsigned char byte;
171
172 do
173 {
174 byte = *data++;
175 num_read++;
176
177 result |= ((unsigned long int) (byte & 0x7f)) << shift;
178
179 shift += 7;
180
181 }
182 while (byte & 0x80);
183
184 if (length_return != NULL)
185 *length_return = num_read;
186
187 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
188 result |= -1L << shift;
189
190 return result;
191}
192
193typedef struct State_Machine_Registers
194{
195 unsigned long address;
196 unsigned int file;
197 unsigned int line;
198 unsigned int column;
199 int is_stmt;
200 int basic_block;
201 int end_sequence;
202/* This variable hold the number of the last entry seen
203 in the File Table. */
204 unsigned int last_file_entry;
205} SMR;
206
207static SMR state_machine_regs;
208
209static void
210reset_state_machine (int is_stmt)
211{
212 state_machine_regs.address = 0;
213 state_machine_regs.file = 1;
214 state_machine_regs.line = 1;
215 state_machine_regs.column = 0;
216 state_machine_regs.is_stmt = is_stmt;
217 state_machine_regs.basic_block = 0;
218 state_machine_regs.end_sequence = 0;
219 state_machine_regs.last_file_entry = 0;
220}
221
222/* Handled an extend line op.
223 Returns the number of bytes read. */
224
225static int
1617e571 226process_extended_line_op (unsigned char *data, int is_stmt)
19e6b90e
L		 227{
228 unsigned char op_code;
229 unsigned int bytes_read;
230 unsigned int len;
231 unsigned char *name;
232 unsigned long adr;
233
234 len = read_leb128 (data, & bytes_read, 0);
235 data += bytes_read;
236
237 if (len == 0)
238 {
239 warn (_("badly formed extended line op encountered!\n"));
240 return bytes_read;
241 }
242
243 len += bytes_read;
244 op_code = *data++;
245
246 printf (_(" Extended opcode %d: "), op_code);
247
248 switch (op_code)
249 {
250 case DW_LNE_end_sequence:
251 printf (_("End of Sequence\n\n"));
252 reset_state_machine (is_stmt);
253 break;
254
255 case DW_LNE_set_address:
1617e571 256 adr = byte_get (data, len - bytes_read - 1);
19e6b90e
L		 257 printf (_("set Address to 0x%lx\n"), adr);
258 state_machine_regs.address = adr;
259 break;
260
261 case DW_LNE_define_file:
262 printf (_(" define new File Table entry\n"));
263 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
264
265 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
266 name = data;
267 data += strlen ((char *) data) + 1;
268 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
269 data += bytes_read;
270 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
271 data += bytes_read;
272 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
273 printf (_("%s\n\n"), name);
274 break;
275
e2a0d921
NC		 276 /* HP extensions. */
277 case DW_LNE_HP_negate_is_UV_update:
278 printf ("DW_LNE_HP_negate_is_UV_update");
279 break;
280 case DW_LNE_HP_push_context:
281 printf ("DW_LNE_HP_push_context");
282 break;
283 case DW_LNE_HP_pop_context:
284 printf ("DW_LNE_HP_pop_context");
285 break;
286 case DW_LNE_HP_set_file_line_column:
287 printf ("DW_LNE_HP_set_file_line_column");
288 break;
289 case DW_LNE_HP_set_routine_name:
290 printf ("DW_LNE_HP_set_routine_name");
291 break;
292 case DW_LNE_HP_set_sequence:
293 printf ("DW_LNE_HP_set_sequence");
294 break;
295 case DW_LNE_HP_negate_post_semantics:
296 printf ("DW_LNE_HP_negate_post_semantics");
297 break;
298 case DW_LNE_HP_negate_function_exit:
299 printf ("DW_LNE_HP_negate_function_exit");
300 break;
301 case DW_LNE_HP_negate_front_end_logical:
302 printf ("DW_LNE_HP_negate_front_end_logical");
303 break;
304 case DW_LNE_HP_define_proc:
305 printf ("DW_LNE_HP_define_proc");
306 break;
307
19e6b90e 308 default:
e2a0d921
NC		 309 if (op_code >= DW_LNE_lo_user
310 /* The test against DW_LNW_hi_user is redundant due to
311 the limited range of the unsigned char data type used
312 for op_code. */
313 /*&& op_code <= DW_LNE_hi_user*/)
314 printf (_("user defined: length %d\n"), len - bytes_read);
315 else
316 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
19e6b90e
L		 317 break;
318 }
319
320 return len;
321}
322
323static const char *
324fetch_indirect_string (unsigned long offset)
325{
326 struct dwarf_section *section = &debug_displays [str].section;
327
328 if (section->start == NULL)
329 return _("<no .debug_str section>");
330
bfe2612a
L		 331 /* DWARF sections under Mach-O have non-zero addresses. */
332 offset -= section->address;
19e6b90e
L		 333 if (offset > section->size)
334 {
335 warn (_("DW_FORM_strp offset too big: %lx\n"), offset);
336 return _("<offset is too big>");
337 }
338
339 return (const char *) section->start + offset;
340}
341
342/* FIXME: There are better and more efficient ways to handle
343 these structures. For now though, I just want something that
344 is simple to implement. */
345typedef struct abbrev_attr
346{
347 unsigned long attribute;
348 unsigned long form;
349 struct abbrev_attr *next;
350}
351abbrev_attr;
352
353typedef struct abbrev_entry
354{
355 unsigned long entry;
356 unsigned long tag;
357 int children;
358 struct abbrev_attr *first_attr;
359 struct abbrev_attr *last_attr;
360 struct abbrev_entry *next;
361}
362abbrev_entry;
363
364static abbrev_entry *first_abbrev = NULL;
365static abbrev_entry *last_abbrev = NULL;
366
367static void
368free_abbrevs (void)
369{
370 abbrev_entry *abbrev;
371
372 for (abbrev = first_abbrev; abbrev;)
373 {
374 abbrev_entry *next = abbrev->next;
375 abbrev_attr *attr;
376
377 for (attr = abbrev->first_attr; attr;)
378 {
379 abbrev_attr *next = attr->next;
380
381 free (attr);
382 attr = next;
383 }
384
385 free (abbrev);
386 abbrev = next;
387 }
388
389 last_abbrev = first_abbrev = NULL;
390}
391
392static void
393add_abbrev (unsigned long number, unsigned long tag, int children)
394{
395 abbrev_entry *entry;
396
397 entry = malloc (sizeof (*entry));
398
399 if (entry == NULL)
400 /* ugg */
401 return;
402
403 entry->entry = number;
404 entry->tag = tag;
405 entry->children = children;
406 entry->first_attr = NULL;
407 entry->last_attr = NULL;
408 entry->next = NULL;
409
410 if (first_abbrev == NULL)
411 first_abbrev = entry;
412 else
413 last_abbrev->next = entry;
414
415 last_abbrev = entry;
416}
417
418static void
419add_abbrev_attr (unsigned long attribute, unsigned long form)
420{
421 abbrev_attr *attr;
422
423 attr = malloc (sizeof (*attr));
424
425 if (attr == NULL)
426 /* ugg */
427 return;
428
429 attr->attribute = attribute;
430 attr->form = form;
431 attr->next = NULL;
432
433 if (last_abbrev->first_attr == NULL)
434 last_abbrev->first_attr = attr;
435 else
436 last_abbrev->last_attr->next = attr;
437
438 last_abbrev->last_attr = attr;
439}
440
441/* Processes the (partial) contents of a .debug_abbrev section.
442 Returns NULL if the end of the section was encountered.
443 Returns the address after the last byte read if the end of
444 an abbreviation set was found. */
445
446static unsigned char *
447process_abbrev_section (unsigned char *start, unsigned char *end)
448{
449 if (first_abbrev != NULL)
450 return NULL;
451
452 while (start < end)
453 {
454 unsigned int bytes_read;
455 unsigned long entry;
456 unsigned long tag;
457 unsigned long attribute;
458 int children;
459
460 entry = read_leb128 (start, & bytes_read, 0);
461 start += bytes_read;
462
463 /* A single zero is supposed to end the section according
464 to the standard. If there's more, then signal that to
465 the caller. */
466 if (entry == 0)
467 return start == end ? NULL : start;
468
469 tag = read_leb128 (start, & bytes_read, 0);
470 start += bytes_read;
471
472 children = *start++;
473
474 add_abbrev (entry, tag, children);
475
476 do
477 {
478 unsigned long form;
479
480 attribute = read_leb128 (start, & bytes_read, 0);
481 start += bytes_read;
482
483 form = read_leb128 (start, & bytes_read, 0);
484 start += bytes_read;
485
486 if (attribute != 0)
487 add_abbrev_attr (attribute, form);
488 }
489 while (attribute != 0);
490 }
491
492 return NULL;
493}
494
495static char *
496get_TAG_name (unsigned long tag)
497{
498 switch (tag)
499 {
500 case DW_TAG_padding: return "DW_TAG_padding";
501 case DW_TAG_array_type: return "DW_TAG_array_type";
502 case DW_TAG_class_type: return "DW_TAG_class_type";
503 case DW_TAG_entry_point: return "DW_TAG_entry_point";
504 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
505 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
506 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
507 case DW_TAG_label: return "DW_TAG_label";
508 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
509 case DW_TAG_member: return "DW_TAG_member";
510 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
511 case DW_TAG_reference_type: return "DW_TAG_reference_type";
512 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
513 case DW_TAG_string_type: return "DW_TAG_string_type";
514 case DW_TAG_structure_type: return "DW_TAG_structure_type";
515 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
516 case DW_TAG_typedef: return "DW_TAG_typedef";
517 case DW_TAG_union_type: return "DW_TAG_union_type";
518 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
519 case DW_TAG_variant: return "DW_TAG_variant";
520 case DW_TAG_common_block: return "DW_TAG_common_block";
521 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
522 case DW_TAG_inheritance: return "DW_TAG_inheritance";
523 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
524 case DW_TAG_module: return "DW_TAG_module";
525 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
526 case DW_TAG_set_type: return "DW_TAG_set_type";
527 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
528 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
529 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
530 case DW_TAG_base_type: return "DW_TAG_base_type";
531 case DW_TAG_catch_block: return "DW_TAG_catch_block";
532 case DW_TAG_const_type: return "DW_TAG_const_type";
533 case DW_TAG_constant: return "DW_TAG_constant";
534 case DW_TAG_enumerator: return "DW_TAG_enumerator";
535 case DW_TAG_file_type: return "DW_TAG_file_type";
536 case DW_TAG_friend: return "DW_TAG_friend";
537 case DW_TAG_namelist: return "DW_TAG_namelist";
538 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
539 case DW_TAG_packed_type: return "DW_TAG_packed_type";
540 case DW_TAG_subprogram: return "DW_TAG_subprogram";
541 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
542 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
543 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
544 case DW_TAG_try_block: return "DW_TAG_try_block";
545 case DW_TAG_variant_part: return "DW_TAG_variant_part";
546 case DW_TAG_variable: return "DW_TAG_variable";
547 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
548 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
549 case DW_TAG_format_label: return "DW_TAG_format_label";
550 case DW_TAG_function_template: return "DW_TAG_function_template";
551 case DW_TAG_class_template: return "DW_TAG_class_template";
552 /* DWARF 2.1 values. */
553 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
554 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
555 case DW_TAG_interface_type: return "DW_TAG_interface_type";
556 case DW_TAG_namespace: return "DW_TAG_namespace";
557 case DW_TAG_imported_module: return "DW_TAG_imported_module";
558 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
559 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
560 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
561 /* UPC values. */
562 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
563 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
564 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
565 default:
566 {
567 static char buffer[100];
568
569 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
570 return buffer;
571 }
572 }
573}
574
575static char *
576get_FORM_name (unsigned long form)
577{
578 switch (form)
579 {
580 case DW_FORM_addr: return "DW_FORM_addr";
581 case DW_FORM_block2: return "DW_FORM_block2";
582 case DW_FORM_block4: return "DW_FORM_block4";
583 case DW_FORM_data2: return "DW_FORM_data2";
584 case DW_FORM_data4: return "DW_FORM_data4";
585 case DW_FORM_data8: return "DW_FORM_data8";
586 case DW_FORM_string: return "DW_FORM_string";
587 case DW_FORM_block: return "DW_FORM_block";
588 case DW_FORM_block1: return "DW_FORM_block1";
589 case DW_FORM_data1: return "DW_FORM_data1";
590 case DW_FORM_flag: return "DW_FORM_flag";
591 case DW_FORM_sdata: return "DW_FORM_sdata";
592 case DW_FORM_strp: return "DW_FORM_strp";
593 case DW_FORM_udata: return "DW_FORM_udata";
594 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
595 case DW_FORM_ref1: return "DW_FORM_ref1";
596 case DW_FORM_ref2: return "DW_FORM_ref2";
597 case DW_FORM_ref4: return "DW_FORM_ref4";
598 case DW_FORM_ref8: return "DW_FORM_ref8";
599 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
600 case DW_FORM_indirect: return "DW_FORM_indirect";
601 default:
602 {
603 static char buffer[100];
604
605 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
606 return buffer;
607 }
608 }
609}
610
611static unsigned char *
612display_block (unsigned char *data, unsigned long length)
613{
614 printf (_(" %lu byte block: "), length);
615
616 while (length --)
617 printf ("%lx ", (unsigned long) byte_get (data++, 1));
618
619 return data;
620}
621
622static int
623decode_location_expression (unsigned char * data,
624 unsigned int pointer_size,
625 unsigned long length,
626 unsigned long cu_offset)
627{
628 unsigned op;
629 unsigned int bytes_read;
630 unsigned long uvalue;
631 unsigned char *end = data + length;
632 int need_frame_base = 0;
633
634 while (data < end)
635 {
636 op = *data++;
637
638 switch (op)
639 {
640 case DW_OP_addr:
641 printf ("DW_OP_addr: %lx",
642 (unsigned long) byte_get (data, pointer_size));
643 data += pointer_size;
644 break;
645 case DW_OP_deref:
646 printf ("DW_OP_deref");
647 break;
648 case DW_OP_const1u:
649 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
650 break;
651 case DW_OP_const1s:
652 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data++, 1));
653 break;
654 case DW_OP_const2u:
655 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
656 data += 2;
657 break;
658 case DW_OP_const2s:
659 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data, 2));
660 data += 2;
661 break;
662 case DW_OP_const4u:
663 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
664 data += 4;
665 break;
666 case DW_OP_const4s:
667 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data, 4));
668 data += 4;
669 break;
670 case DW_OP_const8u:
671 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
672 (unsigned long) byte_get (data + 4, 4));
673 data += 8;
674 break;
675 case DW_OP_const8s:
676 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
677 (long) byte_get (data + 4, 4));
678 data += 8;
679 break;
680 case DW_OP_constu:
681 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
682 data += bytes_read;
683 break;
684 case DW_OP_consts:
685 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
686 data += bytes_read;
687 break;
688 case DW_OP_dup:
689 printf ("DW_OP_dup");
690 break;
691 case DW_OP_drop:
692 printf ("DW_OP_drop");
693 break;
694 case DW_OP_over:
695 printf ("DW_OP_over");
696 break;
697 case DW_OP_pick:
698 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
699 break;
700 case DW_OP_swap:
701 printf ("DW_OP_swap");
702 break;
703 case DW_OP_rot:
704 printf ("DW_OP_rot");
705 break;
706 case DW_OP_xderef:
707 printf ("DW_OP_xderef");
708 break;
709 case DW_OP_abs:
710 printf ("DW_OP_abs");
711 break;
712 case DW_OP_and:
713 printf ("DW_OP_and");
714 break;
715 case DW_OP_div:
716 printf ("DW_OP_div");
717 break;
718 case DW_OP_minus:
719 printf ("DW_OP_minus");
720 break;
721 case DW_OP_mod:
722 printf ("DW_OP_mod");
723 break;
724 case DW_OP_mul:
725 printf ("DW_OP_mul");
726 break;
727 case DW_OP_neg:
728 printf ("DW_OP_neg");
729 break;
730 case DW_OP_not:
731 printf ("DW_OP_not");
732 break;
733 case DW_OP_or:
734 printf ("DW_OP_or");
735 break;
736 case DW_OP_plus:
737 printf ("DW_OP_plus");
738 break;
739 case DW_OP_plus_uconst:
740 printf ("DW_OP_plus_uconst: %lu",
741 read_leb128 (data, &bytes_read, 0));
742 data += bytes_read;
743 break;
744 case DW_OP_shl:
745 printf ("DW_OP_shl");
746 break;
747 case DW_OP_shr:
748 printf ("DW_OP_shr");
749 break;
750 case DW_OP_shra:
751 printf ("DW_OP_shra");
752 break;
753 case DW_OP_xor:
754 printf ("DW_OP_xor");
755 break;
756 case DW_OP_bra:
757 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data, 2));
758 data += 2;
759 break;
760 case DW_OP_eq:
761 printf ("DW_OP_eq");
762 break;
763 case DW_OP_ge:
764 printf ("DW_OP_ge");
765 break;
766 case DW_OP_gt:
767 printf ("DW_OP_gt");
768 break;
769 case DW_OP_le:
770 printf ("DW_OP_le");
771 break;
772 case DW_OP_lt:
773 printf ("DW_OP_lt");
774 break;
775 case DW_OP_ne:
776 printf ("DW_OP_ne");
777 break;
778 case DW_OP_skip:
779 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data, 2));
780 data += 2;
781 break;
782
783 case DW_OP_lit0:
784 case DW_OP_lit1:
785 case DW_OP_lit2:
786 case DW_OP_lit3:
787 case DW_OP_lit4:
788 case DW_OP_lit5:
789 case DW_OP_lit6:
790 case DW_OP_lit7:
791 case DW_OP_lit8:
792 case DW_OP_lit9:
793 case DW_OP_lit10:
794 case DW_OP_lit11:
795 case DW_OP_lit12:
796 case DW_OP_lit13:
797 case DW_OP_lit14:
798 case DW_OP_lit15:
799 case DW_OP_lit16:
800 case DW_OP_lit17:
801 case DW_OP_lit18:
802 case DW_OP_lit19:
803 case DW_OP_lit20:
804 case DW_OP_lit21:
805 case DW_OP_lit22:
806 case DW_OP_lit23:
807 case DW_OP_lit24:
808 case DW_OP_lit25:
809 case DW_OP_lit26:
810 case DW_OP_lit27:
811 case DW_OP_lit28:
812 case DW_OP_lit29:
813 case DW_OP_lit30:
814 case DW_OP_lit31:
815 printf ("DW_OP_lit%d", op - DW_OP_lit0);
816 break;
817
818 case DW_OP_reg0:
819 case DW_OP_reg1:
820 case DW_OP_reg2:
821 case DW_OP_reg3:
822 case DW_OP_reg4:
823 case DW_OP_reg5:
824 case DW_OP_reg6:
825 case DW_OP_reg7:
826 case DW_OP_reg8:
827 case DW_OP_reg9:
828 case DW_OP_reg10:
829 case DW_OP_reg11:
830 case DW_OP_reg12:
831 case DW_OP_reg13:
832 case DW_OP_reg14:
833 case DW_OP_reg15:
834 case DW_OP_reg16:
835 case DW_OP_reg17:
836 case DW_OP_reg18:
837 case DW_OP_reg19:
838 case DW_OP_reg20:
839 case DW_OP_reg21:
840 case DW_OP_reg22:
841 case DW_OP_reg23:
842 case DW_OP_reg24:
843 case DW_OP_reg25:
844 case DW_OP_reg26:
845 case DW_OP_reg27:
846 case DW_OP_reg28:
847 case DW_OP_reg29:
848 case DW_OP_reg30:
849 case DW_OP_reg31:
850 printf ("DW_OP_reg%d", op - DW_OP_reg0);
851 break;
852
853 case DW_OP_breg0:
854 case DW_OP_breg1:
855 case DW_OP_breg2:
856 case DW_OP_breg3:
857 case DW_OP_breg4:
858 case DW_OP_breg5:
859 case DW_OP_breg6:
860 case DW_OP_breg7:
861 case DW_OP_breg8:
862 case DW_OP_breg9:
863 case DW_OP_breg10:
864 case DW_OP_breg11:
865 case DW_OP_breg12:
866 case DW_OP_breg13:
867 case DW_OP_breg14:
868 case DW_OP_breg15:
869 case DW_OP_breg16:
870 case DW_OP_breg17:
871 case DW_OP_breg18:
872 case DW_OP_breg19:
873 case DW_OP_breg20:
874 case DW_OP_breg21:
875 case DW_OP_breg22:
876 case DW_OP_breg23:
877 case DW_OP_breg24:
878 case DW_OP_breg25:
879 case DW_OP_breg26:
880 case DW_OP_breg27:
881 case DW_OP_breg28:
882 case DW_OP_breg29:
883 case DW_OP_breg30:
884 case DW_OP_breg31:
885 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
886 read_leb128 (data, &bytes_read, 1));
887 data += bytes_read;
888 break;
889
890 case DW_OP_regx:
891 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
892 data += bytes_read;
893 break;
894 case DW_OP_fbreg:
895 need_frame_base = 1;
896 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
897 data += bytes_read;
898 break;
899 case DW_OP_bregx:
900 uvalue = read_leb128 (data, &bytes_read, 0);
901 data += bytes_read;
902 printf ("DW_OP_bregx: %lu %ld", uvalue,
903 read_leb128 (data, &bytes_read, 1));
904 data += bytes_read;
905 break;
906 case DW_OP_piece:
907 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
908 data += bytes_read;
909 break;
910 case DW_OP_deref_size:
911 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
912 break;
913 case DW_OP_xderef_size:
914 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
915 break;
916 case DW_OP_nop:
917 printf ("DW_OP_nop");
918 break;
919
920 /* DWARF 3 extensions. */
921 case DW_OP_push_object_address:
922 printf ("DW_OP_push_object_address");
923 break;
924 case DW_OP_call2:
925 /* XXX: Strictly speaking for 64-bit DWARF3 files
926 this ought to be an 8-byte wide computation. */
927 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2) + cu_offset);
928 data += 2;
929 break;
930 case DW_OP_call4:
931 /* XXX: Strictly speaking for 64-bit DWARF3 files
932 this ought to be an 8-byte wide computation. */
933 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4) + cu_offset);
934 data += 4;
935 break;
936 case DW_OP_call_ref:
e2a0d921
NC		 937 /* XXX: Strictly speaking for 64-bit DWARF3 files
938 this ought to be an 8-byte wide computation. */
939 printf ("DW_OP_call_ref: <%lx>", (long) byte_get (data, 4) + cu_offset);
940 data += 4;
19e6b90e 941 break;
a87b0a59
NS		 942 case DW_OP_form_tls_address:
943 printf ("DW_OP_form_tls_address");
944 break;
e2a0d921
NC		 945 case DW_OP_call_frame_cfa:
946 printf ("DW_OP_call_frame_cfa");
947 break;
948 case DW_OP_bit_piece:
949 printf ("DW_OP_bit_piece: ");
950 printf ("size: %lu ", read_leb128 (data, &bytes_read, 0));
951 data += bytes_read;
952 printf ("offset: %lu ", read_leb128 (data, &bytes_read, 0));
953 data += bytes_read;
954 break;
19e6b90e
L		 955
956 /* GNU extensions. */
957 case DW_OP_GNU_push_tls_address:
e2a0d921
NC		 958 printf ("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown");
959 break;
960 case DW_OP_GNU_uninit:
961 printf ("DW_OP_GNU_uninit");
962 /* FIXME: Is there data associated with this OP ? */
963 break;
964
965 /* HP extensions. */
966 case DW_OP_HP_is_value:
967 printf ("DW_OP_HP_is_value");
968 /* FIXME: Is there data associated with this OP ? */
969 break;
970 case DW_OP_HP_fltconst4:
971 printf ("DW_OP_HP_fltconst4");
972 /* FIXME: Is there data associated with this OP ? */
973 break;
974 case DW_OP_HP_fltconst8:
975 printf ("DW_OP_HP_fltconst8");
976 /* FIXME: Is there data associated with this OP ? */
977 break;
978 case DW_OP_HP_mod_range:
979 printf ("DW_OP_HP_mod_range");
980 /* FIXME: Is there data associated with this OP ? */
981 break;
982 case DW_OP_HP_unmod_range:
983 printf ("DW_OP_HP_unmod_range");
984 /* FIXME: Is there data associated with this OP ? */
985 break;
986 case DW_OP_HP_tls:
987 printf ("DW_OP_HP_tls");
988 /* FIXME: Is there data associated with this OP ? */
19e6b90e
L		 989 break;
990
991 default:
992 if (op >= DW_OP_lo_user
993 && op <= DW_OP_hi_user)
994 printf (_("(User defined location op)"));
995 else
996 printf (_("(Unknown location op)"));
997 /* No way to tell where the next op is, so just bail. */
998 return need_frame_base;
999 }
1000
1001 /* Separate the ops. */
1002 if (data < end)
1003 printf ("; ");
1004 }
1005
1006 return need_frame_base;
1007}
1008
1009static unsigned char *
6e3d6dc1
NC		 1010read_and_display_attr_value (unsigned long attribute,
1011 unsigned long form,
ec4d4525 1012 unsigned char * data,
6e3d6dc1
NC		 1013 unsigned long cu_offset,
1014 unsigned long pointer_size,
1015 unsigned long offset_size,
1016 int dwarf_version,
1017 debug_info * debug_info_p,
1018 int do_loc,
1019 struct dwarf_section * section)
19e6b90e
L		 1020{
1021 unsigned long uvalue = 0;
1022 unsigned char *block_start = NULL;
6e3d6dc1 1023 unsigned char * orig_data = data;
19e6b90e
L		 1024 unsigned int bytes_read;
1025
1026 switch (form)
1027 {
1028 default:
1029 break;
1030
1031 case DW_FORM_ref_addr:
1032 if (dwarf_version == 2)
1033 {
1034 uvalue = byte_get (data, pointer_size);
1035 data += pointer_size;
1036 }
1037 else if (dwarf_version == 3)
1038 {
1039 uvalue = byte_get (data, offset_size);
1040 data += offset_size;
1041 }
1042 else
1043 {
1044 error (_("Internal error: DWARF version is not 2 or 3.\n"));
1045 }
1046 break;
1047
1048 case DW_FORM_addr:
1049 uvalue = byte_get (data, pointer_size);
1050 data += pointer_size;
1051 break;
1052
1053 case DW_FORM_strp:
1054 uvalue = byte_get (data, offset_size);
1055 data += offset_size;
1056 break;
1057
1058 case DW_FORM_ref1:
1059 case DW_FORM_flag:
1060 case DW_FORM_data1:
1061 uvalue = byte_get (data++, 1);
1062 break;
1063
1064 case DW_FORM_ref2:
1065 case DW_FORM_data2:
1066 uvalue = byte_get (data, 2);
1067 data += 2;
1068 break;
1069
1070 case DW_FORM_ref4:
1071 case DW_FORM_data4:
1072 uvalue = byte_get (data, 4);
1073 data += 4;
1074 break;
1075
1076 case DW_FORM_sdata:
1077 uvalue = read_leb128 (data, & bytes_read, 1);
1078 data += bytes_read;
1079 break;
1080
1081 case DW_FORM_ref_udata:
1082 case DW_FORM_udata:
1083 uvalue = read_leb128 (data, & bytes_read, 0);
1084 data += bytes_read;
1085 break;
1086
1087 case DW_FORM_indirect:
1088 form = read_leb128 (data, & bytes_read, 0);
1089 data += bytes_read;
1090 if (!do_loc)
1091 printf (" %s", get_FORM_name (form));
1092 return read_and_display_attr_value (attribute, form, data,
1093 cu_offset, pointer_size,
1094 offset_size, dwarf_version,
ec4d4525 1095 debug_info_p, do_loc,
6e3d6dc1 1096 section);
19e6b90e
L		 1097 }
1098
1099 switch (form)
1100 {
1101 case DW_FORM_ref_addr:
1102 if (!do_loc)
ec4d4525 1103 printf (" <0x%lx>", uvalue);
19e6b90e
L		 1104 break;
1105
1106 case DW_FORM_ref1:
1107 case DW_FORM_ref2:
1108 case DW_FORM_ref4:
1109 case DW_FORM_ref_udata:
1110 if (!do_loc)
ec4d4525 1111 printf (" <0x%lx>", uvalue + cu_offset);
19e6b90e
L		 1112 break;
1113
1114 case DW_FORM_data4:
1115 case DW_FORM_addr:
1116 if (!do_loc)
ec4d4525 1117 printf (" 0x%lx", uvalue);
19e6b90e
L		 1118 break;
1119
1120 case DW_FORM_flag:
1121 case DW_FORM_data1:
1122 case DW_FORM_data2:
1123 case DW_FORM_sdata:
1124 case DW_FORM_udata:
1125 if (!do_loc)
1126 printf (" %ld", uvalue);
1127 break;
1128
1129 case DW_FORM_ref8:
1130 case DW_FORM_data8:
1131 if (!do_loc)
1132 {
1133 uvalue = byte_get (data, 4);
ec4d4525
NC		 1134 printf (" 0x%lx", uvalue);
1135 printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4));
19e6b90e
L		 1136 }
1137 if ((do_loc || do_debug_loc || do_debug_ranges)
1138 && num_debug_info_entries == 0)
1139 {
1140 if (sizeof (uvalue) == 8)
1141 uvalue = byte_get (data, 8);
1142 else
1143 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
1144 }
1145 data += 8;
1146 break;
1147
1148 case DW_FORM_string:
1149 if (!do_loc)
1150 printf (" %s", data);
1151 data += strlen ((char *) data) + 1;
1152 break;
1153
1154 case DW_FORM_block:
1155 uvalue = read_leb128 (data, & bytes_read, 0);
1156 block_start = data + bytes_read;
1157 if (do_loc)
1158 data = block_start + uvalue;
1159 else
1160 data = display_block (block_start, uvalue);
1161 break;
1162
1163 case DW_FORM_block1:
1164 uvalue = byte_get (data, 1);
1165 block_start = data + 1;
1166 if (do_loc)
1167 data = block_start + uvalue;
1168 else
1169 data = display_block (block_start, uvalue);
1170 break;
1171
1172 case DW_FORM_block2:
1173 uvalue = byte_get (data, 2);
1174 block_start = data + 2;
1175 if (do_loc)
1176 data = block_start + uvalue;
1177 else
1178 data = display_block (block_start, uvalue);
1179 break;
1180
1181 case DW_FORM_block4:
1182 uvalue = byte_get (data, 4);
1183 block_start = data + 4;
1184 if (do_loc)
1185 data = block_start + uvalue;
1186 else
1187 data = display_block (block_start, uvalue);
1188 break;
1189
1190 case DW_FORM_strp:
1191 if (!do_loc)
1192 printf (_(" (indirect string, offset: 0x%lx): %s"),
1193 uvalue, fetch_indirect_string (uvalue));
1194 break;
1195
1196 case DW_FORM_indirect:
1197 /* Handled above. */
1198 break;
1199
1200 default:
1201 warn (_("Unrecognized form: %lu\n"), form);
1202 break;
1203 }
1204
19e6b90e
L		 1205 if ((do_loc || do_debug_loc || do_debug_ranges)
1206 && num_debug_info_entries == 0)
1207 {
1208 switch (attribute)
1209 {
1210 case DW_AT_frame_base:
1211 have_frame_base = 1;
1212 case DW_AT_location:
e2a0d921
NC		 1213 case DW_AT_string_length:
1214 case DW_AT_return_addr:
19e6b90e
L		 1215 case DW_AT_data_member_location:
1216 case DW_AT_vtable_elem_location:
e2a0d921
NC		 1217 case DW_AT_segment:
1218 case DW_AT_static_link:
1219 case DW_AT_use_location:
1220 if (form == DW_FORM_data4 || form == DW_FORM_data8)
19e6b90e
L		 1221 {
1222 /* Process location list. */
1223 unsigned int max = debug_info_p->max_loc_offsets;
1224 unsigned int num = debug_info_p->num_loc_offsets;
1225
1226 if (max == 0 || num >= max)
1227 {
1228 max += 1024;
1229 debug_info_p->loc_offsets
1230 = xcrealloc (debug_info_p->loc_offsets,
1231 max, sizeof (*debug_info_p->loc_offsets));
1232 debug_info_p->have_frame_base
1233 = xcrealloc (debug_info_p->have_frame_base,
1234 max, sizeof (*debug_info_p->have_frame_base));
1235 debug_info_p->max_loc_offsets = max;
1236 }
1237 debug_info_p->loc_offsets [num] = uvalue;
1238 debug_info_p->have_frame_base [num] = have_frame_base;
1239 debug_info_p->num_loc_offsets++;
1240 }
1241 break;
e2a0d921 1242
19e6b90e
L		 1243 case DW_AT_low_pc:
1244 if (need_base_address)
1245 debug_info_p->base_address = uvalue;
1246 break;
1247
1248 case DW_AT_ranges:
1249 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1250 {
1251 /* Process range list. */
1252 unsigned int max = debug_info_p->max_range_lists;
1253 unsigned int num = debug_info_p->num_range_lists;
1254
1255 if (max == 0 || num >= max)
1256 {
1257 max += 1024;
1258 debug_info_p->range_lists
1259 = xcrealloc (debug_info_p->range_lists,
1260 max, sizeof (*debug_info_p->range_lists));
1261 debug_info_p->max_range_lists = max;
1262 }
1263 debug_info_p->range_lists [num] = uvalue;
1264 debug_info_p->num_range_lists++;
1265 }
1266 break;
1267
1268 default:
1269 break;
1270 }
1271 }
1272
1273 if (do_loc)
1274 return data;
1275
ec4d4525 1276 /* For some attributes we can display further information. */
19e6b90e
L		 1277 printf ("\t");
1278
1279 switch (attribute)
1280 {
1281 case DW_AT_inline:
1282 switch (uvalue)
1283 {
1284 case DW_INL_not_inlined:
1285 printf (_("(not inlined)"));
1286 break;
1287 case DW_INL_inlined:
1288 printf (_("(inlined)"));
1289 break;
1290 case DW_INL_declared_not_inlined:
1291 printf (_("(declared as inline but ignored)"));
1292 break;
1293 case DW_INL_declared_inlined:
1294 printf (_("(declared as inline and inlined)"));
1295 break;
1296 default:
1297 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
1298 break;
1299 }
1300 break;
1301
1302 case DW_AT_language:
1303 switch (uvalue)
1304 {
4b78141a 1305 /* Ordered by the numeric value of these constants. */
19e6b90e 1306 case DW_LANG_C89: printf ("(ANSI C)"); break;
4b78141a
NC		 1307 case DW_LANG_C: printf ("(non-ANSI C)"); break;
1308 case DW_LANG_Ada83: printf ("(Ada)"); break;
19e6b90e 1309 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
4b78141a
NC		 1310 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
1311 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
19e6b90e
L		 1312 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
1313 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
19e6b90e 1314 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
4b78141a 1315 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
19e6b90e 1316 /* DWARF 2.1 values. */
4b78141a 1317 case DW_LANG_Java: printf ("(Java)"); break;
19e6b90e
L		 1318 case DW_LANG_C99: printf ("(ANSI C99)"); break;
1319 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
1320 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
4b78141a
NC		 1321 /* DWARF 3 values. */
1322 case DW_LANG_PLI: printf ("(PLI)"); break;
1323 case DW_LANG_ObjC: printf ("(Objective C)"); break;
1324 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
1325 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
1326 case DW_LANG_D: printf ("(D)"); break;
19e6b90e
L		 1327 /* MIPS extension. */
1328 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1329 /* UPC extension. */
1330 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1331 default:
4b78141a
NC		 1332 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
1333 printf ("(implementation defined: %lx)", uvalue);
1334 else
1335 printf ("(Unknown: %lx)", uvalue);
19e6b90e
L		 1336 break;
1337 }
1338 break;
1339
1340 case DW_AT_encoding:
1341 switch (uvalue)
1342 {
1343 case DW_ATE_void: printf ("(void)"); break;
1344 case DW_ATE_address: printf ("(machine address)"); break;
1345 case DW_ATE_boolean: printf ("(boolean)"); break;
1346 case DW_ATE_complex_float: printf ("(complex float)"); break;
1347 case DW_ATE_float: printf ("(float)"); break;
1348 case DW_ATE_signed: printf ("(signed)"); break;
1349 case DW_ATE_signed_char: printf ("(signed char)"); break;
1350 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1351 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
e2a0d921 1352 /* DWARF 2.1 values: */
19e6b90e
L		 1353 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1354 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
e2a0d921
NC		 1355 /* DWARF 3 values: */
1356 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1357 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1358 case DW_ATE_edited: printf ("(edited)"); break;
1359 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1360 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1361 /* HP extensions: */
1362 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1363 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1364 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1365 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1366 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1367 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1368 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1369
19e6b90e
L		 1370 default:
1371 if (uvalue >= DW_ATE_lo_user
1372 && uvalue <= DW_ATE_hi_user)
1373 printf ("(user defined type)");
1374 else
1375 printf ("(unknown type)");
1376 break;
1377 }
1378 break;
1379
1380 case DW_AT_accessibility:
1381 switch (uvalue)
1382 {
1383 case DW_ACCESS_public: printf ("(public)"); break;
1384 case DW_ACCESS_protected: printf ("(protected)"); break;
1385 case DW_ACCESS_private: printf ("(private)"); break;
1386 default:
1387 printf ("(unknown accessibility)");
1388 break;
1389 }
1390 break;
1391
1392 case DW_AT_visibility:
1393 switch (uvalue)
1394 {
1395 case DW_VIS_local: printf ("(local)"); break;
1396 case DW_VIS_exported: printf ("(exported)"); break;
1397 case DW_VIS_qualified: printf ("(qualified)"); break;
1398 default: printf ("(unknown visibility)"); break;
1399 }
1400 break;
1401
1402 case DW_AT_virtuality:
1403 switch (uvalue)
1404 {
1405 case DW_VIRTUALITY_none: printf ("(none)"); break;
1406 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1407 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
1408 default: printf ("(unknown virtuality)"); break;
1409 }
1410 break;
1411
1412 case DW_AT_identifier_case:
1413 switch (uvalue)
1414 {
1415 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1416 case DW_ID_up_case: printf ("(up_case)"); break;
1417 case DW_ID_down_case: printf ("(down_case)"); break;
1418 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
1419 default: printf ("(unknown case)"); break;
1420 }
1421 break;
1422
1423 case DW_AT_calling_convention:
1424 switch (uvalue)
1425 {
1426 case DW_CC_normal: printf ("(normal)"); break;
1427 case DW_CC_program: printf ("(program)"); break;
1428 case DW_CC_nocall: printf ("(nocall)"); break;
1429 default:
1430 if (uvalue >= DW_CC_lo_user
1431 && uvalue <= DW_CC_hi_user)
1432 printf ("(user defined)");
1433 else
1434 printf ("(unknown convention)");
1435 }
1436 break;
1437
1438 case DW_AT_ordering:
1439 switch (uvalue)
1440 {
1441 case -1: printf ("(undefined)"); break;
1442 case 0: printf ("(row major)"); break;
1443 case 1: printf ("(column major)"); break;
1444 }
1445 break;
1446
1447 case DW_AT_frame_base:
1448 have_frame_base = 1;
1449 case DW_AT_location:
e2a0d921
NC		 1450 case DW_AT_string_length:
1451 case DW_AT_return_addr:
19e6b90e
L		 1452 case DW_AT_data_member_location:
1453 case DW_AT_vtable_elem_location:
e2a0d921
NC		 1454 case DW_AT_segment:
1455 case DW_AT_static_link:
1456 case DW_AT_use_location:
1457 if (form == DW_FORM_data4 || form == DW_FORM_data8)
1458 printf (_("(location list)"));
1459 /* Fall through. */
19e6b90e
L		 1460 case DW_AT_allocated:
1461 case DW_AT_associated:
1462 case DW_AT_data_location:
1463 case DW_AT_stride:
1464 case DW_AT_upper_bound:
e2a0d921 1465 case DW_AT_lower_bound:
19e6b90e
L		 1466 if (block_start)
1467 {
1468 int need_frame_base;
1469
1470 printf ("(");
1471 need_frame_base = decode_location_expression (block_start,
1472 pointer_size,
1473 uvalue,
1474 cu_offset);
1475 printf (")");
1476 if (need_frame_base && !have_frame_base)
1477 printf (_(" [without DW_AT_frame_base]"));
1478 }
19e6b90e
L		 1479 break;
1480
ec4d4525
NC		 1481 case DW_AT_import:
1482 {
ec4d4525
NC		 1483 if (form == DW_FORM_ref1
1484 || form == DW_FORM_ref2
1485 || form == DW_FORM_ref4)
1486 uvalue += cu_offset;
1487
6e3d6dc1
NC		 1488 if (uvalue >= section->size)
1489 warn (_("Offset %lx used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1490 uvalue, (long int)(orig_data - section->start));
1491 else
1492 {
1493 unsigned long abbrev_number;
1494 abbrev_entry * entry;
1495
1496 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
ec4d4525 1497
6e3d6dc1
NC		 1498 printf ("[Abbrev Number: %ld", abbrev_number);
1499 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1500 if (entry->entry == abbrev_number)
1501 break;
1502 if (entry != NULL)
1503 printf (" (%s)", get_TAG_name (entry->tag));
1504 printf ("]");
1505 }
ec4d4525
NC		 1506 }
1507 break;
1508
19e6b90e
L		 1509 default:
1510 break;
1511 }
1512
1513 return data;
1514}
1515
1516static char *
1517get_AT_name (unsigned long attribute)
1518{
1519 switch (attribute)
1520 {
1521 case DW_AT_sibling: return "DW_AT_sibling";
1522 case DW_AT_location: return "DW_AT_location";
1523 case DW_AT_name: return "DW_AT_name";
1524 case DW_AT_ordering: return "DW_AT_ordering";
1525 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1526 case DW_AT_byte_size: return "DW_AT_byte_size";
1527 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1528 case DW_AT_bit_size: return "DW_AT_bit_size";
1529 case DW_AT_element_list: return "DW_AT_element_list";
1530 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1531 case DW_AT_low_pc: return "DW_AT_low_pc";
1532 case DW_AT_high_pc: return "DW_AT_high_pc";
1533 case DW_AT_language: return "DW_AT_language";
1534 case DW_AT_member: return "DW_AT_member";
1535 case DW_AT_discr: return "DW_AT_discr";
1536 case DW_AT_discr_value: return "DW_AT_discr_value";
1537 case DW_AT_visibility: return "DW_AT_visibility";
1538 case DW_AT_import: return "DW_AT_import";
1539 case DW_AT_string_length: return "DW_AT_string_length";
1540 case DW_AT_common_reference: return "DW_AT_common_reference";
1541 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1542 case DW_AT_const_value: return "DW_AT_const_value";
1543 case DW_AT_containing_type: return "DW_AT_containing_type";
1544 case DW_AT_default_value: return "DW_AT_default_value";
1545 case DW_AT_inline: return "DW_AT_inline";
1546 case DW_AT_is_optional: return "DW_AT_is_optional";
1547 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1548 case DW_AT_producer: return "DW_AT_producer";
1549 case DW_AT_prototyped: return "DW_AT_prototyped";
1550 case DW_AT_return_addr: return "DW_AT_return_addr";
1551 case DW_AT_start_scope: return "DW_AT_start_scope";
1552 case DW_AT_stride_size: return "DW_AT_stride_size";
1553 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1554 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1555 case DW_AT_accessibility: return "DW_AT_accessibility";
1556 case DW_AT_address_class: return "DW_AT_address_class";
1557 case DW_AT_artificial: return "DW_AT_artificial";
1558 case DW_AT_base_types: return "DW_AT_base_types";
1559 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1560 case DW_AT_count: return "DW_AT_count";
1561 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1562 case DW_AT_decl_column: return "DW_AT_decl_column";
1563 case DW_AT_decl_file: return "DW_AT_decl_file";
1564 case DW_AT_decl_line: return "DW_AT_decl_line";
1565 case DW_AT_declaration: return "DW_AT_declaration";
1566 case DW_AT_discr_list: return "DW_AT_discr_list";
1567 case DW_AT_encoding: return "DW_AT_encoding";
1568 case DW_AT_external: return "DW_AT_external";
1569 case DW_AT_frame_base: return "DW_AT_frame_base";
1570 case DW_AT_friend: return "DW_AT_friend";
1571 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1572 case DW_AT_macro_info: return "DW_AT_macro_info";
1573 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1574 case DW_AT_priority: return "DW_AT_priority";
1575 case DW_AT_segment: return "DW_AT_segment";
1576 case DW_AT_specification: return "DW_AT_specification";
1577 case DW_AT_static_link: return "DW_AT_static_link";
1578 case DW_AT_type: return "DW_AT_type";
1579 case DW_AT_use_location: return "DW_AT_use_location";
1580 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1581 case DW_AT_virtuality: return "DW_AT_virtuality";
1582 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1583 /* DWARF 2.1 values. */
1584 case DW_AT_allocated: return "DW_AT_allocated";
1585 case DW_AT_associated: return "DW_AT_associated";
1586 case DW_AT_data_location: return "DW_AT_data_location";
1587 case DW_AT_stride: return "DW_AT_stride";
1588 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1589 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1590 case DW_AT_extension: return "DW_AT_extension";
1591 case DW_AT_ranges: return "DW_AT_ranges";
1592 case DW_AT_trampoline: return "DW_AT_trampoline";
1593 case DW_AT_call_column: return "DW_AT_call_column";
1594 case DW_AT_call_file: return "DW_AT_call_file";
1595 case DW_AT_call_line: return "DW_AT_call_line";
e2a0d921
NC		 1596 case DW_AT_description: return "DW_AT_description";
1597 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1598 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1599 case DW_AT_small: return "DW_AT_small";
1600 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1601 case DW_AT_digit_count: return "DW_AT_digit_count";
1602 case DW_AT_picture_string: return "DW_AT_picture_string";
1603 case DW_AT_mutable: return "DW_AT_mutable";
1604 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1605 case DW_AT_explicit: return "DW_AT_explicit";
1606 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1607 case DW_AT_endianity: return "DW_AT_endianity";
1608 case DW_AT_elemental: return "DW_AT_elemental";
1609 case DW_AT_pure: return "DW_AT_pure";
1610 case DW_AT_recursive: return "DW_AT_recursive";
1611
1612 /* HP and SGI/MIPS extensions. */
1613 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1614 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1615 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1616 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1617 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1618 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1619 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1620 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1621 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1622 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1623
1624 /* HP Extensions. */
1625 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
1626 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1627 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1628 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1629 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1630 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1631 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1632 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1633 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1634 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1635 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1636 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1637 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1638
1639 /* One value is shared by the MIPS and HP extensions: */
1640 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1641
19e6b90e
L		 1642 /* GNU extensions. */
1643 case DW_AT_sf_names: return "DW_AT_sf_names";
1644 case DW_AT_src_info: return "DW_AT_src_info";
1645 case DW_AT_mac_info: return "DW_AT_mac_info";
1646 case DW_AT_src_coords: return "DW_AT_src_coords";
1647 case DW_AT_body_begin: return "DW_AT_body_begin";
1648 case DW_AT_body_end: return "DW_AT_body_end";
1649 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
e2a0d921 1650
19e6b90e
L		 1651 /* UPC extension. */
1652 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
e2a0d921
NC		 1653
1654 /* PGI (STMicroelectronics) extensions. */
1655 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1656 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1657 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1658
19e6b90e
L		 1659 default:
1660 {
1661 static char buffer[100];
1662
1663 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1664 attribute);
1665 return buffer;
1666 }
1667 }
1668}
1669
1670static unsigned char *
6e3d6dc1
NC		 1671read_and_display_attr (unsigned long attribute,
1672 unsigned long form,
ec4d4525 1673 unsigned char * data,
6e3d6dc1
NC		 1674 unsigned long cu_offset,
1675 unsigned long pointer_size,
1676 unsigned long offset_size,
1677 int dwarf_version,
1678 debug_info * debug_info_p,
1679 int do_loc,
1680 struct dwarf_section * section)
19e6b90e
L		 1681{
1682 if (!do_loc)
750f03b7 1683 printf (" %-18s:", get_AT_name (attribute));
19e6b90e
L		 1684 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1685 pointer_size, offset_size,
1686 dwarf_version, debug_info_p,
6e3d6dc1 1687 do_loc, section);
19e6b90e
L		 1688 if (!do_loc)
1689 printf ("\n");
1690 return data;
1691}
1692
1693
1694/* Process the contents of a .debug_info section. If do_loc is non-zero
1695 then we are scanning for location lists and we do not want to display
1696 anything to the user. */
1697
1698static int
6e3d6dc1
NC		 1699process_debug_info (struct dwarf_section *section,
1700 void *file,
19e6b90e
L		 1701 int do_loc)
1702{
1703 unsigned char *start = section->start;
1704 unsigned char *end = start + section->size;
1705 unsigned char *section_begin;
1706 unsigned int unit;
1707 unsigned int num_units = 0;
1708
1709 if ((do_loc || do_debug_loc || do_debug_ranges)
1710 && num_debug_info_entries == 0)
1711 {
1712 unsigned long length;
1713
1714 /* First scan the section to get the number of comp units. */
1715 for (section_begin = start, num_units = 0; section_begin < end;
1716 num_units ++)
1717 {
1718 /* Read the first 4 bytes. For a 32-bit DWARF section, this
1719 will be the length. For a 64-bit DWARF section, it'll be
1720 the escape code 0xffffffff followed by an 8 byte length. */
1721 length = byte_get (section_begin, 4);
1722
1723 if (length == 0xffffffff)
1724 {
1725 length = byte_get (section_begin + 4, 8);
1726 section_begin += length + 12;
1727 }
ec4d4525
NC		 1728 else if (length >= 0xfffffff0 && length < 0xffffffff)
1729 {
1730 warn (_("Reserved length value (%lx) found in section %s\n"), length, section->name);
1731 return 0;
1732 }
19e6b90e
L		 1733 else
1734 section_begin += length + 4;
aca88567
NC		 1735
1736 /* Negative values are illegal, they may even cause infinite
1737 looping. This can happen if we can't accurately apply
1738 relocations to an object file. */
1739 if ((signed long) length <= 0)
1740 {
1741 warn (_("Corrupt unit length (%lx) found in section %s\n"), length, section->name);
1742 return 0;
1743 }
19e6b90e
L		 1744 }
1745
1746 if (num_units == 0)
1747 {
1748 error (_("No comp units in %s section ?"), section->name);
1749 return 0;
1750 }
1751
1752 /* Then allocate an array to hold the information. */
1753 debug_information = cmalloc (num_units,
1754 sizeof (* debug_information));
1755 if (debug_information == NULL)
1756 {
1757 error (_("Not enough memory for a debug info array of %u entries"),
1758 num_units);
1759 return 0;
1760 }
1761 }
1762
1763 if (!do_loc)
1764 {
1765 printf (_("The section %s contains:\n\n"), section->name);
1766
1767 load_debug_section (str, file);
1768 }
1769
1770 load_debug_section (abbrev, file);
1771 if (debug_displays [abbrev].section.start == NULL)
1772 {
1773 warn (_("Unable to locate %s section!\n"),
1774 debug_displays [abbrev].section.name);
1775 return 0;
1776 }
1777
1778 for (section_begin = start, unit = 0; start < end; unit++)
1779 {
1780 DWARF2_Internal_CompUnit compunit;
1781 unsigned char *hdrptr;
1782 unsigned char *cu_abbrev_offset_ptr;
1783 unsigned char *tags;
1784 int level;
1785 unsigned long cu_offset;
1786 int offset_size;
1787 int initial_length_size;
1788
1789 hdrptr = start;
1790
1791 compunit.cu_length = byte_get (hdrptr, 4);
1792 hdrptr += 4;
1793
1794 if (compunit.cu_length == 0xffffffff)
1795 {
1796 compunit.cu_length = byte_get (hdrptr, 8);
1797 hdrptr += 8;
1798 offset_size = 8;
1799 initial_length_size = 12;
1800 }
1801 else
1802 {
1803 offset_size = 4;
1804 initial_length_size = 4;
1805 }
1806
1807 compunit.cu_version = byte_get (hdrptr, 2);
1808 hdrptr += 2;
1809
1810 cu_offset = start - section_begin;
19e6b90e
L		 1811
1812 cu_abbrev_offset_ptr = hdrptr;
1813 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
1814 hdrptr += offset_size;
1815
1816 compunit.cu_pointer_size = byte_get (hdrptr, 1);
1817 hdrptr += 1;
1818 if ((do_loc || do_debug_loc || do_debug_ranges)
1819 && num_debug_info_entries == 0)
1820 {
1821 debug_information [unit].cu_offset = cu_offset;
1822 debug_information [unit].pointer_size
1823 = compunit.cu_pointer_size;
1824 debug_information [unit].base_address = 0;
1825 debug_information [unit].loc_offsets = NULL;
1826 debug_information [unit].have_frame_base = NULL;
1827 debug_information [unit].max_loc_offsets = 0;
1828 debug_information [unit].num_loc_offsets = 0;
1829 debug_information [unit].range_lists = NULL;
1830 debug_information [unit].max_range_lists= 0;
1831 debug_information [unit].num_range_lists = 0;
1832 }
1833
19e6b90e
L		 1834 if (!do_loc)
1835 {
1836 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset);
cc86f28f
NC		 1837 printf (_(" Length: 0x%lx (%s)\n"), compunit.cu_length,
1838 initial_length_size == 8 ? "64-bit" : "32-bit");
19e6b90e
L		 1839 printf (_(" Version: %d\n"), compunit.cu_version);
1840 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
1841 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
1842 }
1843
460c89ff
NS		 1844 if (cu_offset + compunit.cu_length + initial_length_size
1845 > section->size)
1846 {
ec4d4525
NC		 1847 warn (_("Debug info is corrupted, length of CU at %lx extends beyond end of section (length = %lx)\n"),
1848 cu_offset, compunit.cu_length);
460c89ff
NS		 1849 break;
1850 }
1851 tags = hdrptr;
1852 start += compunit.cu_length + initial_length_size;
1853
19e6b90e
L		 1854 if (compunit.cu_version != 2 && compunit.cu_version != 3)
1855 {
1febe64d
NC		 1856 warn (_("CU at offset %lx contains corrupt or unsupported version number: %d.\n"),
1857 cu_offset, compunit.cu_version);
19e6b90e
L		 1858 continue;
1859 }
1860
1861 free_abbrevs ();
1862
bfe2612a
L		 1863 /* Process the abbrevs used by this compilation unit. DWARF
1864 sections under Mach-O have non-zero addresses. */
460c89ff 1865 if (compunit.cu_abbrev_offset >= debug_displays [abbrev].section.size)
ec4d4525
NC		 1866 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
1867 (unsigned long) compunit.cu_abbrev_offset,
1868 (unsigned long) debug_displays [abbrev].section.size);
460c89ff
NS		 1869 else
1870 process_abbrev_section
1871 ((unsigned char *) debug_displays [abbrev].section.start
1872 + compunit.cu_abbrev_offset - debug_displays [abbrev].section.address,
1873 (unsigned char *) debug_displays [abbrev].section.start
1874 + debug_displays [abbrev].section.size);
19e6b90e
L		 1875
1876 level = 0;
1877 while (tags < start)
1878 {
1879 unsigned int bytes_read;
1880 unsigned long abbrev_number;
ec4d4525 1881 unsigned long die_offset;
19e6b90e
L		 1882 abbrev_entry *entry;
1883 abbrev_attr *attr;
1884
ec4d4525
NC		 1885 die_offset = tags - section_begin;
1886
19e6b90e
L		 1887 abbrev_number = read_leb128 (tags, & bytes_read, 0);
1888 tags += bytes_read;
1889
ec4d4525 1890 /* A null DIE marks the end of a list of siblings. */
19e6b90e
L		 1891 if (abbrev_number == 0)
1892 {
1893 --level;
ec4d4525
NC		 1894 if (level < 0)
1895 {
1896 static unsigned num_bogus_warns = 0;
1897
1898 if (num_bogus_warns < 3)
1899 {
1900 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
1901 die_offset);
1902 num_bogus_warns ++;
1903 if (num_bogus_warns == 3)
1904 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
1905 }
1906 }
19e6b90e
L		 1907 continue;
1908 }
1909
4b78141a
NC		 1910 if (!do_loc)
1911 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
ec4d4525 1912 level, die_offset, abbrev_number);
4b78141a 1913
19e6b90e
L		 1914 /* Scan through the abbreviation list until we reach the
1915 correct entry. */
1916 for (entry = first_abbrev;
1917 entry && entry->entry != abbrev_number;
1918 entry = entry->next)
1919 continue;
1920
1921 if (entry == NULL)
1922 {
4b78141a
NC		 1923 if (!do_loc)
1924 {
1925 printf ("\n");
1926 fflush (stdout);
1927 }
cc86f28f
NC		 1928 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
1929 die_offset, abbrev_number);
19e6b90e
L		 1930 return 0;
1931 }
1932
1933 if (!do_loc)
4b78141a 1934 printf (_(" (%s)\n"), get_TAG_name (entry->tag));
19e6b90e
L		 1935
1936 switch (entry->tag)
1937 {
1938 default:
1939 need_base_address = 0;
1940 break;
1941 case DW_TAG_compile_unit:
1942 need_base_address = 1;
1943 break;
1944 case DW_TAG_entry_point:
19e6b90e
L		 1945 case DW_TAG_subprogram:
1946 need_base_address = 0;
1947 /* Assuming that there is no DW_AT_frame_base. */
1948 have_frame_base = 0;
1949 break;
1950 }
1951
1952 for (attr = entry->first_attr; attr; attr = attr->next)
4b78141a
NC		 1953 {
1954 if (! do_loc)
1955 /* Show the offset from where the tag was extracted. */
750f03b7 1956 printf (" <%2lx>", (unsigned long)(tags - section_begin));
4b78141a
NC		 1957
1958 tags = read_and_display_attr (attr->attribute,
1959 attr->form,
1960 tags, cu_offset,
1961 compunit.cu_pointer_size,
1962 offset_size,
1963 compunit.cu_version,
ec4d4525 1964 debug_information + unit,
6e3d6dc1 1965 do_loc, section);
4b78141a 1966 }
19e6b90e
L		 1967
1968 if (entry->children)
1969 ++level;
1970 }
1971 }
1972
1973 /* Set num_debug_info_entries here so that it can be used to check if
1974 we need to process .debug_loc and .debug_ranges sections. */
1975 if ((do_loc || do_debug_loc || do_debug_ranges)
1976 && num_debug_info_entries == 0)
1977 num_debug_info_entries = num_units;
1978
1979 if (!do_loc)
1980 {
1981 printf ("\n");
1982 }
1983
1984 return 1;
1985}
1986
1987/* Locate and scan the .debug_info section in the file and record the pointer
1988 sizes and offsets for the compilation units in it. Usually an executable
1989 will have just one pointer size, but this is not guaranteed, and so we try
1990 not to make any assumptions. Returns zero upon failure, or the number of
1991 compilation units upon success. */
1992
1993static unsigned int
1994load_debug_info (void * file)
1995{
1996 /* Reset the last pointer size so that we can issue correct error
1997 messages if we are displaying the contents of more than one section. */
1998 last_pointer_size = 0;
1999 warned_about_missing_comp_units = FALSE;
2000
1febe64d
NC		 2001 /* If we have already tried and failed to load the .debug_info
2002 section then do not bother to repear the task. */
cc86f28f 2003 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
1febe64d
NC		 2004 return 0;
2005
19e6b90e
L		 2006 /* If we already have the information there is nothing else to do. */
2007 if (num_debug_info_entries > 0)
2008 return num_debug_info_entries;
2009
2010 if (load_debug_section (info, file)
2011 && process_debug_info (&debug_displays [info].section, file, 1))
2012 return num_debug_info_entries;
1febe64d 2013
cc86f28f 2014 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
1febe64d 2015 return 0;
19e6b90e
L		 2016}
2017
19e6b90e
L		 2018static int
2019display_debug_lines (struct dwarf_section *section, void *file)
2020{
2021 unsigned char *start = section->start;
2022 unsigned char *data = start;
2023 unsigned char *end = start + section->size;
19e6b90e
L		 2024
2025 printf (_("\nDump of debug contents of section %s:\n\n"),
2026 section->name);
2027
1febe64d
NC		 2028 if (load_debug_info (file) == 0)
2029 {
2030 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2031 section->name);
2032 return 0;
2033 }
19e6b90e
L		 2034
2035 while (data < end)
2036 {
2037 DWARF2_Internal_LineInfo info;
2038 unsigned char *standard_opcodes;
2039 unsigned char *end_of_sequence;
2040 unsigned char *hdrptr;
6523721c 2041 unsigned long hdroff;
19e6b90e
L		 2042 int initial_length_size;
2043 int offset_size;
2044 int i;
2045
2046 hdrptr = data;
6523721c 2047 hdroff = hdrptr - start;
19e6b90e
L		 2048
2049 /* Check the length of the block. */
2050 info.li_length = byte_get (hdrptr, 4);
2051 hdrptr += 4;
2052
2053 if (info.li_length == 0xffffffff)
2054 {
2055 /* This section is 64-bit DWARF 3. */
2056 info.li_length = byte_get (hdrptr, 8);
2057 hdrptr += 8;
2058 offset_size = 8;
2059 initial_length_size = 12;
2060 }
2061 else
2062 {
2063 offset_size = 4;
2064 initial_length_size = 4;
2065 }
2066
2067 if (info.li_length + initial_length_size > section->size)
2068 {
2069 warn
2070 (_("The line info appears to be corrupt - the section is too small\n"));
2071 return 0;
2072 }
2073
2074 /* Check its version number. */
2075 info.li_version = byte_get (hdrptr, 2);
2076 hdrptr += 2;
2077 if (info.li_version != 2 && info.li_version != 3)
2078 {
2079 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
2080 return 0;
2081 }
2082
2083 info.li_prologue_length = byte_get (hdrptr, offset_size);
2084 hdrptr += offset_size;
2085 info.li_min_insn_length = byte_get (hdrptr, 1);
2086 hdrptr++;
2087 info.li_default_is_stmt = byte_get (hdrptr, 1);
2088 hdrptr++;
2089 info.li_line_base = byte_get (hdrptr, 1);
2090 hdrptr++;
2091 info.li_line_range = byte_get (hdrptr, 1);
2092 hdrptr++;
2093 info.li_opcode_base = byte_get (hdrptr, 1);
2094 hdrptr++;
2095
2096 /* Sign extend the line base field. */
2097 info.li_line_base <<= 24;
2098 info.li_line_base >>= 24;
2099
6523721c 2100 printf (_(" Offset: 0x%lx\n"), hdroff);
19e6b90e
L		 2101 printf (_(" Length: %ld\n"), info.li_length);
2102 printf (_(" DWARF Version: %d\n"), info.li_version);
2103 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
2104 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
2105 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
2106 printf (_(" Line Base: %d\n"), info.li_line_base);
2107 printf (_(" Line Range: %d\n"), info.li_line_range);
2108 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
19e6b90e
L		 2109
2110 end_of_sequence = data + info.li_length + initial_length_size;
2111
2112 reset_state_machine (info.li_default_is_stmt);
2113
2114 /* Display the contents of the Opcodes table. */
2115 standard_opcodes = hdrptr;
2116
2117 printf (_("\n Opcodes:\n"));
2118
2119 for (i = 1; i < info.li_opcode_base; i++)
2120 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2121
2122 /* Display the contents of the Directory table. */
2123 data = standard_opcodes + info.li_opcode_base - 1;
2124
2125 if (*data == 0)
2126 printf (_("\n The Directory Table is empty.\n"));
2127 else
2128 {
2129 printf (_("\n The Directory Table:\n"));
2130
2131 while (*data != 0)
2132 {
2133 printf (_(" %s\n"), data);
2134
2135 data += strlen ((char *) data) + 1;
2136 }
2137 }
2138
2139 /* Skip the NUL at the end of the table. */
2140 data++;
2141
2142 /* Display the contents of the File Name table. */
2143 if (*data == 0)
2144 printf (_("\n The File Name Table is empty.\n"));
2145 else
2146 {
2147 printf (_("\n The File Name Table:\n"));
2148 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2149
2150 while (*data != 0)
2151 {
2152 unsigned char *name;
2153 unsigned int bytes_read;
2154
2155 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
2156 name = data;
2157
2158 data += strlen ((char *) data) + 1;
2159
2160 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2161 data += bytes_read;
2162 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2163 data += bytes_read;
2164 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
2165 data += bytes_read;
2166 printf (_("%s\n"), name);
2167 }
2168 }
2169
2170 /* Skip the NUL at the end of the table. */
2171 data++;
2172
2173 /* Now display the statements. */
2174 printf (_("\n Line Number Statements:\n"));
2175
2176 while (data < end_of_sequence)
2177 {
2178 unsigned char op_code;
2179 int adv;
2180 unsigned long int uladv;
2181 unsigned int bytes_read;
2182
2183 op_code = *data++;
2184
2185 if (op_code >= info.li_opcode_base)
2186 {
2187 op_code -= info.li_opcode_base;
2188 uladv = (op_code / info.li_line_range) * info.li_min_insn_length;
2189 state_machine_regs.address += uladv;
2190 printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"),
2191 op_code, uladv, state_machine_regs.address);
2192 adv = (op_code % info.li_line_range) + info.li_line_base;
2193 state_machine_regs.line += adv;
2194 printf (_(" and Line by %d to %d\n"),
2195 adv, state_machine_regs.line);
2196 }
2197 else switch (op_code)
2198 {
2199 case DW_LNS_extended_op:
1617e571 2200 data += process_extended_line_op (data, info.li_default_is_stmt);
19e6b90e
L		 2201 break;
2202
2203 case DW_LNS_copy:
2204 printf (_(" Copy\n"));
2205 break;
2206
2207 case DW_LNS_advance_pc:
2208 uladv = read_leb128 (data, & bytes_read, 0);
2209 uladv *= info.li_min_insn_length;
2210 data += bytes_read;
2211 state_machine_regs.address += uladv;
2212 printf (_(" Advance PC by %lu to 0x%lx\n"), uladv,
2213 state_machine_regs.address);
2214 break;
2215
2216 case DW_LNS_advance_line:
2217 adv = read_leb128 (data, & bytes_read, 1);
2218 data += bytes_read;
2219 state_machine_regs.line += adv;
2220 printf (_(" Advance Line by %d to %d\n"), adv,
2221 state_machine_regs.line);
2222 break;
2223
2224 case DW_LNS_set_file:
2225 adv = read_leb128 (data, & bytes_read, 0);
2226 data += bytes_read;
2227 printf (_(" Set File Name to entry %d in the File Name Table\n"),
2228 adv);
2229 state_machine_regs.file = adv;
2230 break;
2231
2232 case DW_LNS_set_column:
2233 uladv = read_leb128 (data, & bytes_read, 0);
2234 data += bytes_read;
2235 printf (_(" Set column to %lu\n"), uladv);
2236 state_machine_regs.column = uladv;
2237 break;
2238
2239 case DW_LNS_negate_stmt:
2240 adv = state_machine_regs.is_stmt;
2241 adv = ! adv;
2242 printf (_(" Set is_stmt to %d\n"), adv);
2243 state_machine_regs.is_stmt = adv;
2244 break;
2245
2246 case DW_LNS_set_basic_block:
2247 printf (_(" Set basic block\n"));
2248 state_machine_regs.basic_block = 1;
2249 break;
2250
2251 case DW_LNS_const_add_pc:
2252 uladv = (((255 - info.li_opcode_base) / info.li_line_range)
2253 * info.li_min_insn_length);
2254 state_machine_regs.address += uladv;
2255 printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv,
2256 state_machine_regs.address);
2257 break;
2258
2259 case DW_LNS_fixed_advance_pc:
2260 uladv = byte_get (data, 2);
2261 data += 2;
2262 state_machine_regs.address += uladv;
2263 printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"),
2264 uladv, state_machine_regs.address);
2265 break;
2266
2267 case DW_LNS_set_prologue_end:
2268 printf (_(" Set prologue_end to true\n"));
2269 break;
2270
2271 case DW_LNS_set_epilogue_begin:
2272 printf (_(" Set epilogue_begin to true\n"));
2273 break;
2274
2275 case DW_LNS_set_isa:
2276 uladv = read_leb128 (data, & bytes_read, 0);
2277 data += bytes_read;
2278 printf (_(" Set ISA to %lu\n"), uladv);
2279 break;
2280
2281 default:
2282 printf (_(" Unknown opcode %d with operands: "), op_code);
2283
2284 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2285 {
2286 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
2287 i == 1 ? "" : ", ");
2288 data += bytes_read;
2289 }
2290 putchar ('\n');
2291 break;
2292 }
2293 }
2294 putchar ('\n');
2295 }
2296
2297 return 1;
2298}
2299
6e3d6dc1
NC		 2300static debug_info *
2301find_debug_info_for_offset (unsigned long offset)
2302{
2303 unsigned int i;
2304
2305 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
2306 return NULL;
2307
2308 for (i = 0; i < num_debug_info_entries; i++)
2309 if (debug_information[i].cu_offset == offset)
2310 return debug_information + i;
2311
2312 return NULL;
2313}
2314
19e6b90e
L		 2315static int
2316display_debug_pubnames (struct dwarf_section *section,
2317 void *file ATTRIBUTE_UNUSED)
2318{
2319 DWARF2_Internal_PubNames pubnames;
2320 unsigned char *start = section->start;
2321 unsigned char *end = start + section->size;
2322
6e3d6dc1
NC		 2323 /* It does not matter if this load fails,
2324 we test for that later on. */
2325 load_debug_info (file);
2326
19e6b90e
L		 2327 printf (_("Contents of the %s section:\n\n"), section->name);
2328
2329 while (start < end)
2330 {
2331 unsigned char *data;
2332 unsigned long offset;
2333 int offset_size, initial_length_size;
2334
2335 data = start;
2336
2337 pubnames.pn_length = byte_get (data, 4);
2338 data += 4;
2339 if (pubnames.pn_length == 0xffffffff)
2340 {
2341 pubnames.pn_length = byte_get (data, 8);
2342 data += 8;
2343 offset_size = 8;
2344 initial_length_size = 12;
2345 }
2346 else
2347 {
2348 offset_size = 4;
2349 initial_length_size = 4;
2350 }
2351
2352 pubnames.pn_version = byte_get (data, 2);
2353 data += 2;
6e3d6dc1 2354
19e6b90e
L		 2355 pubnames.pn_offset = byte_get (data, offset_size);
2356 data += offset_size;
6e3d6dc1
NC		 2357
2358 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2359 && num_debug_info_entries > 0
2360 && find_debug_info_for_offset (pubnames.pn_offset) == NULL)
2361 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2362 pubnames.pn_offset, section->name);
2363
19e6b90e
L		 2364 pubnames.pn_size = byte_get (data, offset_size);
2365 data += offset_size;
2366
2367 start += pubnames.pn_length + initial_length_size;
2368
2369 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
2370 {
2371 static int warned = 0;
2372
2373 if (! warned)
2374 {
2375 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
2376 warned = 1;
2377 }
2378
2379 continue;
2380 }
2381
2382 printf (_(" Length: %ld\n"),
2383 pubnames.pn_length);
2384 printf (_(" Version: %d\n"),
2385 pubnames.pn_version);
6e3d6dc1 2386 printf (_(" Offset into .debug_info section: 0x%lx\n"),
19e6b90e
L		 2387 pubnames.pn_offset);
2388 printf (_(" Size of area in .debug_info section: %ld\n"),
2389 pubnames.pn_size);
2390
2391 printf (_("\n Offset\tName\n"));
2392
2393 do
2394 {
2395 offset = byte_get (data, offset_size);
2396
2397 if (offset != 0)
2398 {
2399 data += offset_size;
2400 printf (" %-6ld\t\t%s\n", offset, data);
2401 data += strlen ((char *) data) + 1;
2402 }
2403 }
2404 while (offset != 0);
2405 }
2406
2407 printf ("\n");
2408 return 1;
2409}
2410
2411static int
2412display_debug_macinfo (struct dwarf_section *section,
2413 void *file ATTRIBUTE_UNUSED)
2414{
2415 unsigned char *start = section->start;
2416 unsigned char *end = start + section->size;
2417 unsigned char *curr = start;
2418 unsigned int bytes_read;
2419 enum dwarf_macinfo_record_type op;
2420
2421 printf (_("Contents of the %s section:\n\n"), section->name);
2422
2423 while (curr < end)
2424 {
2425 unsigned int lineno;
2426 const char *string;
2427
2428 op = *curr;
2429 curr++;
2430
2431 switch (op)
2432 {
2433 case DW_MACINFO_start_file:
2434 {
2435 unsigned int filenum;
2436
2437 lineno = read_leb128 (curr, & bytes_read, 0);
2438 curr += bytes_read;
2439 filenum = read_leb128 (curr, & bytes_read, 0);
2440 curr += bytes_read;
2441
2442 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
2443 lineno, filenum);
2444 }
2445 break;
2446
2447 case DW_MACINFO_end_file:
2448 printf (_(" DW_MACINFO_end_file\n"));
2449 break;
2450
2451 case DW_MACINFO_define:
2452 lineno = read_leb128 (curr, & bytes_read, 0);
2453 curr += bytes_read;
2454 string = (char *) curr;
2455 curr += strlen (string) + 1;
2456 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
2457 lineno, string);
2458 break;
2459
2460 case DW_MACINFO_undef:
2461 lineno = read_leb128 (curr, & bytes_read, 0);
2462 curr += bytes_read;
2463 string = (char *) curr;
2464 curr += strlen (string) + 1;
2465 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
2466 lineno, string);
2467 break;
2468
2469 case DW_MACINFO_vendor_ext:
2470 {
2471 unsigned int constant;
2472
2473 constant = read_leb128 (curr, & bytes_read, 0);
2474 curr += bytes_read;
2475 string = (char *) curr;
2476 curr += strlen (string) + 1;
2477 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
2478 constant, string);
2479 }
2480 break;
2481 }
2482 }
2483
2484 return 1;
2485}
2486
2487static int
2488display_debug_abbrev (struct dwarf_section *section,
2489 void *file ATTRIBUTE_UNUSED)
2490{
2491 abbrev_entry *entry;
2492 unsigned char *start = section->start;
2493 unsigned char *end = start + section->size;
2494
2495 printf (_("Contents of the %s section:\n\n"), section->name);
2496
2497 do
2498 {
2499 free_abbrevs ();
2500
2501 start = process_abbrev_section (start, end);
2502
2503 if (first_abbrev == NULL)
2504 continue;
2505
2506 printf (_(" Number TAG\n"));
2507
2508 for (entry = first_abbrev; entry; entry = entry->next)
2509 {
2510 abbrev_attr *attr;
2511
2512 printf (_(" %ld %s [%s]\n"),
2513 entry->entry,
2514 get_TAG_name (entry->tag),
2515 entry->children ? _("has children") : _("no children"));
2516
2517 for (attr = entry->first_attr; attr; attr = attr->next)
2518 printf (_(" %-18s %s\n"),
2519 get_AT_name (attr->attribute),
2520 get_FORM_name (attr->form));
2521 }
2522 }
2523 while (start);
2524
2525 printf ("\n");
2526
2527 return 1;
2528}
2529
2530static int
2531display_debug_loc (struct dwarf_section *section, void *file)
2532{
2533 unsigned char *start = section->start;
2534 unsigned char *section_end;
2535 unsigned long bytes;
2536 unsigned char *section_begin = start;
2537 unsigned int num_loc_list = 0;
2538 unsigned long last_offset = 0;
2539 unsigned int first = 0;
2540 unsigned int i;
2541 unsigned int j;
2542 int seen_first_offset = 0;
2543 int use_debug_info = 1;
2544 unsigned char *next;
2545
2546 bytes = section->size;
2547 section_end = start + bytes;
2548
2549 if (bytes == 0)
2550 {
2551 printf (_("\nThe %s section is empty.\n"), section->name);
2552 return 0;
2553 }
2554
1febe64d
NC		 2555 if (load_debug_info (file) == 0)
2556 {
2557 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2558 section->name);
2559 return 0;
2560 }
19e6b90e
L		 2561
2562 /* Check the order of location list in .debug_info section. If
2563 offsets of location lists are in the ascending order, we can
2564 use `debug_information' directly. */
2565 for (i = 0; i < num_debug_info_entries; i++)
2566 {
2567 unsigned int num;
2568
2569 num = debug_information [i].num_loc_offsets;
2570 num_loc_list += num;
2571
2572 /* Check if we can use `debug_information' directly. */
2573 if (use_debug_info && num != 0)
2574 {
2575 if (!seen_first_offset)
2576 {
2577 /* This is the first location list. */
2578 last_offset = debug_information [i].loc_offsets [0];
2579 first = i;
2580 seen_first_offset = 1;
2581 j = 1;
2582 }
2583 else
2584 j = 0;
2585
2586 for (; j < num; j++)
2587 {
2588 if (last_offset >
2589 debug_information [i].loc_offsets [j])
2590 {
2591 use_debug_info = 0;
2592 break;
2593 }
2594 last_offset = debug_information [i].loc_offsets [j];
2595 }
2596 }
2597 }
2598
2599 if (!use_debug_info)
2600 /* FIXME: Should we handle this case? */
2601 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
2602
2603 if (!seen_first_offset)
2604 error (_("No location lists in .debug_info section!\n"));
2605
bfe2612a 2606 /* DWARF sections under Mach-O have non-zero addresses. */
d4bfc77b
AS		 2607 if (debug_information [first].num_loc_offsets > 0
2608 && debug_information [first].loc_offsets [0] != section->address)
19e6b90e
L		 2609 warn (_("Location lists in %s section start at 0x%lx\n"),
2610 section->name, debug_information [first].loc_offsets [0]);
2611
2612 printf (_("Contents of the %s section:\n\n"), section->name);
2613 printf (_(" Offset Begin End Expression\n"));
2614
2615 seen_first_offset = 0;
2616 for (i = first; i < num_debug_info_entries; i++)
2617 {
2618 unsigned long begin;
2619 unsigned long end;
2620 unsigned short length;
2621 unsigned long offset;
2622 unsigned int pointer_size;
2623 unsigned long cu_offset;
2624 unsigned long base_address;
2625 int need_frame_base;
2626 int has_frame_base;
2627
2628 pointer_size = debug_information [i].pointer_size;
2629 cu_offset = debug_information [i].cu_offset;
2630
2631 for (j = 0; j < debug_information [i].num_loc_offsets; j++)
2632 {
2633 has_frame_base = debug_information [i].have_frame_base [j];
bfe2612a
L		 2634 /* DWARF sections under Mach-O have non-zero addresses. */
2635 offset = debug_information [i].loc_offsets [j] - section->address;
19e6b90e
L		 2636 next = section_begin + offset;
2637 base_address = debug_information [i].base_address;
2638
2639 if (!seen_first_offset)
2640 seen_first_offset = 1;
2641 else
2642 {
2643 if (start < next)
2644 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
2645 (long)(start - section_begin), (long)(next - section_begin));
2646 else if (start > next)
2647 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
2648 (long)(start - section_begin), (long)(next - section_begin));
2649 }
2650 start = next;
2651
2652 if (offset >= bytes)
2653 {
2654 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
2655 offset);
2656 continue;
2657 }
2658
2659 while (1)
2660 {
2661 if (start + 2 * pointer_size > section_end)
2662 {
2663 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2664 offset);
2665 break;
2666 }
2667
2668 begin = byte_get (start, pointer_size);
2669 start += pointer_size;
2670 end = byte_get (start, pointer_size);
2671 start += pointer_size;
2672
2673 if (begin == 0 && end == 0)
2674 {
2675 printf (_(" %8.8lx <End of list>\n"), offset);
2676 break;
2677 }
2678
2679 /* Check base address specifiers. */
2680 if (begin == -1UL && end != -1UL)
2681 {
2682 base_address = end;
2683 printf (_(" %8.8lx %8.8lx %8.8lx (base address)\n"),
2684 offset, begin, end);
2685 continue;
2686 }
2687
2688 if (start + 2 > section_end)
2689 {
2690 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2691 offset);
2692 break;
2693 }
2694
2695 length = byte_get (start, 2);
2696 start += 2;
2697
2698 if (start + length > section_end)
2699 {
2700 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
2701 offset);
2702 break;
2703 }
2704
2705 printf (" %8.8lx %8.8lx %8.8lx (",
2706 offset, begin + base_address, end + base_address);
2707 need_frame_base = decode_location_expression (start,
2708 pointer_size,
2709 length,
2710 cu_offset);
2711 putchar (')');
2712
2713 if (need_frame_base && !has_frame_base)
2714 printf (_(" [without DW_AT_frame_base]"));
2715
2716 if (begin == end)
2717 fputs (_(" (start == end)"), stdout);
2718 else if (begin > end)
2719 fputs (_(" (start > end)"), stdout);
2720
2721 putchar ('\n');
2722
2723 start += length;
2724 }
2725 }
2726 }
031cd65f
NC		 2727
2728 if (start < section_end)
2729 warn (_("There are %ld unused bytes at the end of section %s\n"),
0eb090cb 2730 (long) (section_end - start), section->name);
19e6b90e
L		 2731 return 1;
2732}
2733
2734static int
2735display_debug_str (struct dwarf_section *section,
2736 void *file ATTRIBUTE_UNUSED)
2737{
2738 unsigned char *start = section->start;
2739 unsigned long bytes = section->size;
2740 dwarf_vma addr = section->address;
2741
2742 if (bytes == 0)
2743 {
2744 printf (_("\nThe %s section is empty.\n"), section->name);
2745 return 0;
2746 }
2747
2748 printf (_("Contents of the %s section:\n\n"), section->name);
2749
2750 while (bytes)
2751 {
2752 int j;
2753 int k;
2754 int lbytes;
2755
2756 lbytes = (bytes > 16 ? 16 : bytes);
2757
2758 printf (" 0x%8.8lx ", (unsigned long) addr);
2759
2760 for (j = 0; j < 16; j++)
2761 {
2762 if (j < lbytes)
2763 printf ("%2.2x", start[j]);
2764 else
2765 printf (" ");
2766
2767 if ((j & 3) == 3)
2768 printf (" ");
2769 }
2770
2771 for (j = 0; j < lbytes; j++)
2772 {
2773 k = start[j];
2774 if (k >= ' ' && k < 0x80)
2775 printf ("%c", k);
2776 else
2777 printf (".");
2778 }
2779
2780 putchar ('\n');
2781
2782 start += lbytes;
2783 addr += lbytes;
2784 bytes -= lbytes;
2785 }
2786
2787 putchar ('\n');
2788
2789 return 1;
2790}
2791
19e6b90e
L		 2792static int
2793display_debug_info (struct dwarf_section *section, void *file)
2794{
2795 return process_debug_info (section, file, 0);
2796}
2797
2798
2799static int
2800display_debug_aranges (struct dwarf_section *section,
2801 void *file ATTRIBUTE_UNUSED)
2802{
2803 unsigned char *start = section->start;
2804 unsigned char *end = start + section->size;
2805
2806 printf (_("The section %s contains:\n\n"), section->name);
2807
6e3d6dc1
NC		 2808 /* It does not matter if this load fails,
2809 we test for that later on. */
2810 load_debug_info (file);
2811
19e6b90e
L		 2812 while (start < end)
2813 {
2814 unsigned char *hdrptr;
2815 DWARF2_Internal_ARange arange;
2816 unsigned char *ranges;
2817 unsigned long length;
2818 unsigned long address;
53b8873b 2819 unsigned char address_size;
19e6b90e
L		 2820 int excess;
2821 int offset_size;
2822 int initial_length_size;
2823
2824 hdrptr = start;
2825
2826 arange.ar_length = byte_get (hdrptr, 4);
2827 hdrptr += 4;
2828
2829 if (arange.ar_length == 0xffffffff)
2830 {
2831 arange.ar_length = byte_get (hdrptr, 8);
2832 hdrptr += 8;
2833 offset_size = 8;
2834 initial_length_size = 12;
2835 }
2836 else
2837 {
2838 offset_size = 4;
2839 initial_length_size = 4;
2840 }
2841
2842 arange.ar_version = byte_get (hdrptr, 2);
2843 hdrptr += 2;
2844
2845 arange.ar_info_offset = byte_get (hdrptr, offset_size);
2846 hdrptr += offset_size;
2847
6e3d6dc1
NC		 2848 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
2849 && num_debug_info_entries > 0
2850 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
2851 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
2852 arange.ar_info_offset, section->name);
2853
19e6b90e
L		 2854 arange.ar_pointer_size = byte_get (hdrptr, 1);
2855 hdrptr += 1;
2856
2857 arange.ar_segment_size = byte_get (hdrptr, 1);
2858 hdrptr += 1;
2859
2860 if (arange.ar_version != 2 && arange.ar_version != 3)
2861 {
2862 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
2863 break;
2864 }
2865
2866 printf (_(" Length: %ld\n"), arange.ar_length);
2867 printf (_(" Version: %d\n"), arange.ar_version);
6e3d6dc1 2868 printf (_(" Offset into .debug_info: 0x%lx\n"), arange.ar_info_offset);
19e6b90e
L		 2869 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
2870 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
2871
53b8873b
NC		 2872 address_size = arange.ar_pointer_size + arange.ar_segment_size;
2873
2874 /* The DWARF spec does not require that the address size be a power
2875 of two, but we do. This will have to change if we ever encounter
2876 an uneven architecture. */
2877 if ((address_size & (address_size - 1)) != 0)
2878 {
2879 warn (_("Pointer size + Segment size is not a power of two.\n"));
2880 break;
2881 }
2882
209c9a13
NC		 2883 if (address_size > 4)
2884 printf (_("\n Address Length\n"));
2885 else
2886 printf (_("\n Address Length\n"));
19e6b90e
L		 2887
2888 ranges = hdrptr;
2889
53b8873b
NC		 2890 /* Must pad to an alignment boundary that is twice the address size. */
2891 excess = (hdrptr - start) % (2 * address_size);
19e6b90e 2892 if (excess)
53b8873b 2893 ranges += (2 * address_size) - excess;
19e6b90e 2894
1617e571
AM		 2895 start += arange.ar_length + initial_length_size;
2896
53b8873b 2897 while (ranges + 2 * address_size <= start)
19e6b90e 2898 {
53b8873b 2899 address = byte_get (ranges, address_size);
19e6b90e 2900
53b8873b 2901 ranges += address_size;
19e6b90e 2902
53b8873b 2903 length = byte_get (ranges, address_size);
19e6b90e 2904
53b8873b 2905 ranges += address_size;
19e6b90e 2906
209c9a13
NC		 2907 if (address_size > 4)
2908 printf (" 0x%16.16lx 0x%lx\n", address, length);
2909 else
2910 printf (" 0x%8.8lx 0x%lx\n", address, length);
19e6b90e 2911 }
19e6b90e
L		 2912 }
2913
2914 printf ("\n");
2915
2916 return 1;
2917}
2918
2919static int
2920display_debug_ranges (struct dwarf_section *section,
2921 void *file ATTRIBUTE_UNUSED)
2922{
2923 unsigned char *start = section->start;
2924 unsigned char *section_end;
2925 unsigned long bytes;
2926 unsigned char *section_begin = start;
2927 unsigned int num_range_list = 0;
2928 unsigned long last_offset = 0;
2929 unsigned int first = 0;
2930 unsigned int i;
2931 unsigned int j;
2932 int seen_first_offset = 0;
2933 int use_debug_info = 1;
2934 unsigned char *next;
2935
2936 bytes = section->size;
2937 section_end = start + bytes;
2938
2939 if (bytes == 0)
2940 {
2941 printf (_("\nThe %s section is empty.\n"), section->name);
2942 return 0;
2943 }
2944
1febe64d
NC		 2945 if (load_debug_info (file) == 0)
2946 {
2947 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
2948 section->name);
2949 return 0;
2950 }
19e6b90e
L		 2951
2952 /* Check the order of range list in .debug_info section. If
2953 offsets of range lists are in the ascending order, we can
2954 use `debug_information' directly. */
2955 for (i = 0; i < num_debug_info_entries; i++)
2956 {
2957 unsigned int num;
2958
2959 num = debug_information [i].num_range_lists;
2960 num_range_list += num;
2961
2962 /* Check if we can use `debug_information' directly. */
2963 if (use_debug_info && num != 0)
2964 {
2965 if (!seen_first_offset)
2966 {
2967 /* This is the first range list. */
2968 last_offset = debug_information [i].range_lists [0];
2969 first = i;
2970 seen_first_offset = 1;
2971 j = 1;
2972 }
2973 else
2974 j = 0;
2975
2976 for (; j < num; j++)
2977 {
2978 if (last_offset >
2979 debug_information [i].range_lists [j])
2980 {
2981 use_debug_info = 0;
2982 break;
2983 }
2984 last_offset = debug_information [i].range_lists [j];
2985 }
2986 }
2987 }
2988
2989 if (!use_debug_info)
2990 /* FIXME: Should we handle this case? */
2991 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
2992
2993 if (!seen_first_offset)
2994 error (_("No range lists in .debug_info section!\n"));
2995
bfe2612a 2996 /* DWARF sections under Mach-O have non-zero addresses. */
d4bfc77b
AS		 2997 if (debug_information [first].num_range_lists > 0
2998 && debug_information [first].range_lists [0] != section->address)
19e6b90e
L		 2999 warn (_("Range lists in %s section start at 0x%lx\n"),
3000 section->name, debug_information [first].range_lists [0]);
3001
3002 printf (_("Contents of the %s section:\n\n"), section->name);
3003 printf (_(" Offset Begin End\n"));
3004
3005 seen_first_offset = 0;
3006 for (i = first; i < num_debug_info_entries; i++)
3007 {
3008 unsigned long begin;
3009 unsigned long end;
3010 unsigned long offset;
3011 unsigned int pointer_size;
3012 unsigned long base_address;
3013
3014 pointer_size = debug_information [i].pointer_size;
3015
3016 for (j = 0; j < debug_information [i].num_range_lists; j++)
3017 {
bfe2612a
L		 3018 /* DWARF sections under Mach-O have non-zero addresses. */
3019 offset = debug_information [i].range_lists [j] - section->address;
19e6b90e
L		 3020 next = section_begin + offset;
3021 base_address = debug_information [i].base_address;
3022
3023 if (!seen_first_offset)
3024 seen_first_offset = 1;
3025 else
3026 {
3027 if (start < next)
3028 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
3029 (long)(start - section_begin),
3030 (long)(next - section_begin), section->name);
3031 else if (start > next)
3032 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
3033 (long)(start - section_begin),
3034 (long)(next - section_begin), section->name);
3035 }
3036 start = next;
3037
3038 while (1)
3039 {
3040 begin = byte_get (start, pointer_size);
3041 start += pointer_size;
3042 end = byte_get (start, pointer_size);
3043 start += pointer_size;
3044
3045 if (begin == 0 && end == 0)
3046 {
3047 printf (_(" %8.8lx <End of list>\n"), offset);
3048 break;
3049 }
3050
3051 /* Check base address specifiers. */
3052 if (begin == -1UL && end != -1UL)
3053 {
3054 base_address = end;
3055 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
3056 offset, begin, end);
3057 continue;
3058 }
3059
3060 printf (" %8.8lx %8.8lx %8.8lx",
3061 offset, begin + base_address, end + base_address);
3062
3063 if (begin == end)
3064 fputs (_(" (start == end)"), stdout);
3065 else if (begin > end)
3066 fputs (_(" (start > end)"), stdout);
3067
3068 putchar ('\n');
3069 }
3070 }
3071 }
3072 putchar ('\n');
3073 return 1;
3074}
3075
3076typedef struct Frame_Chunk
3077{
3078 struct Frame_Chunk *next;
3079 unsigned char *chunk_start;
3080 int ncols;
3081 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
3082 short int *col_type;
3083 int *col_offset;
3084 char *augmentation;
3085 unsigned int code_factor;
3086 int data_factor;
3087 unsigned long pc_begin;
3088 unsigned long pc_range;
3089 int cfa_reg;
3090 int cfa_offset;
3091 int ra;
3092 unsigned char fde_encoding;
3093 unsigned char cfa_exp;
3094}
3095Frame_Chunk;
3096
3097/* A marker for a col_type that means this column was never referenced
3098 in the frame info. */
3099#define DW_CFA_unreferenced (-1)
3100
3101static void
3102frame_need_space (Frame_Chunk *fc, int reg)
3103{
3104 int prev = fc->ncols;
3105
3106 if (reg < fc->ncols)
3107 return;
3108
3109 fc->ncols = reg + 1;
3110 fc->col_type = xcrealloc (fc->col_type, fc->ncols, sizeof (short int));
3111 fc->col_offset = xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
3112
3113 while (prev < fc->ncols)
3114 {
3115 fc->col_type[prev] = DW_CFA_unreferenced;
3116 fc->col_offset[prev] = 0;
3117 prev++;
3118 }
3119}
3120
3121static void
3122frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
3123{
3124 int r;
3125 char tmp[100];
3126
3127 if (*max_regs < fc->ncols)
3128 *max_regs = fc->ncols;
3129
3130 if (*need_col_headers)
3131 {
3132 *need_col_headers = 0;
3133
3134 printf (" LOC CFA ");
3135
3136 for (r = 0; r < *max_regs; r++)
3137 if (fc->col_type[r] != DW_CFA_unreferenced)
3138 {
3139 if (r == fc->ra)
3140 printf ("ra ");
3141 else
3142 printf ("r%-4d", r);
3143 }
3144
3145 printf ("\n");
3146 }
3147
3148 printf ("%08lx ", fc->pc_begin);
3149 if (fc->cfa_exp)
3150 strcpy (tmp, "exp");
3151 else
3152 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
3153 printf ("%-8s ", tmp);
3154
3155 for (r = 0; r < fc->ncols; r++)
3156 {
3157 if (fc->col_type[r] != DW_CFA_unreferenced)
3158 {
3159 switch (fc->col_type[r])
3160 {
3161 case DW_CFA_undefined:
3162 strcpy (tmp, "u");
3163 break;
3164 case DW_CFA_same_value:
3165 strcpy (tmp, "s");
3166 break;
3167 case DW_CFA_offset:
3168 sprintf (tmp, "c%+d", fc->col_offset[r]);
3169 break;
12eae2d3
JJ		 3170 case DW_CFA_val_offset:
3171 sprintf (tmp, "v%+d", fc->col_offset[r]);
3172 break;
19e6b90e
L		 3173 case DW_CFA_register:
3174 sprintf (tmp, "r%d", fc->col_offset[r]);
3175 break;
3176 case DW_CFA_expression:
3177 strcpy (tmp, "exp");
3178 break;
12eae2d3
JJ		 3179 case DW_CFA_val_expression:
3180 strcpy (tmp, "vexp");
3181 break;
19e6b90e
L		 3182 default:
3183 strcpy (tmp, "n/a");
3184 break;
3185 }
3186 printf ("%-5s", tmp);
3187 }
3188 }
3189 printf ("\n");
3190}
3191
3192static int
3193size_of_encoded_value (int encoding)
3194{
3195 switch (encoding & 0x7)
3196 {
3197 default: /* ??? */
3198 case 0: return eh_addr_size;
3199 case 2: return 2;
3200 case 3: return 4;
3201 case 4: return 8;
3202 }
3203}
3204
3205static dwarf_vma
3206get_encoded_value (unsigned char *data, int encoding)
3207{
3208 int size = size_of_encoded_value (encoding);
53b8873b 3209
19e6b90e
L		 3210 if (encoding & DW_EH_PE_signed)
3211 return byte_get_signed (data, size);
3212 else
3213 return byte_get (data, size);
3214}
3215
3216#define GET(N) byte_get (start, N); start += N
3217#define LEB() read_leb128 (start, & length_return, 0); start += length_return
3218#define SLEB() read_leb128 (start, & length_return, 1); start += length_return
3219
3220static int
3221display_debug_frames (struct dwarf_section *section,
3222 void *file ATTRIBUTE_UNUSED)
3223{
3224 unsigned char *start = section->start;
3225 unsigned char *end = start + section->size;
3226 unsigned char *section_start = start;
3227 Frame_Chunk *chunks = 0;
3228 Frame_Chunk *remembered_state = 0;
3229 Frame_Chunk *rs;
3230 int is_eh = strcmp (section->name, ".eh_frame") == 0;
3231 unsigned int length_return;
3232 int max_regs = 0;
3233
3234 printf (_("The section %s contains:\n"), section->name);
3235
3236 while (start < end)
3237 {
3238 unsigned char *saved_start;
3239 unsigned char *block_end;
3240 unsigned long length;
3241 unsigned long cie_id;
3242 Frame_Chunk *fc;
3243 Frame_Chunk *cie;
3244 int need_col_headers = 1;
3245 unsigned char *augmentation_data = NULL;
3246 unsigned long augmentation_data_len = 0;
3247 int encoded_ptr_size = eh_addr_size;
3248 int offset_size;
3249 int initial_length_size;
3250
3251 saved_start = start;
3252 length = byte_get (start, 4); start += 4;
3253
3254 if (length == 0)
3255 {
3256 printf ("\n%08lx ZERO terminator\n\n",
3257 (unsigned long)(saved_start - section_start));
b758e50f 3258 continue;
19e6b90e
L		 3259 }
3260
3261 if (length == 0xffffffff)
3262 {
3263 length = byte_get (start, 8);
3264 start += 8;
3265 offset_size = 8;
3266 initial_length_size = 12;
3267 }
3268 else
3269 {
3270 offset_size = 4;
3271 initial_length_size = 4;
3272 }
3273
3274 block_end = saved_start + length + initial_length_size;
53b8873b
NC		 3275 if (block_end > end)
3276 {
3277 warn ("Invalid length %#08lx in FDE at %#08lx\n",
3278 length, (unsigned long)(saved_start - section_start));
3279 block_end = end;
3280 }
19e6b90e
L		 3281 cie_id = byte_get (start, offset_size); start += offset_size;
3282
3283 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
3284 {
3285 int version;
3286
3287 fc = xmalloc (sizeof (Frame_Chunk));
3288 memset (fc, 0, sizeof (Frame_Chunk));
3289
3290 fc->next = chunks;
3291 chunks = fc;
3292 fc->chunk_start = saved_start;
3293 fc->ncols = 0;
3294 fc->col_type = xmalloc (sizeof (short int));
3295 fc->col_offset = xmalloc (sizeof (int));
cc86f28f 3296 frame_need_space (fc, max_regs - 1);
19e6b90e
L		 3297
3298 version = *start++;
3299
3300 fc->augmentation = (char *) start;
3301 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
3302
3303 if (fc->augmentation[0] == 'z')
3304 {
3305 fc->code_factor = LEB ();
3306 fc->data_factor = SLEB ();
3307 if (version == 1)
3308 {
3309 fc->ra = GET (1);
3310 }
3311 else
3312 {
3313 fc->ra = LEB ();
3314 }
3315 augmentation_data_len = LEB ();
3316 augmentation_data = start;
3317 start += augmentation_data_len;
3318 }
3319 else if (strcmp (fc->augmentation, "eh") == 0)
3320 {
3321 start += eh_addr_size;
3322 fc->code_factor = LEB ();
3323 fc->data_factor = SLEB ();
3324 if (version == 1)
3325 {
3326 fc->ra = GET (1);
3327 }
3328 else
3329 {
3330 fc->ra = LEB ();
3331 }
3332 }
3333 else
3334 {
3335 fc->code_factor = LEB ();
3336 fc->data_factor = SLEB ();
3337 if (version == 1)
3338 {
3339 fc->ra = GET (1);
3340 }
3341 else
3342 {
3343 fc->ra = LEB ();
3344 }
3345 }
3346 cie = fc;
3347
3348 if (do_debug_frames_interp)
3349 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
3350 (unsigned long)(saved_start - section_start), length, cie_id,
3351 fc->augmentation, fc->code_factor, fc->data_factor,
3352 fc->ra);
3353 else
3354 {
3355 printf ("\n%08lx %08lx %08lx CIE\n",
3356 (unsigned long)(saved_start - section_start), length, cie_id);
3357 printf (" Version: %d\n", version);
3358 printf (" Augmentation: \"%s\"\n", fc->augmentation);
3359 printf (" Code alignment factor: %u\n", fc->code_factor);
3360 printf (" Data alignment factor: %d\n", fc->data_factor);
3361 printf (" Return address column: %d\n", fc->ra);
3362
3363 if (augmentation_data_len)
3364 {
3365 unsigned long i;
3366 printf (" Augmentation data: ");
3367 for (i = 0; i < augmentation_data_len; ++i)
3368 printf (" %02x", augmentation_data[i]);
3369 putchar ('\n');
3370 }
3371 putchar ('\n');
3372 }
3373
3374 if (augmentation_data_len)
3375 {
3376 unsigned char *p, *q;
3377 p = (unsigned char *) fc->augmentation + 1;
3378 q = augmentation_data;
3379
3380 while (1)
3381 {
3382 if (*p == 'L')
3383 q++;
3384 else if (*p == 'P')
3385 q += 1 + size_of_encoded_value (*q);
3386 else if (*p == 'R')
3387 fc->fde_encoding = *q++;
3388 else
3389 break;
3390 p++;
3391 }
3392
3393 if (fc->fde_encoding)
3394 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3395 }
3396
3397 frame_need_space (fc, fc->ra);
3398 }
3399 else
3400 {
3401 unsigned char *look_for;
3402 static Frame_Chunk fde_fc;
3403
3404 fc = & fde_fc;
3405 memset (fc, 0, sizeof (Frame_Chunk));
3406
3407 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
3408
3409 for (cie = chunks; cie ; cie = cie->next)
3410 if (cie->chunk_start == look_for)
3411 break;
3412
3413 if (!cie)
3414 {
53b8873b 3415 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
1617e571 3416 cie_id, (unsigned long)(saved_start - section_start));
19e6b90e
L		 3417 fc->ncols = 0;
3418 fc->col_type = xmalloc (sizeof (short int));
3419 fc->col_offset = xmalloc (sizeof (int));
3420 frame_need_space (fc, max_regs - 1);
3421 cie = fc;
3422 fc->augmentation = "";
3423 fc->fde_encoding = 0;
3424 }
3425 else
3426 {
3427 fc->ncols = cie->ncols;
3428 fc->col_type = xcmalloc (fc->ncols, sizeof (short int));
3429 fc->col_offset = xcmalloc (fc->ncols, sizeof (int));
3430 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
3431 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
3432 fc->augmentation = cie->augmentation;
3433 fc->code_factor = cie->code_factor;
3434 fc->data_factor = cie->data_factor;
3435 fc->cfa_reg = cie->cfa_reg;
3436 fc->cfa_offset = cie->cfa_offset;
3437 fc->ra = cie->ra;
cc86f28f 3438 frame_need_space (fc, max_regs - 1);
19e6b90e
L		 3439 fc->fde_encoding = cie->fde_encoding;
3440 }
3441
3442 if (fc->fde_encoding)
3443 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
3444
3445 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
41e92641 3446 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
19e6b90e
L		 3447 fc->pc_begin += section->address + (start - section_start);
3448 start += encoded_ptr_size;
3449 fc->pc_range = byte_get (start, encoded_ptr_size);
3450 start += encoded_ptr_size;
3451
3452 if (cie->augmentation[0] == 'z')
3453 {
3454 augmentation_data_len = LEB ();
3455 augmentation_data = start;
3456 start += augmentation_data_len;
3457 }
3458
3459 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
3460 (unsigned long)(saved_start - section_start), length, cie_id,
3461 (unsigned long)(cie->chunk_start - section_start),
3462 fc->pc_begin, fc->pc_begin + fc->pc_range);
3463 if (! do_debug_frames_interp && augmentation_data_len)
3464 {
3465 unsigned long i;
3466
3467 printf (" Augmentation data: ");
3468 for (i = 0; i < augmentation_data_len; ++i)
3469 printf (" %02x", augmentation_data[i]);
3470 putchar ('\n');
3471 putchar ('\n');
3472 }
3473 }
3474
3475 /* At this point, fc is the current chunk, cie (if any) is set, and
3476 we're about to interpret instructions for the chunk. */
3477 /* ??? At present we need to do this always, since this sizes the
3478 fc->col_type and fc->col_offset arrays, which we write into always.
3479 We should probably split the interpreted and non-interpreted bits
3480 into two different routines, since there's so much that doesn't
3481 really overlap between them. */
3482 if (1 || do_debug_frames_interp)
3483 {
3484 /* Start by making a pass over the chunk, allocating storage
3485 and taking note of what registers are used. */
3486 unsigned char *tmp = start;
3487
3488 while (start < block_end)
3489 {
3490 unsigned op, opa;
3491 unsigned long reg, tmp;
3492
3493 op = *start++;
3494 opa = op & 0x3f;
3495 if (op & 0xc0)
3496 op &= 0xc0;
3497
3498 /* Warning: if you add any more cases to this switch, be
3499 sure to add them to the corresponding switch below. */
3500 switch (op)
3501 {
3502 case DW_CFA_advance_loc:
3503 break;
3504 case DW_CFA_offset:
3505 LEB ();
3506 frame_need_space (fc, opa);
3507 fc->col_type[opa] = DW_CFA_undefined;
3508 break;
3509 case DW_CFA_restore:
3510 frame_need_space (fc, opa);
3511 fc->col_type[opa] = DW_CFA_undefined;
3512 break;
3513 case DW_CFA_set_loc:
3514 start += encoded_ptr_size;
3515 break;
3516 case DW_CFA_advance_loc1:
3517 start += 1;
3518 break;
3519 case DW_CFA_advance_loc2:
3520 start += 2;
3521 break;
3522 case DW_CFA_advance_loc4:
3523 start += 4;
3524 break;
3525 case DW_CFA_offset_extended:
12eae2d3 3526 case DW_CFA_val_offset:
19e6b90e
L		 3527 reg = LEB (); LEB ();
3528 frame_need_space (fc, reg);
3529 fc->col_type[reg] = DW_CFA_undefined;
3530 break;
3531 case DW_CFA_restore_extended:
3532 reg = LEB ();
3533 frame_need_space (fc, reg);
3534 fc->col_type[reg] = DW_CFA_undefined;
3535 break;
3536 case DW_CFA_undefined:
3537 reg = LEB ();
3538 frame_need_space (fc, reg);
3539 fc->col_type[reg] = DW_CFA_undefined;
3540 break;
3541 case DW_CFA_same_value:
3542 reg = LEB ();
3543 frame_need_space (fc, reg);
3544 fc->col_type[reg] = DW_CFA_undefined;
3545 break;
3546 case DW_CFA_register:
3547 reg = LEB (); LEB ();
3548 frame_need_space (fc, reg);
3549 fc->col_type[reg] = DW_CFA_undefined;
3550 break;
3551 case DW_CFA_def_cfa:
3552 LEB (); LEB ();
3553 break;
3554 case DW_CFA_def_cfa_register:
3555 LEB ();
3556 break;
3557 case DW_CFA_def_cfa_offset:
3558 LEB ();
3559 break;
3560 case DW_CFA_def_cfa_expression:
3561 tmp = LEB ();
3562 start += tmp;
3563 break;
3564 case DW_CFA_expression:
12eae2d3 3565 case DW_CFA_val_expression:
19e6b90e
L		 3566 reg = LEB ();
3567 tmp = LEB ();
3568 start += tmp;
3569 frame_need_space (fc, reg);
3570 fc->col_type[reg] = DW_CFA_undefined;
3571 break;
3572 case DW_CFA_offset_extended_sf:
12eae2d3 3573 case DW_CFA_val_offset_sf:
19e6b90e
L		 3574 reg = LEB (); SLEB ();
3575 frame_need_space (fc, reg);
3576 fc->col_type[reg] = DW_CFA_undefined;
3577 break;
3578 case DW_CFA_def_cfa_sf:
3579 LEB (); SLEB ();
3580 break;
3581 case DW_CFA_def_cfa_offset_sf:
3582 SLEB ();
3583 break;
3584 case DW_CFA_MIPS_advance_loc8:
3585 start += 8;
3586 break;
3587 case DW_CFA_GNU_args_size:
3588 LEB ();
3589 break;
3590 case DW_CFA_GNU_negative_offset_extended:
3591 reg = LEB (); LEB ();
3592 frame_need_space (fc, reg);
3593 fc->col_type[reg] = DW_CFA_undefined;
3594
3595 default:
3596 break;
3597 }
3598 }
3599 start = tmp;
3600 }
3601
3602 /* Now we know what registers are used, make a second pass over
3603 the chunk, this time actually printing out the info. */
3604
3605 while (start < block_end)
3606 {
3607 unsigned op, opa;
3608 unsigned long ul, reg, roffs;
3609 long l, ofs;
3610 dwarf_vma vma;
3611
3612 op = *start++;
3613 opa = op & 0x3f;
3614 if (op & 0xc0)
3615 op &= 0xc0;
3616
3617 /* Warning: if you add any more cases to this switch, be
3618 sure to add them to the corresponding switch above. */
3619 switch (op)
3620 {
3621 case DW_CFA_advance_loc:
3622 if (do_debug_frames_interp)
3623 frame_display_row (fc, &need_col_headers, &max_regs);
3624 else
3625 printf (" DW_CFA_advance_loc: %d to %08lx\n",
3626 opa * fc->code_factor,
3627 fc->pc_begin + opa * fc->code_factor);
3628 fc->pc_begin += opa * fc->code_factor;
3629 break;
3630
3631 case DW_CFA_offset:
3632 roffs = LEB ();
3633 if (! do_debug_frames_interp)
3634 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
3635 opa, roffs * fc->data_factor);
3636 fc->col_type[opa] = DW_CFA_offset;
3637 fc->col_offset[opa] = roffs * fc->data_factor;
3638 break;
3639
3640 case DW_CFA_restore:
3641 if (! do_debug_frames_interp)
3642 printf (" DW_CFA_restore: r%d\n", opa);
3643 fc->col_type[opa] = cie->col_type[opa];
3644 fc->col_offset[opa] = cie->col_offset[opa];
3645 break;
3646
3647 case DW_CFA_set_loc:
3648 vma = get_encoded_value (start, fc->fde_encoding);
41e92641 3649 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
19e6b90e
L		 3650 vma += section->address + (start - section_start);
3651 start += encoded_ptr_size;
3652 if (do_debug_frames_interp)
3653 frame_display_row (fc, &need_col_headers, &max_regs);
3654 else
3655 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
3656 fc->pc_begin = vma;
3657 break;
3658
3659 case DW_CFA_advance_loc1:
3660 ofs = byte_get (start, 1); start += 1;
3661 if (do_debug_frames_interp)
3662 frame_display_row (fc, &need_col_headers, &max_regs);
3663 else
3664 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
3665 ofs * fc->code_factor,
3666 fc->pc_begin + ofs * fc->code_factor);
3667 fc->pc_begin += ofs * fc->code_factor;
3668 break;
3669
3670 case DW_CFA_advance_loc2:
3671 ofs = byte_get (start, 2); start += 2;
3672 if (do_debug_frames_interp)
3673 frame_display_row (fc, &need_col_headers, &max_regs);
3674 else
3675 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
3676 ofs * fc->code_factor,
3677 fc->pc_begin + ofs * fc->code_factor);
3678 fc->pc_begin += ofs * fc->code_factor;
3679 break;
3680
3681 case DW_CFA_advance_loc4:
3682 ofs = byte_get (start, 4); start += 4;
3683 if (do_debug_frames_interp)
3684 frame_display_row (fc, &need_col_headers, &max_regs);
3685 else
3686 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
3687 ofs * fc->code_factor,
3688 fc->pc_begin + ofs * fc->code_factor);
3689 fc->pc_begin += ofs * fc->code_factor;
3690 break;
3691
3692 case DW_CFA_offset_extended:
3693 reg = LEB ();
3694 roffs = LEB ();
3695 if (! do_debug_frames_interp)
3696 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
3697 reg, roffs * fc->data_factor);
3698 fc->col_type[reg] = DW_CFA_offset;
3699 fc->col_offset[reg] = roffs * fc->data_factor;
3700 break;
3701
12eae2d3
JJ		 3702 case DW_CFA_val_offset:
3703 reg = LEB ();
3704 roffs = LEB ();
3705 if (! do_debug_frames_interp)
3706 printf (" DW_CFA_val_offset: r%ld at cfa%+ld\n",
3707 reg, roffs * fc->data_factor);
3708 fc->col_type[reg] = DW_CFA_val_offset;
3709 fc->col_offset[reg] = roffs * fc->data_factor;
3710 break;
3711
19e6b90e
L		 3712 case DW_CFA_restore_extended:
3713 reg = LEB ();
3714 if (! do_debug_frames_interp)
3715 printf (" DW_CFA_restore_extended: r%ld\n", reg);
3716 fc->col_type[reg] = cie->col_type[reg];
3717 fc->col_offset[reg] = cie->col_offset[reg];
3718 break;
3719
3720 case DW_CFA_undefined:
3721 reg = LEB ();
3722 if (! do_debug_frames_interp)
3723 printf (" DW_CFA_undefined: r%ld\n", reg);
3724 fc->col_type[reg] = DW_CFA_undefined;
3725 fc->col_offset[reg] = 0;
3726 break;
3727
3728 case DW_CFA_same_value:
3729 reg = LEB ();
3730 if (! do_debug_frames_interp)
3731 printf (" DW_CFA_same_value: r%ld\n", reg);
3732 fc->col_type[reg] = DW_CFA_same_value;
3733 fc->col_offset[reg] = 0;
3734 break;
3735
3736 case DW_CFA_register:
3737 reg = LEB ();
3738 roffs = LEB ();
3739 if (! do_debug_frames_interp)
3740 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
3741 fc->col_type[reg] = DW_CFA_register;
3742 fc->col_offset[reg] = roffs;
3743 break;
3744
3745 case DW_CFA_remember_state:
3746 if (! do_debug_frames_interp)
3747 printf (" DW_CFA_remember_state\n");
3748 rs = xmalloc (sizeof (Frame_Chunk));
3749 rs->ncols = fc->ncols;
3750 rs->col_type = xcmalloc (rs->ncols, sizeof (short int));
3751 rs->col_offset = xcmalloc (rs->ncols, sizeof (int));
3752 memcpy (rs->col_type, fc->col_type, rs->ncols);
3753 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
3754 rs->next = remembered_state;
3755 remembered_state = rs;
3756 break;
3757
3758 case DW_CFA_restore_state:
3759 if (! do_debug_frames_interp)
3760 printf (" DW_CFA_restore_state\n");
3761 rs = remembered_state;
3762 if (rs)
3763 {
3764 remembered_state = rs->next;
cc86f28f 3765 frame_need_space (fc, rs->ncols - 1);
19e6b90e
L		 3766 memcpy (fc->col_type, rs->col_type, rs->ncols);
3767 memcpy (fc->col_offset, rs->col_offset,
3768 rs->ncols * sizeof (int));
3769 free (rs->col_type);
3770 free (rs->col_offset);
3771 free (rs);
3772 }
3773 else if (do_debug_frames_interp)
3774 printf ("Mismatched DW_CFA_restore_state\n");
3775 break;
3776
3777 case DW_CFA_def_cfa:
3778 fc->cfa_reg = LEB ();
3779 fc->cfa_offset = LEB ();
3780 fc->cfa_exp = 0;
3781 if (! do_debug_frames_interp)
3782 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
3783 fc->cfa_reg, fc->cfa_offset);
3784 break;
3785
3786 case DW_CFA_def_cfa_register:
3787 fc->cfa_reg = LEB ();
3788 fc->cfa_exp = 0;
3789 if (! do_debug_frames_interp)
3790 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
3791 break;
3792
3793 case DW_CFA_def_cfa_offset:
3794 fc->cfa_offset = LEB ();
3795 if (! do_debug_frames_interp)
3796 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
3797 break;
3798
3799 case DW_CFA_nop:
3800 if (! do_debug_frames_interp)
3801 printf (" DW_CFA_nop\n");
3802 break;
3803
3804 case DW_CFA_def_cfa_expression:
3805 ul = LEB ();
3806 if (! do_debug_frames_interp)
3807 {
3808 printf (" DW_CFA_def_cfa_expression (");
3809 decode_location_expression (start, eh_addr_size, ul, 0);
3810 printf (")\n");
3811 }
3812 fc->cfa_exp = 1;
3813 start += ul;
3814 break;
3815
3816 case DW_CFA_expression:
3817 reg = LEB ();
3818 ul = LEB ();
3819 if (! do_debug_frames_interp)
3820 {
3821 printf (" DW_CFA_expression: r%ld (", reg);
3822 decode_location_expression (start, eh_addr_size, ul, 0);
3823 printf (")\n");
3824 }
3825 fc->col_type[reg] = DW_CFA_expression;
3826 start += ul;
3827 break;
3828
12eae2d3
JJ		 3829 case DW_CFA_val_expression:
3830 reg = LEB ();
3831 ul = LEB ();
3832 if (! do_debug_frames_interp)
3833 {
3834 printf (" DW_CFA_val_expression: r%ld (", reg);
3835 decode_location_expression (start, eh_addr_size, ul, 0);
3836 printf (")\n");
3837 }
3838 fc->col_type[reg] = DW_CFA_val_expression;
3839 start += ul;
3840 break;
3841
19e6b90e
L		 3842 case DW_CFA_offset_extended_sf:
3843 reg = LEB ();
3844 l = SLEB ();
3845 frame_need_space (fc, reg);
3846 if (! do_debug_frames_interp)
3847 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
3848 reg, l * fc->data_factor);
3849 fc->col_type[reg] = DW_CFA_offset;
3850 fc->col_offset[reg] = l * fc->data_factor;
3851 break;
3852
12eae2d3
JJ		 3853 case DW_CFA_val_offset_sf:
3854 reg = LEB ();
3855 l = SLEB ();
3856 frame_need_space (fc, reg);
3857 if (! do_debug_frames_interp)
3858 printf (" DW_CFA_val_offset_sf: r%ld at cfa%+ld\n",
3859 reg, l * fc->data_factor);
3860 fc->col_type[reg] = DW_CFA_val_offset;
3861 fc->col_offset[reg] = l * fc->data_factor;
3862 break;
3863
19e6b90e
L		 3864 case DW_CFA_def_cfa_sf:
3865 fc->cfa_reg = LEB ();
3866 fc->cfa_offset = SLEB ();
3867 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3868 fc->cfa_exp = 0;
3869 if (! do_debug_frames_interp)
3870 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
3871 fc->cfa_reg, fc->cfa_offset);
3872 break;
3873
3874 case DW_CFA_def_cfa_offset_sf:
3875 fc->cfa_offset = SLEB ();
3876 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
3877 if (! do_debug_frames_interp)
3878 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
3879 break;
3880
3881 case DW_CFA_MIPS_advance_loc8:
3882 ofs = byte_get (start, 8); start += 8;
3883 if (do_debug_frames_interp)
3884 frame_display_row (fc, &need_col_headers, &max_regs);
3885 else
3886 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
3887 ofs * fc->code_factor,
3888 fc->pc_begin + ofs * fc->code_factor);
3889 fc->pc_begin += ofs * fc->code_factor;
3890 break;
3891
3892 case DW_CFA_GNU_window_save:
3893 if (! do_debug_frames_interp)
3894 printf (" DW_CFA_GNU_window_save\n");
3895 break;
3896
3897 case DW_CFA_GNU_args_size:
3898 ul = LEB ();
3899 if (! do_debug_frames_interp)
3900 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
3901 break;
3902
3903 case DW_CFA_GNU_negative_offset_extended:
3904 reg = LEB ();
3905 l = - LEB ();
3906 frame_need_space (fc, reg);
3907 if (! do_debug_frames_interp)
3908 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
3909 reg, l * fc->data_factor);
3910 fc->col_type[reg] = DW_CFA_offset;
3911 fc->col_offset[reg] = l * fc->data_factor;
3912 break;
3913
3914 default:
53b8873b
NC		 3915 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
3916 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
3917 else
3918 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
19e6b90e
L		 3919 start = block_end;
3920 }
3921 }
3922
3923 if (do_debug_frames_interp)
3924 frame_display_row (fc, &need_col_headers, &max_regs);
3925
3926 start = block_end;
3927 }
3928
3929 printf ("\n");
3930
3931 return 1;
3932}
3933
3934#undef GET
3935#undef LEB
3936#undef SLEB
3937
3938static int
3939display_debug_not_supported (struct dwarf_section *section,
3940 void *file ATTRIBUTE_UNUSED)
3941{
3942 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
3943 section->name);
3944
3945 return 1;
3946}
3947
3948void *
3949cmalloc (size_t nmemb, size_t size)
3950{
3951 /* Check for overflow. */
3952 if (nmemb >= ~(size_t) 0 / size)
3953 return NULL;
3954 else
3955 return malloc (nmemb * size);
3956}
3957
3958void *
3959xcmalloc (size_t nmemb, size_t size)
3960{
3961 /* Check for overflow. */
3962 if (nmemb >= ~(size_t) 0 / size)
3963 return NULL;
3964 else
3965 return xmalloc (nmemb * size);
3966}
3967
3968void *
3969xcrealloc (void *ptr, size_t nmemb, size_t size)
3970{
3971 /* Check for overflow. */
3972 if (nmemb >= ~(size_t) 0 / size)
3973 return NULL;
3974 else
3975 return xrealloc (ptr, nmemb * size);
3976}
3977
3978void
3979error (const char *message, ...)
3980{
3981 va_list args;
3982
3983 va_start (args, message);
3984 fprintf (stderr, _("%s: Error: "), program_name);
3985 vfprintf (stderr, message, args);
3986 va_end (args);
3987}
3988
3989void
3990warn (const char *message, ...)
3991{
3992 va_list args;
3993
3994 va_start (args, message);
3995 fprintf (stderr, _("%s: Warning: "), program_name);
3996 vfprintf (stderr, message, args);
3997 va_end (args);
3998}
3999
4000void
4001free_debug_memory (void)
4002{
4003 enum dwarf_section_display_enum i;
4004
4005 free_abbrevs ();
4006
4007 for (i = 0; i < max; i++)
4008 free_debug_section (i);
4009
cc86f28f 4010 if (debug_information != NULL)
19e6b90e 4011 {
cc86f28f 4012 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
19e6b90e 4013 {
cc86f28f 4014 for (i = 0; i < num_debug_info_entries; i++)
19e6b90e 4015 {
cc86f28f
NC		 4016 if (!debug_information [i].max_loc_offsets)
4017 {
4018 free (debug_information [i].loc_offsets);
4019 free (debug_information [i].have_frame_base);
4020 }
4021 if (!debug_information [i].max_range_lists)
4022 free (debug_information [i].range_lists);
19e6b90e 4023 }
19e6b90e 4024 }
cc86f28f 4025
19e6b90e
L		 4026 free (debug_information);
4027 debug_information = NULL;
4028 num_debug_info_entries = 0;
4029 }
19e6b90e
L		 4030}
4031
4032struct dwarf_section_display debug_displays[] =
4033{
4034 { { ".debug_abbrev", NULL, 0, 0 },
4035 display_debug_abbrev, 0, 0 },
4036 { { ".debug_aranges", NULL, 0, 0 },
4037 display_debug_aranges, 0, 0 },
4038 { { ".debug_frame", NULL, 0, 0 },
4039 display_debug_frames, 1, 0 },
4040 { { ".debug_info", NULL, 0, 0 },
4041 display_debug_info, 1, 0 },
4042 { { ".debug_line", NULL, 0, 0 },
4043 display_debug_lines, 0, 0 },
4044 { { ".debug_pubnames", NULL, 0, 0 },
4045 display_debug_pubnames, 0, 0 },
4046 { { ".eh_frame", NULL, 0, 0 },
4047 display_debug_frames, 1, 1 },
4048 { { ".debug_macinfo", NULL, 0, 0 },
4049 display_debug_macinfo, 0, 0 },
4050 { { ".debug_str", NULL, 0, 0 },
4051 display_debug_str, 0, 0 },
4052 { { ".debug_loc", NULL, 0, 0 },
4053 display_debug_loc, 0, 0 },
4054 { { ".debug_pubtypes", NULL, 0, 0 },
4055 display_debug_pubnames, 0, 0 },
4056 { { ".debug_ranges", NULL, 0, 0 },
4057 display_debug_ranges, 0, 0 },
4058 { { ".debug_static_func", NULL, 0, 0 },
4059 display_debug_not_supported, 0, 0 },
4060 { { ".debug_static_vars", NULL, 0, 0 },
4061 display_debug_not_supported, 0, 0 },
4062 { { ".debug_types", NULL, 0, 0 },
4063 display_debug_not_supported, 0, 0 },
4064 { { ".debug_weaknames", NULL, 0, 0 },
4065 display_debug_not_supported, 0, 0 }
4066};
GDB Binutils - Deliverables
This page took 0.2753 seconds and 4 git commands to generate.