projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2011-10-24 Pedro Alves <pedro@codesourcery.com>
[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;
19e6b90e
L		 1602 /* MIPS extension. */
1603 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
1604 /* UPC extension. */
1605 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
1606 default:
4b78141a 1607 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
9cf03b7e 1608 printf (_("(implementation defined: %s)"),
467c65bc 1609 dwarf_vmatoa ("x", uvalue));
4b78141a 1610 else
9cf03b7e 1611 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
19e6b90e
L		 1612 break;
1613 }
1614 break;
1615
1616 case DW_AT_encoding:
1617 switch (uvalue)
1618 {
1619 case DW_ATE_void: printf ("(void)"); break;
1620 case DW_ATE_address: printf ("(machine address)"); break;
1621 case DW_ATE_boolean: printf ("(boolean)"); break;
1622 case DW_ATE_complex_float: printf ("(complex float)"); break;
1623 case DW_ATE_float: printf ("(float)"); break;
1624 case DW_ATE_signed: printf ("(signed)"); break;
1625 case DW_ATE_signed_char: printf ("(signed char)"); break;
1626 case DW_ATE_unsigned: printf ("(unsigned)"); break;
1627 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
e2a0d921 1628 /* DWARF 2.1 values: */
19e6b90e
L		 1629 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
1630 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
e2a0d921
NC		 1631 /* DWARF 3 values: */
1632 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
1633 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
1634 case DW_ATE_edited: printf ("(edited)"); break;
1635 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
1636 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
1637 /* HP extensions: */
1638 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
1639 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
1640 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
1641 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
1642 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
1643 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
1644 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
1645
19e6b90e
L		 1646 default:
1647 if (uvalue >= DW_ATE_lo_user
1648 && uvalue <= DW_ATE_hi_user)
9cf03b7e 1649 printf (_("(user defined type)"));
19e6b90e 1650 else
9cf03b7e 1651 printf (_("(unknown type)"));
19e6b90e
L		 1652 break;
1653 }
1654 break;
1655
1656 case DW_AT_accessibility:
1657 switch (uvalue)
1658 {
1659 case DW_ACCESS_public: printf ("(public)"); break;
1660 case DW_ACCESS_protected: printf ("(protected)"); break;
1661 case DW_ACCESS_private: printf ("(private)"); break;
1662 default:
9cf03b7e 1663 printf (_("(unknown accessibility)"));
19e6b90e
L		 1664 break;
1665 }
1666 break;
1667
1668 case DW_AT_visibility:
1669 switch (uvalue)
1670 {
1671 case DW_VIS_local: printf ("(local)"); break;
1672 case DW_VIS_exported: printf ("(exported)"); break;
1673 case DW_VIS_qualified: printf ("(qualified)"); break;
9cf03b7e 1674 default: printf (_("(unknown visibility)")); break;
19e6b90e
L		 1675 }
1676 break;
1677
1678 case DW_AT_virtuality:
1679 switch (uvalue)
1680 {
1681 case DW_VIRTUALITY_none: printf ("(none)"); break;
1682 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
1683 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
9cf03b7e 1684 default: printf (_("(unknown virtuality)")); break;
19e6b90e
L		 1685 }
1686 break;
1687
1688 case DW_AT_identifier_case:
1689 switch (uvalue)
1690 {
1691 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
1692 case DW_ID_up_case: printf ("(up_case)"); break;
1693 case DW_ID_down_case: printf ("(down_case)"); break;
1694 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
9cf03b7e 1695 default: printf (_("(unknown case)")); break;
19e6b90e
L		 1696 }
1697 break;
1698
1699 case DW_AT_calling_convention:
1700 switch (uvalue)
1701 {
1702 case DW_CC_normal: printf ("(normal)"); break;
1703 case DW_CC_program: printf ("(program)"); break;
1704 case DW_CC_nocall: printf ("(nocall)"); break;
1705 default:
1706 if (uvalue >= DW_CC_lo_user
1707 && uvalue <= DW_CC_hi_user)
9cf03b7e 1708 printf (_("(user defined)"));
19e6b90e 1709 else
9cf03b7e 1710 printf (_("(unknown convention)"));
19e6b90e
L		 1711 }
1712 break;
1713
1714 case DW_AT_ordering:
1715 switch (uvalue)
1716 {
9cf03b7e 1717 case -1: printf (_("(undefined)")); break;
19e6b90e
L		 1718 case 0: printf ("(row major)"); break;
1719 case 1: printf ("(column major)"); break;
1720 }
1721 break;
1722
1723 case DW_AT_frame_base:
1724 have_frame_base = 1;
1725 case DW_AT_location:
e2a0d921
NC		 1726 case DW_AT_string_length:
1727 case DW_AT_return_addr:
19e6b90e
L		 1728 case DW_AT_data_member_location:
1729 case DW_AT_vtable_elem_location:
e2a0d921
NC		 1730 case DW_AT_segment:
1731 case DW_AT_static_link:
1732 case DW_AT_use_location:
629e7ca8
JJ		 1733 case DW_AT_GNU_call_site_value:
1734 case DW_AT_GNU_call_site_data_value:
1735 case DW_AT_GNU_call_site_target:
1736 case DW_AT_GNU_call_site_target_clobbered:
212b6063
JK		 1737 if ((dwarf_version < 4
1738 && (form == DW_FORM_data4 || form == DW_FORM_data8))
932fd279 1739 || form == DW_FORM_sec_offset)
e2a0d921
NC		 1740 printf (_("(location list)"));
1741 /* Fall through. */
19e6b90e
L		 1742 case DW_AT_allocated:
1743 case DW_AT_associated:
1744 case DW_AT_data_location:
1745 case DW_AT_stride:
1746 case DW_AT_upper_bound:
cecf136e 1747 case DW_AT_lower_bound:
19e6b90e
L		 1748 if (block_start)
1749 {
1750 int need_frame_base;
1751
1752 printf ("(");
1753 need_frame_base = decode_location_expression (block_start,
1754 pointer_size,
b7807392
JJ		 1755 offset_size,
1756 dwarf_version,
19e6b90e 1757 uvalue,
f1c4cc75 1758 cu_offset, section);
19e6b90e
L		 1759 printf (")");
1760 if (need_frame_base && !have_frame_base)
1761 printf (_(" [without DW_AT_frame_base]"));
1762 }
19e6b90e
L		 1763 break;
1764
ec4d4525
NC		 1765 case DW_AT_import:
1766 {
2b6f5997
CC		 1767 if (form == DW_FORM_ref_sig8)
1768 break;
1769
ec4d4525
NC		 1770 if (form == DW_FORM_ref1
1771 || form == DW_FORM_ref2
1772 || form == DW_FORM_ref4)
1773 uvalue += cu_offset;
1774
6e3d6dc1 1775 if (uvalue >= section->size)
47704ddf
KT		 1776 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
1777 dwarf_vmatoa ("x", uvalue),
1778 (unsigned long) (orig_data - section->start));
6e3d6dc1
NC		 1779 else
1780 {
1781 unsigned long abbrev_number;
1782 abbrev_entry * entry;
1783
1784 abbrev_number = read_leb128 (section->start + uvalue, NULL, 0);
cecf136e 1785
9cf03b7e 1786 printf (_("[Abbrev Number: %ld"), abbrev_number);
6e3d6dc1
NC		 1787 for (entry = first_abbrev; entry != NULL; entry = entry->next)
1788 if (entry->entry == abbrev_number)
1789 break;
1790 if (entry != NULL)
1791 printf (" (%s)", get_TAG_name (entry->tag));
1792 printf ("]");
1793 }
ec4d4525
NC		 1794 }
1795 break;
1796
19e6b90e
L		 1797 default:
1798 break;
1799 }
1800
1801 return data;
1802}
1803
1804static char *
1805get_AT_name (unsigned long attribute)
1806{
1807 switch (attribute)
1808 {
1809 case DW_AT_sibling: return "DW_AT_sibling";
1810 case DW_AT_location: return "DW_AT_location";
1811 case DW_AT_name: return "DW_AT_name";
1812 case DW_AT_ordering: return "DW_AT_ordering";
1813 case DW_AT_subscr_data: return "DW_AT_subscr_data";
1814 case DW_AT_byte_size: return "DW_AT_byte_size";
1815 case DW_AT_bit_offset: return "DW_AT_bit_offset";
1816 case DW_AT_bit_size: return "DW_AT_bit_size";
1817 case DW_AT_element_list: return "DW_AT_element_list";
1818 case DW_AT_stmt_list: return "DW_AT_stmt_list";
1819 case DW_AT_low_pc: return "DW_AT_low_pc";
1820 case DW_AT_high_pc: return "DW_AT_high_pc";
1821 case DW_AT_language: return "DW_AT_language";
1822 case DW_AT_member: return "DW_AT_member";
1823 case DW_AT_discr: return "DW_AT_discr";
1824 case DW_AT_discr_value: return "DW_AT_discr_value";
1825 case DW_AT_visibility: return "DW_AT_visibility";
1826 case DW_AT_import: return "DW_AT_import";
1827 case DW_AT_string_length: return "DW_AT_string_length";
1828 case DW_AT_common_reference: return "DW_AT_common_reference";
1829 case DW_AT_comp_dir: return "DW_AT_comp_dir";
1830 case DW_AT_const_value: return "DW_AT_const_value";
1831 case DW_AT_containing_type: return "DW_AT_containing_type";
1832 case DW_AT_default_value: return "DW_AT_default_value";
1833 case DW_AT_inline: return "DW_AT_inline";
1834 case DW_AT_is_optional: return "DW_AT_is_optional";
1835 case DW_AT_lower_bound: return "DW_AT_lower_bound";
1836 case DW_AT_producer: return "DW_AT_producer";
1837 case DW_AT_prototyped: return "DW_AT_prototyped";
1838 case DW_AT_return_addr: return "DW_AT_return_addr";
1839 case DW_AT_start_scope: return "DW_AT_start_scope";
1840 case DW_AT_stride_size: return "DW_AT_stride_size";
1841 case DW_AT_upper_bound: return "DW_AT_upper_bound";
1842 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
1843 case DW_AT_accessibility: return "DW_AT_accessibility";
1844 case DW_AT_address_class: return "DW_AT_address_class";
1845 case DW_AT_artificial: return "DW_AT_artificial";
1846 case DW_AT_base_types: return "DW_AT_base_types";
1847 case DW_AT_calling_convention: return "DW_AT_calling_convention";
1848 case DW_AT_count: return "DW_AT_count";
1849 case DW_AT_data_member_location: return "DW_AT_data_member_location";
1850 case DW_AT_decl_column: return "DW_AT_decl_column";
1851 case DW_AT_decl_file: return "DW_AT_decl_file";
1852 case DW_AT_decl_line: return "DW_AT_decl_line";
1853 case DW_AT_declaration: return "DW_AT_declaration";
1854 case DW_AT_discr_list: return "DW_AT_discr_list";
1855 case DW_AT_encoding: return "DW_AT_encoding";
1856 case DW_AT_external: return "DW_AT_external";
1857 case DW_AT_frame_base: return "DW_AT_frame_base";
1858 case DW_AT_friend: return "DW_AT_friend";
1859 case DW_AT_identifier_case: return "DW_AT_identifier_case";
1860 case DW_AT_macro_info: return "DW_AT_macro_info";
1861 case DW_AT_namelist_items: return "DW_AT_namelist_items";
1862 case DW_AT_priority: return "DW_AT_priority";
1863 case DW_AT_segment: return "DW_AT_segment";
1864 case DW_AT_specification: return "DW_AT_specification";
1865 case DW_AT_static_link: return "DW_AT_static_link";
1866 case DW_AT_type: return "DW_AT_type";
1867 case DW_AT_use_location: return "DW_AT_use_location";
1868 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
1869 case DW_AT_virtuality: return "DW_AT_virtuality";
1870 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
1871 /* DWARF 2.1 values. */
1872 case DW_AT_allocated: return "DW_AT_allocated";
1873 case DW_AT_associated: return "DW_AT_associated";
1874 case DW_AT_data_location: return "DW_AT_data_location";
1875 case DW_AT_stride: return "DW_AT_stride";
1876 case DW_AT_entry_pc: return "DW_AT_entry_pc";
1877 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
1878 case DW_AT_extension: return "DW_AT_extension";
1879 case DW_AT_ranges: return "DW_AT_ranges";
1880 case DW_AT_trampoline: return "DW_AT_trampoline";
1881 case DW_AT_call_column: return "DW_AT_call_column";
1882 case DW_AT_call_file: return "DW_AT_call_file";
1883 case DW_AT_call_line: return "DW_AT_call_line";
e2a0d921
NC		 1884 case DW_AT_description: return "DW_AT_description";
1885 case DW_AT_binary_scale: return "DW_AT_binary_scale";
1886 case DW_AT_decimal_scale: return "DW_AT_decimal_scale";
1887 case DW_AT_small: return "DW_AT_small";
1888 case DW_AT_decimal_sign: return "DW_AT_decimal_sign";
1889 case DW_AT_digit_count: return "DW_AT_digit_count";
1890 case DW_AT_picture_string: return "DW_AT_picture_string";
1891 case DW_AT_mutable: return "DW_AT_mutable";
1892 case DW_AT_threads_scaled: return "DW_AT_threads_scaled";
1893 case DW_AT_explicit: return "DW_AT_explicit";
1894 case DW_AT_object_pointer: return "DW_AT_object_pointer";
1895 case DW_AT_endianity: return "DW_AT_endianity";
1896 case DW_AT_elemental: return "DW_AT_elemental";
1897 case DW_AT_pure: return "DW_AT_pure";
1898 case DW_AT_recursive: return "DW_AT_recursive";
2b6f5997
CC		 1899 /* DWARF 4 values. */
1900 case DW_AT_signature: return "DW_AT_signature";
1901 case DW_AT_main_subprogram: return "DW_AT_main_subprogram";
1902 case DW_AT_data_bit_offset: return "DW_AT_data_bit_offset";
1903 case DW_AT_const_expr: return "DW_AT_const_expr";
1904 case DW_AT_enum_class: return "DW_AT_enum_class";
1905 case DW_AT_linkage_name: return "DW_AT_linkage_name";
e2a0d921
NC		 1906
1907 /* HP and SGI/MIPS extensions. */
1908 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
1909 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
1910 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
1911 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
1912 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
1913 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
1914 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
1915 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
1916 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
1917 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
1918
1919 /* HP Extensions. */
cecf136e 1920 case DW_AT_HP_block_index: return "DW_AT_HP_block_index";
e2a0d921
NC		 1921 case DW_AT_HP_actuals_stmt_list: return "DW_AT_HP_actuals_stmt_list";
1922 case DW_AT_HP_proc_per_section: return "DW_AT_HP_proc_per_section";
1923 case DW_AT_HP_raw_data_ptr: return "DW_AT_HP_raw_data_ptr";
1924 case DW_AT_HP_pass_by_reference: return "DW_AT_HP_pass_by_reference";
1925 case DW_AT_HP_opt_level: return "DW_AT_HP_opt_level";
1926 case DW_AT_HP_prof_version_id: return "DW_AT_HP_prof_version_id";
1927 case DW_AT_HP_opt_flags: return "DW_AT_HP_opt_flags";
1928 case DW_AT_HP_cold_region_low_pc: return "DW_AT_HP_cold_region_low_pc";
1929 case DW_AT_HP_cold_region_high_pc: return "DW_AT_HP_cold_region_high_pc";
1930 case DW_AT_HP_all_variables_modifiable: return "DW_AT_HP_all_variables_modifiable";
1931 case DW_AT_HP_linkage_name: return "DW_AT_HP_linkage_name";
1932 case DW_AT_HP_prof_flags: return "DW_AT_HP_prof_flags";
1933
1934 /* One value is shared by the MIPS and HP extensions: */
1935 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
cecf136e 1936
19e6b90e 1937 /* GNU extensions. */
2b6f5997
CC		 1938 case DW_AT_sf_names: return "DW_AT_sf_names";
1939 case DW_AT_src_info: return "DW_AT_src_info";
1940 case DW_AT_mac_info: return "DW_AT_mac_info";
1941 case DW_AT_src_coords: return "DW_AT_src_coords";
1942 case DW_AT_body_begin: return "DW_AT_body_begin";
1943 case DW_AT_body_end: return "DW_AT_body_end";
1944 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
1945 case DW_AT_GNU_guarded_by: return "DW_AT_GNU_guarded_by";
1946 case DW_AT_GNU_pt_guarded_by: return "DW_AT_GNU_pt_guarded_by";
1947 case DW_AT_GNU_guarded: return "DW_AT_GNU_guarded";
1948 case DW_AT_GNU_pt_guarded: return "DW_AT_GNU_pt_guarded";
1949 case DW_AT_GNU_locks_excluded: return "DW_AT_GNU_locks_excluded";
1950 case DW_AT_GNU_exclusive_locks_required: return "DW_AT_GNU_exclusive_locks_required";
1951 case DW_AT_GNU_shared_locks_required: return "DW_AT_GNU_shared_locks_required";
1952 case DW_AT_GNU_odr_signature: return "DW_AT_GNU_odr_signature";
60a0e0e7
TG		 1953 case DW_AT_use_GNAT_descriptive_type: return "DW_AT_use_GNAT_descriptive_type";
1954 case DW_AT_GNAT_descriptive_type: return "DW_AT_GNAT_descriptive_type";
629e7ca8
JJ		 1955 case DW_AT_GNU_call_site_value: return "DW_AT_GNU_call_site_value";
1956 case DW_AT_GNU_call_site_data_value: return "DW_AT_GNU_call_site_data_value";
1957 case DW_AT_GNU_call_site_target: return "DW_AT_GNU_call_site_target";
1958 case DW_AT_GNU_call_site_target_clobbered: return "DW_AT_GNU_call_site_target_clobbered";
1959 case DW_AT_GNU_tail_call: return "DW_AT_GNU_tail_call";
1960 case DW_AT_GNU_all_tail_call_sites: return "DW_AT_GNU_all_tail_call_sites";
1961 case DW_AT_GNU_all_call_sites: return "DW_AT_GNU_all_call_sites";
1962 case DW_AT_GNU_all_source_call_sites: return "DW_AT_GNU_all_source_call_sites";
4ccf1e31 1963 case DW_AT_GNU_macros: return "DW_AT_GNU_macros";
e2a0d921 1964
19e6b90e
L		 1965 /* UPC extension. */
1966 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
e2a0d921
NC		 1967
1968 /* PGI (STMicroelectronics) extensions. */
1969 case DW_AT_PGI_lbase: return "DW_AT_PGI_lbase";
1970 case DW_AT_PGI_soffset: return "DW_AT_PGI_soffset";
1971 case DW_AT_PGI_lstride: return "DW_AT_PGI_lstride";
1972
19e6b90e
L		 1973 default:
1974 {
1975 static char buffer[100];
1976
1977 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
1978 attribute);
1979 return buffer;
1980 }
1981 }
1982}
1983
1984static unsigned char *
6e3d6dc1
NC		 1985read_and_display_attr (unsigned long attribute,
1986 unsigned long form,
ec4d4525 1987 unsigned char * data,
467c65bc
NC		 1988 dwarf_vma cu_offset,
1989 dwarf_vma pointer_size,
1990 dwarf_vma offset_size,
6e3d6dc1
NC		 1991 int dwarf_version,
1992 debug_info * debug_info_p,
1993 int do_loc,
1994 struct dwarf_section * section)
19e6b90e
L		 1995{
1996 if (!do_loc)
750f03b7 1997 printf (" %-18s:", get_AT_name (attribute));
19e6b90e
L		 1998 data = read_and_display_attr_value (attribute, form, data, cu_offset,
1999 pointer_size, offset_size,
2000 dwarf_version, debug_info_p,
6e3d6dc1 2001 do_loc, section);
19e6b90e
L		 2002 if (!do_loc)
2003 printf ("\n");
2004 return data;
2005}
2006
2007
2008/* Process the contents of a .debug_info section. If do_loc is non-zero
2009 then we are scanning for location lists and we do not want to display
2b6f5997
CC		 2010 anything to the user. If do_types is non-zero, we are processing
2011 a .debug_types section instead of a .debug_info section. */
19e6b90e
L		 2012
2013static int
6e3d6dc1
NC		 2014process_debug_info (struct dwarf_section *section,
2015 void *file,
6f875884 2016 enum dwarf_section_display_enum abbrev_sec,
2b6f5997
CC		 2017 int do_loc,
2018 int do_types)
19e6b90e
L		 2019{
2020 unsigned char *start = section->start;
2021 unsigned char *end = start + section->size;
2022 unsigned char *section_begin;
2023 unsigned int unit;
2024 unsigned int num_units = 0;
2025
2026 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2027 && num_debug_info_entries == 0
2028 && ! do_types)
19e6b90e 2029 {
767221a9 2030 dwarf_vma length;
19e6b90e
L		 2031
2032 /* First scan the section to get the number of comp units. */
2033 for (section_begin = start, num_units = 0; section_begin < end;
2034 num_units ++)
2035 {
2036 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2037 will be the length. For a 64-bit DWARF section, it'll be
2038 the escape code 0xffffffff followed by an 8 byte length. */
2039 length = byte_get (section_begin, 4);
2040
2041 if (length == 0xffffffff)
2042 {
2043 length = byte_get (section_begin + 4, 8);
2044 section_begin += length + 12;
2045 }
ec4d4525
NC		 2046 else if (length >= 0xfffffff0 && length < 0xffffffff)
2047 {
767221a9
NC		 2048 warn (_("Reserved length value (0x%s) found in section %s\n"),
2049 dwarf_vmatoa ("x", length), section->name);
ec4d4525
NC		 2050 return 0;
2051 }
19e6b90e
L		 2052 else
2053 section_begin += length + 4;
aca88567
NC		 2054
2055 /* Negative values are illegal, they may even cause infinite
2056 looping. This can happen if we can't accurately apply
2057 relocations to an object file. */
2058 if ((signed long) length <= 0)
2059 {
767221a9
NC		 2060 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2061 dwarf_vmatoa ("x", length), section->name);
aca88567
NC		 2062 return 0;
2063 }
19e6b90e
L		 2064 }
2065
2066 if (num_units == 0)
2067 {
2068 error (_("No comp units in %s section ?"), section->name);
2069 return 0;
2070 }
2071
2072 /* Then allocate an array to hold the information. */
3f5e193b
NC		 2073 debug_information = (debug_info *) cmalloc (num_units,
2074 sizeof (* debug_information));
19e6b90e
L		 2075 if (debug_information == NULL)
2076 {
2077 error (_("Not enough memory for a debug info array of %u entries"),
2078 num_units);
2079 return 0;
2080 }
2081 }
2082
2083 if (!do_loc)
2084 {
fd2f0033
TT		 2085 if (dwarf_start_die == 0)
2086 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e
L		 2087
2088 load_debug_section (str, file);
2089 }
2090
6f875884
TG		 2091 load_debug_section (abbrev_sec, file);
2092 if (debug_displays [abbrev_sec].section.start == NULL)
19e6b90e
L		 2093 {
2094 warn (_("Unable to locate %s section!\n"),
6f875884 2095 debug_displays [abbrev_sec].section.name);
19e6b90e
L		 2096 return 0;
2097 }
2098
2099 for (section_begin = start, unit = 0; start < end; unit++)
2100 {
2101 DWARF2_Internal_CompUnit compunit;
2102 unsigned char *hdrptr;
19e6b90e 2103 unsigned char *tags;
fd2f0033 2104 int level, last_level, saved_level;
467c65bc 2105 dwarf_vma cu_offset;
19e6b90e
L		 2106 int offset_size;
2107 int initial_length_size;
1e70a64d 2108 unsigned char signature[8] = { 0 };
767221a9 2109 dwarf_vma type_offset = 0;
19e6b90e
L		 2110
2111 hdrptr = start;
2112
2113 compunit.cu_length = byte_get (hdrptr, 4);
2114 hdrptr += 4;
2115
2116 if (compunit.cu_length == 0xffffffff)
2117 {
2118 compunit.cu_length = byte_get (hdrptr, 8);
2119 hdrptr += 8;
2120 offset_size = 8;
2121 initial_length_size = 12;
2122 }
2123 else
2124 {
2125 offset_size = 4;
2126 initial_length_size = 4;
2127 }
2128
2129 compunit.cu_version = byte_get (hdrptr, 2);
2130 hdrptr += 2;
2131
2132 cu_offset = start - section_begin;
19e6b90e 2133
19e6b90e
L		 2134 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
2135 hdrptr += offset_size;
2136
2137 compunit.cu_pointer_size = byte_get (hdrptr, 1);
2138 hdrptr += 1;
2b6f5997
CC		 2139
2140 if (do_types)
2141 {
2142 int i;
2143
2144 for (i = 0; i < 8; i++)
2145 {
2146 signature[i] = byte_get (hdrptr, 1);
2147 hdrptr += 1;
2148 }
2149
2150 type_offset = byte_get (hdrptr, offset_size);
2151 hdrptr += offset_size;
2152 }
2153
19e6b90e 2154 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2155 && num_debug_info_entries == 0
2156 && ! do_types)
19e6b90e
L		 2157 {
2158 debug_information [unit].cu_offset = cu_offset;
2159 debug_information [unit].pointer_size
2160 = compunit.cu_pointer_size;
b7807392
JJ		 2161 debug_information [unit].offset_size = offset_size;
2162 debug_information [unit].dwarf_version = compunit.cu_version;
19e6b90e
L		 2163 debug_information [unit].base_address = 0;
2164 debug_information [unit].loc_offsets = NULL;
2165 debug_information [unit].have_frame_base = NULL;
2166 debug_information [unit].max_loc_offsets = 0;
2167 debug_information [unit].num_loc_offsets = 0;
2168 debug_information [unit].range_lists = NULL;
2169 debug_information [unit].max_range_lists= 0;
2170 debug_information [unit].num_range_lists = 0;
2171 }
2172
fd2f0033 2173 if (!do_loc && dwarf_start_die == 0)
19e6b90e 2174 {
47704ddf
KT		 2175 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2176 dwarf_vmatoa ("x", cu_offset));
2177 printf (_(" Length: 0x%s (%s)\n"),
2178 dwarf_vmatoa ("x", compunit.cu_length),
49e7b350 2179 offset_size == 8 ? "64-bit" : "32-bit");
19e6b90e 2180 printf (_(" Version: %d\n"), compunit.cu_version);
47704ddf
KT		 2181 printf (_(" Abbrev Offset: %s\n"),
2182 dwarf_vmatoa ("d", compunit.cu_abbrev_offset));
19e6b90e 2183 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2b6f5997
CC		 2184 if (do_types)
2185 {
2186 int i;
2187 printf (_(" Signature: "));
2188 for (i = 0; i < 8; i++)
2189 printf ("%02x", signature[i]);
2190 printf ("\n");
767221a9
NC		 2191 printf (_(" Type Offset: 0x%s\n"),
2192 dwarf_vmatoa ("x", type_offset));
2b6f5997 2193 }
19e6b90e
L		 2194 }
2195
460c89ff
NS		 2196 if (cu_offset + compunit.cu_length + initial_length_size
2197 > section->size)
2198 {
47704ddf
KT		 2199 warn (_("Debug info is corrupted, length of CU at %s"
2200 " extends beyond end of section (length = %s)\n"),
2201 dwarf_vmatoa ("x", cu_offset),
2202 dwarf_vmatoa ("x", compunit.cu_length));
460c89ff
NS		 2203 break;
2204 }
2205 tags = hdrptr;
2206 start += compunit.cu_length + initial_length_size;
2207
932fd279
JJ		 2208 if (compunit.cu_version != 2
2209 && compunit.cu_version != 3
2210 && compunit.cu_version != 4)
19e6b90e 2211 {
47704ddf
KT		 2212 warn (_("CU at offset %s contains corrupt or "
2213 "unsupported version number: %d.\n"),
2214 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
19e6b90e
L		 2215 continue;
2216 }
2217
2218 free_abbrevs ();
2219
bfe2612a
L		 2220 /* Process the abbrevs used by this compilation unit. DWARF
2221 sections under Mach-O have non-zero addresses. */
6f875884 2222 if (compunit.cu_abbrev_offset >= debug_displays [abbrev_sec].section.size)
ec4d4525
NC		 2223 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2224 (unsigned long) compunit.cu_abbrev_offset,
6f875884 2225 (unsigned long) debug_displays [abbrev_sec].section.size);
460c89ff
NS		 2226 else
2227 process_abbrev_section
6f875884 2228 ((unsigned char *) debug_displays [abbrev_sec].section.start
0ac6fba0 2229 + compunit.cu_abbrev_offset,
6f875884
TG		 2230 (unsigned char *) debug_displays [abbrev_sec].section.start
2231 + debug_displays [abbrev_sec].section.size);
19e6b90e
L		 2232
2233 level = 0;
fd2f0033
TT		 2234 last_level = level;
2235 saved_level = -1;
19e6b90e
L		 2236 while (tags < start)
2237 {
2238 unsigned int bytes_read;
2239 unsigned long abbrev_number;
ec4d4525 2240 unsigned long die_offset;
19e6b90e
L		 2241 abbrev_entry *entry;
2242 abbrev_attr *attr;
fd2f0033 2243 int do_printing = 1;
19e6b90e 2244
ec4d4525
NC		 2245 die_offset = tags - section_begin;
2246
19e6b90e
L		 2247 abbrev_number = read_leb128 (tags, & bytes_read, 0);
2248 tags += bytes_read;
2249
eb7cc021
JK		 2250 /* A null DIE marks the end of a list of siblings or it may also be
2251 a section padding. */
19e6b90e
L		 2252 if (abbrev_number == 0)
2253 {
eb7cc021
JK		 2254 /* Check if it can be a section padding for the last CU. */
2255 if (level == 0 && start == end)
2256 {
2257 unsigned char *chk;
2258
2259 for (chk = tags; chk < start; chk++)
2260 if (*chk != 0)
2261 break;
2262 if (chk == start)
2263 break;
2264 }
2265
19e6b90e 2266 --level;
ec4d4525
NC		 2267 if (level < 0)
2268 {
2269 static unsigned num_bogus_warns = 0;
2270
2271 if (num_bogus_warns < 3)
2272 {
2273 warn (_("Bogus end-of-siblings marker detected at offset %lx in .debug_info section\n"),
2274 die_offset);
2275 num_bogus_warns ++;
2276 if (num_bogus_warns == 3)
2277 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2278 }
2279 }
fd2f0033
TT		 2280 if (dwarf_start_die != 0 && level < saved_level)
2281 return 1;
19e6b90e
L		 2282 continue;
2283 }
2284
4b78141a 2285 if (!do_loc)
fd2f0033
TT		 2286 {
2287 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2288 do_printing = 0;
2289 else
2290 {
2291 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2292 saved_level = level;
2293 do_printing = (dwarf_cutoff_level == -1
2294 || level < dwarf_cutoff_level);
2295 if (do_printing)
2296 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2297 level, die_offset, abbrev_number);
2298 else if (dwarf_cutoff_level == -1
2299 || last_level < dwarf_cutoff_level)
2300 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2301 last_level = level;
2302 }
2303 }
cecf136e 2304
19e6b90e
L		 2305 /* Scan through the abbreviation list until we reach the
2306 correct entry. */
2307 for (entry = first_abbrev;
2308 entry && entry->entry != abbrev_number;
2309 entry = entry->next)
2310 continue;
2311
2312 if (entry == NULL)
2313 {
fd2f0033 2314 if (!do_loc && do_printing)
4b78141a
NC		 2315 {
2316 printf ("\n");
2317 fflush (stdout);
2318 }
cc86f28f
NC		 2319 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2320 die_offset, abbrev_number);
19e6b90e
L		 2321 return 0;
2322 }
2323
fd2f0033 2324 if (!do_loc && do_printing)
cc5914eb 2325 printf (" (%s)\n", get_TAG_name (entry->tag));
cecf136e 2326
19e6b90e
L		 2327 switch (entry->tag)
2328 {
2329 default:
2330 need_base_address = 0;
2331 break;
2332 case DW_TAG_compile_unit:
2333 need_base_address = 1;
2334 break;
2335 case DW_TAG_entry_point:
19e6b90e
L		 2336 case DW_TAG_subprogram:
2337 need_base_address = 0;
2338 /* Assuming that there is no DW_AT_frame_base. */
2339 have_frame_base = 0;
2340 break;
2341 }
2342
2343 for (attr = entry->first_attr; attr; attr = attr->next)
4b78141a 2344 {
fd2f0033
TT		 2345 debug_info *arg;
2346
2347 if (! do_loc && do_printing)
4b78141a 2348 /* Show the offset from where the tag was extracted. */
fd2f0033
TT		 2349 printf (" <%lx>", (unsigned long)(tags - section_begin));
2350
2351 arg = debug_information;
2352 if (debug_information)
2353 arg += unit;
4b78141a
NC		 2354
2355 tags = read_and_display_attr (attr->attribute,
2356 attr->form,
2357 tags, cu_offset,
2358 compunit.cu_pointer_size,
2359 offset_size,
2360 compunit.cu_version,
fd2f0033
TT		 2361 arg,
2362 do_loc || ! do_printing, section);
4b78141a 2363 }
cecf136e 2364
19e6b90e
L		 2365 if (entry->children)
2366 ++level;
2367 }
2368 }
cecf136e 2369
19e6b90e
L		 2370 /* Set num_debug_info_entries here so that it can be used to check if
2371 we need to process .debug_loc and .debug_ranges sections. */
2372 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2373 && num_debug_info_entries == 0
2374 && ! do_types)
19e6b90e 2375 num_debug_info_entries = num_units;
cecf136e 2376
19e6b90e 2377 if (!do_loc)
467c65bc 2378 printf ("\n");
cecf136e 2379
19e6b90e
L		 2380 return 1;
2381}
2382
2383/* Locate and scan the .debug_info section in the file and record the pointer
2384 sizes and offsets for the compilation units in it. Usually an executable
2385 will have just one pointer size, but this is not guaranteed, and so we try
2386 not to make any assumptions. Returns zero upon failure, or the number of
2387 compilation units upon success. */
2388
2389static unsigned int
2390load_debug_info (void * file)
2391{
2392 /* Reset the last pointer size so that we can issue correct error
2393 messages if we are displaying the contents of more than one section. */
2394 last_pointer_size = 0;
2395 warned_about_missing_comp_units = FALSE;
2396
1febe64d
NC		 2397 /* If we have already tried and failed to load the .debug_info
2398 section then do not bother to repear the task. */
cc86f28f 2399 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
1febe64d
NC		 2400 return 0;
2401
19e6b90e
L		 2402 /* If we already have the information there is nothing else to do. */
2403 if (num_debug_info_entries > 0)
2404 return num_debug_info_entries;
2405
2406 if (load_debug_section (info, file)
6f875884 2407 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
19e6b90e 2408 return num_debug_info_entries;
1febe64d 2409
cc86f28f 2410 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
1febe64d 2411 return 0;
19e6b90e
L		 2412}
2413
19e6b90e 2414static int
a262ae96
NC		 2415display_debug_lines_raw (struct dwarf_section *section,
2416 unsigned char *data,
2417 unsigned char *end)
19e6b90e
L		 2418{
2419 unsigned char *start = section->start;
19e6b90e 2420
a262ae96
NC		 2421 printf (_("Raw dump of debug contents of section %s:\n\n"),
2422 section->name);
19e6b90e
L		 2423
2424 while (data < end)
2425 {
91d6fa6a 2426 DWARF2_Internal_LineInfo linfo;
19e6b90e
L		 2427 unsigned char *standard_opcodes;
2428 unsigned char *end_of_sequence;
2429 unsigned char *hdrptr;
6523721c 2430 unsigned long hdroff;
19e6b90e
L		 2431 int initial_length_size;
2432 int offset_size;
2433 int i;
2434
2435 hdrptr = data;
6523721c 2436 hdroff = hdrptr - start;
19e6b90e
L		 2437
2438 /* Check the length of the block. */
91d6fa6a 2439 linfo.li_length = byte_get (hdrptr, 4);
19e6b90e
L		 2440 hdrptr += 4;
2441
91d6fa6a 2442 if (linfo.li_length == 0xffffffff)
19e6b90e
L		 2443 {
2444 /* This section is 64-bit DWARF 3. */
91d6fa6a 2445 linfo.li_length = byte_get (hdrptr, 8);
19e6b90e
L		 2446 hdrptr += 8;
2447 offset_size = 8;
2448 initial_length_size = 12;
2449 }
2450 else
2451 {
2452 offset_size = 4;
2453 initial_length_size = 4;
2454 }
2455
91d6fa6a 2456 if (linfo.li_length + initial_length_size > section->size)
19e6b90e
L		 2457 {
2458 warn
cf13d699
NC		 2459 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2460 section->name);
19e6b90e
L		 2461 return 0;
2462 }
2463
2464 /* Check its version number. */
91d6fa6a 2465 linfo.li_version = byte_get (hdrptr, 2);
19e6b90e 2466 hdrptr += 2;
932fd279
JJ		 2467 if (linfo.li_version != 2
2468 && linfo.li_version != 3
2469 && linfo.li_version != 4)
19e6b90e 2470 {
932fd279 2471 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
19e6b90e
L		 2472 return 0;
2473 }
2474
91d6fa6a 2475 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
19e6b90e 2476 hdrptr += offset_size;
91d6fa6a 2477 linfo.li_min_insn_length = byte_get (hdrptr, 1);
19e6b90e 2478 hdrptr++;
a233b20c
JJ		 2479 if (linfo.li_version >= 4)
2480 {
2481 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2482 hdrptr++;
2483 if (linfo.li_max_ops_per_insn == 0)
2484 {
2485 warn (_("Invalid maximum operations per insn.\n"));
2486 return 0;
2487 }
2488 }
2489 else
2490 linfo.li_max_ops_per_insn = 1;
91d6fa6a 2491 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
19e6b90e 2492 hdrptr++;
91d6fa6a 2493 linfo.li_line_base = byte_get (hdrptr, 1);
19e6b90e 2494 hdrptr++;
91d6fa6a 2495 linfo.li_line_range = byte_get (hdrptr, 1);
19e6b90e 2496 hdrptr++;
91d6fa6a 2497 linfo.li_opcode_base = byte_get (hdrptr, 1);
19e6b90e
L		 2498 hdrptr++;
2499
2500 /* Sign extend the line base field. */
91d6fa6a
NC		 2501 linfo.li_line_base <<= 24;
2502 linfo.li_line_base >>= 24;
19e6b90e 2503
6523721c 2504 printf (_(" Offset: 0x%lx\n"), hdroff);
47704ddf 2505 printf (_(" Length: %ld\n"), (long) linfo.li_length);
91d6fa6a
NC		 2506 printf (_(" DWARF Version: %d\n"), linfo.li_version);
2507 printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length);
2508 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
a233b20c
JJ		 2509 if (linfo.li_version >= 4)
2510 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
91d6fa6a
NC		 2511 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2512 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2513 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2514 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
19e6b90e 2515
91d6fa6a 2516 end_of_sequence = data + linfo.li_length + initial_length_size;
19e6b90e 2517
91d6fa6a 2518 reset_state_machine (linfo.li_default_is_stmt);
19e6b90e
L		 2519
2520 /* Display the contents of the Opcodes table. */
2521 standard_opcodes = hdrptr;
2522
2523 printf (_("\n Opcodes:\n"));
2524
91d6fa6a 2525 for (i = 1; i < linfo.li_opcode_base; i++)
19e6b90e
L		 2526 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
2527
2528 /* Display the contents of the Directory table. */
91d6fa6a 2529 data = standard_opcodes + linfo.li_opcode_base - 1;
19e6b90e
L		 2530
2531 if (*data == 0)
2532 printf (_("\n The Directory Table is empty.\n"));
2533 else
2534 {
2535 printf (_("\n The Directory Table:\n"));
2536
2537 while (*data != 0)
2538 {
cc5914eb 2539 printf (" %s\n", data);
19e6b90e
L		 2540
2541 data += strlen ((char *) data) + 1;
2542 }
2543 }
2544
2545 /* Skip the NUL at the end of the table. */
2546 data++;
2547
2548 /* Display the contents of the File Name table. */
2549 if (*data == 0)
2550 printf (_("\n The File Name Table is empty.\n"));
2551 else
2552 {
2553 printf (_("\n The File Name Table:\n"));
2554 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2555
2556 while (*data != 0)
2557 {
2558 unsigned char *name;
2559 unsigned int bytes_read;
2560
cc5914eb 2561 printf (" %d\t", ++state_machine_regs.last_file_entry);
19e6b90e
L		 2562 name = data;
2563
2564 data += strlen ((char *) data) + 1;
2565
467c65bc
NC		 2566 printf ("%s\t",
2567 dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0)));
19e6b90e 2568 data += bytes_read;
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;
cc5914eb 2575 printf ("%s\n", name);
19e6b90e
L		 2576 }
2577 }
2578
2579 /* Skip the NUL at the end of the table. */
2580 data++;
2581
2582 /* Now display the statements. */
2583 printf (_("\n Line Number Statements:\n"));
2584
2585 while (data < end_of_sequence)
2586 {
2587 unsigned char op_code;
467c65bc
NC		 2588 dwarf_signed_vma adv;
2589 dwarf_vma uladv;
19e6b90e
L		 2590 unsigned int bytes_read;
2591
2592 op_code = *data++;
2593
91d6fa6a 2594 if (op_code >= linfo.li_opcode_base)
19e6b90e 2595 {
91d6fa6a 2596 op_code -= linfo.li_opcode_base;
a233b20c
JJ		 2597 uladv = (op_code / linfo.li_line_range);
2598 if (linfo.li_max_ops_per_insn == 1)
2599 {
2600 uladv *= linfo.li_min_insn_length;
2601 state_machine_regs.address += uladv;
467c65bc
NC		 2602 printf (_(" Special opcode %d: "
2603 "advance Address by %s to 0x%s"),
2604 op_code, dwarf_vmatoa ("u", uladv),
2605 dwarf_vmatoa ("x", state_machine_regs.address));
a233b20c
JJ		 2606 }
2607 else
2608 {
2609 state_machine_regs.address
2610 += ((state_machine_regs.op_index + uladv)
2611 / linfo.li_max_ops_per_insn)
2612 * linfo.li_min_insn_length;
2613 state_machine_regs.op_index
2614 = (state_machine_regs.op_index + uladv)
2615 % linfo.li_max_ops_per_insn;
467c65bc
NC		 2616 printf (_(" Special opcode %d: "
2617 "advance Address by %s to 0x%s[%d]"),
2618 op_code, dwarf_vmatoa ("u", uladv),
2619 dwarf_vmatoa ("x", state_machine_regs.address),
a233b20c
JJ		 2620 state_machine_regs.op_index);
2621 }
91d6fa6a 2622 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
19e6b90e 2623 state_machine_regs.line += adv;
467c65bc
NC		 2624 printf (_(" and Line by %s to %d\n"),
2625 dwarf_vmatoa ("d", adv), state_machine_regs.line);
19e6b90e
L		 2626 }
2627 else switch (op_code)
2628 {
2629 case DW_LNS_extended_op:
91d6fa6a 2630 data += process_extended_line_op (data, linfo.li_default_is_stmt);
19e6b90e
L		 2631 break;
2632
2633 case DW_LNS_copy:
2634 printf (_(" Copy\n"));
2635 break;
2636
2637 case DW_LNS_advance_pc:
2638 uladv = read_leb128 (data, & bytes_read, 0);
19e6b90e 2639 data += bytes_read;
a233b20c
JJ		 2640 if (linfo.li_max_ops_per_insn == 1)
2641 {
2642 uladv *= linfo.li_min_insn_length;
2643 state_machine_regs.address += uladv;
467c65bc
NC		 2644 printf (_(" Advance PC by %s to 0x%s\n"),
2645 dwarf_vmatoa ("u", uladv),
2646 dwarf_vmatoa ("x", state_machine_regs.address));
a233b20c
JJ		 2647 }
2648 else
2649 {
2650 state_machine_regs.address
2651 += ((state_machine_regs.op_index + uladv)
2652 / linfo.li_max_ops_per_insn)
2653 * linfo.li_min_insn_length;
2654 state_machine_regs.op_index
2655 = (state_machine_regs.op_index + uladv)
2656 % linfo.li_max_ops_per_insn;
467c65bc
NC		 2657 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2658 dwarf_vmatoa ("u", uladv),
2659 dwarf_vmatoa ("x", state_machine_regs.address),
a233b20c
JJ		 2660 state_machine_regs.op_index);
2661 }
19e6b90e
L		 2662 break;
2663
2664 case DW_LNS_advance_line:
467c65bc 2665 adv = read_sleb128 (data, & bytes_read);
19e6b90e
L		 2666 data += bytes_read;
2667 state_machine_regs.line += adv;
467c65bc
NC		 2668 printf (_(" Advance Line by %s to %d\n"),
2669 dwarf_vmatoa ("d", adv),
2670 state_machine_regs.line);
19e6b90e
L		 2671 break;
2672
2673 case DW_LNS_set_file:
2674 adv = read_leb128 (data, & bytes_read, 0);
2675 data += bytes_read;
467c65bc
NC		 2676 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2677 dwarf_vmatoa ("d", adv));
19e6b90e
L		 2678 state_machine_regs.file = adv;
2679 break;
2680
2681 case DW_LNS_set_column:
2682 uladv = read_leb128 (data, & bytes_read, 0);
2683 data += bytes_read;
467c65bc
NC		 2684 printf (_(" Set column to %s\n"),
2685 dwarf_vmatoa ("u", uladv));
19e6b90e
L		 2686 state_machine_regs.column = uladv;
2687 break;
2688
2689 case DW_LNS_negate_stmt:
2690 adv = state_machine_regs.is_stmt;
2691 adv = ! adv;
467c65bc 2692 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
19e6b90e
L		 2693 state_machine_regs.is_stmt = adv;
2694 break;
2695
2696 case DW_LNS_set_basic_block:
2697 printf (_(" Set basic block\n"));
2698 state_machine_regs.basic_block = 1;
2699 break;
2700
2701 case DW_LNS_const_add_pc:
a233b20c
JJ		 2702 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
2703 if (linfo.li_max_ops_per_insn)
2704 {
2705 uladv *= linfo.li_min_insn_length;
2706 state_machine_regs.address += uladv;
467c65bc
NC		 2707 printf (_(" Advance PC by constant %s to 0x%s\n"),
2708 dwarf_vmatoa ("u", uladv),
2709 dwarf_vmatoa ("x", state_machine_regs.address));
a233b20c
JJ		 2710 }
2711 else
2712 {
2713 state_machine_regs.address
2714 += ((state_machine_regs.op_index + uladv)
2715 / linfo.li_max_ops_per_insn)
2716 * linfo.li_min_insn_length;
2717 state_machine_regs.op_index
2718 = (state_machine_regs.op_index + uladv)
2719 % linfo.li_max_ops_per_insn;
467c65bc
NC		 2720 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2721 dwarf_vmatoa ("u", uladv),
2722 dwarf_vmatoa ("x", state_machine_regs.address),
a233b20c
JJ		 2723 state_machine_regs.op_index);
2724 }
19e6b90e
L		 2725 break;
2726
2727 case DW_LNS_fixed_advance_pc:
2728 uladv = byte_get (data, 2);
2729 data += 2;
2730 state_machine_regs.address += uladv;
a233b20c 2731 state_machine_regs.op_index = 0;
467c65bc
NC		 2732 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2733 dwarf_vmatoa ("u", uladv),
2734 dwarf_vmatoa ("x", state_machine_regs.address));
19e6b90e
L		 2735 break;
2736
2737 case DW_LNS_set_prologue_end:
2738 printf (_(" Set prologue_end to true\n"));
2739 break;
2740
2741 case DW_LNS_set_epilogue_begin:
2742 printf (_(" Set epilogue_begin to true\n"));
2743 break;
2744
2745 case DW_LNS_set_isa:
2746 uladv = read_leb128 (data, & bytes_read, 0);
2747 data += bytes_read;
467c65bc 2748 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
19e6b90e
L		 2749 break;
2750
2751 default:
2752 printf (_(" Unknown opcode %d with operands: "), op_code);
2753
2754 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
2755 {
467c65bc
NC		 2756 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
2757 &bytes_read, 0)),
19e6b90e
L		 2758 i == 1 ? "" : ", ");
2759 data += bytes_read;
2760 }
2761 putchar ('\n');
2762 break;
2763 }
2764 }
2765 putchar ('\n');
2766 }
2767
2768 return 1;
2769}
2770
a262ae96
NC		 2771typedef struct
2772{
467c65bc
NC		 2773 unsigned char *name;
2774 unsigned int directory_index;
2775 unsigned int modification_date;
2776 unsigned int length;
a262ae96
NC		 2777} File_Entry;
2778
2779/* Output a decoded representation of the .debug_line section. */
2780
2781static int
2782display_debug_lines_decoded (struct dwarf_section *section,
2783 unsigned char *data,
2784 unsigned char *end)
2785{
2786 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2787 section->name);
2788
2789 while (data < end)
2790 {
2791 /* This loop amounts to one iteration per compilation unit. */
91d6fa6a 2792 DWARF2_Internal_LineInfo linfo;
a262ae96
NC		 2793 unsigned char *standard_opcodes;
2794 unsigned char *end_of_sequence;
2795 unsigned char *hdrptr;
2796 int initial_length_size;
2797 int offset_size;
2798 int i;
2799 File_Entry *file_table = NULL;
2800 unsigned char **directory_table = NULL;
a262ae96
NC		 2801
2802 hdrptr = data;
2803
2804 /* Extract information from the Line Number Program Header.
2805 (section 6.2.4 in the Dwarf3 doc). */
2806
2807 /* Get the length of this CU's line number information block. */
91d6fa6a 2808 linfo.li_length = byte_get (hdrptr, 4);
a262ae96
NC		 2809 hdrptr += 4;
2810
91d6fa6a 2811 if (linfo.li_length == 0xffffffff)
a262ae96
NC		 2812 {
2813 /* This section is 64-bit DWARF 3. */
91d6fa6a 2814 linfo.li_length = byte_get (hdrptr, 8);
a262ae96
NC		 2815 hdrptr += 8;
2816 offset_size = 8;
2817 initial_length_size = 12;
2818 }
2819 else
2820 {
2821 offset_size = 4;
2822 initial_length_size = 4;
2823 }
2824
91d6fa6a 2825 if (linfo.li_length + initial_length_size > section->size)
a262ae96
NC		 2826 {
2827 warn (_("The line info appears to be corrupt - "
2828 "the section is too small\n"));
2829 return 0;
2830 }
2831
2832 /* Get this CU's Line Number Block version number. */
91d6fa6a 2833 linfo.li_version = byte_get (hdrptr, 2);
a262ae96 2834 hdrptr += 2;
932fd279
JJ		 2835 if (linfo.li_version != 2
2836 && linfo.li_version != 3
2837 && linfo.li_version != 4)
a262ae96 2838 {
932fd279 2839 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
a262ae96
NC		 2840 "supported.\n"));
2841 return 0;
2842 }
2843
91d6fa6a 2844 linfo.li_prologue_length = byte_get (hdrptr, offset_size);
a262ae96 2845 hdrptr += offset_size;
91d6fa6a 2846 linfo.li_min_insn_length = byte_get (hdrptr, 1);
a262ae96 2847 hdrptr++;
a233b20c
JJ		 2848 if (linfo.li_version >= 4)
2849 {
2850 linfo.li_max_ops_per_insn = byte_get (hdrptr, 1);
2851 hdrptr++;
2852 if (linfo.li_max_ops_per_insn == 0)
2853 {
2854 warn (_("Invalid maximum operations per insn.\n"));
2855 return 0;
2856 }
2857 }
2858 else
2859 linfo.li_max_ops_per_insn = 1;
91d6fa6a 2860 linfo.li_default_is_stmt = byte_get (hdrptr, 1);
a262ae96 2861 hdrptr++;
91d6fa6a 2862 linfo.li_line_base = byte_get (hdrptr, 1);
a262ae96 2863 hdrptr++;
91d6fa6a 2864 linfo.li_line_range = byte_get (hdrptr, 1);
a262ae96 2865 hdrptr++;
91d6fa6a 2866 linfo.li_opcode_base = byte_get (hdrptr, 1);
a262ae96
NC		 2867 hdrptr++;
2868
2869 /* Sign extend the line base field. */
91d6fa6a
NC		 2870 linfo.li_line_base <<= 24;
2871 linfo.li_line_base >>= 24;
a262ae96
NC		 2872
2873 /* Find the end of this CU's Line Number Information Block. */
91d6fa6a 2874 end_of_sequence = data + linfo.li_length + initial_length_size;
a262ae96 2875
91d6fa6a 2876 reset_state_machine (linfo.li_default_is_stmt);
a262ae96
NC		 2877
2878 /* Save a pointer to the contents of the Opcodes table. */
2879 standard_opcodes = hdrptr;
2880
2881 /* Traverse the Directory table just to count entries. */
91d6fa6a 2882 data = standard_opcodes + linfo.li_opcode_base - 1;
a262ae96
NC		 2883 if (*data != 0)
2884 {
2885 unsigned int n_directories = 0;
2886 unsigned char *ptr_directory_table = data;
a262ae96
NC		 2887
2888 while (*data != 0)
2889 {
2890 data += strlen ((char *) data) + 1;
2891 n_directories++;
2892 }
2893
2894 /* Go through the directory table again to save the directories. */
3f5e193b
NC		 2895 directory_table = (unsigned char **)
2896 xmalloc (n_directories * sizeof (unsigned char *));
a262ae96
NC		 2897
2898 i = 0;
2899 while (*ptr_directory_table != 0)
2900 {
2901 directory_table[i] = ptr_directory_table;
2902 ptr_directory_table += strlen ((char *) ptr_directory_table) + 1;
2903 i++;
2904 }
2905 }
2906 /* Skip the NUL at the end of the table. */
2907 data++;
2908
2909 /* Traverse the File Name table just to count the entries. */
2910 if (*data != 0)
2911 {
2912 unsigned int n_files = 0;
2913 unsigned char *ptr_file_name_table = data;
a262ae96
NC		 2914
2915 while (*data != 0)
2916 {
2917 unsigned int bytes_read;
2918
2919 /* Skip Name, directory index, last modification time and length
2920 of file. */
2921 data += strlen ((char *) data) + 1;
2922 read_leb128 (data, & bytes_read, 0);
2923 data += bytes_read;
2924 read_leb128 (data, & bytes_read, 0);
2925 data += bytes_read;
2926 read_leb128 (data, & bytes_read, 0);
2927 data += bytes_read;
2928
2929 n_files++;
2930 }
2931
2932 /* Go through the file table again to save the strings. */
3f5e193b 2933 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
a262ae96
NC		 2934
2935 i = 0;
2936 while (*ptr_file_name_table != 0)
2937 {
2938 unsigned int bytes_read;
2939
2940 file_table[i].name = ptr_file_name_table;
2941 ptr_file_name_table += strlen ((char *) ptr_file_name_table) + 1;
2942
2943 /* We are not interested in directory, time or size. */
2944 file_table[i].directory_index = read_leb128 (ptr_file_name_table,
2945 & bytes_read, 0);
2946 ptr_file_name_table += bytes_read;
2947 file_table[i].modification_date = read_leb128 (ptr_file_name_table,
2948 & bytes_read, 0);
2949 ptr_file_name_table += bytes_read;
2950 file_table[i].length = read_leb128 (ptr_file_name_table, & bytes_read, 0);
2951 ptr_file_name_table += bytes_read;
2952 i++;
2953 }
2954 i = 0;
2955
2956 /* Print the Compilation Unit's name and a header. */
2957 if (directory_table == NULL)
2958 {
2959 printf (_("CU: %s:\n"), file_table[0].name);
2960 printf (_("File name Line number Starting address\n"));
2961 }
2962 else
2963 {
4eee63bc
CD		 2964 unsigned int ix = file_table[0].directory_index;
2965 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
2966 if (do_wide || strlen (directory) < 76)
2967 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
a262ae96 2968 else
cc5914eb
AM		 2969 printf ("%s:\n", file_table[0].name);
2970
a262ae96
NC		 2971 printf (_("File name Line number Starting address\n"));
2972 }
2973 }
2974
2975 /* Skip the NUL at the end of the table. */
2976 data++;
2977
2978 /* This loop iterates through the Dwarf Line Number Program. */
2979 while (data < end_of_sequence)
2980 {
2981 unsigned char op_code;
2982 int adv;
2983 unsigned long int uladv;
2984 unsigned int bytes_read;
2985 int is_special_opcode = 0;
2986
2987 op_code = *data++;
a262ae96 2988
91d6fa6a 2989 if (op_code >= linfo.li_opcode_base)
a262ae96 2990 {
91d6fa6a 2991 op_code -= linfo.li_opcode_base;
a233b20c
JJ		 2992 uladv = (op_code / linfo.li_line_range);
2993 if (linfo.li_max_ops_per_insn == 1)
2994 {
2995 uladv *= linfo.li_min_insn_length;
2996 state_machine_regs.address += uladv;
2997 }
2998 else
2999 {
3000 state_machine_regs.address
3001 += ((state_machine_regs.op_index + uladv)
3002 / linfo.li_max_ops_per_insn)
3003 * linfo.li_min_insn_length;
3004 state_machine_regs.op_index
3005 = (state_machine_regs.op_index + uladv)
3006 % linfo.li_max_ops_per_insn;
3007 }
a262ae96 3008
91d6fa6a 3009 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
a262ae96
NC		 3010 state_machine_regs.line += adv;
3011 is_special_opcode = 1;
3012 }
3013 else switch (op_code)
3014 {
3015 case DW_LNS_extended_op:
3016 {
3017 unsigned int ext_op_code_len;
a262ae96
NC		 3018 unsigned char ext_op_code;
3019 unsigned char *op_code_data = data;
3020
3021 ext_op_code_len = read_leb128 (op_code_data, &bytes_read, 0);
3022 op_code_data += bytes_read;
3023
3024 if (ext_op_code_len == 0)
3025 {
3026 warn (_("badly formed extended line op encountered!\n"));
3027 break;
3028 }
3029 ext_op_code_len += bytes_read;
3030 ext_op_code = *op_code_data++;
3031
3032 switch (ext_op_code)
3033 {
3034 case DW_LNE_end_sequence:
91d6fa6a 3035 reset_state_machine (linfo.li_default_is_stmt);
a262ae96
NC		 3036 break;
3037 case DW_LNE_set_address:
3038 state_machine_regs.address =
3039 byte_get (op_code_data, ext_op_code_len - bytes_read - 1);
a233b20c 3040 state_machine_regs.op_index = 0;
a262ae96
NC		 3041 break;
3042 case DW_LNE_define_file:
3043 {
3044 unsigned int dir_index = 0;
3045
3046 ++state_machine_regs.last_file_entry;
3047 op_code_data += strlen ((char *) op_code_data) + 1;
3048 dir_index = read_leb128 (op_code_data, & bytes_read, 0);
3049 op_code_data += bytes_read;
3050 read_leb128 (op_code_data, & bytes_read, 0);
3051 op_code_data += bytes_read;
3052 read_leb128 (op_code_data, & bytes_read, 0);
3053
cc5914eb 3054 printf ("%s:\n", directory_table[dir_index]);
a262ae96
NC		 3055 break;
3056 }
3057 default:
3058 printf (_("UNKNOWN: length %d\n"), ext_op_code_len - bytes_read);
3059 break;
3060 }
3061 data += ext_op_code_len;
3062 break;
3063 }
3064 case DW_LNS_copy:
3065 break;
3066
3067 case DW_LNS_advance_pc:
3068 uladv = read_leb128 (data, & bytes_read, 0);
a262ae96 3069 data += bytes_read;
a233b20c
JJ		 3070 if (linfo.li_max_ops_per_insn == 1)
3071 {
3072 uladv *= linfo.li_min_insn_length;
3073 state_machine_regs.address += uladv;
3074 }
3075 else
3076 {
3077 state_machine_regs.address
3078 += ((state_machine_regs.op_index + uladv)
3079 / linfo.li_max_ops_per_insn)
3080 * linfo.li_min_insn_length;
3081 state_machine_regs.op_index
3082 = (state_machine_regs.op_index + uladv)
3083 % linfo.li_max_ops_per_insn;
3084 }
a262ae96
NC		 3085 break;
3086
3087 case DW_LNS_advance_line:
467c65bc 3088 adv = read_sleb128 (data, & bytes_read);
a262ae96
NC		 3089 data += bytes_read;
3090 state_machine_regs.line += adv;
3091 break;
3092
3093 case DW_LNS_set_file:
3094 adv = read_leb128 (data, & bytes_read, 0);
3095 data += bytes_read;
3096 state_machine_regs.file = adv;
3097 if (file_table[state_machine_regs.file - 1].directory_index == 0)
3098 {
3099 /* If directory index is 0, that means current directory. */
cc5914eb 3100 printf ("\n./%s:[++]\n",
a262ae96
NC		 3101 file_table[state_machine_regs.file - 1].name);
3102 }
3103 else
3104 {
3105 /* The directory index starts counting at 1. */
cc5914eb 3106 printf ("\n%s/%s:\n",
a262ae96
NC		 3107 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3108 file_table[state_machine_regs.file - 1].name);
3109 }
3110 break;
3111
3112 case DW_LNS_set_column:
3113 uladv = read_leb128 (data, & bytes_read, 0);
3114 data += bytes_read;
3115 state_machine_regs.column = uladv;
3116 break;
3117
3118 case DW_LNS_negate_stmt:
3119 adv = state_machine_regs.is_stmt;
3120 adv = ! adv;
3121 state_machine_regs.is_stmt = adv;
3122 break;
3123
3124 case DW_LNS_set_basic_block:
3125 state_machine_regs.basic_block = 1;
3126 break;
3127
3128 case DW_LNS_const_add_pc:
a233b20c
JJ		 3129 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3130 if (linfo.li_max_ops_per_insn == 1)
3131 {
3132 uladv *= linfo.li_min_insn_length;
3133 state_machine_regs.address += uladv;
3134 }
3135 else
3136 {
3137 state_machine_regs.address
3138 += ((state_machine_regs.op_index + uladv)
3139 / linfo.li_max_ops_per_insn)
3140 * linfo.li_min_insn_length;
3141 state_machine_regs.op_index
3142 = (state_machine_regs.op_index + uladv)
3143 % linfo.li_max_ops_per_insn;
3144 }
a262ae96
NC		 3145 break;
3146
3147 case DW_LNS_fixed_advance_pc:
3148 uladv = byte_get (data, 2);
3149 data += 2;
3150 state_machine_regs.address += uladv;
a233b20c 3151 state_machine_regs.op_index = 0;
a262ae96
NC		 3152 break;
3153
3154 case DW_LNS_set_prologue_end:
3155 break;
3156
3157 case DW_LNS_set_epilogue_begin:
3158 break;
3159
3160 case DW_LNS_set_isa:
3161 uladv = read_leb128 (data, & bytes_read, 0);
3162 data += bytes_read;
3163 printf (_(" Set ISA to %lu\n"), uladv);
3164 break;
3165
3166 default:
3167 printf (_(" Unknown opcode %d with operands: "), op_code);
3168
3169 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3170 {
467c65bc
NC		 3171 printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data,
3172 &bytes_read, 0)),
a262ae96
NC		 3173 i == 1 ? "" : ", ");
3174 data += bytes_read;
3175 }
3176 putchar ('\n');
3177 break;
3178 }
3179
3180 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3181 to the DWARF address/line matrix. */
3182 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3183 || (op_code == DW_LNS_copy))
3184 {
3185 const unsigned int MAX_FILENAME_LENGTH = 35;
3186 char *fileName = (char *)file_table[state_machine_regs.file - 1].name;
3187 char *newFileName = NULL;
3188 size_t fileNameLength = strlen (fileName);
3189
3190 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3191 {
3f5e193b 3192 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
a262ae96
NC		 3193 /* Truncate file name */
3194 strncpy (newFileName,
3195 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3196 MAX_FILENAME_LENGTH + 1);
3197 }
3198 else
3199 {
3f5e193b 3200 newFileName = (char *) xmalloc (fileNameLength + 1);
a262ae96
NC		 3201 strncpy (newFileName, fileName, fileNameLength + 1);
3202 }
3203
3204 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3205 {
a233b20c 3206 if (linfo.li_max_ops_per_insn == 1)
467c65bc
NC		 3207 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3208 newFileName, state_machine_regs.line,
a233b20c
JJ		 3209 state_machine_regs.address);
3210 else
467c65bc
NC		 3211 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3212 newFileName, state_machine_regs.line,
a233b20c
JJ		 3213 state_machine_regs.address,
3214 state_machine_regs.op_index);
a262ae96
NC		 3215 }
3216 else
3217 {
a233b20c 3218 if (linfo.li_max_ops_per_insn == 1)
467c65bc
NC		 3219 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3220 newFileName, state_machine_regs.line,
a233b20c
JJ		 3221 state_machine_regs.address);
3222 else
467c65bc
NC		 3223 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3224 newFileName, state_machine_regs.line,
a233b20c
JJ		 3225 state_machine_regs.address,
3226 state_machine_regs.op_index);
a262ae96
NC		 3227 }
3228
3229 if (op_code == DW_LNE_end_sequence)
3230 printf ("\n");
3231
3232 free (newFileName);
3233 }
3234 }
3235 free (file_table);
3236 file_table = NULL;
3237 free (directory_table);
3238 directory_table = NULL;
3239 putchar ('\n');
3240 }
3241
3242 return 1;
3243}
3244
3245static int
1c4cc746 3246display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
a262ae96
NC		 3247{
3248 unsigned char *data = section->start;
3249 unsigned char *end = data + section->size;
4cb93e3b
TG		 3250 int retValRaw = 1;
3251 int retValDecoded = 1;
a262ae96 3252
008f4c78
NC		 3253 if (do_debug_lines == 0)
3254 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3255
4cb93e3b 3256 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
a262ae96
NC		 3257 retValRaw = display_debug_lines_raw (section, data, end);
3258
4cb93e3b 3259 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
a262ae96
NC		 3260 retValDecoded = display_debug_lines_decoded (section, data, end);
3261
4cb93e3b 3262 if (!retValRaw || !retValDecoded)
a262ae96
NC		 3263 return 0;
3264
3265 return 1;
3266}
3267
6e3d6dc1
NC		 3268static debug_info *
3269find_debug_info_for_offset (unsigned long offset)
3270{
3271 unsigned int i;
3272
3273 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3274 return NULL;
3275
3276 for (i = 0; i < num_debug_info_entries; i++)
3277 if (debug_information[i].cu_offset == offset)
3278 return debug_information + i;
3279
3280 return NULL;
3281}
3282
19e6b90e
L		 3283static int
3284display_debug_pubnames (struct dwarf_section *section,
3285 void *file ATTRIBUTE_UNUSED)
3286{
91d6fa6a 3287 DWARF2_Internal_PubNames names;
19e6b90e
L		 3288 unsigned char *start = section->start;
3289 unsigned char *end = start + section->size;
3290
6e3d6dc1
NC		 3291 /* It does not matter if this load fails,
3292 we test for that later on. */
3293 load_debug_info (file);
3294
19e6b90e
L		 3295 printf (_("Contents of the %s section:\n\n"), section->name);
3296
3297 while (start < end)
3298 {
3299 unsigned char *data;
3300 unsigned long offset;
3301 int offset_size, initial_length_size;
3302
3303 data = start;
3304
91d6fa6a 3305 names.pn_length = byte_get (data, 4);
19e6b90e 3306 data += 4;
91d6fa6a 3307 if (names.pn_length == 0xffffffff)
19e6b90e 3308 {
91d6fa6a 3309 names.pn_length = byte_get (data, 8);
19e6b90e
L		 3310 data += 8;
3311 offset_size = 8;
3312 initial_length_size = 12;
3313 }
3314 else
3315 {
3316 offset_size = 4;
3317 initial_length_size = 4;
3318 }
3319
91d6fa6a 3320 names.pn_version = byte_get (data, 2);
19e6b90e 3321 data += 2;
6e3d6dc1 3322
91d6fa6a 3323 names.pn_offset = byte_get (data, offset_size);
19e6b90e 3324 data += offset_size;
6e3d6dc1
NC		 3325
3326 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3327 && num_debug_info_entries > 0
91d6fa6a 3328 && find_debug_info_for_offset (names.pn_offset) == NULL)
6e3d6dc1 3329 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 3330 (unsigned long) names.pn_offset, section->name);
cecf136e 3331
91d6fa6a 3332 names.pn_size = byte_get (data, offset_size);
19e6b90e
L		 3333 data += offset_size;
3334
91d6fa6a 3335 start += names.pn_length + initial_length_size;
19e6b90e 3336
91d6fa6a 3337 if (names.pn_version != 2 && names.pn_version != 3)
19e6b90e
L		 3338 {
3339 static int warned = 0;
3340
3341 if (! warned)
3342 {
3343 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3344 warned = 1;
3345 }
3346
3347 continue;
3348 }
3349
3350 printf (_(" Length: %ld\n"),
47704ddf 3351 (long) names.pn_length);
19e6b90e 3352 printf (_(" Version: %d\n"),
91d6fa6a 3353 names.pn_version);
6e3d6dc1 3354 printf (_(" Offset into .debug_info section: 0x%lx\n"),
47704ddf 3355 (unsigned long) names.pn_offset);
19e6b90e 3356 printf (_(" Size of area in .debug_info section: %ld\n"),
47704ddf 3357 (long) names.pn_size);
19e6b90e
L		 3358
3359 printf (_("\n Offset\tName\n"));
3360
3361 do
3362 {
3363 offset = byte_get (data, offset_size);
3364
3365 if (offset != 0)
3366 {
3367 data += offset_size;
80c35038 3368 printf (" %-6lx\t%s\n", offset, data);
19e6b90e
L		 3369 data += strlen ((char *) data) + 1;
3370 }
3371 }
3372 while (offset != 0);
3373 }
3374
3375 printf ("\n");
3376 return 1;
3377}
3378
3379static int
3380display_debug_macinfo (struct dwarf_section *section,
3381 void *file ATTRIBUTE_UNUSED)
3382{
3383 unsigned char *start = section->start;
3384 unsigned char *end = start + section->size;
3385 unsigned char *curr = start;
3386 unsigned int bytes_read;
3387 enum dwarf_macinfo_record_type op;
3388
3389 printf (_("Contents of the %s section:\n\n"), section->name);
3390
3391 while (curr < end)
3392 {
3393 unsigned int lineno;
3394 const char *string;
3395
3f5e193b 3396 op = (enum dwarf_macinfo_record_type) *curr;
19e6b90e
L		 3397 curr++;
3398
3399 switch (op)
3400 {
3401 case DW_MACINFO_start_file:
3402 {
3403 unsigned int filenum;
3404
3405 lineno = read_leb128 (curr, & bytes_read, 0);
3406 curr += bytes_read;
3407 filenum = read_leb128 (curr, & bytes_read, 0);
3408 curr += bytes_read;
3409
3410 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3411 lineno, filenum);
3412 }
3413 break;
3414
3415 case DW_MACINFO_end_file:
3416 printf (_(" DW_MACINFO_end_file\n"));
3417 break;
3418
3419 case DW_MACINFO_define:
3420 lineno = read_leb128 (curr, & bytes_read, 0);
3421 curr += bytes_read;
3422 string = (char *) curr;
3423 curr += strlen (string) + 1;
3424 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3425 lineno, string);
3426 break;
3427
3428 case DW_MACINFO_undef:
3429 lineno = read_leb128 (curr, & bytes_read, 0);
3430 curr += bytes_read;
3431 string = (char *) curr;
3432 curr += strlen (string) + 1;
3433 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3434 lineno, string);
3435 break;
3436
3437 case DW_MACINFO_vendor_ext:
3438 {
3439 unsigned int constant;
3440
3441 constant = read_leb128 (curr, & bytes_read, 0);
3442 curr += bytes_read;
3443 string = (char *) curr;
3444 curr += strlen (string) + 1;
3445 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3446 constant, string);
3447 }
3448 break;
3449 }
3450 }
3451
3452 return 1;
3453}
3454
4ccf1e31
JJ		 3455/* Given LINE_OFFSET into the .debug_line section, attempt to return
3456 filename and dirname corresponding to file name table entry with index
3457 FILEIDX. Return NULL on failure. */
3458
3459static unsigned char *
3460get_line_filename_and_dirname (dwarf_vma line_offset, dwarf_vma fileidx,
3461 unsigned char **dir_name)
3462{
3463 struct dwarf_section *section = &debug_displays [line].section;
3464 unsigned char *hdrptr, *dirtable, *file_name;
3465 unsigned int offset_size, initial_length_size;
3466 unsigned int version, opcode_base, bytes_read;
3467 dwarf_vma length, diridx;
3468
3469 *dir_name = NULL;
3470 if (section->start == NULL
3471 || line_offset >= section->size
3472 || fileidx == 0)
3473 return NULL;
3474
3475 hdrptr = section->start + line_offset;
3476 length = byte_get (hdrptr, 4);
3477 hdrptr += 4;
3478 if (length == 0xffffffff)
3479 {
3480 /* This section is 64-bit DWARF 3. */
3481 length = byte_get (hdrptr, 8);
3482 hdrptr += 8;
3483 offset_size = 8;
3484 initial_length_size = 12;
3485 }
3486 else
3487 {
3488 offset_size = 4;
3489 initial_length_size = 4;
3490 }
3491 if (length + initial_length_size > section->size)
3492 return NULL;
3493 version = byte_get (hdrptr, 2);
3494 hdrptr += 2;
3495 if (version != 2 && version != 3 && version != 4)
3496 return NULL;
3497 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3498 if (version >= 4)
3499 hdrptr++; /* Skip max_ops_per_insn. */
3500 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
3501 opcode_base = byte_get (hdrptr, 1);
3502 if (opcode_base == 0)
3503 return NULL;
3504 hdrptr++;
3505 hdrptr += opcode_base - 1;
3506 dirtable = hdrptr;
3507 /* Skip over dirname table. */
3508 while (*hdrptr != '\0')
3509 hdrptr += strlen ((char *) hdrptr) + 1;
3510 hdrptr++; /* Skip the NUL at the end of the table. */
3511 /* Now skip over preceding filename table entries. */
3512 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3513 {
3514 hdrptr += strlen ((char *) hdrptr) + 1;
3515 read_leb128 (hdrptr, &bytes_read, 0);
3516 hdrptr += bytes_read;
3517 read_leb128 (hdrptr, &bytes_read, 0);
3518 hdrptr += bytes_read;
3519 read_leb128 (hdrptr, &bytes_read, 0);
3520 hdrptr += bytes_read;
3521 }
3522 if (*hdrptr == '\0')
3523 return NULL;
3524 file_name = hdrptr;
3525 hdrptr += strlen ((char *) hdrptr) + 1;
3526 diridx = read_leb128 (hdrptr, &bytes_read, 0);
3527 if (diridx == 0)
3528 return file_name;
3529 for (; *dirtable != '\0' && diridx > 1; diridx--)
3530 dirtable += strlen ((char *) dirtable) + 1;
3531 if (*dirtable == '\0')
3532 return NULL;
3533 *dir_name = dirtable;
3534 return file_name;
3535}
3536
3537static int
3538display_debug_macro (struct dwarf_section *section,
3539 void *file)
3540{
3541 unsigned char *start = section->start;
3542 unsigned char *end = start + section->size;
3543 unsigned char *curr = start;
3544 unsigned char *extended_op_buf[256];
3545 unsigned int bytes_read;
3546
3547 load_debug_section (str, file);
3548 load_debug_section (line, file);
3549
3550 printf (_("Contents of the %s section:\n\n"), section->name);
3551
3552 while (curr < end)
3553 {
3554 unsigned int lineno, version, flags;
3555 unsigned int offset_size = 4;
3556 const char *string;
3557 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
3558 unsigned char **extended_ops = NULL;
3559
3560 version = byte_get (curr, 2);
3561 curr += 2;
3562
3563 if (version != 4)
3564 {
3565 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3566 section->name);
3567 return 0;
3568 }
3569
3570 flags = byte_get (curr++, 1);
3571 if (flags & 1)
3572 offset_size = 8;
3573 printf (_(" Offset: 0x%lx\n"),
3574 (unsigned long) sec_offset);
3575 printf (_(" Version: %d\n"), version);
3576 printf (_(" Offset size: %d\n"), offset_size);
3577 if (flags & 2)
3578 {
3579 line_offset = byte_get (curr, offset_size);
3580 curr += offset_size;
3581 printf (_(" Offset into .debug_line: 0x%lx\n"),
3582 (unsigned long) line_offset);
3583 }
3584 if (flags & 4)
3585 {
3586 unsigned int i, count = byte_get (curr++, 1), op;
3587 dwarf_vma nargs, n;
3588 memset (extended_op_buf, 0, sizeof (extended_op_buf));
3589 extended_ops = extended_op_buf;
3590 if (count)
3591 {
3592 printf (_(" Extension opcode arguments:\n"));
3593 for (i = 0; i < count; i++)
3594 {
3595 op = byte_get (curr++, 1);
3596 extended_ops[op] = curr;
3597 nargs = read_leb128 (curr, &bytes_read, 0);
3598 curr += bytes_read;
3599 if (nargs == 0)
3600 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
3601 else
3602 {
3603 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
3604 for (n = 0; n < nargs; n++)
3605 {
3606 unsigned int form = byte_get (curr++, 1);
3607 printf ("%s%s", get_FORM_name (form),
3608 n == nargs - 1 ? "\n" : ", ");
3609 switch (form)
3610 {
3611 case DW_FORM_data1:
3612 case DW_FORM_data2:
3613 case DW_FORM_data4:
3614 case DW_FORM_data8:
3615 case DW_FORM_sdata:
3616 case DW_FORM_udata:
3617 case DW_FORM_block:
3618 case DW_FORM_block1:
3619 case DW_FORM_block2:
3620 case DW_FORM_block4:
3621 case DW_FORM_flag:
3622 case DW_FORM_string:
3623 case DW_FORM_strp:
3624 case DW_FORM_sec_offset:
3625 break;
3626 default:
3627 error (_("Invalid extension opcode form %s\n"),
3628 get_FORM_name (form));
3629 return 0;
3630 }
3631 }
3632 }
3633 }
3634 }
3635 }
3636 printf ("\n");
3637
3638 while (1)
3639 {
3640 unsigned int op;
3641
3642 if (curr >= end)
3643 {
3644 error (_(".debug_macro section not zero terminated\n"));
3645 return 0;
3646 }
3647
3648 op = byte_get (curr++, 1);
3649 if (op == 0)
3650 break;
3651
3652 switch (op)
3653 {
3654 case DW_MACRO_GNU_start_file:
3655 {
3656 unsigned int filenum;
3657 unsigned char *file_name = NULL, *dir_name = NULL;
3658
3659 lineno = read_leb128 (curr, &bytes_read, 0);
3660 curr += bytes_read;
3661 filenum = read_leb128 (curr, &bytes_read, 0);
3662 curr += bytes_read;
3663
3664 if ((flags & 2) == 0)
3665 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3666 else
3667 file_name
3668 = get_line_filename_and_dirname (line_offset, filenum,
3669 &dir_name);
3670 if (file_name == NULL)
3671 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3672 lineno, filenum);
3673 else
3674 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3675 lineno, filenum,
3676 dir_name != NULL ? (const char *) dir_name : "",
3677 dir_name != NULL ? "/" : "", file_name);
3678 }
3679 break;
3680
3681 case DW_MACRO_GNU_end_file:
3682 printf (_(" DW_MACRO_GNU_end_file\n"));
3683 break;
3684
3685 case DW_MACRO_GNU_define:
3686 lineno = read_leb128 (curr, &bytes_read, 0);
3687 curr += bytes_read;
3688 string = (char *) curr;
3689 curr += strlen (string) + 1;
3690 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3691 lineno, string);
3692 break;
3693
3694 case DW_MACRO_GNU_undef:
3695 lineno = read_leb128 (curr, &bytes_read, 0);
3696 curr += bytes_read;
3697 string = (char *) curr;
3698 curr += strlen (string) + 1;
3699 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3700 lineno, string);
3701 break;
3702
3703 case DW_MACRO_GNU_define_indirect:
3704 lineno = read_leb128 (curr, &bytes_read, 0);
3705 curr += bytes_read;
3706 offset = byte_get (curr, offset_size);
3707 curr += offset_size;
3708 string = fetch_indirect_string (offset);
3709 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3710 lineno, string);
3711 break;
3712
3713 case DW_MACRO_GNU_undef_indirect:
3714 lineno = read_leb128 (curr, &bytes_read, 0);
3715 curr += bytes_read;
3716 offset = byte_get (curr, offset_size);
3717 curr += offset_size;
3718 string = fetch_indirect_string (offset);
3719 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3720 lineno, string);
3721 break;
3722
3723 case DW_MACRO_GNU_transparent_include:
3724 offset = byte_get (curr, offset_size);
3725 curr += offset_size;
3726 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3727 (unsigned long) offset);
3728 break;
3729
3730 default:
3731 if (extended_ops == NULL || extended_ops[op] == NULL)
3732 {
3733 error (_(" Unknown macro opcode %02x seen\n"), op);
3734 return 0;
3735 }
3736 else
3737 {
3738 /* Skip over unhandled opcodes. */
3739 dwarf_vma nargs, n;
3740 unsigned char *desc = extended_ops[op];
3741 nargs = read_leb128 (desc, &bytes_read, 0);
3742 desc += bytes_read;
3743 if (nargs == 0)
3744 {
3745 printf (_(" DW_MACRO_GNU_%02x\n"), op);
3746 break;
3747 }
3748 printf (_(" DW_MACRO_GNU_%02x -"), op);
3749 for (n = 0; n < nargs; n++)
3750 {
3751 curr
3752 = read_and_display_attr_value (0, byte_get (desc++, 1),
3753 curr, 0, 0, offset_size,
3754 version, NULL, 0, NULL);
3755 if (n != nargs - 1)
3756 printf (",");
3757 }
3758 printf ("\n");
3759 }
3760 break;
3761 }
3762 }
3763
3764 printf ("\n");
3765 }
3766
3767 return 1;
3768}
3769
19e6b90e
L		 3770static int
3771display_debug_abbrev (struct dwarf_section *section,
3772 void *file ATTRIBUTE_UNUSED)
3773{
3774 abbrev_entry *entry;
3775 unsigned char *start = section->start;
3776 unsigned char *end = start + section->size;
3777
3778 printf (_("Contents of the %s section:\n\n"), section->name);
3779
3780 do
3781 {
3782 free_abbrevs ();
3783
3784 start = process_abbrev_section (start, end);
3785
3786 if (first_abbrev == NULL)
3787 continue;
3788
3789 printf (_(" Number TAG\n"));
3790
3791 for (entry = first_abbrev; entry; entry = entry->next)
3792 {
3793 abbrev_attr *attr;
3794
cc5914eb 3795 printf (" %ld %s [%s]\n",
19e6b90e
L		 3796 entry->entry,
3797 get_TAG_name (entry->tag),
3798 entry->children ? _("has children") : _("no children"));
3799
3800 for (attr = entry->first_attr; attr; attr = attr->next)
cc5914eb 3801 printf (" %-18s %s\n",
19e6b90e
L		 3802 get_AT_name (attr->attribute),
3803 get_FORM_name (attr->form));
3804 }
3805 }
3806 while (start);
3807
3808 printf ("\n");
3809
3810 return 1;
3811}
3812
51d0d03f
JJ		 3813/* Sort array of indexes in ascending order of loc_offsets[idx]. */
3814
3815static dwarf_vma *loc_offsets;
3816
3817static int
3818loc_offsets_compar (const void *ap, const void *bp)
3819{
3820 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
3821 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
3822
3823 return (a > b) - (b > a);
3824}
3825
19e6b90e
L		 3826static int
3827display_debug_loc (struct dwarf_section *section, void *file)
3828{
3829 unsigned char *start = section->start;
3830 unsigned char *section_end;
3831 unsigned long bytes;
3832 unsigned char *section_begin = start;
3833 unsigned int num_loc_list = 0;
3834 unsigned long last_offset = 0;
3835 unsigned int first = 0;
3836 unsigned int i;
3837 unsigned int j;
51d0d03f 3838 unsigned int k;
19e6b90e 3839 int seen_first_offset = 0;
51d0d03f 3840 int locs_sorted = 1;
19e6b90e 3841 unsigned char *next;
51d0d03f 3842 unsigned int *array = NULL;
19e6b90e
L		 3843
3844 bytes = section->size;
3845 section_end = start + bytes;
3846
3847 if (bytes == 0)
3848 {
3849 printf (_("\nThe %s section is empty.\n"), section->name);
3850 return 0;
3851 }
3852
1febe64d
NC		 3853 if (load_debug_info (file) == 0)
3854 {
3855 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
3856 section->name);
3857 return 0;
3858 }
19e6b90e
L		 3859
3860 /* Check the order of location list in .debug_info section. If
3861 offsets of location lists are in the ascending order, we can
3862 use `debug_information' directly. */
3863 for (i = 0; i < num_debug_info_entries; i++)
3864 {
3865 unsigned int num;
3866
3867 num = debug_information [i].num_loc_offsets;
51d0d03f
JJ		 3868 if (num > num_loc_list)
3869 num_loc_list = num;
19e6b90e
L		 3870
3871 /* Check if we can use `debug_information' directly. */
51d0d03f 3872 if (locs_sorted && num != 0)
19e6b90e
L		 3873 {
3874 if (!seen_first_offset)
3875 {
3876 /* This is the first location list. */
3877 last_offset = debug_information [i].loc_offsets [0];
3878 first = i;
3879 seen_first_offset = 1;
3880 j = 1;
3881 }
3882 else
3883 j = 0;
3884
3885 for (; j < num; j++)
3886 {
3887 if (last_offset >
3888 debug_information [i].loc_offsets [j])
3889 {
51d0d03f 3890 locs_sorted = 0;
19e6b90e
L		 3891 break;
3892 }
3893 last_offset = debug_information [i].loc_offsets [j];
3894 }
3895 }
3896 }
3897
19e6b90e
L		 3898 if (!seen_first_offset)
3899 error (_("No location lists in .debug_info section!\n"));
3900
bfe2612a 3901 /* DWARF sections under Mach-O have non-zero addresses. */
d4bfc77b
AS		 3902 if (debug_information [first].num_loc_offsets > 0
3903 && debug_information [first].loc_offsets [0] != section->address)
47704ddf
KT		 3904 warn (_("Location lists in %s section start at 0x%s\n"),
3905 section->name,
3906 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
19e6b90e 3907
51d0d03f
JJ		 3908 if (!locs_sorted)
3909 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
19e6b90e
L		 3910 printf (_("Contents of the %s section:\n\n"), section->name);
3911 printf (_(" Offset Begin End Expression\n"));
3912
3913 seen_first_offset = 0;
3914 for (i = first; i < num_debug_info_entries; i++)
3915 {
2d9472a2
NC		 3916 dwarf_vma begin;
3917 dwarf_vma end;
19e6b90e
L		 3918 unsigned short length;
3919 unsigned long offset;
3920 unsigned int pointer_size;
b7807392
JJ		 3921 unsigned int offset_size;
3922 int dwarf_version;
19e6b90e
L		 3923 unsigned long cu_offset;
3924 unsigned long base_address;
3925 int need_frame_base;
3926 int has_frame_base;
3927
3928 pointer_size = debug_information [i].pointer_size;
3929 cu_offset = debug_information [i].cu_offset;
b7807392
JJ		 3930 offset_size = debug_information [i].offset_size;
3931 dwarf_version = debug_information [i].dwarf_version;
51d0d03f
JJ		 3932 if (!locs_sorted)
3933 {
3934 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
3935 array[k] = k;
3936 loc_offsets = debug_information [i].loc_offsets;
3937 qsort (array, debug_information [i].num_loc_offsets,
3938 sizeof (*array), loc_offsets_compar);
3939 }
19e6b90e 3940
51d0d03f 3941 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
19e6b90e 3942 {
51d0d03f
JJ		 3943 j = locs_sorted ? k : array[k];
3944 if (k
3945 && debug_information [i].loc_offsets [locs_sorted
3946 ? k - 1 : array [k - 1]]
3947 == debug_information [i].loc_offsets [j])
3948 continue;
19e6b90e 3949 has_frame_base = debug_information [i].have_frame_base [j];
bfe2612a 3950 /* DWARF sections under Mach-O have non-zero addresses. */
cecf136e 3951 offset = debug_information [i].loc_offsets [j] - section->address;
19e6b90e
L		 3952 next = section_begin + offset;
3953 base_address = debug_information [i].base_address;
3954
3955 if (!seen_first_offset)
3956 seen_first_offset = 1;
3957 else
3958 {
3959 if (start < next)
3960 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e
AM		 3961 (unsigned long) (start - section_begin),
3962 (unsigned long) (next - section_begin));
19e6b90e
L		 3963 else if (start > next)
3964 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e
AM		 3965 (unsigned long) (start - section_begin),
3966 (unsigned long) (next - section_begin));
19e6b90e
L		 3967 }
3968 start = next;
3969
3970 if (offset >= bytes)
3971 {
3972 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
3973 offset);
3974 continue;
3975 }
3976
3977 while (1)
3978 {
3979 if (start + 2 * pointer_size > section_end)
3980 {
3981 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
3982 offset);
3983 break;
3984 }
3985
2d9472a2
NC		 3986 /* Note: we use sign extension here in order to be sure that
3987 we can detect the -1 escape value. Sign extension into the
3988 top 32 bits of a 32-bit address will not affect the values
3989 that we display since we always show hex values, and always
cecf136e 3990 the bottom 32-bits. */
2d9472a2 3991 begin = byte_get_signed (start, pointer_size);
19e6b90e 3992 start += pointer_size;
2d9472a2 3993 end = byte_get_signed (start, pointer_size);
19e6b90e
L		 3994 start += pointer_size;
3995
2d9472a2
NC		 3996 printf (" %8.8lx ", offset);
3997
19e6b90e
L		 3998 if (begin == 0 && end == 0)
3999 {
2d9472a2 4000 printf (_("<End of list>\n"));
19e6b90e
L		 4001 break;
4002 }
4003
4004 /* Check base address specifiers. */
2d9472a2 4005 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
19e6b90e
L		 4006 {
4007 base_address = end;
2d9472a2
NC		 4008 print_dwarf_vma (begin, pointer_size);
4009 print_dwarf_vma (end, pointer_size);
4010 printf (_("(base address)\n"));
19e6b90e
L		 4011 continue;
4012 }
4013
4014 if (start + 2 > section_end)
4015 {
4016 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4017 offset);
4018 break;
4019 }
4020
4021 length = byte_get (start, 2);
4022 start += 2;
4023
4024 if (start + length > section_end)
4025 {
4026 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4027 offset);
4028 break;
4029 }
4030
2d9472a2
NC		 4031 print_dwarf_vma (begin + base_address, pointer_size);
4032 print_dwarf_vma (end + base_address, pointer_size);
4033
4034 putchar ('(');
19e6b90e
L		 4035 need_frame_base = decode_location_expression (start,
4036 pointer_size,
b7807392
JJ		 4037 offset_size,
4038 dwarf_version,
19e6b90e 4039 length,
f1c4cc75 4040 cu_offset, section);
19e6b90e
L		 4041 putchar (')');
4042
4043 if (need_frame_base && !has_frame_base)
4044 printf (_(" [without DW_AT_frame_base]"));
4045
4046 if (begin == end)
4047 fputs (_(" (start == end)"), stdout);
4048 else if (begin > end)
4049 fputs (_(" (start > end)"), stdout);
4050
4051 putchar ('\n');
4052
4053 start += length;
4054 }
4055 }
4056 }
031cd65f
NC		 4057
4058 if (start < section_end)
4059 warn (_("There are %ld unused bytes at the end of section %s\n"),
0eb090cb 4060 (long) (section_end - start), section->name);
98fb390a 4061 putchar ('\n');
51d0d03f 4062 free (array);
19e6b90e
L		 4063 return 1;
4064}
4065
4066static int
4067display_debug_str (struct dwarf_section *section,
4068 void *file ATTRIBUTE_UNUSED)
4069{
4070 unsigned char *start = section->start;
4071 unsigned long bytes = section->size;
4072 dwarf_vma addr = section->address;
4073
4074 if (bytes == 0)
4075 {
4076 printf (_("\nThe %s section is empty.\n"), section->name);
4077 return 0;
4078 }
4079
4080 printf (_("Contents of the %s section:\n\n"), section->name);
4081
4082 while (bytes)
4083 {
4084 int j;
4085 int k;
4086 int lbytes;
4087
4088 lbytes = (bytes > 16 ? 16 : bytes);
4089
4090 printf (" 0x%8.8lx ", (unsigned long) addr);
4091
4092 for (j = 0; j < 16; j++)
4093 {
4094 if (j < lbytes)
4095 printf ("%2.2x", start[j]);
4096 else
4097 printf (" ");
4098
4099 if ((j & 3) == 3)
4100 printf (" ");
4101 }
4102
4103 for (j = 0; j < lbytes; j++)
4104 {
4105 k = start[j];
4106 if (k >= ' ' && k < 0x80)
4107 printf ("%c", k);
4108 else
4109 printf (".");
4110 }
4111
4112 putchar ('\n');
4113
4114 start += lbytes;
4115 addr += lbytes;
4116 bytes -= lbytes;
4117 }
4118
4119 putchar ('\n');
4120
4121 return 1;
4122}
4123
19e6b90e
L		 4124static int
4125display_debug_info (struct dwarf_section *section, void *file)
4126{
6f875884 4127 return process_debug_info (section, file, abbrev, 0, 0);
19e6b90e
L		 4128}
4129
2b6f5997
CC		 4130static int
4131display_debug_types (struct dwarf_section *section, void *file)
4132{
6f875884
TG		 4133 return process_debug_info (section, file, abbrev, 0, 1);
4134}
4135
4136static int
4137display_trace_info (struct dwarf_section *section, void *file)
4138{
4139 return process_debug_info (section, file, trace_abbrev, 0, 0);
2b6f5997 4140}
19e6b90e
L		 4141
4142static int
4143display_debug_aranges (struct dwarf_section *section,
4144 void *file ATTRIBUTE_UNUSED)
4145{
4146 unsigned char *start = section->start;
4147 unsigned char *end = start + section->size;
4148
80c35038 4149 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e 4150
6e3d6dc1
NC		 4151 /* It does not matter if this load fails,
4152 we test for that later on. */
4153 load_debug_info (file);
4154
19e6b90e
L		 4155 while (start < end)
4156 {
4157 unsigned char *hdrptr;
4158 DWARF2_Internal_ARange arange;
91d6fa6a 4159 unsigned char *addr_ranges;
2d9472a2
NC		 4160 dwarf_vma length;
4161 dwarf_vma address;
53b8873b 4162 unsigned char address_size;
19e6b90e
L		 4163 int excess;
4164 int offset_size;
4165 int initial_length_size;
4166
4167 hdrptr = start;
4168
4169 arange.ar_length = byte_get (hdrptr, 4);
4170 hdrptr += 4;
4171
4172 if (arange.ar_length == 0xffffffff)
4173 {
4174 arange.ar_length = byte_get (hdrptr, 8);
4175 hdrptr += 8;
4176 offset_size = 8;
4177 initial_length_size = 12;
4178 }
4179 else
4180 {
4181 offset_size = 4;
4182 initial_length_size = 4;
4183 }
4184
4185 arange.ar_version = byte_get (hdrptr, 2);
4186 hdrptr += 2;
4187
4188 arange.ar_info_offset = byte_get (hdrptr, offset_size);
4189 hdrptr += offset_size;
4190
6e3d6dc1
NC		 4191 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4192 && num_debug_info_entries > 0
4193 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4194 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 4195 (unsigned long) arange.ar_info_offset, section->name);
6e3d6dc1 4196
19e6b90e
L		 4197 arange.ar_pointer_size = byte_get (hdrptr, 1);
4198 hdrptr += 1;
4199
4200 arange.ar_segment_size = byte_get (hdrptr, 1);
4201 hdrptr += 1;
4202
4203 if (arange.ar_version != 2 && arange.ar_version != 3)
4204 {
4205 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4206 break;
4207 }
4208
47704ddf
KT		 4209 printf (_(" Length: %ld\n"),
4210 (long) arange.ar_length);
19e6b90e 4211 printf (_(" Version: %d\n"), arange.ar_version);
47704ddf
KT		 4212 printf (_(" Offset into .debug_info: 0x%lx\n"),
4213 (unsigned long) arange.ar_info_offset);
19e6b90e
L		 4214 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4215 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4216
53b8873b
NC		 4217 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4218
b3681d67
L		 4219 if (address_size == 0)
4220 {
4221 error (_("Invalid address size in %s section!\n"),
4222 section->name);
4223 break;
4224 }
4225
53b8873b
NC		 4226 /* The DWARF spec does not require that the address size be a power
4227 of two, but we do. This will have to change if we ever encounter
4228 an uneven architecture. */
4229 if ((address_size & (address_size - 1)) != 0)
4230 {
4231 warn (_("Pointer size + Segment size is not a power of two.\n"));
4232 break;
4233 }
cecf136e 4234
209c9a13
NC		 4235 if (address_size > 4)
4236 printf (_("\n Address Length\n"));
4237 else
4238 printf (_("\n Address Length\n"));
19e6b90e 4239
91d6fa6a 4240 addr_ranges = hdrptr;
19e6b90e 4241
53b8873b
NC		 4242 /* Must pad to an alignment boundary that is twice the address size. */
4243 excess = (hdrptr - start) % (2 * address_size);
19e6b90e 4244 if (excess)
91d6fa6a 4245 addr_ranges += (2 * address_size) - excess;
19e6b90e 4246
1617e571
AM		 4247 start += arange.ar_length + initial_length_size;
4248
91d6fa6a 4249 while (addr_ranges + 2 * address_size <= start)
19e6b90e 4250 {
91d6fa6a 4251 address = byte_get (addr_ranges, address_size);
19e6b90e 4252
91d6fa6a 4253 addr_ranges += address_size;
19e6b90e 4254
91d6fa6a 4255 length = byte_get (addr_ranges, address_size);
19e6b90e 4256
91d6fa6a 4257 addr_ranges += address_size;
19e6b90e 4258
80c35038 4259 printf (" ");
2d9472a2
NC		 4260 print_dwarf_vma (address, address_size);
4261 print_dwarf_vma (length, address_size);
4262 putchar ('\n');
19e6b90e 4263 }
19e6b90e
L		 4264 }
4265
4266 printf ("\n");
4267
4268 return 1;
4269}
4270
01a8f077
JK		 4271/* Each debug_information[x].range_lists[y] gets this representation for
4272 sorting purposes. */
4273
4274struct range_entry
467c65bc
NC		 4275{
4276 /* The debug_information[x].range_lists[y] value. */
4277 unsigned long ranges_offset;
01a8f077 4278
467c65bc
NC		 4279 /* Original debug_information to find parameters of the data. */
4280 debug_info *debug_info_p;
4281};
01a8f077
JK		 4282
4283/* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4284
4285static int
4286range_entry_compar (const void *ap, const void *bp)
4287{
3f5e193b
NC		 4288 const struct range_entry *a_re = (const struct range_entry *) ap;
4289 const struct range_entry *b_re = (const struct range_entry *) bp;
01a8f077
JK		 4290 const unsigned long a = a_re->ranges_offset;
4291 const unsigned long b = b_re->ranges_offset;
4292
4293 return (a > b) - (b > a);
4294}
4295
19e6b90e
L		 4296static int
4297display_debug_ranges (struct dwarf_section *section,
4298 void *file ATTRIBUTE_UNUSED)
4299{
4300 unsigned char *start = section->start;
19e6b90e
L		 4301 unsigned long bytes;
4302 unsigned char *section_begin = start;
01a8f077
JK		 4303 unsigned int num_range_list, i;
4304 struct range_entry *range_entries, *range_entry_fill;
19e6b90e
L		 4305
4306 bytes = section->size;
19e6b90e
L		 4307
4308 if (bytes == 0)
4309 {
4310 printf (_("\nThe %s section is empty.\n"), section->name);
4311 return 0;
4312 }
4313
1febe64d
NC		 4314 if (load_debug_info (file) == 0)
4315 {
4316 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4317 section->name);
4318 return 0;
4319 }
19e6b90e 4320
01a8f077 4321 num_range_list = 0;
19e6b90e 4322 for (i = 0; i < num_debug_info_entries; i++)
01a8f077 4323 num_range_list += debug_information [i].num_range_lists;
19e6b90e 4324
01a8f077
JK		 4325 if (num_range_list == 0)
4326 error (_("No range lists in .debug_info section!\n"));
19e6b90e 4327
3f5e193b
NC		 4328 range_entries = (struct range_entry *)
4329 xmalloc (sizeof (*range_entries) * num_range_list);
01a8f077 4330 range_entry_fill = range_entries;
19e6b90e 4331
01a8f077
JK		 4332 for (i = 0; i < num_debug_info_entries; i++)
4333 {
4334 debug_info *debug_info_p = &debug_information[i];
4335 unsigned int j;
4336
4337 for (j = 0; j < debug_info_p->num_range_lists; j++)
4338 {
4339 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
4340 range_entry_fill->debug_info_p = debug_info_p;
4341 range_entry_fill++;
19e6b90e
L		 4342 }
4343 }
4344
01a8f077
JK		 4345 qsort (range_entries, num_range_list, sizeof (*range_entries),
4346 range_entry_compar);
19e6b90e 4347
bfe2612a 4348 /* DWARF sections under Mach-O have non-zero addresses. */
01a8f077 4349 if (range_entries[0].ranges_offset != section->address)
19e6b90e 4350 warn (_("Range lists in %s section start at 0x%lx\n"),
01a8f077 4351 section->name, range_entries[0].ranges_offset);
19e6b90e
L		 4352
4353 printf (_("Contents of the %s section:\n\n"), section->name);
4354 printf (_(" Offset Begin End\n"));
4355
01a8f077 4356 for (i = 0; i < num_range_list; i++)
19e6b90e 4357 {
01a8f077
JK		 4358 struct range_entry *range_entry = &range_entries[i];
4359 debug_info *debug_info_p = range_entry->debug_info_p;
19e6b90e 4360 unsigned int pointer_size;
01a8f077
JK		 4361 unsigned long offset;
4362 unsigned char *next;
19e6b90e
L		 4363 unsigned long base_address;
4364
01a8f077
JK		 4365 pointer_size = debug_info_p->pointer_size;
4366
4367 /* DWARF sections under Mach-O have non-zero addresses. */
4368 offset = range_entry->ranges_offset - section->address;
4369 next = section_begin + offset;
4370 base_address = debug_info_p->base_address;
cecf136e 4371
01a8f077 4372 if (i > 0)
19e6b90e 4373 {
01a8f077
JK		 4374 if (start < next)
4375 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4376 (unsigned long) (start - section_begin),
4377 (unsigned long) (next - section_begin), section->name);
4378 else if (start > next)
4379 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4380 (unsigned long) (start - section_begin),
4381 (unsigned long) (next - section_begin), section->name);
4382 }
4383 start = next;
19e6b90e 4384
01a8f077
JK		 4385 while (1)
4386 {
4387 dwarf_vma begin;
4388 dwarf_vma end;
4389
4390 /* Note: we use sign extension here in order to be sure that
4391 we can detect the -1 escape value. Sign extension into the
4392 top 32 bits of a 32-bit address will not affect the values
4393 that we display since we always show hex values, and always
4394 the bottom 32-bits. */
4395 begin = byte_get_signed (start, pointer_size);
4396 start += pointer_size;
4397 end = byte_get_signed (start, pointer_size);
4398 start += pointer_size;
4399
4400 printf (" %8.8lx ", offset);
4401
4402 if (begin == 0 && end == 0)
19e6b90e 4403 {
01a8f077
JK		 4404 printf (_("<End of list>\n"));
4405 break;
19e6b90e 4406 }
19e6b90e 4407
01a8f077
JK		 4408 /* Check base address specifiers. */
4409 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
19e6b90e 4410 {
01a8f077
JK		 4411 base_address = end;
4412 print_dwarf_vma (begin, pointer_size);
4413 print_dwarf_vma (end, pointer_size);
4414 printf ("(base address)\n");
4415 continue;
4416 }
19e6b90e 4417
01a8f077
JK		 4418 print_dwarf_vma (begin + base_address, pointer_size);
4419 print_dwarf_vma (end + base_address, pointer_size);
4a149252 4420
01a8f077
JK		 4421 if (begin == end)
4422 fputs (_("(start == end)"), stdout);
4423 else if (begin > end)
4424 fputs (_("(start > end)"), stdout);
19e6b90e 4425
01a8f077 4426 putchar ('\n');
19e6b90e
L		 4427 }
4428 }
4429 putchar ('\n');
01a8f077
JK		 4430
4431 free (range_entries);
4432
19e6b90e
L		 4433 return 1;
4434}
4435
4436typedef struct Frame_Chunk
4437{
4438 struct Frame_Chunk *next;
4439 unsigned char *chunk_start;
4440 int ncols;
4441 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4442 short int *col_type;
4443 int *col_offset;
4444 char *augmentation;
4445 unsigned int code_factor;
4446 int data_factor;
4447 unsigned long pc_begin;
4448 unsigned long pc_range;
4449 int cfa_reg;
4450 int cfa_offset;
4451 int ra;
4452 unsigned char fde_encoding;
4453 unsigned char cfa_exp;
604282a7
JJ		 4454 unsigned char ptr_size;
4455 unsigned char segment_size;
19e6b90e
L		 4456}
4457Frame_Chunk;
4458
665ce1f6
L		 4459static const char *const *dwarf_regnames;
4460static unsigned int dwarf_regnames_count;
4461
19e6b90e
L		 4462/* A marker for a col_type that means this column was never referenced
4463 in the frame info. */
4464#define DW_CFA_unreferenced (-1)
4465
665ce1f6
L		 4466/* Return 0 if not more space is needed, 1 if more space is needed,
4467 -1 for invalid reg. */
4468
4469static int
4470frame_need_space (Frame_Chunk *fc, unsigned int reg)
19e6b90e
L		 4471{
4472 int prev = fc->ncols;
4473
665ce1f6
L		 4474 if (reg < (unsigned int) fc->ncols)
4475 return 0;
4476
4477 if (dwarf_regnames_count
4478 && reg > dwarf_regnames_count)
4479 return -1;
19e6b90e
L		 4480
4481 fc->ncols = reg + 1;
3f5e193b
NC		 4482 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
4483 sizeof (short int));
4484 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
19e6b90e
L		 4485
4486 while (prev < fc->ncols)
4487 {
4488 fc->col_type[prev] = DW_CFA_unreferenced;
4489 fc->col_offset[prev] = 0;
4490 prev++;
4491 }
665ce1f6 4492 return 1;
19e6b90e
L		 4493}
4494
2dc4cec1
L		 4495static const char *const dwarf_regnames_i386[] =
4496{
4497 "eax", "ecx", "edx", "ebx",
4498 "esp", "ebp", "esi", "edi",
4499 "eip", "eflags", NULL,
4500 "st0", "st1", "st2", "st3",
4501 "st4", "st5", "st6", "st7",
4502 NULL, NULL,
4503 "xmm0", "xmm1", "xmm2", "xmm3",
4504 "xmm4", "xmm5", "xmm6", "xmm7",
4505 "mm0", "mm1", "mm2", "mm3",
4506 "mm4", "mm5", "mm6", "mm7",
4507 "fcw", "fsw", "mxcsr",
4508 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
a656ed5b 4509 "tr", "ldtr"
2dc4cec1
L		 4510};
4511
b129eb0e
RH		 4512void
4513init_dwarf_regnames_i386 (void)
4514{
4515 dwarf_regnames = dwarf_regnames_i386;
4516 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
4517}
4518
2dc4cec1
L		 4519static const char *const dwarf_regnames_x86_64[] =
4520{
4521 "rax", "rdx", "rcx", "rbx",
4522 "rsi", "rdi", "rbp", "rsp",
4523 "r8", "r9", "r10", "r11",
4524 "r12", "r13", "r14", "r15",
4525 "rip",
4526 "xmm0", "xmm1", "xmm2", "xmm3",
4527 "xmm4", "xmm5", "xmm6", "xmm7",
4528 "xmm8", "xmm9", "xmm10", "xmm11",
4529 "xmm12", "xmm13", "xmm14", "xmm15",
4530 "st0", "st1", "st2", "st3",
4531 "st4", "st5", "st6", "st7",
4532 "mm0", "mm1", "mm2", "mm3",
4533 "mm4", "mm5", "mm6", "mm7",
4534 "rflags",
4535 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
4536 "fs.base", "gs.base", NULL, NULL,
4537 "tr", "ldtr",
a656ed5b 4538 "mxcsr", "fcw", "fsw"
2dc4cec1
L		 4539};
4540
b129eb0e
RH		 4541void
4542init_dwarf_regnames_x86_64 (void)
4543{
4544 dwarf_regnames = dwarf_regnames_x86_64;
4545 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
4546}
4547
2dc4cec1
L		 4548void
4549init_dwarf_regnames (unsigned int e_machine)
4550{
4551 switch (e_machine)
4552 {
4553 case EM_386:
4554 case EM_486:
b129eb0e 4555 init_dwarf_regnames_i386 ();
2dc4cec1
L		 4556 break;
4557
4558 case EM_X86_64:
7f502d6c 4559 case EM_L1OM:
7a9068fe 4560 case EM_K1OM:
b129eb0e 4561 init_dwarf_regnames_x86_64 ();
2dc4cec1
L		 4562 break;
4563
4564 default:
4565 break;
4566 }
4567}
4568
4569static const char *
4570regname (unsigned int regno, int row)
4571{
4572 static char reg[64];
4573 if (dwarf_regnames
4574 && regno < dwarf_regnames_count
4575 && dwarf_regnames [regno] != NULL)
4576 {
4577 if (row)
4578 return dwarf_regnames [regno];
4579 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
4580 dwarf_regnames [regno]);
4581 }
4582 else
4583 snprintf (reg, sizeof (reg), "r%d", regno);
4584 return reg;
4585}
4586
19e6b90e
L		 4587static void
4588frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
4589{
4590 int r;
4591 char tmp[100];
4592
4593 if (*max_regs < fc->ncols)
4594 *max_regs = fc->ncols;
4595
4596 if (*need_col_headers)
4597 {
91d6fa6a 4598 static const char *sloc = " LOC";
2dc4cec1 4599
19e6b90e
L		 4600 *need_col_headers = 0;
4601
91d6fa6a 4602 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
19e6b90e
L		 4603
4604 for (r = 0; r < *max_regs; r++)
4605 if (fc->col_type[r] != DW_CFA_unreferenced)
4606 {
4607 if (r == fc->ra)
2dc4cec1 4608 printf ("ra ");
19e6b90e 4609 else
2dc4cec1 4610 printf ("%-5s ", regname (r, 1));
19e6b90e
L		 4611 }
4612
4613 printf ("\n");
4614 }
4615
2dc4cec1 4616 printf ("%0*lx ", eh_addr_size * 2, fc->pc_begin);
19e6b90e
L		 4617 if (fc->cfa_exp)
4618 strcpy (tmp, "exp");
4619 else
2dc4cec1 4620 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
19e6b90e
L		 4621 printf ("%-8s ", tmp);
4622
4623 for (r = 0; r < fc->ncols; r++)
4624 {
4625 if (fc->col_type[r] != DW_CFA_unreferenced)
4626 {
4627 switch (fc->col_type[r])
4628 {
4629 case DW_CFA_undefined:
4630 strcpy (tmp, "u");
4631 break;
4632 case DW_CFA_same_value:
4633 strcpy (tmp, "s");
4634 break;
4635 case DW_CFA_offset:
4636 sprintf (tmp, "c%+d", fc->col_offset[r]);
4637 break;
12eae2d3
JJ		 4638 case DW_CFA_val_offset:
4639 sprintf (tmp, "v%+d", fc->col_offset[r]);
4640 break;
19e6b90e 4641 case DW_CFA_register:
2dc4cec1 4642 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
19e6b90e
L		 4643 break;
4644 case DW_CFA_expression:
4645 strcpy (tmp, "exp");
4646 break;
12eae2d3
JJ		 4647 case DW_CFA_val_expression:
4648 strcpy (tmp, "vexp");
4649 break;
19e6b90e
L		 4650 default:
4651 strcpy (tmp, "n/a");
4652 break;
4653 }
2dc4cec1 4654 printf ("%-5s ", tmp);
19e6b90e
L		 4655 }
4656 }
4657 printf ("\n");
4658}
4659
19e6b90e
L		 4660#define GET(N) byte_get (start, N); start += N
4661#define LEB() read_leb128 (start, & length_return, 0); start += length_return
467c65bc 4662#define SLEB() read_sleb128 (start, & length_return); start += length_return
19e6b90e
L		 4663
4664static int
4665display_debug_frames (struct dwarf_section *section,
4666 void *file ATTRIBUTE_UNUSED)
4667{
4668 unsigned char *start = section->start;
4669 unsigned char *end = start + section->size;
4670 unsigned char *section_start = start;
4671 Frame_Chunk *chunks = 0;
4672 Frame_Chunk *remembered_state = 0;
4673 Frame_Chunk *rs;
4674 int is_eh = strcmp (section->name, ".eh_frame") == 0;
4675 unsigned int length_return;
4676 int max_regs = 0;
665ce1f6 4677 const char *bad_reg = _("bad register: ");
604282a7 4678 int saved_eh_addr_size = eh_addr_size;
19e6b90e 4679
80c35038 4680 printf (_("Contents of the %s section:\n"), section->name);
19e6b90e
L		 4681
4682 while (start < end)
4683 {
4684 unsigned char *saved_start;
4685 unsigned char *block_end;
4686 unsigned long length;
4687 unsigned long cie_id;
4688 Frame_Chunk *fc;
4689 Frame_Chunk *cie;
4690 int need_col_headers = 1;
4691 unsigned char *augmentation_data = NULL;
4692 unsigned long augmentation_data_len = 0;
604282a7 4693 int encoded_ptr_size = saved_eh_addr_size;
19e6b90e
L		 4694 int offset_size;
4695 int initial_length_size;
4696
4697 saved_start = start;
4698 length = byte_get (start, 4); start += 4;
4699
4700 if (length == 0)
4701 {
4702 printf ("\n%08lx ZERO terminator\n\n",
4703 (unsigned long)(saved_start - section_start));
b758e50f 4704 continue;
19e6b90e
L		 4705 }
4706
4707 if (length == 0xffffffff)
4708 {
4709 length = byte_get (start, 8);
4710 start += 8;
4711 offset_size = 8;
4712 initial_length_size = 12;
4713 }
4714 else
4715 {
4716 offset_size = 4;
4717 initial_length_size = 4;
4718 }
4719
4720 block_end = saved_start + length + initial_length_size;
53b8873b
NC		 4721 if (block_end > end)
4722 {
4723 warn ("Invalid length %#08lx in FDE at %#08lx\n",
4724 length, (unsigned long)(saved_start - section_start));
4725 block_end = end;
4726 }
19e6b90e
L		 4727 cie_id = byte_get (start, offset_size); start += offset_size;
4728
4729 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
4730 {
4731 int version;
4732
3f5e193b 4733 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
19e6b90e
L		 4734 memset (fc, 0, sizeof (Frame_Chunk));
4735
4736 fc->next = chunks;
4737 chunks = fc;
4738 fc->chunk_start = saved_start;
4739 fc->ncols = 0;
3f5e193b
NC		 4740 fc->col_type = (short int *) xmalloc (sizeof (short int));
4741 fc->col_offset = (int *) xmalloc (sizeof (int));
cc86f28f 4742 frame_need_space (fc, max_regs - 1);
19e6b90e
L		 4743
4744 version = *start++;
4745
4746 fc->augmentation = (char *) start;
4747 start = (unsigned char *) strchr ((char *) start, '\0') + 1;
4748
604282a7
JJ		 4749 if (strcmp (fc->augmentation, "eh") == 0)
4750 start += eh_addr_size;
4751
4752 if (version >= 4)
19e6b90e 4753 {
604282a7
JJ		 4754 fc->ptr_size = GET (1);
4755 fc->segment_size = GET (1);
4756 eh_addr_size = fc->ptr_size;
19e6b90e 4757 }
604282a7 4758 else
19e6b90e 4759 {
604282a7
JJ		 4760 fc->ptr_size = eh_addr_size;
4761 fc->segment_size = 0;
4762 }
4763 fc->code_factor = LEB ();
4764 fc->data_factor = SLEB ();
4765 if (version == 1)
4766 {
4767 fc->ra = GET (1);
19e6b90e
L		 4768 }
4769 else
4770 {
604282a7
JJ		 4771 fc->ra = LEB ();
4772 }
4773
4774 if (fc->augmentation[0] == 'z')
4775 {
4776 augmentation_data_len = LEB ();
4777 augmentation_data = start;
4778 start += augmentation_data_len;
19e6b90e
L		 4779 }
4780 cie = fc;
4781
4782 if (do_debug_frames_interp)
4783 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
4784 (unsigned long)(saved_start - section_start), length, cie_id,
4785 fc->augmentation, fc->code_factor, fc->data_factor,
4786 fc->ra);
4787 else
4788 {
4789 printf ("\n%08lx %08lx %08lx CIE\n",
4790 (unsigned long)(saved_start - section_start), length, cie_id);
4791 printf (" Version: %d\n", version);
4792 printf (" Augmentation: \"%s\"\n", fc->augmentation);
604282a7
JJ		 4793 if (version >= 4)
4794 {
4795 printf (" Pointer Size: %u\n", fc->ptr_size);
4796 printf (" Segment Size: %u\n", fc->segment_size);
4797 }
19e6b90e
L		 4798 printf (" Code alignment factor: %u\n", fc->code_factor);
4799 printf (" Data alignment factor: %d\n", fc->data_factor);
4800 printf (" Return address column: %d\n", fc->ra);
4801
4802 if (augmentation_data_len)
4803 {
4804 unsigned long i;
4805 printf (" Augmentation data: ");
4806 for (i = 0; i < augmentation_data_len; ++i)
4807 printf (" %02x", augmentation_data[i]);
4808 putchar ('\n');
4809 }
4810 putchar ('\n');
4811 }
4812
4813 if (augmentation_data_len)
4814 {
4815 unsigned char *p, *q;
4816 p = (unsigned char *) fc->augmentation + 1;
4817 q = augmentation_data;
4818
4819 while (1)
4820 {
4821 if (*p == 'L')
4822 q++;
4823 else if (*p == 'P')
4824 q += 1 + size_of_encoded_value (*q);
4825 else if (*p == 'R')
4826 fc->fde_encoding = *q++;
d80e8de2
JB		 4827 else if (*p == 'S')
4828 ;
19e6b90e
L		 4829 else
4830 break;
4831 p++;
4832 }
4833
4834 if (fc->fde_encoding)
4835 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4836 }
4837
4838 frame_need_space (fc, fc->ra);
4839 }
4840 else
4841 {
4842 unsigned char *look_for;
4843 static Frame_Chunk fde_fc;
604282a7 4844 unsigned long segment_selector;
19e6b90e
L		 4845
4846 fc = & fde_fc;
4847 memset (fc, 0, sizeof (Frame_Chunk));
4848
4849 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
4850
4851 for (cie = chunks; cie ; cie = cie->next)
4852 if (cie->chunk_start == look_for)
4853 break;
4854
4855 if (!cie)
4856 {
53b8873b 4857 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
1617e571 4858 cie_id, (unsigned long)(saved_start - section_start));
19e6b90e 4859 fc->ncols = 0;
3f5e193b
NC		 4860 fc->col_type = (short int *) xmalloc (sizeof (short int));
4861 fc->col_offset = (int *) xmalloc (sizeof (int));
19e6b90e
L		 4862 frame_need_space (fc, max_regs - 1);
4863 cie = fc;
4864 fc->augmentation = "";
4865 fc->fde_encoding = 0;
604282a7
JJ		 4866 fc->ptr_size = eh_addr_size;
4867 fc->segment_size = 0;
19e6b90e
L		 4868 }
4869 else
4870 {
4871 fc->ncols = cie->ncols;
3f5e193b
NC		 4872 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
4873 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
19e6b90e
L		 4874 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
4875 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
4876 fc->augmentation = cie->augmentation;
604282a7
JJ		 4877 fc->ptr_size = cie->ptr_size;
4878 eh_addr_size = cie->ptr_size;
4879 fc->segment_size = cie->segment_size;
19e6b90e
L		 4880 fc->code_factor = cie->code_factor;
4881 fc->data_factor = cie->data_factor;
4882 fc->cfa_reg = cie->cfa_reg;
4883 fc->cfa_offset = cie->cfa_offset;
4884 fc->ra = cie->ra;
cc86f28f 4885 frame_need_space (fc, max_regs - 1);
19e6b90e
L		 4886 fc->fde_encoding = cie->fde_encoding;
4887 }
4888
4889 if (fc->fde_encoding)
4890 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
4891
604282a7
JJ		 4892 segment_selector = 0;
4893 if (fc->segment_size)
4894 {
4895 segment_selector = byte_get (start, fc->segment_size);
4896 start += fc->segment_size;
4897 }
bad62cf5 4898 fc->pc_begin = get_encoded_value (start, fc->fde_encoding, section);
19e6b90e
L		 4899 start += encoded_ptr_size;
4900 fc->pc_range = byte_get (start, encoded_ptr_size);
4901 start += encoded_ptr_size;
4902
4903 if (cie->augmentation[0] == 'z')
4904 {
4905 augmentation_data_len = LEB ();
4906 augmentation_data = start;
4907 start += augmentation_data_len;
4908 }
4909
604282a7 4910 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
19e6b90e 4911 (unsigned long)(saved_start - section_start), length, cie_id,
604282a7
JJ		 4912 (unsigned long)(cie->chunk_start - section_start));
4913 if (fc->segment_size)
4914 printf ("%04lx:", segment_selector);
4915 printf ("%08lx..%08lx\n", fc->pc_begin, fc->pc_begin + fc->pc_range);
19e6b90e
L		 4916 if (! do_debug_frames_interp && augmentation_data_len)
4917 {
4918 unsigned long i;
4919
4920 printf (" Augmentation data: ");
4921 for (i = 0; i < augmentation_data_len; ++i)
4922 printf (" %02x", augmentation_data[i]);
4923 putchar ('\n');
4924 putchar ('\n');
4925 }
4926 }
4927
4928 /* At this point, fc is the current chunk, cie (if any) is set, and
4929 we're about to interpret instructions for the chunk. */
4930 /* ??? At present we need to do this always, since this sizes the
4931 fc->col_type and fc->col_offset arrays, which we write into always.
4932 We should probably split the interpreted and non-interpreted bits
4933 into two different routines, since there's so much that doesn't
4934 really overlap between them. */
4935 if (1 || do_debug_frames_interp)
4936 {
4937 /* Start by making a pass over the chunk, allocating storage
4938 and taking note of what registers are used. */
4939 unsigned char *tmp = start;
4940
4941 while (start < block_end)
4942 {
4943 unsigned op, opa;
91d6fa6a 4944 unsigned long reg, temp;
19e6b90e
L		 4945
4946 op = *start++;
4947 opa = op & 0x3f;
4948 if (op & 0xc0)
4949 op &= 0xc0;
4950
4951 /* Warning: if you add any more cases to this switch, be
4952 sure to add them to the corresponding switch below. */
4953 switch (op)
4954 {
4955 case DW_CFA_advance_loc:
4956 break;
4957 case DW_CFA_offset:
4958 LEB ();
665ce1f6
L		 4959 if (frame_need_space (fc, opa) >= 0)
4960 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 4961 break;
4962 case DW_CFA_restore:
665ce1f6
L		 4963 if (frame_need_space (fc, opa) >= 0)
4964 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 4965 break;
4966 case DW_CFA_set_loc:
4967 start += encoded_ptr_size;
4968 break;
4969 case DW_CFA_advance_loc1:
4970 start += 1;
4971 break;
4972 case DW_CFA_advance_loc2:
4973 start += 2;
4974 break;
4975 case DW_CFA_advance_loc4:
4976 start += 4;
4977 break;
4978 case DW_CFA_offset_extended:
12eae2d3 4979 case DW_CFA_val_offset:
19e6b90e 4980 reg = LEB (); LEB ();
665ce1f6
L		 4981 if (frame_need_space (fc, reg) >= 0)
4982 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 4983 break;
4984 case DW_CFA_restore_extended:
4985 reg = LEB ();
4986 frame_need_space (fc, reg);
665ce1f6
L		 4987 if (frame_need_space (fc, reg) >= 0)
4988 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 4989 break;
4990 case DW_CFA_undefined:
4991 reg = LEB ();
665ce1f6
L		 4992 if (frame_need_space (fc, reg) >= 0)
4993 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 4994 break;
4995 case DW_CFA_same_value:
4996 reg = LEB ();
665ce1f6
L		 4997 if (frame_need_space (fc, reg) >= 0)
4998 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 4999 break;
5000 case DW_CFA_register:
5001 reg = LEB (); LEB ();
665ce1f6
L		 5002 if (frame_need_space (fc, reg) >= 0)
5003 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 5004 break;
5005 case DW_CFA_def_cfa:
5006 LEB (); LEB ();
5007 break;
5008 case DW_CFA_def_cfa_register:
5009 LEB ();
5010 break;
5011 case DW_CFA_def_cfa_offset:
5012 LEB ();
5013 break;
5014 case DW_CFA_def_cfa_expression:
91d6fa6a
NC		 5015 temp = LEB ();
5016 start += temp;
19e6b90e
L		 5017 break;
5018 case DW_CFA_expression:
12eae2d3 5019 case DW_CFA_val_expression:
19e6b90e 5020 reg = LEB ();
91d6fa6a
NC		 5021 temp = LEB ();
5022 start += temp;
665ce1f6
L		 5023 if (frame_need_space (fc, reg) >= 0)
5024 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 5025 break;
5026 case DW_CFA_offset_extended_sf:
12eae2d3 5027 case DW_CFA_val_offset_sf:
19e6b90e 5028 reg = LEB (); SLEB ();
665ce1f6
L		 5029 if (frame_need_space (fc, reg) >= 0)
5030 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 5031 break;
5032 case DW_CFA_def_cfa_sf:
5033 LEB (); SLEB ();
5034 break;
5035 case DW_CFA_def_cfa_offset_sf:
5036 SLEB ();
5037 break;
5038 case DW_CFA_MIPS_advance_loc8:
5039 start += 8;
5040 break;
5041 case DW_CFA_GNU_args_size:
5042 LEB ();
5043 break;
5044 case DW_CFA_GNU_negative_offset_extended:
5045 reg = LEB (); LEB ();
665ce1f6
L		 5046 if (frame_need_space (fc, reg) >= 0)
5047 fc->col_type[reg] = DW_CFA_undefined;
5048 break;
19e6b90e
L		 5049 default:
5050 break;
5051 }
5052 }
5053 start = tmp;
5054 }
5055
5056 /* Now we know what registers are used, make a second pass over
5057 the chunk, this time actually printing out the info. */
5058
5059 while (start < block_end)
5060 {
5061 unsigned op, opa;
5062 unsigned long ul, reg, roffs;
5063 long l, ofs;
5064 dwarf_vma vma;
665ce1f6 5065 const char *reg_prefix = "";
19e6b90e
L		 5066
5067 op = *start++;
5068 opa = op & 0x3f;
5069 if (op & 0xc0)
5070 op &= 0xc0;
5071
5072 /* Warning: if you add any more cases to this switch, be
5073 sure to add them to the corresponding switch above. */
5074 switch (op)
5075 {
5076 case DW_CFA_advance_loc:
5077 if (do_debug_frames_interp)
5078 frame_display_row (fc, &need_col_headers, &max_regs);
5079 else
5080 printf (" DW_CFA_advance_loc: %d to %08lx\n",
5081 opa * fc->code_factor,
5082 fc->pc_begin + opa * fc->code_factor);
5083 fc->pc_begin += opa * fc->code_factor;
5084 break;
5085
5086 case DW_CFA_offset:
5087 roffs = LEB ();
665ce1f6
L		 5088 if (opa >= (unsigned int) fc->ncols)
5089 reg_prefix = bad_reg;
5090 if (! do_debug_frames_interp || *reg_prefix != '\0')
5091 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5092 reg_prefix, regname (opa, 0),
5093 roffs * fc->data_factor);
5094 if (*reg_prefix == '\0')
5095 {
5096 fc->col_type[opa] = DW_CFA_offset;
5097 fc->col_offset[opa] = roffs * fc->data_factor;
5098 }
19e6b90e
L		 5099 break;
5100
5101 case DW_CFA_restore:
665ce1f6
L		 5102 if (opa >= (unsigned int) cie->ncols
5103 || opa >= (unsigned int) fc->ncols)
5104 reg_prefix = bad_reg;
5105 if (! do_debug_frames_interp || *reg_prefix != '\0')
5106 printf (" DW_CFA_restore: %s%s\n",
5107 reg_prefix, regname (opa, 0));
5108 if (*reg_prefix == '\0')
5109 {
5110 fc->col_type[opa] = cie->col_type[opa];
5111 fc->col_offset[opa] = cie->col_offset[opa];
5112 }
19e6b90e
L		 5113 break;
5114
5115 case DW_CFA_set_loc:
bad62cf5 5116 vma = get_encoded_value (start, fc->fde_encoding, section);
19e6b90e
L		 5117 start += encoded_ptr_size;
5118 if (do_debug_frames_interp)
5119 frame_display_row (fc, &need_col_headers, &max_regs);
5120 else
5121 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
5122 fc->pc_begin = vma;
5123 break;
5124
5125 case DW_CFA_advance_loc1:
5126 ofs = byte_get (start, 1); start += 1;
5127 if (do_debug_frames_interp)
5128 frame_display_row (fc, &need_col_headers, &max_regs);
5129 else
5130 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
5131 ofs * fc->code_factor,
5132 fc->pc_begin + ofs * fc->code_factor);
5133 fc->pc_begin += ofs * fc->code_factor;
5134 break;
5135
5136 case DW_CFA_advance_loc2:
5137 ofs = byte_get (start, 2); start += 2;
5138 if (do_debug_frames_interp)
5139 frame_display_row (fc, &need_col_headers, &max_regs);
5140 else
5141 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
5142 ofs * fc->code_factor,
5143 fc->pc_begin + ofs * fc->code_factor);
5144 fc->pc_begin += ofs * fc->code_factor;
5145 break;
5146
5147 case DW_CFA_advance_loc4:
5148 ofs = byte_get (start, 4); start += 4;
5149 if (do_debug_frames_interp)
5150 frame_display_row (fc, &need_col_headers, &max_regs);
5151 else
5152 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
5153 ofs * fc->code_factor,
5154 fc->pc_begin + ofs * fc->code_factor);
5155 fc->pc_begin += ofs * fc->code_factor;
5156 break;
5157
5158 case DW_CFA_offset_extended:
5159 reg = LEB ();
5160 roffs = LEB ();
665ce1f6
L		 5161 if (reg >= (unsigned int) fc->ncols)
5162 reg_prefix = bad_reg;
5163 if (! do_debug_frames_interp || *reg_prefix != '\0')
5164 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5165 reg_prefix, regname (reg, 0),
5166 roffs * fc->data_factor);
5167 if (*reg_prefix == '\0')
5168 {
5169 fc->col_type[reg] = DW_CFA_offset;
5170 fc->col_offset[reg] = roffs * fc->data_factor;
5171 }
19e6b90e
L		 5172 break;
5173
12eae2d3
JJ		 5174 case DW_CFA_val_offset:
5175 reg = LEB ();
5176 roffs = LEB ();
665ce1f6
L		 5177 if (reg >= (unsigned int) fc->ncols)
5178 reg_prefix = bad_reg;
5179 if (! do_debug_frames_interp || *reg_prefix != '\0')
5180 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5181 reg_prefix, regname (reg, 0),
5182 roffs * fc->data_factor);
5183 if (*reg_prefix == '\0')
5184 {
5185 fc->col_type[reg] = DW_CFA_val_offset;
5186 fc->col_offset[reg] = roffs * fc->data_factor;
5187 }
12eae2d3
JJ		 5188 break;
5189
19e6b90e
L		 5190 case DW_CFA_restore_extended:
5191 reg = LEB ();
665ce1f6
L		 5192 if (reg >= (unsigned int) cie->ncols
5193 || reg >= (unsigned int) fc->ncols)
5194 reg_prefix = bad_reg;
5195 if (! do_debug_frames_interp || *reg_prefix != '\0')
5196 printf (" DW_CFA_restore_extended: %s%s\n",
5197 reg_prefix, regname (reg, 0));
5198 if (*reg_prefix == '\0')
5199 {
5200 fc->col_type[reg] = cie->col_type[reg];
5201 fc->col_offset[reg] = cie->col_offset[reg];
5202 }
19e6b90e
L		 5203 break;
5204
5205 case DW_CFA_undefined:
5206 reg = LEB ();
665ce1f6
L		 5207 if (reg >= (unsigned int) fc->ncols)
5208 reg_prefix = bad_reg;
5209 if (! do_debug_frames_interp || *reg_prefix != '\0')
5210 printf (" DW_CFA_undefined: %s%s\n",
5211 reg_prefix, regname (reg, 0));
5212 if (*reg_prefix == '\0')
5213 {
5214 fc->col_type[reg] = DW_CFA_undefined;
5215 fc->col_offset[reg] = 0;
5216 }
19e6b90e
L		 5217 break;
5218
5219 case DW_CFA_same_value:
5220 reg = LEB ();
665ce1f6
L		 5221 if (reg >= (unsigned int) fc->ncols)
5222 reg_prefix = bad_reg;
5223 if (! do_debug_frames_interp || *reg_prefix != '\0')
5224 printf (" DW_CFA_same_value: %s%s\n",
5225 reg_prefix, regname (reg, 0));
5226 if (*reg_prefix == '\0')
5227 {
5228 fc->col_type[reg] = DW_CFA_same_value;
5229 fc->col_offset[reg] = 0;
5230 }
19e6b90e
L		 5231 break;
5232
5233 case DW_CFA_register:
5234 reg = LEB ();
5235 roffs = LEB ();
665ce1f6
L		 5236 if (reg >= (unsigned int) fc->ncols)
5237 reg_prefix = bad_reg;
5238 if (! do_debug_frames_interp || *reg_prefix != '\0')
2dc4cec1 5239 {
665ce1f6
L		 5240 printf (" DW_CFA_register: %s%s in ",
5241 reg_prefix, regname (reg, 0));
2dc4cec1
L		 5242 puts (regname (roffs, 0));
5243 }
665ce1f6
L		 5244 if (*reg_prefix == '\0')
5245 {
5246 fc->col_type[reg] = DW_CFA_register;
5247 fc->col_offset[reg] = roffs;
5248 }
19e6b90e
L		 5249 break;
5250
5251 case DW_CFA_remember_state:
5252 if (! do_debug_frames_interp)
5253 printf (" DW_CFA_remember_state\n");
3f5e193b 5254 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
19e6b90e 5255 rs->ncols = fc->ncols;
3f5e193b
NC		 5256 rs->col_type = (short int *) xcmalloc (rs->ncols,
5257 sizeof (short int));
5258 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (int));
19e6b90e
L		 5259 memcpy (rs->col_type, fc->col_type, rs->ncols);
5260 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
5261 rs->next = remembered_state;
5262 remembered_state = rs;
5263 break;
5264
5265 case DW_CFA_restore_state:
5266 if (! do_debug_frames_interp)
5267 printf (" DW_CFA_restore_state\n");
5268 rs = remembered_state;
5269 if (rs)
5270 {
5271 remembered_state = rs->next;
cc86f28f 5272 frame_need_space (fc, rs->ncols - 1);
19e6b90e
L		 5273 memcpy (fc->col_type, rs->col_type, rs->ncols);
5274 memcpy (fc->col_offset, rs->col_offset,
5275 rs->ncols * sizeof (int));
5276 free (rs->col_type);
5277 free (rs->col_offset);
5278 free (rs);
5279 }
5280 else if (do_debug_frames_interp)
5281 printf ("Mismatched DW_CFA_restore_state\n");
5282 break;
5283
5284 case DW_CFA_def_cfa:
5285 fc->cfa_reg = LEB ();
5286 fc->cfa_offset = LEB ();
5287 fc->cfa_exp = 0;
5288 if (! do_debug_frames_interp)
2dc4cec1
L		 5289 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5290 regname (fc->cfa_reg, 0), fc->cfa_offset);
19e6b90e
L		 5291 break;
5292
5293 case DW_CFA_def_cfa_register:
5294 fc->cfa_reg = LEB ();
5295 fc->cfa_exp = 0;
5296 if (! do_debug_frames_interp)
2dc4cec1
L		 5297 printf (" DW_CFA_def_cfa_register: %s\n",
5298 regname (fc->cfa_reg, 0));
19e6b90e
L		 5299 break;
5300
5301 case DW_CFA_def_cfa_offset:
5302 fc->cfa_offset = LEB ();
5303 if (! do_debug_frames_interp)
5304 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
5305 break;
5306
5307 case DW_CFA_nop:
5308 if (! do_debug_frames_interp)
5309 printf (" DW_CFA_nop\n");
5310 break;
5311
5312 case DW_CFA_def_cfa_expression:
5313 ul = LEB ();
5314 if (! do_debug_frames_interp)
5315 {
5316 printf (" DW_CFA_def_cfa_expression (");
b7807392
JJ		 5317 decode_location_expression (start, eh_addr_size, 0, -1,
5318 ul, 0, section);
19e6b90e
L		 5319 printf (")\n");
5320 }
5321 fc->cfa_exp = 1;
5322 start += ul;
5323 break;
5324
5325 case DW_CFA_expression:
5326 reg = LEB ();
5327 ul = LEB ();
665ce1f6
L		 5328 if (reg >= (unsigned int) fc->ncols)
5329 reg_prefix = bad_reg;
5330 if (! do_debug_frames_interp || *reg_prefix != '\0')
19e6b90e 5331 {
665ce1f6
L		 5332 printf (" DW_CFA_expression: %s%s (",
5333 reg_prefix, regname (reg, 0));
b7807392 5334 decode_location_expression (start, eh_addr_size, 0, -1,
f1c4cc75 5335 ul, 0, section);
19e6b90e
L		 5336 printf (")\n");
5337 }
665ce1f6
L		 5338 if (*reg_prefix == '\0')
5339 fc->col_type[reg] = DW_CFA_expression;
19e6b90e
L		 5340 start += ul;
5341 break;
5342
12eae2d3
JJ		 5343 case DW_CFA_val_expression:
5344 reg = LEB ();
5345 ul = LEB ();
665ce1f6
L		 5346 if (reg >= (unsigned int) fc->ncols)
5347 reg_prefix = bad_reg;
5348 if (! do_debug_frames_interp || *reg_prefix != '\0')
12eae2d3 5349 {
665ce1f6
L		 5350 printf (" DW_CFA_val_expression: %s%s (",
5351 reg_prefix, regname (reg, 0));
b7807392
JJ		 5352 decode_location_expression (start, eh_addr_size, 0, -1,
5353 ul, 0, section);
12eae2d3
JJ		 5354 printf (")\n");
5355 }
665ce1f6
L		 5356 if (*reg_prefix == '\0')
5357 fc->col_type[reg] = DW_CFA_val_expression;
12eae2d3
JJ		 5358 start += ul;
5359 break;
5360
19e6b90e
L		 5361 case DW_CFA_offset_extended_sf:
5362 reg = LEB ();
5363 l = SLEB ();
665ce1f6
L		 5364 if (frame_need_space (fc, reg) < 0)
5365 reg_prefix = bad_reg;
5366 if (! do_debug_frames_interp || *reg_prefix != '\0')
5367 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5368 reg_prefix, regname (reg, 0),
5369 l * fc->data_factor);
5370 if (*reg_prefix == '\0')
5371 {
5372 fc->col_type[reg] = DW_CFA_offset;
5373 fc->col_offset[reg] = l * fc->data_factor;
5374 }
19e6b90e
L		 5375 break;
5376
12eae2d3
JJ		 5377 case DW_CFA_val_offset_sf:
5378 reg = LEB ();
5379 l = SLEB ();
665ce1f6
L		 5380 if (frame_need_space (fc, reg) < 0)
5381 reg_prefix = bad_reg;
5382 if (! do_debug_frames_interp || *reg_prefix != '\0')
5383 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5384 reg_prefix, regname (reg, 0),
5385 l * fc->data_factor);
5386 if (*reg_prefix == '\0')
5387 {
5388 fc->col_type[reg] = DW_CFA_val_offset;
5389 fc->col_offset[reg] = l * fc->data_factor;
5390 }
12eae2d3
JJ		 5391 break;
5392
19e6b90e
L		 5393 case DW_CFA_def_cfa_sf:
5394 fc->cfa_reg = LEB ();
5395 fc->cfa_offset = SLEB ();
5396 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5397 fc->cfa_exp = 0;
5398 if (! do_debug_frames_interp)
2dc4cec1
L		 5399 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5400 regname (fc->cfa_reg, 0), fc->cfa_offset);
19e6b90e
L		 5401 break;
5402
5403 case DW_CFA_def_cfa_offset_sf:
5404 fc->cfa_offset = SLEB ();
5405 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
5406 if (! do_debug_frames_interp)
5407 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
5408 break;
5409
5410 case DW_CFA_MIPS_advance_loc8:
5411 ofs = byte_get (start, 8); start += 8;
5412 if (do_debug_frames_interp)
5413 frame_display_row (fc, &need_col_headers, &max_regs);
5414 else
5415 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5416 ofs * fc->code_factor,
5417 fc->pc_begin + ofs * fc->code_factor);
5418 fc->pc_begin += ofs * fc->code_factor;
5419 break;
5420
5421 case DW_CFA_GNU_window_save:
5422 if (! do_debug_frames_interp)
5423 printf (" DW_CFA_GNU_window_save\n");
5424 break;
5425
5426 case DW_CFA_GNU_args_size:
5427 ul = LEB ();
5428 if (! do_debug_frames_interp)
5429 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
5430 break;
5431
5432 case DW_CFA_GNU_negative_offset_extended:
5433 reg = LEB ();
5434 l = - LEB ();
665ce1f6
L		 5435 if (frame_need_space (fc, reg) < 0)
5436 reg_prefix = bad_reg;
5437 if (! do_debug_frames_interp || *reg_prefix != '\0')
5438 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5439 reg_prefix, regname (reg, 0),
5440 l * fc->data_factor);
5441 if (*reg_prefix == '\0')
5442 {
5443 fc->col_type[reg] = DW_CFA_offset;
5444 fc->col_offset[reg] = l * fc->data_factor;
5445 }
19e6b90e
L		 5446 break;
5447
5448 default:
53b8873b
NC		 5449 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
5450 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
5451 else
cecf136e 5452 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
19e6b90e
L		 5453 start = block_end;
5454 }
5455 }
5456
5457 if (do_debug_frames_interp)
5458 frame_display_row (fc, &need_col_headers, &max_regs);
5459
5460 start = block_end;
604282a7 5461 eh_addr_size = saved_eh_addr_size;
19e6b90e
L		 5462 }
5463
5464 printf ("\n");
5465
5466 return 1;
5467}
5468
5469#undef GET
5470#undef LEB
5471#undef SLEB
5472
5bbdf3d5
DE		 5473static int
5474display_gdb_index (struct dwarf_section *section,
5475 void *file ATTRIBUTE_UNUSED)
5476{
5477 unsigned char *start = section->start;
5478 uint32_t version;
5479 uint32_t cu_list_offset, tu_list_offset;
5480 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
5481 unsigned int cu_list_elements, tu_list_elements;
5482 unsigned int address_table_size, symbol_table_slots;
5483 unsigned char *cu_list, *tu_list;
5484 unsigned char *address_table, *symbol_table, *constant_pool;
5485 unsigned int i;
5486
5487 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
5488
5489 printf (_("Contents of the %s section:\n"), section->name);
5490
5491 if (section->size < 6 * sizeof (uint32_t))
5492 {
5493 warn (_("Truncated header in the %s section.\n"), section->name);
5494 return 0;
5495 }
5496
5497 version = byte_get_little_endian (start, 4);
da88a764 5498 printf (_("Version %ld\n"), (long) version);
5bbdf3d5
DE		 5499
5500 /* Prior versions are obsolete, and future versions may not be
5501 backwards compatible. */
6ec8b48e 5502 switch (version)
5bbdf3d5 5503 {
6ec8b48e
JK		 5504 case 3:
5505 warn (_("The address table data in version 3 may be wrong.\n"));
5506 break;
5507 case 4:
6adc060c
JK		 5508 warn (_("Version 4 does not support case insensitive lookups.\n"));
5509 break;
5510 case 5:
6ec8b48e
JK		 5511 break;
5512 default:
da88a764 5513 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5bbdf3d5
DE		 5514 return 0;
5515 }
5516
5517 cu_list_offset = byte_get_little_endian (start + 4, 4);
5518 tu_list_offset = byte_get_little_endian (start + 8, 4);
5519 address_table_offset = byte_get_little_endian (start + 12, 4);
5520 symbol_table_offset = byte_get_little_endian (start + 16, 4);
5521 constant_pool_offset = byte_get_little_endian (start + 20, 4);
5522
5523 if (cu_list_offset > section->size
5524 || tu_list_offset > section->size
5525 || address_table_offset > section->size
5526 || symbol_table_offset > section->size
5527 || constant_pool_offset > section->size)
5528 {
5529 warn (_("Corrupt header in the %s section.\n"), section->name);
5530 return 0;
5531 }
5532
5533 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
5534 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
5535 address_table_size = symbol_table_offset - address_table_offset;
5536 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
5537
5538 cu_list = start + cu_list_offset;
5539 tu_list = start + tu_list_offset;
5540 address_table = start + address_table_offset;
5541 symbol_table = start + symbol_table_offset;
5542 constant_pool = start + constant_pool_offset;
5543
5544 printf (_("\nCU table:\n"));
5545 for (i = 0; i < cu_list_elements; i += 2)
5546 {
5547 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
5548 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
5549
5550 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
5551 (unsigned long) cu_offset,
5552 (unsigned long) (cu_offset + cu_length - 1));
5553 }
5554
5555 printf (_("\nTU table:\n"));
5556 for (i = 0; i < tu_list_elements; i += 3)
5557 {
5558 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
5559 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
5560 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
5561
5562 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
5563 (unsigned long) tu_offset,
5564 (unsigned long) type_offset);
5565 print_dwarf_vma (signature, 8);
5566 printf ("\n");
5567 }
5568
5569 printf (_("\nAddress table:\n"));
5570 for (i = 0; i < address_table_size; i += 2 * 8 + 4)
5571 {
5572 uint64_t low = byte_get_little_endian (address_table + i, 8);
5573 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
5574 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
5575
5576 print_dwarf_vma (low, 8);
5577 print_dwarf_vma (high, 8);
da88a764 5578 printf (_("%lu\n"), (unsigned long) cu_index);
5bbdf3d5
DE		 5579 }
5580
5581 printf (_("\nSymbol table:\n"));
5582 for (i = 0; i < symbol_table_slots; ++i)
5583 {
5584 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
5585 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
5586 uint32_t num_cus, cu;
5587
5588 if (name_offset != 0
5589 || cu_vector_offset != 0)
5590 {
5591 unsigned int j;
5592
5593 printf ("[%3u] %s:", i, constant_pool + name_offset);
5594 num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4);
5595 for (j = 0; j < num_cus; ++j)
5596 {
5597 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
5598 /* Convert to TU number if it's for a type unit. */
ad6b52dd
CC		 5599 if (cu >= cu_list_elements / 2)
5600 printf (" T%lu", (unsigned long) (cu - cu_list_elements / 2));
5bbdf3d5 5601 else
da88a764 5602 printf (" %lu", (unsigned long) cu);
5bbdf3d5
DE		 5603 }
5604 printf ("\n");
5605 }
5606 }
5607
5608 return 1;
5609}
5610
19e6b90e
L		 5611static int
5612display_debug_not_supported (struct dwarf_section *section,
5613 void *file ATTRIBUTE_UNUSED)
5614{
5615 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5616 section->name);
5617
5618 return 1;
5619}
5620
5621void *
5622cmalloc (size_t nmemb, size_t size)
5623{
5624 /* Check for overflow. */
5625 if (nmemb >= ~(size_t) 0 / size)
5626 return NULL;
5627 else
5628 return malloc (nmemb * size);
5629}
5630
5631void *
5632xcmalloc (size_t nmemb, size_t size)
5633{
5634 /* Check for overflow. */
5635 if (nmemb >= ~(size_t) 0 / size)
5636 return NULL;
5637 else
5638 return xmalloc (nmemb * size);
5639}
5640
5641void *
5642xcrealloc (void *ptr, size_t nmemb, size_t size)
5643{
5644 /* Check for overflow. */
5645 if (nmemb >= ~(size_t) 0 / size)
5646 return NULL;
5647 else
5648 return xrealloc (ptr, nmemb * size);
5649}
5650
19e6b90e
L		 5651void
5652free_debug_memory (void)
5653{
3f5e193b 5654 unsigned int i;
19e6b90e
L		 5655
5656 free_abbrevs ();
5657
5658 for (i = 0; i < max; i++)
3f5e193b 5659 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 5660
cc86f28f 5661 if (debug_information != NULL)
19e6b90e 5662 {
cc86f28f 5663 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
19e6b90e 5664 {
cc86f28f 5665 for (i = 0; i < num_debug_info_entries; i++)
19e6b90e 5666 {
cc86f28f
NC		 5667 if (!debug_information [i].max_loc_offsets)
5668 {
5669 free (debug_information [i].loc_offsets);
5670 free (debug_information [i].have_frame_base);
5671 }
5672 if (!debug_information [i].max_range_lists)
5673 free (debug_information [i].range_lists);
19e6b90e 5674 }
19e6b90e 5675 }
cc86f28f 5676
19e6b90e
L		 5677 free (debug_information);
5678 debug_information = NULL;
5679 num_debug_info_entries = 0;
5680 }
19e6b90e
L		 5681}
5682
4cb93e3b
TG		 5683void
5684dwarf_select_sections_by_names (const char *names)
5685{
5686 typedef struct
5687 {
5688 const char * option;
5689 int * variable;
f9f0e732 5690 int val;
4cb93e3b
TG		 5691 }
5692 debug_dump_long_opts;
5693
5694 static const debug_dump_long_opts opts_table [] =
5695 {
5696 /* Please keep this table alpha- sorted. */
5697 { "Ranges", & do_debug_ranges, 1 },
5698 { "abbrev", & do_debug_abbrevs, 1 },
5699 { "aranges", & do_debug_aranges, 1 },
5700 { "frames", & do_debug_frames, 1 },
5701 { "frames-interp", & do_debug_frames_interp, 1 },
5702 { "info", & do_debug_info, 1 },
5703 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
5704 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
5705 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
5706 { "loc", & do_debug_loc, 1 },
5707 { "macro", & do_debug_macinfo, 1 },
5708 { "pubnames", & do_debug_pubnames, 1 },
357da287 5709 { "pubtypes", & do_debug_pubtypes, 1 },
4cb93e3b
TG		 5710 /* This entry is for compatability
5711 with earlier versions of readelf. */
5712 { "ranges", & do_debug_aranges, 1 },
5713 { "str", & do_debug_str, 1 },
5bbdf3d5
DE		 5714 /* The special .gdb_index section. */
5715 { "gdb_index", & do_gdb_index, 1 },
6f875884
TG		 5716 /* These trace_* sections are used by Itanium VMS. */
5717 { "trace_abbrev", & do_trace_abbrevs, 1 },
5718 { "trace_aranges", & do_trace_aranges, 1 },
5719 { "trace_info", & do_trace_info, 1 },
4cb93e3b
TG		 5720 { NULL, NULL, 0 }
5721 };
5722
5723 const char *p;
467c65bc 5724
4cb93e3b
TG		 5725 p = names;
5726 while (*p)
5727 {
5728 const debug_dump_long_opts * entry;
467c65bc 5729
4cb93e3b
TG		 5730 for (entry = opts_table; entry->option; entry++)
5731 {
5732 size_t len = strlen (entry->option);
467c65bc 5733
4cb93e3b
TG		 5734 if (strncmp (p, entry->option, len) == 0
5735 && (p[len] == ',' || p[len] == '\0'))
5736 {
5737 * entry->variable |= entry->val;
467c65bc 5738
4cb93e3b
TG		 5739 /* The --debug-dump=frames-interp option also
5740 enables the --debug-dump=frames option. */
5741 if (do_debug_frames_interp)
5742 do_debug_frames = 1;
5743
5744 p += len;
5745 break;
5746 }
5747 }
467c65bc 5748
4cb93e3b
TG		 5749 if (entry->option == NULL)
5750 {
5751 warn (_("Unrecognized debug option '%s'\n"), p);
5752 p = strchr (p, ',');
5753 if (p == NULL)
5754 break;
5755 }
467c65bc 5756
4cb93e3b
TG		 5757 if (*p == ',')
5758 p++;
5759 }
5760}
5761
5762void
5763dwarf_select_sections_by_letters (const char *letters)
5764{
91d6fa6a 5765 unsigned int lindex = 0;
4cb93e3b 5766
91d6fa6a
NC		 5767 while (letters[lindex])
5768 switch (letters[lindex++])
4cb93e3b
TG		 5769 {
5770 case 'i':
5771 do_debug_info = 1;
5772 break;
467c65bc 5773
4cb93e3b
TG		 5774 case 'a':
5775 do_debug_abbrevs = 1;
5776 break;
467c65bc 5777
4cb93e3b
TG		 5778 case 'l':
5779 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
5780 break;
467c65bc 5781
4cb93e3b
TG		 5782 case 'L':
5783 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
5784 break;
467c65bc 5785
4cb93e3b
TG		 5786 case 'p':
5787 do_debug_pubnames = 1;
5788 break;
467c65bc 5789
f9f0e732
NC		 5790 case 't':
5791 do_debug_pubtypes = 1;
5792 break;
467c65bc 5793
4cb93e3b
TG		 5794 case 'r':
5795 do_debug_aranges = 1;
5796 break;
467c65bc 5797
4cb93e3b
TG		 5798 case 'R':
5799 do_debug_ranges = 1;
5800 break;
467c65bc 5801
4cb93e3b
TG		 5802 case 'F':
5803 do_debug_frames_interp = 1;
5804 case 'f':
5805 do_debug_frames = 1;
5806 break;
467c65bc 5807
4cb93e3b
TG		 5808 case 'm':
5809 do_debug_macinfo = 1;
5810 break;
467c65bc 5811
4cb93e3b
TG		 5812 case 's':
5813 do_debug_str = 1;
5814 break;
467c65bc 5815
4cb93e3b
TG		 5816 case 'o':
5817 do_debug_loc = 1;
5818 break;
467c65bc 5819
4cb93e3b
TG		 5820 default:
5821 warn (_("Unrecognized debug option '%s'\n"), optarg);
5822 break;
5823 }
5824}
5825
5826void
5827dwarf_select_sections_all (void)
5828{
5829 do_debug_info = 1;
5830 do_debug_abbrevs = 1;
5831 do_debug_lines = FLAG_DEBUG_LINES_RAW;
5832 do_debug_pubnames = 1;
f9f0e732 5833 do_debug_pubtypes = 1;
4cb93e3b
TG		 5834 do_debug_aranges = 1;
5835 do_debug_ranges = 1;
5836 do_debug_frames = 1;
5837 do_debug_macinfo = 1;
5838 do_debug_str = 1;
5839 do_debug_loc = 1;
5bbdf3d5 5840 do_gdb_index = 1;
6f875884
TG		 5841 do_trace_info = 1;
5842 do_trace_abbrevs = 1;
5843 do_trace_aranges = 1;
4cb93e3b
TG		 5844}
5845
19e6b90e
L		 5846struct dwarf_section_display debug_displays[] =
5847{
6f875884 5848 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0 },
c8450da8 5849 display_debug_abbrev, &do_debug_abbrevs, 0 },
6f875884 5850 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0 },
c8450da8 5851 display_debug_aranges, &do_debug_aranges, 1 },
6f875884 5852 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0 },
c8450da8 5853 display_debug_frames, &do_debug_frames, 1 },
6f875884 5854 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0 },
c8450da8 5855 display_debug_info, &do_debug_info, 1 },
6f875884 5856 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0 },
c8450da8 5857 display_debug_lines, &do_debug_lines, 1 },
6f875884 5858 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0 },
c8450da8 5859 display_debug_pubnames, &do_debug_pubnames, 0 },
6f875884 5860 { { ".eh_frame", "", NULL, NULL, 0, 0 },
c8450da8 5861 display_debug_frames, &do_debug_frames, 1 },
6f875884 5862 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0 },
c8450da8 5863 display_debug_macinfo, &do_debug_macinfo, 0 },
4ccf1e31
JJ		 5864 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0 },
5865 display_debug_macro, &do_debug_macinfo, 1 },
6f875884 5866 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0 },
c8450da8 5867 display_debug_str, &do_debug_str, 0 },
6f875884 5868 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0 },
c8450da8 5869 display_debug_loc, &do_debug_loc, 1 },
6f875884 5870 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0 },
f9f0e732 5871 display_debug_pubnames, &do_debug_pubtypes, 0 },
6f875884 5872 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0 },
c8450da8 5873 display_debug_ranges, &do_debug_ranges, 1 },
6f875884 5874 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0 },
c8450da8 5875 display_debug_not_supported, NULL, 0 },
6f875884 5876 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0 },
c8450da8 5877 display_debug_not_supported, NULL, 0 },
6f875884 5878 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0 },
2b6f5997 5879 display_debug_types, &do_debug_info, 1 },
6f875884
TG		 5880 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0 },
5881 display_debug_not_supported, NULL, 0 },
5bbdf3d5
DE		 5882 { { ".gdb_index", "", NULL, NULL, 0, 0 },
5883 display_gdb_index, &do_gdb_index, 0 },
6f875884
TG		 5884 { { ".trace_info", "", NULL, NULL, 0, 0 },
5885 display_trace_info, &do_trace_info, 1 },
5886 { { ".trace_abbrev", "", NULL, NULL, 0, 0 },
5887 display_debug_abbrev, &do_trace_abbrevs, 0 },
5888 { { ".trace_aranges", "", NULL, NULL, 0, 0 },
5889 display_debug_aranges, &do_trace_aranges, 0 }
19e6b90e 5890};
GDB Binutils - Deliverables
This page took 0.748913 seconds and 4 git commands to generate.