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