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