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