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