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