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