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