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