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