projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
LD/testsuite: Fix undefined symbol tests for MIPS and S+core targets
[deliverable/binutils-gdb.git] / binutils / dwarf.c
CommitLineData
19e6b90e 1/* dwarf.c -- display DWARF contents of a BFD binary file
2571583a 2 Copyright (C) 2005-2017 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"
61364358
JK		 31#include <assert.h>
32
33#undef MAX
34#undef MIN
35#define MAX(a, b) ((a) > (b) ? (a) : (b))
36#define MIN(a, b) ((a) < (b) ? (a) : (b))
19e6b90e 37
18464d4d
JK		 38static const char *regname (unsigned int regno, int row);
39
19e6b90e
L		 40static int have_frame_base;
41static int need_base_address;
42
19e6b90e 43static unsigned int num_debug_info_entries = 0;
82b1b41b 44static unsigned int alloc_num_debug_info_entries = 0;
19e6b90e 45static debug_info *debug_information = NULL;
cc86f28f
NC		 46/* Special value for num_debug_info_entries to indicate
47 that the .debug_info section could not be loaded/parsed. */
48#define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
19e6b90e 49
77ef8654 50unsigned int eh_addr_size;
19e6b90e
L		 51
52int do_debug_info;
53int do_debug_abbrevs;
54int do_debug_lines;
55int do_debug_pubnames;
f9f0e732 56int do_debug_pubtypes;
19e6b90e
L		 57int do_debug_aranges;
58int do_debug_ranges;
59int do_debug_frames;
60int do_debug_frames_interp;
61int do_debug_macinfo;
62int do_debug_str;
63int do_debug_loc;
5bbdf3d5 64int do_gdb_index;
6f875884
TG		 65int do_trace_info;
66int do_trace_abbrevs;
67int do_trace_aranges;
657d0d47
CC		 68int do_debug_addr;
69int do_debug_cu_index;
a262ae96 70int do_wide;
19e6b90e 71
fd2f0033
TT		 72int dwarf_cutoff_level = -1;
73unsigned long dwarf_start_die;
74
4723351a
CC		 75int dwarf_check = 0;
76
9f272209
AO		 77/* Convenient constant, to avoid having to cast -1 to dwarf_vma when
78 testing whether e.g. a locview list is present. */
79static const dwarf_vma vm1 = -1;
80
341f9135
CC		 81/* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
82 sections. For version 1 package files, each set is stored in SHNDX_POOL
83 as a zero-terminated list of section indexes comprising one set of debug
84 sections from a .dwo file. */
85
341f9135
CC		 86static unsigned int *shndx_pool = NULL;
87static unsigned int shndx_pool_size = 0;
88static unsigned int shndx_pool_used = 0;
89
90/* For version 2 package files, each set contains an array of section offsets
91 and an array of section sizes, giving the offset and size of the
92 contribution from a CU or TU within one of the debug sections.
93 When displaying debug info from a package file, we need to use these
94 tables to locate the corresponding contributions to each section. */
95
96struct cu_tu_set
97{
98 uint64_t signature;
99 dwarf_vma section_offsets[DW_SECT_MAX];
100 size_t section_sizes[DW_SECT_MAX];
101};
102
103static int cu_count = 0;
104static int tu_count = 0;
105static struct cu_tu_set *cu_sets = NULL;
106static struct cu_tu_set *tu_sets = NULL;
107
43a444f9 108static bfd_boolean load_cu_tu_indexes (void *);
341f9135 109
4cb93e3b
TG		 110/* Values for do_debug_lines. */
111#define FLAG_DEBUG_LINES_RAW 1
112#define FLAG_DEBUG_LINES_DECODED 2
113
77ef8654 114static unsigned int
f1c4cc75
RH		 115size_of_encoded_value (int encoding)
116{
117 switch (encoding & 0x7)
118 {
119 default: /* ??? */
120 case 0: return eh_addr_size;
121 case 2: return 2;
122 case 3: return 4;
123 case 4: return 8;
124 }
125}
126
127static dwarf_vma
041830e0 128get_encoded_value (unsigned char **pdata,
bad62cf5 129 int encoding,
041830e0
NC		 130 struct dwarf_section *section,
131 unsigned char * end)
f1c4cc75 132{
041830e0 133 unsigned char * data = * pdata;
6937bb54 134 unsigned int size = size_of_encoded_value (encoding);
bad62cf5 135 dwarf_vma val;
f1c4cc75 136
041830e0
NC		 137 if (data + size >= end)
138 {
139 warn (_("Encoded value extends past end of section\n"));
140 * pdata = end;
141 return 0;
142 }
143
6937bb54
NC		 144 /* PR 17512: file: 002-829853-0.004. */
145 if (size > 8)
146 {
147 warn (_("Encoded size of %d is too large to read\n"), size);
148 * pdata = end;
149 return 0;
150 }
151
0a9d414a
NC		 152 /* PR 17512: file: 1085-5603-0.004. */
153 if (size == 0)
154 {
155 warn (_("Encoded size of 0 is too small to read\n"));
156 * pdata = end;
157 return 0;
158 }
159
f1c4cc75 160 if (encoding & DW_EH_PE_signed)
bad62cf5 161 val = byte_get_signed (data, size);
f1c4cc75 162 else
bad62cf5
AM		 163 val = byte_get (data, size);
164
165 if ((encoding & 0x70) == DW_EH_PE_pcrel)
166 val += section->address + (data - section->start);
041830e0
NC		 167
168 * pdata = data + size;
bad62cf5 169 return val;
f1c4cc75
RH		 170}
171
4c219c2e
AM		 172#if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
173# ifndef __MINGW32__
174# define DWARF_VMA_FMT "ll"
175# define DWARF_VMA_FMT_LONG "%16.16llx"
176# else
177# define DWARF_VMA_FMT "I64"
178# define DWARF_VMA_FMT_LONG "%016I64x"
179# endif
2e14fae2 180#else
4c219c2e
AM		 181# define DWARF_VMA_FMT "l"
182# define DWARF_VMA_FMT_LONG "%16.16lx"
2d9472a2
NC		 183#endif
184
bf5117e3
NC		 185/* Convert a dwarf vma value into a string. Returns a pointer to a static
186 buffer containing the converted VALUE. The value is converted according
187 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
188 it specifies the maximum number of bytes to be displayed in the converted
189 value and FMTCH is ignored - hex is always used. */
467c65bc 190
47704ddf 191static const char *
bf5117e3 192dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)
47704ddf
KT		 193{
194 /* As dwarf_vmatoa is used more then once in a printf call
195 for output, we are cycling through an fixed array of pointers
196 for return address. */
197 static int buf_pos = 0;
467c65bc
NC		 198 static struct dwarf_vmatoa_buf
199 {
47704ddf
KT		 200 char place[64];
201 } buf[16];
47704ddf
KT		 202 char *ret;
203
47704ddf 204 ret = buf[buf_pos++].place;
467c65bc 205 buf_pos %= ARRAY_SIZE (buf);
47704ddf 206
bf5117e3
NC		 207 if (num_bytes)
208 {
222c2bf0 209 /* Printf does not have a way of specifying a maximum field width for an
bf5117e3
NC		 210 integer value, so we print the full value into a buffer and then select
211 the precision we need. */
212 snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);
213 if (num_bytes > 8)
214 num_bytes = 8;
215 return ret + (16 - 2 * num_bytes);
216 }
217 else
218 {
219 char fmt[32];
220
0bae9e9e
NC		 221 if (fmtch)
222 sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);
223 else
224 sprintf (fmt, "%%%s", DWARF_VMA_FMT);
bf5117e3
NC		 225 snprintf (ret, sizeof (buf[0].place), fmt, value);
226 return ret;
227 }
228}
47704ddf 229
bf5117e3
NC		 230static inline const char *
231dwarf_vmatoa (const char * fmtch, dwarf_vma value)
232{
233 return dwarf_vmatoa_1 (fmtch, value, 0);
234}
235
236/* Print a dwarf_vma value (typically an address, offset or length) in
237 hexadecimal format, followed by a space. The length of the VALUE (and
238 hence the precision displayed) is determined by the NUM_BYTES parameter. */
239
240static void
241print_dwarf_vma (dwarf_vma value, unsigned num_bytes)
242{
243 printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));
47704ddf
KT		 244}
245
9f272209
AO		 246/* Print a view number in hexadecimal value, with the same width
247 print_dwarf_vma would have printed it with the same num_bytes.
248 Print blanks for zero view, unless force is nonzero. */
249
250static void
251print_dwarf_view (dwarf_vma value, unsigned num_bytes, int force)
252{
253 int len;
254 if (!num_bytes)
255 len = 4;
256 else
257 len = num_bytes * 2;
258
259 assert (value == (unsigned long) value);
260 if (value || force)
261 printf ("v%0*lx ", len - 1, (unsigned long) value);
262 else
263 printf ("%*s", len + 1, "");
264}
265
74bc6052
CC		 266/* Format a 64-bit value, given as two 32-bit values, in hex.
267 For reentrancy, this uses a buffer provided by the caller. */
268
269static const char *
270dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,
271 unsigned int buf_len)
272{
273 int len = 0;
274
275 if (hvalue == 0)
276 snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);
277 else
278 {
279 len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);
280 snprintf (buf + len, buf_len - len,
281 "%08" DWARF_VMA_FMT "x", lvalue);
282 }
283
284 return buf;
285}
286
f6f0e17b
NC		 287/* Read in a LEB128 encoded value starting at address DATA.
288 If SIGN is true, return a signed LEB128 value.
289 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
290 No bytes will be read at address END or beyond. */
291
467c65bc 292dwarf_vma
f6f0e17b
NC		 293read_leb128 (unsigned char *data,
294 unsigned int *length_return,
295 bfd_boolean sign,
296 const unsigned char * const end)
19e6b90e 297{
467c65bc 298 dwarf_vma result = 0;
19e6b90e
L		 299 unsigned int num_read = 0;
300 unsigned int shift = 0;
f6f0e17b 301 unsigned char byte = 0;
19e6b90e 302
f6f0e17b 303 while (data < end)
19e6b90e
L		 304 {
305 byte = *data++;
306 num_read++;
307
467c65bc 308 result |= ((dwarf_vma) (byte & 0x7f)) << shift;
19e6b90e
L		 309
310 shift += 7;
f6f0e17b
NC		 311 if ((byte & 0x80) == 0)
312 break;
77ef8654
NC		 313
314 /* PR 17512: file: 0ca183b8.
315 FIXME: Should we signal this error somehow ? */
f641dd96 316 if (shift >= sizeof (result) * 8)
77ef8654 317 break;
19e6b90e 318 }
19e6b90e
L		 319
320 if (length_return != NULL)
321 *length_return = num_read;
322
323 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
c4e0beac 324 result |= -((dwarf_vma) 1 << shift);
19e6b90e
L		 325
326 return result;
327}
328
467c65bc 329/* Create a signed version to avoid painful typecasts. */
f6f0e17b
NC		 330static inline dwarf_signed_vma
331read_sleb128 (unsigned char * data,
332 unsigned int * length_return,
333 const unsigned char * const end)
334{
335 return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);
336}
337
338static inline dwarf_vma
339read_uleb128 (unsigned char * data,
340 unsigned int * length_return,
341 const unsigned char * const end)
467c65bc 342{
f6f0e17b 343 return read_leb128 (data, length_return, FALSE, end);
467c65bc
NC		 344}
345
7f2c8a1d
NC		 346#define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return
347#define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return
348
349#define READ_ULEB(var) \
350 do \
351 { \
352 dwarf_vma _val; \
353 \
354 (var) = _val = read_uleb128 (start, &length_return, end); \
355 if ((var) != _val) \
66cfc0fd
AM		 356 error (_("Internal error: %s:%d: LEB value (%s) " \
357 "too large for containing variable\n"), \
358 __FILE__, __LINE__, dwarf_vmatoa ("u", _val)); \
7f2c8a1d
NC		 359 start += length_return; \
360 } \
361 while (0)
362
363#define READ_SLEB(var) \
364 do \
365 { \
366 dwarf_signed_vma _val; \
367 \
368 (var) = _val = read_sleb128 (start, &length_return, end); \
369 if ((var) != _val) \
66cfc0fd
AM		 370 error (_("Internal error: %s:%d: LEB value (%s) " \
371 "too large for containing variable\n"), \
372 __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \
7f2c8a1d
NC		 373 start += length_return; \
374 } \
375 while (0)
376
0c588247
NC		 377#define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
378 do \
379 { \
380 unsigned int amount = (AMOUNT); \
34b9f729
NC		 381 if (sizeof (VAL) < amount) \
382 { \
383 error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
384 amount, (int) sizeof (VAL)); \
385 amount = sizeof (VAL); \
386 } \
0c588247
NC		 387 if (((PTR) + amount) >= (END)) \
388 { \
389 if ((PTR) < (END)) \
390 amount = (END) - (PTR); \
391 else \
392 amount = 0; \
393 } \
6937bb54 394 if (amount == 0 || amount > 8) \
0c588247 395 VAL = 0; \
6937bb54
NC		 396 else \
397 VAL = byte_get ((PTR), amount); \
0c588247
NC		 398 } \
399 while (0)
400
401#define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
402 do \
403 { \
404 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
405 PTR += AMOUNT; \
406 } \
407 while (0)
408
409#define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
410 do \
411 { \
412 unsigned int amount = (AMOUNT); \
413 if (((PTR) + amount) >= (END)) \
414 { \
415 if ((PTR) < (END)) \
416 amount = (END) - (PTR); \
417 else \
418 amount = 0; \
419 } \
420 if (amount) \
421 VAL = byte_get_signed ((PTR), amount); \
422 else \
423 VAL = 0; \
424 } \
425 while (0)
426
427#define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
428 do \
429 { \
430 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
431 PTR += AMOUNT; \
432 } \
433 while (0)
434
435#define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
436 do \
437 { \
87bc83b3 438 if (((PTR) + 8) <= (END)) \
0c588247
NC		 439 { \
440 byte_get_64 ((PTR), (HIGH), (LOW)); \
441 } \
442 else \
443 { \
0c588247
NC		 444 * (LOW) = * (HIGH) = 0; \
445 } \
446 } \
447 while (0)
448
19e6b90e
L		 449typedef struct State_Machine_Registers
450{
467c65bc 451 dwarf_vma address;
ba8826a8 452 unsigned int view;
19e6b90e
L		 453 unsigned int file;
454 unsigned int line;
455 unsigned int column;
456 int is_stmt;
457 int basic_block;
a233b20c
JJ		 458 unsigned char op_index;
459 unsigned char end_sequence;
ba8826a8
AO		 460 /* This variable hold the number of the last entry seen
461 in the File Table. */
19e6b90e
L		 462 unsigned int last_file_entry;
463} SMR;
464
465static SMR state_machine_regs;
466
467static void
468reset_state_machine (int is_stmt)
469{
470 state_machine_regs.address = 0;
ba8826a8 471 state_machine_regs.view = 0;
a233b20c 472 state_machine_regs.op_index = 0;
19e6b90e
L		 473 state_machine_regs.file = 1;
474 state_machine_regs.line = 1;
475 state_machine_regs.column = 0;
476 state_machine_regs.is_stmt = is_stmt;
477 state_machine_regs.basic_block = 0;
478 state_machine_regs.end_sequence = 0;
479 state_machine_regs.last_file_entry = 0;
480}
481
482/* Handled an extend line op.
483 Returns the number of bytes read. */
484
485static int
f6f0e17b
NC		 486process_extended_line_op (unsigned char * data,
487 int is_stmt,
488 unsigned char * end)
19e6b90e
L		 489{
490 unsigned char op_code;
491 unsigned int bytes_read;
492 unsigned int len;
493 unsigned char *name;
143a3db0 494 unsigned char *orig_data = data;
f6f0e17b 495 dwarf_vma adr;
19e6b90e 496
f6f0e17b 497 len = read_uleb128 (data, & bytes_read, end);
19e6b90e
L		 498 data += bytes_read;
499
e44c58ce 500 if (len == 0 || data == end || len > (uintptr_t) (end - data))
19e6b90e 501 {
f41e4712 502 warn (_("Badly formed extended line op encountered!\n"));
19e6b90e
L		 503 return bytes_read;
504 }
505
506 len += bytes_read;
507 op_code = *data++;
508
509 printf (_(" Extended opcode %d: "), op_code);
510
511 switch (op_code)
512 {
513 case DW_LNE_end_sequence:
514 printf (_("End of Sequence\n\n"));
515 reset_state_machine (is_stmt);
516 break;
517
518 case DW_LNE_set_address:
6937bb54
NC		 519 /* PR 17512: file: 002-100480-0.004. */
520 if (len - bytes_read - 1 > 8)
77ef8654
NC		 521 {
522 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
523 len - bytes_read - 1);
524 adr = 0;
525 }
526 else
527 SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end);
47704ddf 528 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));
19e6b90e 529 state_machine_regs.address = adr;
ba8826a8 530 state_machine_regs.view = 0;
a233b20c 531 state_machine_regs.op_index = 0;
19e6b90e
L		 532 break;
533
534 case DW_LNE_define_file:
143a3db0 535 printf (_("define new File Table entry\n"));
19e6b90e 536 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
cc5914eb 537 printf (" %d\t", ++state_machine_regs.last_file_entry);
f6f0e17b 538
d949ff56
NC		 539 {
540 size_t l;
541
542 name = data;
543 l = strnlen ((char *) data, end - data);
544 data += len + 1;
545 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
546 data += bytes_read;
547 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
548 data += bytes_read;
549 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
550 data += bytes_read;
551 printf ("%.*s\n\n", (int) l, name);
552 }
f6f0e17b
NC		 553
554 if (((unsigned int) (data - orig_data) != len) || data == end)
b4eb7656 555 warn (_("DW_LNE_define_file: Bad opcode length\n"));
19e6b90e
L		 556 break;
557
ed4a4bdf 558 case DW_LNE_set_discriminator:
47704ddf 559 printf (_("set Discriminator to %s\n"),
f6f0e17b 560 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
ed4a4bdf
CC		 561 break;
562
e2a0d921
NC		 563 /* HP extensions. */
564 case DW_LNE_HP_negate_is_UV_update:
ed4a4bdf 565 printf ("DW_LNE_HP_negate_is_UV_update\n");
e2a0d921
NC		 566 break;
567 case DW_LNE_HP_push_context:
ed4a4bdf 568 printf ("DW_LNE_HP_push_context\n");
e2a0d921
NC		 569 break;
570 case DW_LNE_HP_pop_context:
ed4a4bdf 571 printf ("DW_LNE_HP_pop_context\n");
e2a0d921
NC		 572 break;
573 case DW_LNE_HP_set_file_line_column:
ed4a4bdf 574 printf ("DW_LNE_HP_set_file_line_column\n");
e2a0d921
NC		 575 break;
576 case DW_LNE_HP_set_routine_name:
ed4a4bdf 577 printf ("DW_LNE_HP_set_routine_name\n");
e2a0d921
NC		 578 break;
579 case DW_LNE_HP_set_sequence:
ed4a4bdf 580 printf ("DW_LNE_HP_set_sequence\n");
e2a0d921
NC		 581 break;
582 case DW_LNE_HP_negate_post_semantics:
ed4a4bdf 583 printf ("DW_LNE_HP_negate_post_semantics\n");
e2a0d921
NC		 584 break;
585 case DW_LNE_HP_negate_function_exit:
ed4a4bdf 586 printf ("DW_LNE_HP_negate_function_exit\n");
e2a0d921
NC		 587 break;
588 case DW_LNE_HP_negate_front_end_logical:
ed4a4bdf 589 printf ("DW_LNE_HP_negate_front_end_logical\n");
e2a0d921
NC		 590 break;
591 case DW_LNE_HP_define_proc:
ed4a4bdf 592 printf ("DW_LNE_HP_define_proc\n");
e2a0d921 593 break;
43294ab7
TG		 594 case DW_LNE_HP_source_file_correlation:
595 {
b4eb7656
AM		 596 unsigned char *edata = data + len - bytes_read - 1;
597
598 printf ("DW_LNE_HP_source_file_correlation\n");
599
600 while (data < edata)
601 {
602 unsigned int opc;
603
604 opc = read_uleb128 (data, & bytes_read, edata);
605 data += bytes_read;
606
607 switch (opc)
608 {
609 case DW_LNE_HP_SFC_formfeed:
610 printf (" DW_LNE_HP_SFC_formfeed\n");
611 break;
612 case DW_LNE_HP_SFC_set_listing_line:
613 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
614 dwarf_vmatoa ("u",
615 read_uleb128 (data, & bytes_read, edata)));
616 data += bytes_read;
617 break;
618 case DW_LNE_HP_SFC_associate:
619 printf (" DW_LNE_HP_SFC_associate ");
620 printf ("(%s",
621 dwarf_vmatoa ("u",
622 read_uleb128 (data, & bytes_read, edata)));
623 data += bytes_read;
624 printf (",%s",
625 dwarf_vmatoa ("u",
626 read_uleb128 (data, & bytes_read, edata)));
627 data += bytes_read;
628 printf (",%s)\n",
629 dwarf_vmatoa ("u",
630 read_uleb128 (data, & bytes_read, edata)));
631 data += bytes_read;
632 break;
633 default:
634 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
635 data = edata;
636 break;
637 }
638 }
43294ab7
TG		 639 }
640 break;
cecf136e 641
19e6b90e 642 default:
7e665af3 643 {
b4eb7656
AM		 644 unsigned int rlen = len - bytes_read - 1;
645
646 if (op_code >= DW_LNE_lo_user
647 /* The test against DW_LNW_hi_user is redundant due to
648 the limited range of the unsigned char data type used
649 for op_code. */
650 /*&& op_code <= DW_LNE_hi_user*/)
651 printf (_("user defined: "));
652 else
653 printf (_("UNKNOWN: "));
654 printf (_("length %d ["), rlen);
655 for (; rlen; rlen--)
656 printf (" %02x", *data++);
657 printf ("]\n");
7e665af3 658 }
19e6b90e
L		 659 break;
660 }
661
662 return len;
663}
664
0c588247 665static const unsigned char *
467c65bc 666fetch_indirect_string (dwarf_vma offset)
19e6b90e
L		 667{
668 struct dwarf_section *section = &debug_displays [str].section;
d949ff56 669 const unsigned char * ret;
19e6b90e
L		 670
671 if (section->start == NULL)
0c588247 672 return (const unsigned char *) _("<no .debug_str section>");
19e6b90e 673
d949ff56 674 if (offset >= section->size)
19e6b90e 675 {
467c65bc
NC		 676 warn (_("DW_FORM_strp offset too big: %s\n"),
677 dwarf_vmatoa ("x", offset));
0c588247 678 return (const unsigned char *) _("<offset is too big>");
19e6b90e
L		 679 }
680
d949ff56
NC		 681 ret = section->start + offset;
682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
683 NUL byte. Since our caller is expecting to receive a well formed C
684 string we test for the lack of a terminating byte here. */
685 if (strnlen ((const char *) ret, section->size - offset)
686 == section->size - offset)
687 ret = (const unsigned char *)
688 _("<no NUL byte at end of .debug_str section>");
689
690 return ret;
19e6b90e
L		 691}
692
77145576
JK		 693static const unsigned char *
694fetch_indirect_line_string (dwarf_vma offset)
695{
696 struct dwarf_section *section = &debug_displays [line_str].section;
d949ff56 697 const unsigned char * ret;
77145576
JK		 698
699 if (section->start == NULL)
700 return (const unsigned char *) _("<no .debug_line_str section>");
701
d949ff56 702 if (offset >= section->size)
77145576
JK		 703 {
704 warn (_("DW_FORM_line_strp offset too big: %s\n"),
705 dwarf_vmatoa ("x", offset));
706 return (const unsigned char *) _("<offset is too big>");
707 }
708
d949ff56
NC		 709 ret = section->start + offset;
710 /* Unfortunately we cannot rely upon the .debug_line_str section ending
711 with a NUL byte. Since our caller is expecting to receive a well formed
712 C string we test for the lack of a terminating byte here. */
713 if (strnlen ((const char *) ret, section->size - offset)
714 == section->size - offset)
715 ret = (const unsigned char *)
716 _("<no NUL byte at end of .debug_line_str section>");
717
718 return ret;
77145576
JK		 719}
720
4723351a 721static const char *
341f9135
CC		 722fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
723 dwarf_vma offset_size, int dwo)
4723351a
CC		 724{
725 enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
726 enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
727 struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;
728 struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;
729 dwarf_vma index_offset = idx * offset_size;
730 dwarf_vma str_offset;
d949ff56 731 const char * ret;
4723351a
CC		 732
733 if (index_section->start == NULL)
734 return (dwo ? _("<no .debug_str_offsets.dwo section>")
735 : _("<no .debug_str_offsets section>"));
736
341f9135
CC		 737 if (this_set != NULL)
738 index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];
d949ff56 739 if (index_offset >= index_section->size)
4723351a
CC		 740 {
741 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
742 dwarf_vmatoa ("x", index_offset));
743 return _("<index offset is too big>");
744 }
745
746 if (str_section->start == NULL)
747 return (dwo ? _("<no .debug_str.dwo section>")
748 : _("<no .debug_str section>"));
749
750 str_offset = byte_get (index_section->start + index_offset, offset_size);
751 str_offset -= str_section->address;
d949ff56 752 if (str_offset >= str_section->size)
4723351a
CC		 753 {
754 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
755 dwarf_vmatoa ("x", str_offset));
756 return _("<indirect index offset is too big>");
757 }
758
d949ff56
NC		 759 ret = (const char *) str_section->start + str_offset;
760 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
761 Since our caller is expecting to receive a well formed C string we test
762 for the lack of a terminating byte here. */
763 if (strnlen (ret, str_section->size - str_offset)
764 == str_section->size - str_offset)
765 ret = (const char *) _("<no NUL byte at end of section>");
766
767 return ret;
4723351a
CC		 768}
769
770static const char *
771fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)
772{
773 struct dwarf_section *section = &debug_displays [debug_addr].section;
774
775 if (section->start == NULL)
776 return (_("<no .debug_addr section>"));
777
778 if (offset + bytes > section->size)
779 {
780 warn (_("Offset into section %s too big: %s\n"),
b4eb7656 781 section->name, dwarf_vmatoa ("x", offset));
4723351a
CC		 782 return "<offset too big>";
783 }
784
785 return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));
786}
787
788
19e6b90e
L		 789/* FIXME: There are better and more efficient ways to handle
790 these structures. For now though, I just want something that
791 is simple to implement. */
792typedef struct abbrev_attr
793{
794 unsigned long attribute;
795 unsigned long form;
77145576 796 bfd_signed_vma implicit_const;
19e6b90e
L		 797 struct abbrev_attr *next;
798}
799abbrev_attr;
800
801typedef struct abbrev_entry
802{
803 unsigned long entry;
804 unsigned long tag;
805 int children;
806 struct abbrev_attr *first_attr;
807 struct abbrev_attr *last_attr;
808 struct abbrev_entry *next;
809}
810abbrev_entry;
811
812static abbrev_entry *first_abbrev = NULL;
813static abbrev_entry *last_abbrev = NULL;
814
815static void
816free_abbrevs (void)
817{
91d6fa6a 818 abbrev_entry *abbrv;
19e6b90e 819
91d6fa6a 820 for (abbrv = first_abbrev; abbrv;)
19e6b90e 821 {
91d6fa6a 822 abbrev_entry *next_abbrev = abbrv->next;
19e6b90e
L		 823 abbrev_attr *attr;
824
91d6fa6a 825 for (attr = abbrv->first_attr; attr;)
19e6b90e 826 {
91d6fa6a 827 abbrev_attr *next_attr = attr->next;
19e6b90e
L		 828
829 free (attr);
91d6fa6a 830 attr = next_attr;
19e6b90e
L		 831 }
832
91d6fa6a
NC		 833 free (abbrv);
834 abbrv = next_abbrev;
19e6b90e
L		 835 }
836
837 last_abbrev = first_abbrev = NULL;
838}
839
840static void
841add_abbrev (unsigned long number, unsigned long tag, int children)
842{
843 abbrev_entry *entry;
844
3f5e193b 845 entry = (abbrev_entry *) malloc (sizeof (*entry));
19e6b90e
L		 846 if (entry == NULL)
847 /* ugg */
848 return;
849
850 entry->entry = number;
851 entry->tag = tag;
852 entry->children = children;
853 entry->first_attr = NULL;
854 entry->last_attr = NULL;
855 entry->next = NULL;
856
857 if (first_abbrev == NULL)
858 first_abbrev = entry;
859 else
860 last_abbrev->next = entry;
861
862 last_abbrev = entry;
863}
864
865static void
77145576
JK		 866add_abbrev_attr (unsigned long attribute, unsigned long form,
867 bfd_signed_vma implicit_const)
19e6b90e
L		 868{
869 abbrev_attr *attr;
870
3f5e193b 871 attr = (abbrev_attr *) malloc (sizeof (*attr));
19e6b90e
L		 872 if (attr == NULL)
873 /* ugg */
874 return;
875
876 attr->attribute = attribute;
877 attr->form = form;
77145576 878 attr->implicit_const = implicit_const;
19e6b90e
L		 879 attr->next = NULL;
880
881 if (last_abbrev->first_attr == NULL)
882 last_abbrev->first_attr = attr;
883 else
884 last_abbrev->last_attr->next = attr;
885
886 last_abbrev->last_attr = attr;
887}
888
889/* Processes the (partial) contents of a .debug_abbrev section.
890 Returns NULL if the end of the section was encountered.
891 Returns the address after the last byte read if the end of
892 an abbreviation set was found. */
893
894static unsigned char *
895process_abbrev_section (unsigned char *start, unsigned char *end)
896{
897 if (first_abbrev != NULL)
898 return NULL;
899
900 while (start < end)
901 {
902 unsigned int bytes_read;
903 unsigned long entry;
904 unsigned long tag;
905 unsigned long attribute;
906 int children;
907
f6f0e17b 908 entry = read_uleb128 (start, & bytes_read, end);
19e6b90e
L		 909 start += bytes_read;
910
911 /* A single zero is supposed to end the section according
912 to the standard. If there's more, then signal that to
913 the caller. */
f6f0e17b
NC		 914 if (start == end)
915 return NULL;
19e6b90e 916 if (entry == 0)
f6f0e17b 917 return start;
19e6b90e 918
f6f0e17b 919 tag = read_uleb128 (start, & bytes_read, end);
19e6b90e 920 start += bytes_read;
f6f0e17b
NC		 921 if (start == end)
922 return NULL;
19e6b90e
L		 923
924 children = *start++;
925
926 add_abbrev (entry, tag, children);
927
928 do
929 {
930 unsigned long form;
77145576
JK		 931 /* Initialize it due to a false compiler warning. */
932 bfd_signed_vma implicit_const = -1;
19e6b90e 933
f6f0e17b 934 attribute = read_uleb128 (start, & bytes_read, end);
19e6b90e 935 start += bytes_read;
f6f0e17b
NC		 936 if (start == end)
937 break;
19e6b90e 938
f6f0e17b 939 form = read_uleb128 (start, & bytes_read, end);
19e6b90e 940 start += bytes_read;
f6f0e17b
NC		 941 if (start == end)
942 break;
19e6b90e 943
77145576
JK		 944 if (form == DW_FORM_implicit_const)
945 {
946 implicit_const = read_sleb128 (start, & bytes_read, end);
947 start += bytes_read;
948 if (start == end)
949 break;
950 }
951
952 add_abbrev_attr (attribute, form, implicit_const);
19e6b90e
L		 953 }
954 while (attribute != 0);
955 }
956
399c99f7
L		 957 /* Report the missing single zero which ends the section. */
958 error (_(".debug_abbrev section not zero terminated\n"));
959
19e6b90e
L		 960 return NULL;
961}
962
a19c41a7 963static const char *
19e6b90e
L		 964get_TAG_name (unsigned long tag)
965{
b9c361e0 966 const char *name = get_DW_TAG_name ((unsigned int)tag);
a19c41a7
TT		 967
968 if (name == NULL)
19e6b90e 969 {
a19c41a7 970 static char buffer[100];
19e6b90e 971
a19c41a7
TT		 972 snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);
973 return buffer;
19e6b90e 974 }
a19c41a7
TT		 975
976 return name;
19e6b90e
L		 977}
978
a19c41a7 979static const char *
19e6b90e
L		 980get_FORM_name (unsigned long form)
981{
399c99f7 982 const char *name;
bf5117e3 983
399c99f7
L		 984 if (form == 0)
985 return "DW_FORM value: 0";
a19c41a7 986
399c99f7 987 name = get_DW_FORM_name (form);
a19c41a7 988 if (name == NULL)
19e6b90e 989 {
a19c41a7 990 static char buffer[100];
19e6b90e 991
a19c41a7
TT		 992 snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);
993 return buffer;
19e6b90e 994 }
a19c41a7
TT		 995
996 return name;
19e6b90e
L		 997}
998
61364358
JK		 999static const char *
1000get_IDX_name (unsigned long idx)
1001{
1002 const char *name = get_DW_IDX_name ((unsigned int) idx);
1003
1004 if (name == NULL)
1005 {
1006 static char buffer[100];
1007
1008 snprintf (buffer, sizeof (buffer), _("Unknown IDX value: %lx"), idx);
1009 return buffer;
1010 }
1011
1012 return name;
1013}
1014
19e6b90e 1015static unsigned char *
0c588247
NC		 1016display_block (unsigned char *data,
1017 dwarf_vma length,
ef0b5f1c 1018 const unsigned char * const end, char delimiter)
19e6b90e 1019{
0c588247
NC		 1020 dwarf_vma maxlen;
1021
ef0b5f1c 1022 printf (_("%c%s byte block: "), delimiter, dwarf_vmatoa ("u", length));
a1165289
NC		 1023 if (data > end)
1024 return (unsigned char *) end;
19e6b90e 1025
0c588247
NC		 1026 maxlen = (dwarf_vma) (end - data);
1027 length = length > maxlen ? maxlen : length;
1028
19e6b90e
L		 1029 while (length --)
1030 printf ("%lx ", (unsigned long) byte_get (data++, 1));
1031
1032 return data;
1033}
1034
1035static int
1036decode_location_expression (unsigned char * data,
1037 unsigned int pointer_size,
b7807392
JJ		 1038 unsigned int offset_size,
1039 int dwarf_version,
467c65bc
NC		 1040 dwarf_vma length,
1041 dwarf_vma cu_offset,
f1c4cc75 1042 struct dwarf_section * section)
19e6b90e
L		 1043{
1044 unsigned op;
1045 unsigned int bytes_read;
467c65bc 1046 dwarf_vma uvalue;
0c588247 1047 dwarf_signed_vma svalue;
19e6b90e
L		 1048 unsigned char *end = data + length;
1049 int need_frame_base = 0;
1050
1051 while (data < end)
1052 {
1053 op = *data++;
1054
1055 switch (op)
1056 {
1057 case DW_OP_addr:
0c588247
NC		 1058 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
1059 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));
19e6b90e
L		 1060 break;
1061 case DW_OP_deref:
1062 printf ("DW_OP_deref");
1063 break;
1064 case DW_OP_const1u:
0c588247
NC		 1065 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1066 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);
19e6b90e
L		 1067 break;
1068 case DW_OP_const1s:
0c588247
NC		 1069 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);
1070 printf ("DW_OP_const1s: %ld", (long) svalue);
19e6b90e
L		 1071 break;
1072 case DW_OP_const2u:
87bc83b3 1073 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
0c588247 1074 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);
19e6b90e
L		 1075 break;
1076 case DW_OP_const2s:
0c588247
NC		 1077 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1078 printf ("DW_OP_const2s: %ld", (long) svalue);
19e6b90e
L		 1079 break;
1080 case DW_OP_const4u:
0c588247
NC		 1081 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1082 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);
19e6b90e
L		 1083 break;
1084 case DW_OP_const4s:
0c588247
NC		 1085 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1086 printf ("DW_OP_const4s: %ld", (long) svalue);
19e6b90e
L		 1087 break;
1088 case DW_OP_const8u:
0c588247
NC		 1089 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1090 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);
1091 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
1092 printf ("%lu", (unsigned long) uvalue);
19e6b90e
L		 1093 break;
1094 case DW_OP_const8s:
0c588247
NC		 1095 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1096 printf ("DW_OP_const8s: %ld ", (long) svalue);
1097 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
1098 printf ("%ld", (long) svalue);
19e6b90e
L		 1099 break;
1100 case DW_OP_constu:
467c65bc 1101 printf ("DW_OP_constu: %s",
f6f0e17b 1102 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
19e6b90e
L		 1103 data += bytes_read;
1104 break;
1105 case DW_OP_consts:
467c65bc 1106 printf ("DW_OP_consts: %s",
f6f0e17b 1107 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
19e6b90e
L		 1108 data += bytes_read;
1109 break;
1110 case DW_OP_dup:
1111 printf ("DW_OP_dup");
1112 break;
1113 case DW_OP_drop:
1114 printf ("DW_OP_drop");
1115 break;
1116 case DW_OP_over:
1117 printf ("DW_OP_over");
1118 break;
1119 case DW_OP_pick:
0c588247
NC		 1120 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1121 printf ("DW_OP_pick: %ld", (unsigned long) uvalue);
19e6b90e
L		 1122 break;
1123 case DW_OP_swap:
1124 printf ("DW_OP_swap");
1125 break;
1126 case DW_OP_rot:
1127 printf ("DW_OP_rot");
1128 break;
1129 case DW_OP_xderef:
1130 printf ("DW_OP_xderef");
1131 break;
1132 case DW_OP_abs:
1133 printf ("DW_OP_abs");
1134 break;
1135 case DW_OP_and:
1136 printf ("DW_OP_and");
1137 break;
1138 case DW_OP_div:
1139 printf ("DW_OP_div");
1140 break;
1141 case DW_OP_minus:
1142 printf ("DW_OP_minus");
1143 break;
1144 case DW_OP_mod:
1145 printf ("DW_OP_mod");
1146 break;
1147 case DW_OP_mul:
1148 printf ("DW_OP_mul");
1149 break;
1150 case DW_OP_neg:
1151 printf ("DW_OP_neg");
1152 break;
1153 case DW_OP_not:
1154 printf ("DW_OP_not");
1155 break;
1156 case DW_OP_or:
1157 printf ("DW_OP_or");
1158 break;
1159 case DW_OP_plus:
1160 printf ("DW_OP_plus");
1161 break;
1162 case DW_OP_plus_uconst:
467c65bc 1163 printf ("DW_OP_plus_uconst: %s",
f6f0e17b 1164 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
19e6b90e
L		 1165 data += bytes_read;
1166 break;
1167 case DW_OP_shl:
1168 printf ("DW_OP_shl");
1169 break;
1170 case DW_OP_shr:
1171 printf ("DW_OP_shr");
1172 break;
1173 case DW_OP_shra:
1174 printf ("DW_OP_shra");
1175 break;
1176 case DW_OP_xor:
1177 printf ("DW_OP_xor");
1178 break;
1179 case DW_OP_bra:
0c588247
NC		 1180 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1181 printf ("DW_OP_bra: %ld", (long) svalue);
19e6b90e
L		 1182 break;
1183 case DW_OP_eq:
1184 printf ("DW_OP_eq");
1185 break;
1186 case DW_OP_ge:
1187 printf ("DW_OP_ge");
1188 break;
1189 case DW_OP_gt:
1190 printf ("DW_OP_gt");
1191 break;
1192 case DW_OP_le:
1193 printf ("DW_OP_le");
1194 break;
1195 case DW_OP_lt:
1196 printf ("DW_OP_lt");
1197 break;
1198 case DW_OP_ne:
1199 printf ("DW_OP_ne");
1200 break;
1201 case DW_OP_skip:
0c588247
NC		 1202 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
1203 printf ("DW_OP_skip: %ld", (long) svalue);
19e6b90e
L		 1204 break;
1205
1206 case DW_OP_lit0:
1207 case DW_OP_lit1:
1208 case DW_OP_lit2:
1209 case DW_OP_lit3:
1210 case DW_OP_lit4:
1211 case DW_OP_lit5:
1212 case DW_OP_lit6:
1213 case DW_OP_lit7:
1214 case DW_OP_lit8:
1215 case DW_OP_lit9:
1216 case DW_OP_lit10:
1217 case DW_OP_lit11:
1218 case DW_OP_lit12:
1219 case DW_OP_lit13:
1220 case DW_OP_lit14:
1221 case DW_OP_lit15:
1222 case DW_OP_lit16:
1223 case DW_OP_lit17:
1224 case DW_OP_lit18:
1225 case DW_OP_lit19:
1226 case DW_OP_lit20:
1227 case DW_OP_lit21:
1228 case DW_OP_lit22:
1229 case DW_OP_lit23:
1230 case DW_OP_lit24:
1231 case DW_OP_lit25:
1232 case DW_OP_lit26:
1233 case DW_OP_lit27:
1234 case DW_OP_lit28:
1235 case DW_OP_lit29:
1236 case DW_OP_lit30:
1237 case DW_OP_lit31:
1238 printf ("DW_OP_lit%d", op - DW_OP_lit0);
1239 break;
1240
1241 case DW_OP_reg0:
1242 case DW_OP_reg1:
1243 case DW_OP_reg2:
1244 case DW_OP_reg3:
1245 case DW_OP_reg4:
1246 case DW_OP_reg5:
1247 case DW_OP_reg6:
1248 case DW_OP_reg7:
1249 case DW_OP_reg8:
1250 case DW_OP_reg9:
1251 case DW_OP_reg10:
1252 case DW_OP_reg11:
1253 case DW_OP_reg12:
1254 case DW_OP_reg13:
1255 case DW_OP_reg14:
1256 case DW_OP_reg15:
1257 case DW_OP_reg16:
1258 case DW_OP_reg17:
1259 case DW_OP_reg18:
1260 case DW_OP_reg19:
1261 case DW_OP_reg20:
1262 case DW_OP_reg21:
1263 case DW_OP_reg22:
1264 case DW_OP_reg23:
1265 case DW_OP_reg24:
1266 case DW_OP_reg25:
1267 case DW_OP_reg26:
1268 case DW_OP_reg27:
1269 case DW_OP_reg28:
1270 case DW_OP_reg29:
1271 case DW_OP_reg30:
1272 case DW_OP_reg31:
18464d4d
JK		 1273 printf ("DW_OP_reg%d (%s)", op - DW_OP_reg0,
1274 regname (op - DW_OP_reg0, 1));
19e6b90e
L		 1275 break;
1276
1277 case DW_OP_breg0:
1278 case DW_OP_breg1:
1279 case DW_OP_breg2:
1280 case DW_OP_breg3:
1281 case DW_OP_breg4:
1282 case DW_OP_breg5:
1283 case DW_OP_breg6:
1284 case DW_OP_breg7:
1285 case DW_OP_breg8:
1286 case DW_OP_breg9:
1287 case DW_OP_breg10:
1288 case DW_OP_breg11:
1289 case DW_OP_breg12:
1290 case DW_OP_breg13:
1291 case DW_OP_breg14:
1292 case DW_OP_breg15:
1293 case DW_OP_breg16:
1294 case DW_OP_breg17:
1295 case DW_OP_breg18:
1296 case DW_OP_breg19:
1297 case DW_OP_breg20:
1298 case DW_OP_breg21:
1299 case DW_OP_breg22:
1300 case DW_OP_breg23:
1301 case DW_OP_breg24:
1302 case DW_OP_breg25:
1303 case DW_OP_breg26:
1304 case DW_OP_breg27:
1305 case DW_OP_breg28:
1306 case DW_OP_breg29:
1307 case DW_OP_breg30:
1308 case DW_OP_breg31:
467c65bc 1309 printf ("DW_OP_breg%d (%s): %s",
47704ddf 1310 op - DW_OP_breg0,
18464d4d 1311 regname (op - DW_OP_breg0, 1),
f6f0e17b 1312 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
19e6b90e
L		 1313 data += bytes_read;
1314 break;
1315
1316 case DW_OP_regx:
f6f0e17b 1317 uvalue = read_uleb128 (data, &bytes_read, end);
19e6b90e 1318 data += bytes_read;
467c65bc
NC		 1319 printf ("DW_OP_regx: %s (%s)",
1320 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
19e6b90e
L		 1321 break;
1322 case DW_OP_fbreg:
1323 need_frame_base = 1;
467c65bc 1324 printf ("DW_OP_fbreg: %s",
f6f0e17b 1325 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
19e6b90e
L		 1326 data += bytes_read;
1327 break;
1328 case DW_OP_bregx:
f6f0e17b 1329 uvalue = read_uleb128 (data, &bytes_read, end);
19e6b90e 1330 data += bytes_read;
467c65bc
NC		 1331 printf ("DW_OP_bregx: %s (%s) %s",
1332 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1),
f6f0e17b 1333 dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));
19e6b90e
L		 1334 data += bytes_read;
1335 break;
1336 case DW_OP_piece:
467c65bc 1337 printf ("DW_OP_piece: %s",
f6f0e17b 1338 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
19e6b90e
L		 1339 data += bytes_read;
1340 break;
1341 case DW_OP_deref_size:
0c588247
NC		 1342 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1343 printf ("DW_OP_deref_size: %ld", (long) uvalue);
19e6b90e
L		 1344 break;
1345 case DW_OP_xderef_size:
0c588247
NC		 1346 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
1347 printf ("DW_OP_xderef_size: %ld", (long) uvalue);
19e6b90e
L		 1348 break;
1349 case DW_OP_nop:
1350 printf ("DW_OP_nop");
1351 break;
1352
1353 /* DWARF 3 extensions. */
1354 case DW_OP_push_object_address:
1355 printf ("DW_OP_push_object_address");
1356 break;
1357 case DW_OP_call2:
1358 /* XXX: Strictly speaking for 64-bit DWARF3 files
1359 this ought to be an 8-byte wide computation. */
0c588247 1360 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);
467c65bc 1361 printf ("DW_OP_call2: <0x%s>",
0c588247 1362 dwarf_vmatoa ("x", svalue + cu_offset));
19e6b90e
L		 1363 break;
1364 case DW_OP_call4:
1365 /* XXX: Strictly speaking for 64-bit DWARF3 files
1366 this ought to be an 8-byte wide computation. */
0c588247 1367 SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);
467c65bc 1368 printf ("DW_OP_call4: <0x%s>",
0c588247 1369 dwarf_vmatoa ("x", svalue + cu_offset));
19e6b90e
L		 1370 break;
1371 case DW_OP_call_ref:
e2a0d921
NC		 1372 /* XXX: Strictly speaking for 64-bit DWARF3 files
1373 this ought to be an 8-byte wide computation. */
b7807392
JJ		 1374 if (dwarf_version == -1)
1375 {
1376 printf (_("(DW_OP_call_ref in frame info)"));
1377 /* No way to tell where the next op is, so just bail. */
1378 return need_frame_base;
1379 }
1380 if (dwarf_version == 2)
1381 {
0c588247 1382 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
b7807392
JJ		 1383 }
1384 else
1385 {
0c588247 1386 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
b7807392 1387 }
0c588247 1388 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue));
19e6b90e 1389 break;
a87b0a59
NS		 1390 case DW_OP_form_tls_address:
1391 printf ("DW_OP_form_tls_address");
1392 break;
e2a0d921
NC		 1393 case DW_OP_call_frame_cfa:
1394 printf ("DW_OP_call_frame_cfa");
1395 break;
1396 case DW_OP_bit_piece:
1397 printf ("DW_OP_bit_piece: ");
9cf03b7e 1398 printf (_("size: %s "),
f6f0e17b 1399 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
e2a0d921 1400 data += bytes_read;
9cf03b7e 1401 printf (_("offset: %s "),
f6f0e17b 1402 dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));
e2a0d921
NC		 1403 data += bytes_read;
1404 break;
19e6b90e 1405
3244e8f5
JJ		 1406 /* DWARF 4 extensions. */
1407 case DW_OP_stack_value:
1408 printf ("DW_OP_stack_value");
1409 break;
1410
1411 case DW_OP_implicit_value:
1412 printf ("DW_OP_implicit_value");
f6f0e17b 1413 uvalue = read_uleb128 (data, &bytes_read, end);
3244e8f5 1414 data += bytes_read;
ef0b5f1c 1415 data = display_block (data, uvalue, end, ' ');
3244e8f5
JJ		 1416 break;
1417
19e6b90e
L		 1418 /* GNU extensions. */
1419 case DW_OP_GNU_push_tls_address:
9cf03b7e 1420 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
e2a0d921
NC		 1421 break;
1422 case DW_OP_GNU_uninit:
1423 printf ("DW_OP_GNU_uninit");
1424 /* FIXME: Is there data associated with this OP ? */
1425 break;
f1c4cc75
RH		 1426 case DW_OP_GNU_encoded_addr:
1427 {
6937bb54 1428 int encoding = 0;
f1c4cc75 1429 dwarf_vma addr;
467c65bc 1430
6937bb54
NC		 1431 if (data < end)
1432 encoding = *data++;
041830e0 1433 addr = get_encoded_value (&data, encoding, section, end);
f1c4cc75
RH		 1434
1435 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding);
1436 print_dwarf_vma (addr, pointer_size);
1437 }
1438 break;
bc0a77d2 1439 case DW_OP_implicit_pointer:
b7807392
JJ		 1440 case DW_OP_GNU_implicit_pointer:
1441 /* XXX: Strictly speaking for 64-bit DWARF3 files
1442 this ought to be an 8-byte wide computation. */
1443 if (dwarf_version == -1)
1444 {
bc0a77d2
JK		 1445 printf (_("(%s in frame info)"),
1446 (op == DW_OP_implicit_pointer
1447 ? "DW_OP_implicit_pointer"
1448 : "DW_OP_GNU_implicit_pointer"));
b7807392
JJ		 1449 /* No way to tell where the next op is, so just bail. */
1450 return need_frame_base;
1451 }
1452 if (dwarf_version == 2)
1453 {
0c588247 1454 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
b7807392
JJ		 1455 }
1456 else
1457 {
0c588247 1458 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
b7807392 1459 }
bc0a77d2
JK		 1460 printf ("%s: <0x%s> %s",
1461 (op == DW_OP_implicit_pointer
1462 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
0c588247
NC		 1463 dwarf_vmatoa ("x", uvalue),
1464 dwarf_vmatoa ("d", read_sleb128 (data,
1465 &bytes_read, end)));
1466 data += bytes_read;
b7807392 1467 break;
77145576 1468 case DW_OP_entry_value:
0892011d 1469 case DW_OP_GNU_entry_value:
f6f0e17b 1470 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d 1471 data += bytes_read;
058037d3
NC		 1472 /* PR 17531: file: 0cc9cd00. */
1473 if (uvalue > (dwarf_vma) (end - data))
1474 uvalue = end - data;
77145576
JK		 1475 printf ("%s: (", (op == DW_OP_entry_value ? "DW_OP_entry_value"
1476 : "DW_OP_GNU_entry_value"));
0892011d
JJ		 1477 if (decode_location_expression (data, pointer_size, offset_size,
1478 dwarf_version, uvalue,
1479 cu_offset, section))
1480 need_frame_base = 1;
1481 putchar (')');
1482 data += uvalue;
6937bb54
NC		 1483 if (data > end)
1484 data = end;
0892011d 1485 break;
bc0a77d2 1486 case DW_OP_const_type:
0892011d 1487 case DW_OP_GNU_const_type:
f6f0e17b 1488 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d 1489 data += bytes_read;
bc0a77d2
JK		 1490 printf ("%s: <0x%s> ",
1491 (op == DW_OP_const_type ? "DW_OP_const_type"
1492 : "DW_OP_GNU_const_type"),
0892011d 1493 dwarf_vmatoa ("x", cu_offset + uvalue));
0c588247 1494 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
ef0b5f1c 1495 data = display_block (data, uvalue, end, ' ');
0892011d 1496 break;
bc0a77d2 1497 case DW_OP_regval_type:
0892011d 1498 case DW_OP_GNU_regval_type:
f6f0e17b 1499 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d 1500 data += bytes_read;
bc0a77d2
JK		 1501 printf ("%s: %s (%s)",
1502 (op == DW_OP_regval_type ? "DW_OP_regval_type"
1503 : "DW_OP_GNU_regval_type"),
0892011d 1504 dwarf_vmatoa ("u", uvalue), regname (uvalue, 1));
f6f0e17b 1505 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d
JJ		 1506 data += bytes_read;
1507 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1508 break;
bc0a77d2 1509 case DW_OP_deref_type:
0892011d 1510 case DW_OP_GNU_deref_type:
0c588247 1511 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
bc0a77d2
JK		 1512 printf ("%s: %ld",
1513 (op == DW_OP_deref_type ? "DW_OP_deref_type"
1514 : "DW_OP_GNU_deref_type"),
1515 (long) uvalue);
f6f0e17b 1516 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d
JJ		 1517 data += bytes_read;
1518 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue));
1519 break;
bc0a77d2 1520 case DW_OP_convert:
0892011d 1521 case DW_OP_GNU_convert:
f6f0e17b 1522 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d 1523 data += bytes_read;
bc0a77d2
JK		 1524 printf ("%s <0x%s>",
1525 (op == DW_OP_convert ? "DW_OP_convert" : "DW_OP_GNU_convert"),
f8b999f9 1526 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
0892011d 1527 break;
bc0a77d2 1528 case DW_OP_reinterpret:
0892011d 1529 case DW_OP_GNU_reinterpret:
f6f0e17b 1530 uvalue = read_uleb128 (data, &bytes_read, end);
0892011d 1531 data += bytes_read;
bc0a77d2
JK		 1532 printf ("%s <0x%s>",
1533 (op == DW_OP_reinterpret ? "DW_OP_reinterpret"
1534 : "DW_OP_GNU_reinterpret"),
f8b999f9
JJ		 1535 dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0));
1536 break;
1537 case DW_OP_GNU_parameter_ref:
0c588247 1538 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
f8b999f9 1539 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
0c588247 1540 dwarf_vmatoa ("x", cu_offset + uvalue));
0892011d 1541 break;
b4eb7656
AM		 1542 case DW_OP_GNU_addr_index:
1543 uvalue = read_uleb128 (data, &bytes_read, end);
1544 data += bytes_read;
1545 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1546 break;
1547 case DW_OP_GNU_const_index:
1548 uvalue = read_uleb128 (data, &bytes_read, end);
1549 data += bytes_read;
1550 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1551 break;
e2a0d921
NC		 1552
1553 /* HP extensions. */
1554 case DW_OP_HP_is_value:
1555 printf ("DW_OP_HP_is_value");
1556 /* FIXME: Is there data associated with this OP ? */
1557 break;
1558 case DW_OP_HP_fltconst4:
1559 printf ("DW_OP_HP_fltconst4");
1560 /* FIXME: Is there data associated with this OP ? */
1561 break;
1562 case DW_OP_HP_fltconst8:
1563 printf ("DW_OP_HP_fltconst8");
1564 /* FIXME: Is there data associated with this OP ? */
1565 break;
1566 case DW_OP_HP_mod_range:
1567 printf ("DW_OP_HP_mod_range");
1568 /* FIXME: Is there data associated with this OP ? */
1569 break;
1570 case DW_OP_HP_unmod_range:
1571 printf ("DW_OP_HP_unmod_range");
1572 /* FIXME: Is there data associated with this OP ? */
1573 break;
1574 case DW_OP_HP_tls:
1575 printf ("DW_OP_HP_tls");
1576 /* FIXME: Is there data associated with this OP ? */
19e6b90e
L		 1577 break;
1578
35d60fe4
NC		 1579 /* PGI (STMicroelectronics) extensions. */
1580 case DW_OP_PGI_omp_thread_num:
1581 /* Pushes the thread number for the current thread as it would be
1582 returned by the standard OpenMP library function:
1583 omp_get_thread_num(). The "current thread" is the thread for
1584 which the expression is being evaluated. */
1585 printf ("DW_OP_PGI_omp_thread_num");
1586 break;
1587
19e6b90e
L		 1588 default:
1589 if (op >= DW_OP_lo_user
1590 && op <= DW_OP_hi_user)
0502a2b4 1591 printf (_("(User defined location op 0x%x)"), op);
19e6b90e 1592 else
0502a2b4 1593 printf (_("(Unknown location op 0x%x)"), op);
19e6b90e
L		 1594 /* No way to tell where the next op is, so just bail. */
1595 return need_frame_base;
1596 }
1597
1598 /* Separate the ops. */
1599 if (data < end)
1600 printf ("; ");
1601 }
1602
1603 return need_frame_base;
1604}
1605
341f9135
CC		 1606/* Find the CU or TU set corresponding to the given CU_OFFSET.
1607 This is used for DWARF package files. */
1608
1609static struct cu_tu_set *
1610find_cu_tu_set_v2 (dwarf_vma cu_offset, int do_types)
1611{
1612 struct cu_tu_set *p;
1613 unsigned int nsets;
1614 unsigned int dw_sect;
1615
1616 if (do_types)
1617 {
1618 p = tu_sets;
1619 nsets = tu_count;
1620 dw_sect = DW_SECT_TYPES;
1621 }
1622 else
1623 {
1624 p = cu_sets;
1625 nsets = cu_count;
1626 dw_sect = DW_SECT_INFO;
1627 }
1628 while (nsets > 0)
1629 {
1630 if (p->section_offsets [dw_sect] == cu_offset)
1631 return p;
1632 p++;
1633 nsets--;
1634 }
1635 return NULL;
1636}
1637
a69c4772
NC		 1638/* Add INC to HIGH_BITS:LOW_BITS. */
1639static void
1640add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc)
1641{
1642 dwarf_vma tmp = * low_bits;
1643
1644 tmp += inc;
1645
1646 /* FIXME: There is probably a better way of handling this:
1647
1648 We need to cope with dwarf_vma being a 32-bit or 64-bit
1649 type. Plus regardless of its size LOW_BITS is meant to
1650 only hold 32-bits, so if there is overflow or wrap around
1651 we must propagate into HIGH_BITS. */
1652 if (tmp < * low_bits)
1653 {
1654 ++ * high_bits;
1655 }
1656 else if (sizeof (tmp) > 8
1657 && (tmp >> 31) > 1)
1658 {
1659 ++ * high_bits;
1660 tmp &= 0xFFFFFFFF;
1661 }
1662
1663 * low_bits = tmp;
1664}
1665
19e6b90e 1666static unsigned char *
6e3d6dc1
NC		 1667read_and_display_attr_value (unsigned long attribute,
1668 unsigned long form,
77145576 1669 dwarf_signed_vma implicit_const,
ec4d4525 1670 unsigned char * data,
f6f0e17b 1671 unsigned char * end,
467c65bc
NC		 1672 dwarf_vma cu_offset,
1673 dwarf_vma pointer_size,
1674 dwarf_vma offset_size,
6e3d6dc1
NC		 1675 int dwarf_version,
1676 debug_info * debug_info_p,
1677 int do_loc,
341f9135 1678 struct dwarf_section * section,
ef0b5f1c 1679 struct cu_tu_set * this_set, char delimiter)
19e6b90e 1680{
467c65bc 1681 dwarf_vma uvalue = 0;
19e6b90e 1682 unsigned char *block_start = NULL;
6e3d6dc1 1683 unsigned char * orig_data = data;
19e6b90e
L		 1684 unsigned int bytes_read;
1685
f41e4712 1686 if (data > end || (data == end && form != DW_FORM_flag_present))
0c588247 1687 {
f41e4712 1688 warn (_("Corrupt attribute\n"));
0c588247
NC		 1689 return data;
1690 }
1691
19e6b90e
L		 1692 switch (form)
1693 {
1694 default:
1695 break;
1696
1697 case DW_FORM_ref_addr:
1698 if (dwarf_version == 2)
0c588247 1699 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
932fd279 1700 else if (dwarf_version == 3 || dwarf_version == 4)
0c588247 1701 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
19e6b90e 1702 else
467c65bc
NC		 1703 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1704
19e6b90e
L		 1705 break;
1706
1707 case DW_FORM_addr:
0c588247 1708 SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
19e6b90e
L		 1709 break;
1710
1711 case DW_FORM_strp:
77145576 1712 case DW_FORM_line_strp:
932fd279 1713 case DW_FORM_sec_offset:
a081f3cd
JJ		 1714 case DW_FORM_GNU_ref_alt:
1715 case DW_FORM_GNU_strp_alt:
0c588247 1716 SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
19e6b90e
L		 1717 break;
1718
932fd279
JJ		 1719 case DW_FORM_flag_present:
1720 uvalue = 1;
1721 break;
1722
19e6b90e
L		 1723 case DW_FORM_ref1:
1724 case DW_FORM_flag:
1725 case DW_FORM_data1:
0c588247 1726 SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);
19e6b90e
L		 1727 break;
1728
1729 case DW_FORM_ref2:
1730 case DW_FORM_data2:
0c588247 1731 SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);
19e6b90e
L		 1732 break;
1733
1734 case DW_FORM_ref4:
1735 case DW_FORM_data4:
0c588247 1736 SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);
19e6b90e
L		 1737 break;
1738
1739 case DW_FORM_sdata:
f6f0e17b 1740 uvalue = read_sleb128 (data, & bytes_read, end);
19e6b90e
L		 1741 data += bytes_read;
1742 break;
1743
4723351a 1744 case DW_FORM_GNU_str_index:
f6f0e17b 1745 uvalue = read_uleb128 (data, & bytes_read, end);
4723351a
CC		 1746 data += bytes_read;
1747 break;
1748
19e6b90e
L		 1749 case DW_FORM_ref_udata:
1750 case DW_FORM_udata:
f6f0e17b 1751 uvalue = read_uleb128 (data, & bytes_read, end);
19e6b90e
L		 1752 data += bytes_read;
1753 break;
1754
1755 case DW_FORM_indirect:
f6f0e17b 1756 form = read_uleb128 (data, & bytes_read, end);
19e6b90e
L		 1757 data += bytes_read;
1758 if (!do_loc)
ef0b5f1c 1759 printf ("%c%s", delimiter, get_FORM_name (form));
77145576
JK		 1760 if (form == DW_FORM_implicit_const)
1761 {
1762 implicit_const = read_sleb128 (data, & bytes_read, end);
1763 data += bytes_read;
1764 }
1765 return read_and_display_attr_value (attribute, form, implicit_const, data,
1766 end, cu_offset, pointer_size,
19e6b90e 1767 offset_size, dwarf_version,
ec4d4525 1768 debug_info_p, do_loc,
ef0b5f1c 1769 section, this_set, delimiter);
4723351a 1770 case DW_FORM_GNU_addr_index:
f6f0e17b 1771 uvalue = read_uleb128 (data, & bytes_read, end);
4723351a
CC		 1772 data += bytes_read;
1773 break;
19e6b90e
L		 1774 }
1775
1776 switch (form)
1777 {
1778 case DW_FORM_ref_addr:
1779 if (!do_loc)
ef0b5f1c 1780 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
19e6b90e
L		 1781 break;
1782
a081f3cd
JJ		 1783 case DW_FORM_GNU_ref_alt:
1784 if (!do_loc)
ef0b5f1c 1785 printf ("%c<alt 0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
a081f3cd
JJ		 1786 break;
1787
19e6b90e
L		 1788 case DW_FORM_ref1:
1789 case DW_FORM_ref2:
1790 case DW_FORM_ref4:
1791 case DW_FORM_ref_udata:
1792 if (!do_loc)
ef0b5f1c 1793 printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x", uvalue + cu_offset));
19e6b90e
L		 1794 break;
1795
1796 case DW_FORM_data4:
1797 case DW_FORM_addr:
932fd279 1798 case DW_FORM_sec_offset:
19e6b90e 1799 if (!do_loc)
ef0b5f1c 1800 printf ("%c0x%s", delimiter, dwarf_vmatoa ("x", uvalue));
19e6b90e
L		 1801 break;
1802
932fd279 1803 case DW_FORM_flag_present:
19e6b90e
L		 1804 case DW_FORM_flag:
1805 case DW_FORM_data1:
1806 case DW_FORM_data2:
1807 case DW_FORM_sdata:
1808 case DW_FORM_udata:
1809 if (!do_loc)
ef0b5f1c 1810 printf ("%c%s", delimiter, dwarf_vmatoa ("d", uvalue));
19e6b90e
L		 1811 break;
1812
77145576
JK		 1813 case DW_FORM_implicit_const:
1814 if (!do_loc)
1815 printf ("%c%s", delimiter, dwarf_vmatoa ("d", implicit_const));
1816 break;
1817
19e6b90e
L		 1818 case DW_FORM_ref8:
1819 case DW_FORM_data8:
2bc8690c 1820 if (!do_loc)
19e6b90e 1821 {
74bc6052 1822 dwarf_vma high_bits;
a69c4772 1823 dwarf_vma utmp;
74bc6052
CC		 1824 char buf[64];
1825
0c588247 1826 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
a69c4772
NC		 1827 utmp = uvalue;
1828 if (form == DW_FORM_ref8)
1829 add64 (& high_bits, & utmp, cu_offset);
ef0b5f1c 1830 printf ("%c0x%s", delimiter,
a69c4772 1831 dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf)));
19e6b90e 1832 }
0c588247 1833
19e6b90e
L		 1834 if ((do_loc || do_debug_loc || do_debug_ranges)
1835 && num_debug_info_entries == 0)
1836 {
1837 if (sizeof (uvalue) == 8)
0c588247 1838 SAFE_BYTE_GET (uvalue, data, 8, end);
19e6b90e 1839 else
467c65bc 1840 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
19e6b90e 1841 }
0c588247 1842
19e6b90e
L		 1843 data += 8;
1844 break;
1845
2f6cd591
JK		 1846 case DW_FORM_data16:
1847 if (!do_loc)
1848 {
1849 dwarf_vma left_high_bits, left_low_bits;
1850 dwarf_vma right_high_bits, right_low_bits;
1851
1852 SAFE_BYTE_GET64 (data, &left_high_bits, &left_low_bits, end);
1853 SAFE_BYTE_GET64 (data + 8, &right_high_bits, &right_low_bits, end);
1854 if (byte_get == byte_get_little_endian)
1855 {
1856 /* Swap them. */
1857 left_high_bits ^= right_high_bits;
1858 right_high_bits ^= left_high_bits;
1859 left_high_bits ^= right_high_bits;
1860 left_low_bits ^= right_low_bits;
1861 right_low_bits ^= left_low_bits;
1862 left_low_bits ^= right_low_bits;
1863 }
1864 printf (" 0x%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x"
1865 "%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x",
1866 left_high_bits, left_low_bits, right_high_bits,
1867 right_low_bits);
1868 }
1869 data += 16;
1870 break;
1871
19e6b90e
L		 1872 case DW_FORM_string:
1873 if (!do_loc)
ef0b5f1c 1874 printf ("%c%.*s", delimiter, (int) (end - data), data);
0c588247 1875 data += strnlen ((char *) data, end - data) + 1;
19e6b90e
L		 1876 break;
1877
1878 case DW_FORM_block:
932fd279 1879 case DW_FORM_exprloc:
f6f0e17b 1880 uvalue = read_uleb128 (data, & bytes_read, end);
19e6b90e 1881 block_start = data + bytes_read;
a1165289
NC		 1882 if (block_start >= end)
1883 {
1884 warn (_("Block ends prematurely\n"));
1885 uvalue = 0;
1886 block_start = end;
1887 }
f3853b34
NC		 1888 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1889 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1890 block_start + uvalue here. */
1891 data = block_start + uvalue;
f41e4712 1892 /* PR 17512: file: 008-103549-0.001:0.1. */
f3853b34 1893 if (block_start + uvalue > end || data < block_start)
f41e4712
NC		 1894 {
1895 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1896 uvalue = end - block_start;
1897 }
19e6b90e
L		 1898 if (do_loc)
1899 data = block_start + uvalue;
1900 else
ef0b5f1c 1901 data = display_block (block_start, uvalue, end, delimiter);
19e6b90e
L		 1902 break;
1903
1904 case DW_FORM_block1:
0c588247 1905 SAFE_BYTE_GET (uvalue, data, 1, end);
19e6b90e 1906 block_start = data + 1;
a1165289
NC		 1907 if (block_start >= end)
1908 {
1909 warn (_("Block ends prematurely\n"));
1910 uvalue = 0;
1911 block_start = end;
1912 }
f3853b34
NC		 1913 data = block_start + uvalue;
1914 if (block_start + uvalue > end || data < block_start)
f41e4712
NC		 1915 {
1916 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1917 uvalue = end - block_start;
1918 }
19e6b90e
L		 1919 if (do_loc)
1920 data = block_start + uvalue;
1921 else
ef0b5f1c 1922 data = display_block (block_start, uvalue, end, delimiter);
19e6b90e
L		 1923 break;
1924
1925 case DW_FORM_block2:
0c588247 1926 SAFE_BYTE_GET (uvalue, data, 2, end);
19e6b90e 1927 block_start = data + 2;
a1165289
NC		 1928 if (block_start >= end)
1929 {
1930 warn (_("Block ends prematurely\n"));
1931 uvalue = 0;
1932 block_start = end;
1933 }
f3853b34
NC		 1934 data = block_start + uvalue;
1935 if (block_start + uvalue > end || data < block_start)
f41e4712
NC		 1936 {
1937 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1938 uvalue = end - block_start;
1939 }
19e6b90e
L		 1940 if (do_loc)
1941 data = block_start + uvalue;
1942 else
ef0b5f1c 1943 data = display_block (block_start, uvalue, end, delimiter);
19e6b90e
L		 1944 break;
1945
1946 case DW_FORM_block4:
0c588247 1947 SAFE_BYTE_GET (uvalue, data, 4, end);
19e6b90e 1948 block_start = data + 4;
a1165289
NC		 1949 /* PR 17512: file: 3371-3907-0.004. */
1950 if (block_start >= end)
1951 {
1952 warn (_("Block ends prematurely\n"));
1953 uvalue = 0;
1954 block_start = end;
1955 }
f3853b34
NC		 1956 data = block_start + uvalue;
1957 if (block_start + uvalue > end
b4eb7656 1958 /* PR 17531: file: 5b5f0592. */
f3853b34 1959 || data < block_start)
f41e4712
NC		 1960 {
1961 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue);
1962 uvalue = end - block_start;
1963 }
19e6b90e
L		 1964 if (do_loc)
1965 data = block_start + uvalue;
1966 else
ef0b5f1c 1967 data = display_block (block_start, uvalue, end, delimiter);
19e6b90e
L		 1968 break;
1969
1970 case DW_FORM_strp:
1971 if (!do_loc)
ef0b5f1c 1972 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter,
47704ddf
KT		 1973 dwarf_vmatoa ("x", uvalue),
1974 fetch_indirect_string (uvalue));
19e6b90e
L		 1975 break;
1976
77145576
JK		 1977 case DW_FORM_line_strp:
1978 if (!do_loc)
1979 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter,
1980 dwarf_vmatoa ("x", uvalue),
1981 fetch_indirect_line_string (uvalue));
1982 break;
1983
4723351a
CC		 1984 case DW_FORM_GNU_str_index:
1985 if (!do_loc)
b4eb7656
AM		 1986 {
1987 const char *suffix = strrchr (section->name, '.');
1988 int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0;
1989
ef0b5f1c 1990 printf (_("%c(indexed string: 0x%s): %s"), delimiter,
b4eb7656
AM		 1991 dwarf_vmatoa ("x", uvalue),
1992 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
1993 }
4723351a
CC		 1994 break;
1995
a081f3cd
JJ		 1996 case DW_FORM_GNU_strp_alt:
1997 if (!do_loc)
ef0b5f1c 1998 printf (_("%c(alt indirect string, offset: 0x%s)"), delimiter,
a081f3cd
JJ		 1999 dwarf_vmatoa ("x", uvalue));
2000 break;
2001
19e6b90e
L		 2002 case DW_FORM_indirect:
2003 /* Handled above. */
2004 break;
2005
2b6f5997
CC		 2006 case DW_FORM_ref_sig8:
2007 if (!do_loc)
2008 {
74bc6052
CC		 2009 dwarf_vma high_bits;
2010 char buf[64];
2011
0c588247 2012 SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end);
ef0b5f1c 2013 printf ("%csignature: 0x%s", delimiter,
74bc6052 2014 dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf)));
2b6f5997 2015 }
74bc6052 2016 data += 8;
2b6f5997
CC		 2017 break;
2018
4723351a
CC		 2019 case DW_FORM_GNU_addr_index:
2020 if (!do_loc)
ef0b5f1c 2021 printf (_("%c(addr_index: 0x%s): %s"), delimiter,
b4eb7656
AM		 2022 dwarf_vmatoa ("x", uvalue),
2023 fetch_indexed_value (uvalue * pointer_size, pointer_size));
4723351a
CC		 2024 break;
2025
19e6b90e
L		 2026 default:
2027 warn (_("Unrecognized form: %lu\n"), form);
2028 break;
2029 }
2030
19e6b90e 2031 if ((do_loc || do_debug_loc || do_debug_ranges)
fd2f0033
TT		 2032 && num_debug_info_entries == 0
2033 && debug_info_p != NULL)
19e6b90e
L		 2034 {
2035 switch (attribute)
2036 {
2037 case DW_AT_frame_base:
2038 have_frame_base = 1;
1a0670f3 2039 /* Fall through. */
19e6b90e 2040 case DW_AT_location:
9f272209 2041 case DW_AT_GNU_locviews:
e2a0d921
NC		 2042 case DW_AT_string_length:
2043 case DW_AT_return_addr:
19e6b90e
L		 2044 case DW_AT_data_member_location:
2045 case DW_AT_vtable_elem_location:
e2a0d921
NC		 2046 case DW_AT_segment:
2047 case DW_AT_static_link:
2048 case DW_AT_use_location:
bc0a77d2 2049 case DW_AT_call_value:
629e7ca8 2050 case DW_AT_GNU_call_site_value:
bc0a77d2 2051 case DW_AT_call_data_value:
629e7ca8 2052 case DW_AT_GNU_call_site_data_value:
bc0a77d2 2053 case DW_AT_call_target:
629e7ca8 2054 case DW_AT_GNU_call_site_target:
bc0a77d2 2055 case DW_AT_call_target_clobbered:
629e7ca8 2056 case DW_AT_GNU_call_site_target_clobbered:
b4eb7656 2057 if ((dwarf_version < 4
212b6063 2058 && (form == DW_FORM_data4 || form == DW_FORM_data8))
932fd279 2059 || form == DW_FORM_sec_offset)
19e6b90e
L		 2060 {
2061 /* Process location list. */
91d6fa6a 2062 unsigned int lmax = debug_info_p->max_loc_offsets;
19e6b90e
L		 2063 unsigned int num = debug_info_p->num_loc_offsets;
2064
91d6fa6a 2065 if (lmax == 0 || num >= lmax)
19e6b90e 2066 {
91d6fa6a 2067 lmax += 1024;
467c65bc 2068 debug_info_p->loc_offsets = (dwarf_vma *)
b4eb7656
AM		 2069 xcrealloc (debug_info_p->loc_offsets,
2070 lmax, sizeof (*debug_info_p->loc_offsets));
9f272209
AO		 2071 debug_info_p->loc_views = (dwarf_vma *)
2072 xcrealloc (debug_info_p->loc_views,
2073 lmax, sizeof (*debug_info_p->loc_views));
3f5e193b 2074 debug_info_p->have_frame_base = (int *)
b4eb7656
AM		 2075 xcrealloc (debug_info_p->have_frame_base,
2076 lmax, sizeof (*debug_info_p->have_frame_base));
91d6fa6a 2077 debug_info_p->max_loc_offsets = lmax;
19e6b90e 2078 }
341f9135 2079 if (this_set != NULL)
b4eb7656 2080 uvalue += this_set->section_offsets [DW_SECT_LOC];
19e6b90e 2081 debug_info_p->have_frame_base [num] = have_frame_base;
9f272209
AO		 2082 if (attribute != DW_AT_GNU_locviews)
2083 {
2084 debug_info_p->loc_offsets [num] = uvalue;
2085 debug_info_p->num_loc_offsets++;
2086 assert (debug_info_p->num_loc_offsets
2087 - debug_info_p->num_loc_views <= 1);
2088 }
2089 else
2090 {
2091 assert (debug_info_p->num_loc_views <= num);
2092 num = debug_info_p->num_loc_views;
2093 debug_info_p->loc_views [num] = uvalue;
2094 debug_info_p->num_loc_views++;
2095 assert (debug_info_p->num_loc_views
2096 - debug_info_p->num_loc_offsets <= 1);
2097 }
19e6b90e
L		 2098 }
2099 break;
e2a0d921 2100
19e6b90e
L		 2101 case DW_AT_low_pc:
2102 if (need_base_address)
2103 debug_info_p->base_address = uvalue;
2104 break;
2105
4723351a 2106 case DW_AT_GNU_addr_base:
b4eb7656 2107 debug_info_p->addr_base = uvalue;
4723351a
CC		 2108 break;
2109
2110 case DW_AT_GNU_ranges_base:
b4eb7656 2111 debug_info_p->ranges_base = uvalue;
4723351a
CC		 2112 break;
2113
19e6b90e 2114 case DW_AT_ranges:
b4eb7656 2115 if ((dwarf_version < 4
212b6063 2116 && (form == DW_FORM_data4 || form == DW_FORM_data8))
932fd279 2117 || form == DW_FORM_sec_offset)
19e6b90e
L		 2118 {
2119 /* Process range list. */
91d6fa6a 2120 unsigned int lmax = debug_info_p->max_range_lists;
19e6b90e
L		 2121 unsigned int num = debug_info_p->num_range_lists;
2122
91d6fa6a 2123 if (lmax == 0 || num >= lmax)
19e6b90e 2124 {
91d6fa6a 2125 lmax += 1024;
467c65bc 2126 debug_info_p->range_lists = (dwarf_vma *)
b4eb7656
AM		 2127 xcrealloc (debug_info_p->range_lists,
2128 lmax, sizeof (*debug_info_p->range_lists));
91d6fa6a 2129 debug_info_p->max_range_lists = lmax;
19e6b90e
L		 2130 }
2131 debug_info_p->range_lists [num] = uvalue;
2132 debug_info_p->num_range_lists++;
2133 }
2134 break;
2135
2136 default:
2137 break;
2138 }
2139 }
2140
4ccf1e31 2141 if (do_loc || attribute == 0)
19e6b90e
L		 2142 return data;
2143
ec4d4525 2144 /* For some attributes we can display further information. */
19e6b90e
L		 2145 switch (attribute)
2146 {
2147 case DW_AT_inline:
2e9e81a8 2148 printf ("\t");
19e6b90e
L		 2149 switch (uvalue)
2150 {
2151 case DW_INL_not_inlined:
2152 printf (_("(not inlined)"));
2153 break;
2154 case DW_INL_inlined:
2155 printf (_("(inlined)"));
2156 break;
2157 case DW_INL_declared_not_inlined:
2158 printf (_("(declared as inline but ignored)"));
2159 break;
2160 case DW_INL_declared_inlined:
2161 printf (_("(declared as inline and inlined)"));
2162 break;
2163 default:
47704ddf
KT		 2164 printf (_(" (Unknown inline attribute value: %s)"),
2165 dwarf_vmatoa ("x", uvalue));
19e6b90e
L		 2166 break;
2167 }
2168 break;
2169
2170 case DW_AT_language:
2e9e81a8 2171 printf ("\t");
19e6b90e
L		 2172 switch (uvalue)
2173 {
4b78141a 2174 /* Ordered by the numeric value of these constants. */
19e6b90e 2175 case DW_LANG_C89: printf ("(ANSI C)"); break;
4b78141a
NC		 2176 case DW_LANG_C: printf ("(non-ANSI C)"); break;
2177 case DW_LANG_Ada83: printf ("(Ada)"); break;
19e6b90e 2178 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
4b78141a
NC		 2179 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
2180 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
19e6b90e
L		 2181 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
2182 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
19e6b90e 2183 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
4b78141a 2184 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
19e6b90e 2185 /* DWARF 2.1 values. */
4b78141a 2186 case DW_LANG_Java: printf ("(Java)"); break;
19e6b90e
L		 2187 case DW_LANG_C99: printf ("(ANSI C99)"); break;
2188 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
2189 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
4b78141a
NC		 2190 /* DWARF 3 values. */
2191 case DW_LANG_PLI: printf ("(PLI)"); break;
2192 case DW_LANG_ObjC: printf ("(Objective C)"); break;
2193 case DW_LANG_ObjC_plus_plus: printf ("(Objective C++)"); break;
2194 case DW_LANG_UPC: printf ("(Unified Parallel C)"); break;
2195 case DW_LANG_D: printf ("(D)"); break;
2b6f5997
CC		 2196 /* DWARF 4 values. */
2197 case DW_LANG_Python: printf ("(Python)"); break;
3362e0d9
ILT		 2198 /* DWARF 5 values. */
2199 case DW_LANG_Go: printf ("(Go)"); break;
8bc10620 2200 case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break;
6ddfe5b4 2201 case DW_LANG_C11: printf ("(C11)"); break;
8bc10620 2202 case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break;
5a195044
MW		 2203 case DW_LANG_Fortran03: printf ("(Fortran 03)"); break;
2204 case DW_LANG_Fortran08: printf ("(Fortran 08)"); break;
19e6b90e
L		 2205 /* MIPS extension. */
2206 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
2207 /* UPC extension. */
2208 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
2209 default:
4b78141a 2210 if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user)
9cf03b7e 2211 printf (_("(implementation defined: %s)"),
467c65bc 2212 dwarf_vmatoa ("x", uvalue));
4b78141a 2213 else
9cf03b7e 2214 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue));
19e6b90e
L		 2215 break;
2216 }
2217 break;
2218
2219 case DW_AT_encoding:
2e9e81a8 2220 printf ("\t");
19e6b90e
L		 2221 switch (uvalue)
2222 {
2223 case DW_ATE_void: printf ("(void)"); break;
2224 case DW_ATE_address: printf ("(machine address)"); break;
2225 case DW_ATE_boolean: printf ("(boolean)"); break;
2226 case DW_ATE_complex_float: printf ("(complex float)"); break;
2227 case DW_ATE_float: printf ("(float)"); break;
2228 case DW_ATE_signed: printf ("(signed)"); break;
2229 case DW_ATE_signed_char: printf ("(signed char)"); break;
2230 case DW_ATE_unsigned: printf ("(unsigned)"); break;
2231 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
e2a0d921 2232 /* DWARF 2.1 values: */
19e6b90e
L		 2233 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
2234 case DW_ATE_decimal_float: printf ("(decimal float)"); break;
e2a0d921
NC		 2235 /* DWARF 3 values: */
2236 case DW_ATE_packed_decimal: printf ("(packed_decimal)"); break;
2237 case DW_ATE_numeric_string: printf ("(numeric_string)"); break;
2238 case DW_ATE_edited: printf ("(edited)"); break;
2239 case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break;
2240 case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break;
2241 /* HP extensions: */
2242 case DW_ATE_HP_float80: printf ("(HP_float80)"); break;
2243 case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break;
2244 case DW_ATE_HP_float128: printf ("(HP_float128)"); break;
2245 case DW_ATE_HP_complex_float128:printf ("(HP_complex_float128)"); break;
2246 case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break;
2247 case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break;
2248 case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break;
153a2776
NC		 2249 /* DWARF 4 values: */
2250 case DW_ATE_UTF: printf ("(unicode string)"); break;
e2a0d921 2251
19e6b90e
L		 2252 default:
2253 if (uvalue >= DW_ATE_lo_user
2254 && uvalue <= DW_ATE_hi_user)
9cf03b7e 2255 printf (_("(user defined type)"));
19e6b90e 2256 else
9cf03b7e 2257 printf (_("(unknown type)"));
19e6b90e
L		 2258 break;
2259 }
2260 break;
2261
2262 case DW_AT_accessibility:
2e9e81a8 2263 printf ("\t");
19e6b90e
L		 2264 switch (uvalue)
2265 {
2266 case DW_ACCESS_public: printf ("(public)"); break;
2267 case DW_ACCESS_protected: printf ("(protected)"); break;
2268 case DW_ACCESS_private: printf ("(private)"); break;
2269 default:
9cf03b7e 2270 printf (_("(unknown accessibility)"));
19e6b90e
L		 2271 break;
2272 }
2273 break;
2274
2275 case DW_AT_visibility:
2e9e81a8 2276 printf ("\t");
19e6b90e
L		 2277 switch (uvalue)
2278 {
2279 case DW_VIS_local: printf ("(local)"); break;
2280 case DW_VIS_exported: printf ("(exported)"); break;
2281 case DW_VIS_qualified: printf ("(qualified)"); break;
9cf03b7e 2282 default: printf (_("(unknown visibility)")); break;
19e6b90e
L		 2283 }
2284 break;
2285
2286 case DW_AT_virtuality:
2e9e81a8 2287 printf ("\t");
19e6b90e
L		 2288 switch (uvalue)
2289 {
2290 case DW_VIRTUALITY_none: printf ("(none)"); break;
2291 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2292 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
9cf03b7e 2293 default: printf (_("(unknown virtuality)")); break;
19e6b90e
L		 2294 }
2295 break;
2296
2297 case DW_AT_identifier_case:
2e9e81a8 2298 printf ("\t");
19e6b90e
L		 2299 switch (uvalue)
2300 {
2301 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2302 case DW_ID_up_case: printf ("(up_case)"); break;
2303 case DW_ID_down_case: printf ("(down_case)"); break;
2304 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
9cf03b7e 2305 default: printf (_("(unknown case)")); break;
19e6b90e
L		 2306 }
2307 break;
2308
2309 case DW_AT_calling_convention:
2e9e81a8 2310 printf ("\t");
19e6b90e
L		 2311 switch (uvalue)
2312 {
2313 case DW_CC_normal: printf ("(normal)"); break;
2314 case DW_CC_program: printf ("(program)"); break;
2315 case DW_CC_nocall: printf ("(nocall)"); break;
2316 default:
2317 if (uvalue >= DW_CC_lo_user
2318 && uvalue <= DW_CC_hi_user)
9cf03b7e 2319 printf (_("(user defined)"));
19e6b90e 2320 else
9cf03b7e 2321 printf (_("(unknown convention)"));
19e6b90e
L		 2322 }
2323 break;
2324
2325 case DW_AT_ordering:
2e9e81a8 2326 printf ("\t");
19e6b90e
L		 2327 switch (uvalue)
2328 {
9cf03b7e 2329 case -1: printf (_("(undefined)")); break;
19e6b90e
L		 2330 case 0: printf ("(row major)"); break;
2331 case 1: printf ("(column major)"); break;
2332 }
2333 break;
2334
2335 case DW_AT_frame_base:
2336 have_frame_base = 1;
1a0670f3 2337 /* Fall through. */
19e6b90e 2338 case DW_AT_location:
e2a0d921
NC		 2339 case DW_AT_string_length:
2340 case DW_AT_return_addr:
19e6b90e
L		 2341 case DW_AT_data_member_location:
2342 case DW_AT_vtable_elem_location:
e2a0d921
NC		 2343 case DW_AT_segment:
2344 case DW_AT_static_link:
2345 case DW_AT_use_location:
bc0a77d2 2346 case DW_AT_call_value:
629e7ca8 2347 case DW_AT_GNU_call_site_value:
bc0a77d2 2348 case DW_AT_call_data_value:
629e7ca8 2349 case DW_AT_GNU_call_site_data_value:
bc0a77d2 2350 case DW_AT_call_target:
629e7ca8 2351 case DW_AT_GNU_call_site_target:
bc0a77d2 2352 case DW_AT_call_target_clobbered:
629e7ca8 2353 case DW_AT_GNU_call_site_target_clobbered:
212b6063 2354 if ((dwarf_version < 4
b4eb7656 2355 && (form == DW_FORM_data4 || form == DW_FORM_data8))
932fd279 2356 || form == DW_FORM_sec_offset)
2e9e81a8 2357 printf (_(" (location list)"));
e2a0d921 2358 /* Fall through. */
19e6b90e
L		 2359 case DW_AT_allocated:
2360 case DW_AT_associated:
2361 case DW_AT_data_location:
2362 case DW_AT_stride:
2363 case DW_AT_upper_bound:
cecf136e 2364 case DW_AT_lower_bound:
19e6b90e
L		 2365 if (block_start)
2366 {
2367 int need_frame_base;
2368
2e9e81a8 2369 printf ("\t(");
19e6b90e
L		 2370 need_frame_base = decode_location_expression (block_start,
2371 pointer_size,
b7807392
JJ		 2372 offset_size,
2373 dwarf_version,
19e6b90e 2374 uvalue,
f1c4cc75 2375 cu_offset, section);
19e6b90e
L		 2376 printf (")");
2377 if (need_frame_base && !have_frame_base)
2378 printf (_(" [without DW_AT_frame_base]"));
2379 }
19e6b90e
L		 2380 break;
2381
ec4d4525
NC		 2382 case DW_AT_import:
2383 {
a081f3cd
JJ		 2384 if (form == DW_FORM_ref_sig8
2385 || form == DW_FORM_GNU_ref_alt)
b4eb7656 2386 break;
2b6f5997 2387
ec4d4525
NC		 2388 if (form == DW_FORM_ref1
2389 || form == DW_FORM_ref2
a7a0b6a5
JK		 2390 || form == DW_FORM_ref4
2391 || form == DW_FORM_ref_udata)
ec4d4525
NC		 2392 uvalue += cu_offset;
2393
6e3d6dc1 2394 if (uvalue >= section->size)
f3853b34 2395 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
47704ddf
KT		 2396 dwarf_vmatoa ("x", uvalue),
2397 (unsigned long) (orig_data - section->start));
6e3d6dc1
NC		 2398 else
2399 {
2400 unsigned long abbrev_number;
2401 abbrev_entry * entry;
2402
f6f0e17b 2403 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
cecf136e 2404
2e9e81a8 2405 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
afd6e1ff
JJ		 2406 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2407 use different abbrev table, and we don't track .debug_info chunks
2408 yet. */
2409 if (form != DW_FORM_ref_addr)
2410 {
2411 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2412 if (entry->entry == abbrev_number)
2413 break;
2414 if (entry != NULL)
2415 printf (" (%s)", get_TAG_name (entry->tag));
2416 }
6e3d6dc1
NC		 2417 printf ("]");
2418 }
ec4d4525
NC		 2419 }
2420 break;
2421
19e6b90e
L		 2422 default:
2423 break;
2424 }
2425
2426 return data;
2427}
2428
a19c41a7 2429static const char *
19e6b90e
L		 2430get_AT_name (unsigned long attribute)
2431{
a19c41a7 2432 const char *name;
e2a0d921 2433
399c99f7
L		 2434 if (attribute == 0)
2435 return "DW_AT value: 0";
2436
a19c41a7
TT		 2437 /* One value is shared by the MIPS and HP extensions: */
2438 if (attribute == DW_AT_MIPS_fde)
2439 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
19e6b90e 2440
a19c41a7
TT		 2441 name = get_DW_AT_name (attribute);
2442
2443 if (name == NULL)
2444 {
2445 static char buffer[100];
2446
2447 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2448 attribute);
2449 return buffer;
19e6b90e 2450 }
a19c41a7
TT		 2451
2452 return name;
19e6b90e
L		 2453}
2454
2455static unsigned char *
6e3d6dc1
NC		 2456read_and_display_attr (unsigned long attribute,
2457 unsigned long form,
77145576 2458 dwarf_signed_vma implicit_const,
ec4d4525 2459 unsigned char * data,
f6f0e17b 2460 unsigned char * end,
467c65bc
NC		 2461 dwarf_vma cu_offset,
2462 dwarf_vma pointer_size,
2463 dwarf_vma offset_size,
6e3d6dc1
NC		 2464 int dwarf_version,
2465 debug_info * debug_info_p,
2466 int do_loc,
341f9135
CC		 2467 struct dwarf_section * section,
2468 struct cu_tu_set * this_set)
19e6b90e
L		 2469{
2470 if (!do_loc)
750f03b7 2471 printf (" %-18s:", get_AT_name (attribute));
77145576 2472 data = read_and_display_attr_value (attribute, form, implicit_const, data, end,
f6f0e17b 2473 cu_offset, pointer_size, offset_size,
19e6b90e 2474 dwarf_version, debug_info_p,
ef0b5f1c 2475 do_loc, section, this_set, ' ');
19e6b90e
L		 2476 if (!do_loc)
2477 printf ("\n");
2478 return data;
2479}
2480
19e6b90e
L		 2481/* Process the contents of a .debug_info section. If do_loc is non-zero
2482 then we are scanning for location lists and we do not want to display
2b6f5997
CC		 2483 anything to the user. If do_types is non-zero, we are processing
2484 a .debug_types section instead of a .debug_info section. */
19e6b90e
L		 2485
2486static int
6e3d6dc1
NC		 2487process_debug_info (struct dwarf_section *section,
2488 void *file,
b4eb7656 2489 enum dwarf_section_display_enum abbrev_sec,
2b6f5997
CC		 2490 int do_loc,
2491 int do_types)
19e6b90e
L		 2492{
2493 unsigned char *start = section->start;
2494 unsigned char *end = start + section->size;
2495 unsigned char *section_begin;
2496 unsigned int unit;
2497 unsigned int num_units = 0;
2498
2499 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2500 && num_debug_info_entries == 0
2501 && ! do_types)
19e6b90e 2502 {
767221a9 2503 dwarf_vma length;
19e6b90e
L		 2504
2505 /* First scan the section to get the number of comp units. */
2506 for (section_begin = start, num_units = 0; section_begin < end;
2507 num_units ++)
2508 {
2509 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2510 will be the length. For a 64-bit DWARF section, it'll be
2511 the escape code 0xffffffff followed by an 8 byte length. */
0c588247 2512 SAFE_BYTE_GET (length, section_begin, 4, end);
19e6b90e
L		 2513
2514 if (length == 0xffffffff)
2515 {
0c588247 2516 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
19e6b90e
L		 2517 section_begin += length + 12;
2518 }
ec4d4525
NC		 2519 else if (length >= 0xfffffff0 && length < 0xffffffff)
2520 {
767221a9
NC		 2521 warn (_("Reserved length value (0x%s) found in section %s\n"),
2522 dwarf_vmatoa ("x", length), section->name);
ec4d4525
NC		 2523 return 0;
2524 }
19e6b90e
L		 2525 else
2526 section_begin += length + 4;
aca88567
NC		 2527
2528 /* Negative values are illegal, they may even cause infinite
2529 looping. This can happen if we can't accurately apply
f3853b34
NC		 2530 relocations to an object file, or if the file is corrupt. */
2531 if ((signed long) length <= 0 || section_begin < start)
aca88567 2532 {
767221a9
NC		 2533 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2534 dwarf_vmatoa ("x", length), section->name);
aca88567
NC		 2535 return 0;
2536 }
19e6b90e
L		 2537 }
2538
2539 if (num_units == 0)
2540 {
f41e4712 2541 error (_("No comp units in %s section ?\n"), section->name);
19e6b90e
L		 2542 return 0;
2543 }
2544
2545 /* Then allocate an array to hold the information. */
3f5e193b 2546 debug_information = (debug_info *) cmalloc (num_units,
1306a742 2547 sizeof (* debug_information));
19e6b90e
L		 2548 if (debug_information == NULL)
2549 {
f41e4712 2550 error (_("Not enough memory for a debug info array of %u entries\n"),
19e6b90e 2551 num_units);
82b1b41b 2552 alloc_num_debug_info_entries = num_debug_info_entries = 0;
19e6b90e
L		 2553 return 0;
2554 }
03a91817
NC		 2555 /* PR 17531: file: 92ca3797.
2556 We cannot rely upon the debug_information array being initialised
2557 before it is used. A corrupt file could easily contain references
2558 to a unit for which information has not been made available. So
2559 we ensure that the array is zeroed here. */
b4eb7656
AM		 2560 memset (debug_information, 0, num_units * sizeof (*debug_information));
2561
82b1b41b 2562 alloc_num_debug_info_entries = num_units;
19e6b90e
L		 2563 }
2564
2565 if (!do_loc)
2566 {
fd2f0033
TT		 2567 if (dwarf_start_die == 0)
2568 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e
L		 2569
2570 load_debug_section (str, file);
77145576 2571 load_debug_section (line_str, file);
4723351a
CC		 2572 load_debug_section (str_dwo, file);
2573 load_debug_section (str_index, file);
2574 load_debug_section (str_index_dwo, file);
2575 load_debug_section (debug_addr, file);
19e6b90e
L		 2576 }
2577
6f875884
TG		 2578 load_debug_section (abbrev_sec, file);
2579 if (debug_displays [abbrev_sec].section.start == NULL)
19e6b90e
L		 2580 {
2581 warn (_("Unable to locate %s section!\n"),
6f875884 2582 debug_displays [abbrev_sec].section.name);
19e6b90e
L		 2583 return 0;
2584 }
2585
2586 for (section_begin = start, unit = 0; start < end; unit++)
2587 {
2588 DWARF2_Internal_CompUnit compunit;
2589 unsigned char *hdrptr;
19e6b90e 2590 unsigned char *tags;
fd2f0033 2591 int level, last_level, saved_level;
467c65bc 2592 dwarf_vma cu_offset;
bf5117e3 2593 unsigned int offset_size;
19e6b90e 2594 int initial_length_size;
74bc6052
CC		 2595 dwarf_vma signature_high = 0;
2596 dwarf_vma signature_low = 0;
767221a9 2597 dwarf_vma type_offset = 0;
341f9135
CC		 2598 struct cu_tu_set *this_set;
2599 dwarf_vma abbrev_base;
2600 size_t abbrev_size;
19e6b90e
L		 2601
2602 hdrptr = start;
2603
0c588247 2604 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
19e6b90e
L		 2605
2606 if (compunit.cu_length == 0xffffffff)
2607 {
0c588247 2608 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
19e6b90e
L		 2609 offset_size = 8;
2610 initial_length_size = 12;
2611 }
2612 else
2613 {
2614 offset_size = 4;
2615 initial_length_size = 4;
2616 }
2617
0c588247 2618 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
19e6b90e
L		 2619
2620 cu_offset = start - section_begin;
19e6b90e 2621
341f9135
CC		 2622 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2623
77145576
JK		 2624 if (compunit.cu_version < 5)
2625 {
2626 compunit.cu_unit_type = DW_UT_compile;
2627 /* Initialize it due to a false compiler warning. */
2628 compunit.cu_pointer_size = -1;
2629 }
2630 else
2631 {
2632 SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end);
2633 do_types = (compunit.cu_unit_type == DW_UT_type);
2634
2635 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2636 }
2637
0c588247 2638 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
19e6b90e 2639
341f9135
CC		 2640 if (this_set == NULL)
2641 {
2642 abbrev_base = 0;
2643 abbrev_size = debug_displays [abbrev_sec].section.size;
2644 }
2645 else
2646 {
2647 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2648 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2649 }
2650
77145576
JK		 2651 if (compunit.cu_version < 5)
2652 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
2653
f41e4712
NC		 2654 /* PR 17512: file: 001-108546-0.001:0.1. */
2655 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2656 {
2657 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2658 compunit.cu_pointer_size, offset_size);
2659 compunit.cu_pointer_size = offset_size;
2660 }
2b6f5997
CC		 2661
2662 if (do_types)
b4eb7656 2663 {
0c588247 2664 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
f048b142 2665 hdrptr += 8;
0c588247 2666 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
b4eb7656 2667 }
2b6f5997 2668
19e6b90e 2669 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2670 && num_debug_info_entries == 0
2671 && ! do_types)
19e6b90e
L		 2672 {
2673 debug_information [unit].cu_offset = cu_offset;
2674 debug_information [unit].pointer_size
2675 = compunit.cu_pointer_size;
b7807392
JJ		 2676 debug_information [unit].offset_size = offset_size;
2677 debug_information [unit].dwarf_version = compunit.cu_version;
19e6b90e 2678 debug_information [unit].base_address = 0;
4723351a
CC		 2679 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2680 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
19e6b90e
L		 2681 debug_information [unit].loc_offsets = NULL;
2682 debug_information [unit].have_frame_base = NULL;
2683 debug_information [unit].max_loc_offsets = 0;
2684 debug_information [unit].num_loc_offsets = 0;
2685 debug_information [unit].range_lists = NULL;
2686 debug_information [unit].max_range_lists= 0;
2687 debug_information [unit].num_range_lists = 0;
2688 }
2689
fd2f0033 2690 if (!do_loc && dwarf_start_die == 0)
19e6b90e 2691 {
47704ddf
KT		 2692 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2693 dwarf_vmatoa ("x", cu_offset));
2694 printf (_(" Length: 0x%s (%s)\n"),
2695 dwarf_vmatoa ("x", compunit.cu_length),
49e7b350 2696 offset_size == 8 ? "64-bit" : "32-bit");
19e6b90e 2697 printf (_(" Version: %d\n"), compunit.cu_version);
7282333f
AM		 2698 printf (_(" Abbrev Offset: 0x%s\n"),
2699 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
19e6b90e 2700 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2b6f5997
CC		 2701 if (do_types)
2702 {
74bc6052
CC		 2703 char buf[64];
2704
2705 printf (_(" Signature: 0x%s\n"),
2706 dwarf_vmatoa64 (signature_high, signature_low,
2707 buf, sizeof (buf)));
2708 printf (_(" Type Offset: 0x%s\n"),
2709 dwarf_vmatoa ("x", type_offset));
2b6f5997 2710 }
341f9135
CC		 2711 if (this_set != NULL)
2712 {
2713 dwarf_vma *offsets = this_set->section_offsets;
2714 size_t *sizes = this_set->section_sizes;
2715
2716 printf (_(" Section contributions:\n"));
2717 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2718 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2719 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2720 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2721 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2722 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2723 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2724 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2725 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2726 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2727 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2728 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2729 }
19e6b90e
L		 2730 }
2731
460c89ff
NS		 2732 if (cu_offset + compunit.cu_length + initial_length_size
2733 > section->size)
2734 {
47704ddf 2735 warn (_("Debug info is corrupted, length of CU at %s"
b4eb7656 2736 " extends beyond end of section (length = %s)\n"),
47704ddf
KT		 2737 dwarf_vmatoa ("x", cu_offset),
2738 dwarf_vmatoa ("x", compunit.cu_length));
57028622 2739 num_units = unit;
460c89ff
NS		 2740 break;
2741 }
2742 tags = hdrptr;
2743 start += compunit.cu_length + initial_length_size;
2744
57028622
NC		 2745 if (start > end)
2746 {
2747 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2748 dwarf_vmatoa ("x", cu_offset));
2749 start = end;
2750 }
2751
77145576 2752 if (compunit.cu_version < 2 || compunit.cu_version > 5)
19e6b90e 2753 {
47704ddf
KT		 2754 warn (_("CU at offset %s contains corrupt or "
2755 "unsupported version number: %d.\n"),
2756 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
19e6b90e
L		 2757 continue;
2758 }
2759
77145576
JK		 2760 if (compunit.cu_unit_type != DW_UT_compile
2761 && compunit.cu_unit_type != DW_UT_type)
2762 {
2763 warn (_("CU at offset %s contains corrupt or "
2764 "unsupported unit type: %d.\n"),
2765 dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type);
2766 continue;
2767 }
2768
19e6b90e
L		 2769 free_abbrevs ();
2770
d493b283 2771 /* Process the abbrevs used by this compilation unit. */
341f9135 2772 if (compunit.cu_abbrev_offset >= abbrev_size)
ec4d4525
NC		 2773 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2774 (unsigned long) compunit.cu_abbrev_offset,
341f9135 2775 (unsigned long) abbrev_size);
b4eb7656 2776 /* PR 17531: file:4bcd9ce9. */
a0a3b04c
L		 2777 else if ((abbrev_base + abbrev_size)
2778 > debug_displays [abbrev_sec].section.size)
2779 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2780 (unsigned long) abbrev_base + abbrev_size,
2781 (unsigned long) debug_displays [abbrev_sec].section.size);
460c89ff
NS		 2782 else
2783 process_abbrev_section
341f9135
CC		 2784 (((unsigned char *) debug_displays [abbrev_sec].section.start
2785 + abbrev_base + compunit.cu_abbrev_offset),
2786 ((unsigned char *) debug_displays [abbrev_sec].section.start
2787 + abbrev_base + abbrev_size));
19e6b90e
L		 2788
2789 level = 0;
fd2f0033
TT		 2790 last_level = level;
2791 saved_level = -1;
19e6b90e
L		 2792 while (tags < start)
2793 {
2794 unsigned int bytes_read;
2795 unsigned long abbrev_number;
ec4d4525 2796 unsigned long die_offset;
19e6b90e
L		 2797 abbrev_entry *entry;
2798 abbrev_attr *attr;
fd2f0033 2799 int do_printing = 1;
19e6b90e 2800
ec4d4525
NC		 2801 die_offset = tags - section_begin;
2802
f6f0e17b 2803 abbrev_number = read_uleb128 (tags, & bytes_read, start);
19e6b90e
L		 2804 tags += bytes_read;
2805
eb7cc021
JK		 2806 /* A null DIE marks the end of a list of siblings or it may also be
2807 a section padding. */
19e6b90e
L		 2808 if (abbrev_number == 0)
2809 {
eb7cc021
JK		 2810 /* Check if it can be a section padding for the last CU. */
2811 if (level == 0 && start == end)
2812 {
2813 unsigned char *chk;
2814
2815 for (chk = tags; chk < start; chk++)
2816 if (*chk != 0)
2817 break;
2818 if (chk == start)
2819 break;
2820 }
2821
4337774f
TT		 2822 if (!do_loc && die_offset >= dwarf_start_die
2823 && (dwarf_cutoff_level == -1
2824 || level < dwarf_cutoff_level))
399c99f7
L		 2825 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2826 level, die_offset);
2827
19e6b90e 2828 --level;
ec4d4525
NC		 2829 if (level < 0)
2830 {
2831 static unsigned num_bogus_warns = 0;
2832
2833 if (num_bogus_warns < 3)
2834 {
4723351a
CC		 2835 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2836 die_offset, section->name);
ec4d4525
NC		 2837 num_bogus_warns ++;
2838 if (num_bogus_warns == 3)
2839 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2840 }
2841 }
fd2f0033
TT		 2842 if (dwarf_start_die != 0 && level < saved_level)
2843 return 1;
19e6b90e
L		 2844 continue;
2845 }
2846
4b78141a 2847 if (!do_loc)
fd2f0033
TT		 2848 {
2849 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2850 do_printing = 0;
2851 else
2852 {
2853 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2854 saved_level = level;
2855 do_printing = (dwarf_cutoff_level == -1
2856 || level < dwarf_cutoff_level);
2857 if (do_printing)
2858 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2859 level, die_offset, abbrev_number);
2860 else if (dwarf_cutoff_level == -1
2861 || last_level < dwarf_cutoff_level)
2862 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2863 last_level = level;
2864 }
2865 }
cecf136e 2866
19e6b90e
L		 2867 /* Scan through the abbreviation list until we reach the
2868 correct entry. */
2869 for (entry = first_abbrev;
2870 entry && entry->entry != abbrev_number;
2871 entry = entry->next)
2872 continue;
2873
2874 if (entry == NULL)
2875 {
fd2f0033 2876 if (!do_loc && do_printing)
4b78141a
NC		 2877 {
2878 printf ("\n");
2879 fflush (stdout);
2880 }
f3853b34 2881 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
cc86f28f 2882 die_offset, abbrev_number);
19e6b90e
L		 2883 return 0;
2884 }
2885
fd2f0033 2886 if (!do_loc && do_printing)
cc5914eb 2887 printf (" (%s)\n", get_TAG_name (entry->tag));
cecf136e 2888
19e6b90e
L		 2889 switch (entry->tag)
2890 {
2891 default:
2892 need_base_address = 0;
2893 break;
2894 case DW_TAG_compile_unit:
2895 need_base_address = 1;
2896 break;
2897 case DW_TAG_entry_point:
19e6b90e
L		 2898 case DW_TAG_subprogram:
2899 need_base_address = 0;
2900 /* Assuming that there is no DW_AT_frame_base. */
2901 have_frame_base = 0;
2902 break;
2903 }
2904
9f272209
AO		 2905 debug_info *debug_info_p =
2906 (debug_information && unit < alloc_num_debug_info_entries)
2907 ? debug_information + unit : NULL;
2908
2909 assert (!debug_info_p
2910 || (debug_info_p->num_loc_offsets
2911 == debug_info_p->num_loc_views));
2912
399c99f7
L		 2913 for (attr = entry->first_attr;
2914 attr && attr->attribute;
2915 attr = attr->next)
4b78141a 2916 {
fd2f0033 2917 if (! do_loc && do_printing)
4b78141a 2918 /* Show the offset from where the tag was extracted. */
fd2f0033
TT		 2919 printf (" <%lx>", (unsigned long)(tags - section_begin));
2920
4b78141a
NC		 2921 tags = read_and_display_attr (attr->attribute,
2922 attr->form,
77145576 2923 attr->implicit_const,
341f9135 2924 tags,
f6f0e17b 2925 end,
341f9135 2926 cu_offset,
4b78141a
NC		 2927 compunit.cu_pointer_size,
2928 offset_size,
2929 compunit.cu_version,
9f272209 2930 debug_info_p,
341f9135
CC		 2931 do_loc || ! do_printing,
2932 section,
2933 this_set);
4b78141a 2934 }
cecf136e 2935
9f272209
AO		 2936 /* If a locview attribute appears before a location one,
2937 make sure we don't associate it with an earlier
2938 loclist. */
2939 if (debug_info_p)
2940 switch (debug_info_p->num_loc_offsets - debug_info_p->num_loc_views)
2941 {
2942 case 1:
2943 debug_info_p->loc_views [debug_info_p->num_loc_views] = vm1;
2944 debug_info_p->num_loc_views++;
2945 assert (debug_info_p->num_loc_views
2946 == debug_info_p->num_loc_offsets);
2947 break;
2948
2949 case 0:
2950 break;
2951
2952 case -1:
2953 warn(_("DIE has locviews without loclist\n"));
2954 debug_info_p->num_loc_views--;
2955 break;
2956
2957 default:
2958 assert (0);
2959 }
2960
b4eb7656
AM		 2961 if (entry->children)
2962 ++level;
2963 }
19e6b90e 2964 }
cecf136e 2965
19e6b90e
L		 2966 /* Set num_debug_info_entries here so that it can be used to check if
2967 we need to process .debug_loc and .debug_ranges sections. */
2968 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2969 && num_debug_info_entries == 0
2970 && ! do_types)
82b1b41b 2971 {
b4eb7656 2972 if (num_units > alloc_num_debug_info_entries)
82b1b41b
NC		 2973 num_debug_info_entries = alloc_num_debug_info_entries;
2974 else
2975 num_debug_info_entries = num_units;
2976 }
cecf136e 2977
19e6b90e 2978 if (!do_loc)
467c65bc 2979 printf ("\n");
cecf136e 2980
19e6b90e
L		 2981 return 1;
2982}
2983
2984/* Locate and scan the .debug_info section in the file and record the pointer
2985 sizes and offsets for the compilation units in it. Usually an executable
2986 will have just one pointer size, but this is not guaranteed, and so we try
2987 not to make any assumptions. Returns zero upon failure, or the number of
2988 compilation units upon success. */
2989
2990static unsigned int
2991load_debug_info (void * file)
2992{
1febe64d 2993 /* If we have already tried and failed to load the .debug_info
657d0d47 2994 section then do not bother to repeat the task. */
cc86f28f 2995 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
1febe64d
NC		 2996 return 0;
2997
19e6b90e
L		 2998 /* If we already have the information there is nothing else to do. */
2999 if (num_debug_info_entries > 0)
3000 return num_debug_info_entries;
3001
341f9135 3002 /* If this is a DWARF package file, load the CU and TU indexes. */
43a444f9 3003 (void) load_cu_tu_indexes (file);
341f9135 3004
19e6b90e 3005 if (load_debug_section (info, file)
6f875884 3006 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
19e6b90e 3007 return num_debug_info_entries;
82b1b41b
NC		 3008
3009 if (load_debug_section (info_dwo, file)
3010 && process_debug_info (&debug_displays [info_dwo].section, file,
3011 abbrev_dwo, 1, 0))
4723351a 3012 return num_debug_info_entries;
1febe64d 3013
cc86f28f 3014 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
1febe64d 3015 return 0;
19e6b90e
L		 3016}
3017
b40bf0a2
NC		 3018/* Read a DWARF .debug_line section header starting at DATA.
3019 Upon success returns an updated DATA pointer and the LINFO
3020 structure and the END_OF_SEQUENCE pointer will be filled in.
3021 Otherwise returns NULL. */
19e6b90e 3022
b40bf0a2
NC		 3023static unsigned char *
3024read_debug_line_header (struct dwarf_section * section,
3025 unsigned char * data,
3026 unsigned char * end,
3027 DWARF2_Internal_LineInfo * linfo,
3028 unsigned char ** end_of_sequence)
3029{
3030 unsigned char *hdrptr;
b40bf0a2 3031 unsigned int initial_length_size;
77145576 3032 unsigned char address_size, segment_selector_size;
19e6b90e 3033
b40bf0a2
NC		 3034 /* Extract information from the Line Number Program Header.
3035 (section 6.2.4 in the Dwarf3 doc). */
6937bb54 3036 hdrptr = data;
19e6b90e 3037
b40bf0a2
NC		 3038 /* Get and check the length of the block. */
3039 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
19e6b90e 3040
b40bf0a2 3041 if (linfo->li_length == 0xffffffff)
f41e4712
NC		 3042 {
3043 /* This section is 64-bit DWARF 3. */
b40bf0a2 3044 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
77145576 3045 linfo->li_offset_size = 8;
f41e4712
NC		 3046 initial_length_size = 12;
3047 }
3048 else
3049 {
77145576 3050 linfo->li_offset_size = 4;
f41e4712
NC		 3051 initial_length_size = 4;
3052 }
19e6b90e 3053
b40bf0a2 3054 if (linfo->li_length + initial_length_size > section->size)
f41e4712 3055 {
8fcc61b4
NC		 3056 /* If the length field has a relocation against it, then we should
3057 not complain if it is inaccurate (and probably negative). This
3058 happens in object files when the .debug_line section is actually
3059 comprised of several different .debug_line.* sections, (some of
3060 which may be removed by linker garbage collection), and a relocation
3061 is used to compute the correct length once that is done. */
77145576 3062 if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size))
b40bf0a2 3063 {
8fcc61b4 3064 linfo->li_length = (end - data) - initial_length_size;
b40bf0a2
NC		 3065 }
3066 else
3067 {
8fcc61b4
NC		 3068 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3069 (long) linfo->li_length);
b40bf0a2
NC		 3070 return NULL;
3071 }
f41e4712 3072 }
19e6b90e 3073
b40bf0a2
NC		 3074 /* Get and check the version number. */
3075 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
3076
3077 if (linfo->li_version != 2
3078 && linfo->li_version != 3
77145576
JK		 3079 && linfo->li_version != 4
3080 && linfo->li_version != 5)
f41e4712 3081 {
77145576
JK		 3082 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3083 "is currently supported.\n"));
b40bf0a2 3084 return NULL;
f41e4712 3085 }
19e6b90e 3086
77145576
JK		 3087 if (linfo->li_version >= 5)
3088 {
3089 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
3090
3091 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
3092 if (segment_selector_size != 0)
3093 {
3094 warn (_("The %s section contains "
3095 "unsupported segment selector size: %d.\n"),
3096 section->name, segment_selector_size);
3097 return 0;
3098 }
3099 }
3100
3101 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr,
3102 linfo->li_offset_size, end);
b40bf0a2 3103 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
0c588247 3104
b40bf0a2 3105 if (linfo->li_version >= 4)
f41e4712 3106 {
b40bf0a2 3107 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
0c588247 3108
b40bf0a2 3109 if (linfo->li_max_ops_per_insn == 0)
f41e4712
NC		 3110 {
3111 warn (_("Invalid maximum operations per insn.\n"));
b40bf0a2 3112 return NULL;
a233b20c 3113 }
f41e4712
NC		 3114 }
3115 else
b40bf0a2 3116 linfo->li_max_ops_per_insn = 1;
0c588247 3117
b40bf0a2 3118 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
65879393 3119 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
b40bf0a2
NC		 3120 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
3121 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
19e6b90e 3122
b40bf0a2 3123 * end_of_sequence = data + linfo->li_length + initial_length_size;
b4eb7656 3124 /* PR 17512: file:002-117414-0.004. */
6937bb54
NC		 3125 if (* end_of_sequence > end)
3126 {
4c219c2e
AM		 3127 warn (_("Line length %s extends beyond end of section\n"),
3128 dwarf_vmatoa ("u", linfo->li_length));
6937bb54
NC		 3129 * end_of_sequence = end;
3130 return NULL;
3131 }
3132
b40bf0a2
NC		 3133 return hdrptr;
3134}
19e6b90e 3135
77145576
JK		 3136static unsigned char *
3137display_formatted_table (unsigned char *data,
3138 unsigned char *start, unsigned char *end,
3139 const DWARF2_Internal_LineInfo *linfo,
3140 struct dwarf_section *section, const char *what)
3141{
3142 unsigned char *format_start, format_count, *format, formati;
3143 dwarf_vma data_count, datai;
3144 unsigned int bytes_read, namepass, last_entry = 0;
3145
3146 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3147 format_start = data;
3148 for (formati = 0; formati < format_count; formati++)
3149 {
3150 read_uleb128 (data, & bytes_read, end);
3151 data += bytes_read;
3152 read_uleb128 (data, & bytes_read, end);
3153 data += bytes_read;
3154 if (data == end)
3155 {
14357de1 3156 warn (_("Corrupt %s format table entry\n"), what);
77145576
JK		 3157 return data;
3158 }
3159 }
3160
3161 data_count = read_uleb128 (data, & bytes_read, end);
3162 data += bytes_read;
3163 if (data == end)
3164 {
3165 warn (_("Corrupt %s list\n"), what);
3166 return data;
3167 }
3168
3169 if (data_count == 0)
3170 {
3171 printf (_("\n The %s Table is empty.\n"), what);
3172 return data;
3173 }
3174
3175 printf (_("\n The %s Table (offset 0x%lx):\n"), what,
3176 (long)(data - start));
3177
3178 printf (_(" Entry"));
3179 /* Delay displaying name as the last entry for better screen layout. */
3180 for (namepass = 0; namepass < 2; namepass++)
3181 {
3182 format = format_start;
3183 for (formati = 0; formati < format_count; formati++)
3184 {
3185 dwarf_vma content_type;
3186
3187 content_type = read_uleb128 (format, & bytes_read, end);
3188 format += bytes_read;
3189 if ((content_type == DW_LNCT_path) == (namepass == 1))
3190 switch (content_type)
3191 {
3192 case DW_LNCT_path:
3193 printf (_("\tName"));
3194 break;
3195 case DW_LNCT_directory_index:
3196 printf (_("\tDir"));
3197 break;
3198 case DW_LNCT_timestamp:
3199 printf (_("\tTime"));
3200 break;
3201 case DW_LNCT_size:
3202 printf (_("\tSize"));
3203 break;
3204 case DW_LNCT_MD5:
3205 printf (_("\tMD5"));
3206 break;
3207 default:
3208 printf (_("\t(Unknown format content type %s)"),
3209 dwarf_vmatoa ("u", content_type));
3210 }
3211 read_uleb128 (format, & bytes_read, end);
3212 format += bytes_read;
3213 }
3214 }
3215 putchar ('\n');
3216
3217 for (datai = 0; datai < data_count; datai++)
3218 {
3219 unsigned char *datapass = data;
3220
3221 printf (" %d", last_entry++);
3222 /* Delay displaying name as the last entry for better screen layout. */
3223 for (namepass = 0; namepass < 2; namepass++)
3224 {
3225 format = format_start;
3226 data = datapass;
3227 for (formati = 0; formati < format_count; formati++)
3228 {
3229 dwarf_vma content_type, form;
3230
3231 content_type = read_uleb128 (format, & bytes_read, end);
3232 format += bytes_read;
3233 form = read_uleb128 (format, & bytes_read, end);
3234 format += bytes_read;
3235 data = read_and_display_attr_value (0, form, 0, data, end, 0, 0,
3236 linfo->li_offset_size,
3237 linfo->li_version, NULL,
3238 ((content_type == DW_LNCT_path) != (namepass == 1)),
3239 section, NULL, '\t');
3240 }
3241 }
3242 if (data == end)
3243 {
3244 warn (_("Corrupt %s entries list\n"), what);
3245 return data;
3246 }
3247 putchar ('\n');
3248 }
3249 return data;
3250}
3251
b40bf0a2
NC		 3252static int
3253display_debug_lines_raw (struct dwarf_section *section,
3254 unsigned char *data,
77145576 3255 unsigned char *end, void *file)
b40bf0a2
NC		 3256{
3257 unsigned char *start = section->start;
ba8826a8 3258 int verbose_view = 0;
19e6b90e 3259
b40bf0a2 3260 printf (_("Raw dump of debug contents of section %s:\n\n"),
b4eb7656 3261 section->name);
19e6b90e 3262
b40bf0a2
NC		 3263 while (data < end)
3264 {
3265 static DWARF2_Internal_LineInfo saved_linfo;
3266 DWARF2_Internal_LineInfo linfo;
3267 unsigned char *standard_opcodes;
3268 unsigned char *end_of_sequence;
fe59e83d 3269 int i;
19e6b90e 3270
4925cdd7
NC		 3271 if (const_strneq (section->name, ".debug_line.")
3272 /* Note: the following does not apply to .debug_line.dwo sections.
3273 These are full debug_line sections. */
3274 && strcmp (section->name, ".debug_line.dwo") != 0)
19e6b90e 3275 {
b40bf0a2
NC		 3276 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3277 section containing just the Line Number Statements. They are
3278 created by the assembler and intended to be used alongside gcc's
3279 -ffunction-sections command line option. When the linker's
3280 garbage collection decides to discard a .text.<foo> section it
3281 can then also discard the line number information in .debug_line.<foo>.
3282
4925cdd7 3283 Since the section is a fragment it does not have the details
b40bf0a2 3284 needed to fill out a LineInfo structure, so instead we use the
4925cdd7 3285 details from the last full debug_line section that we processed. */
b40bf0a2
NC		 3286 end_of_sequence = end;
3287 standard_opcodes = NULL;
3288 linfo = saved_linfo;
058037d3
NC		 3289 /* PR 17531: file: 0522b371. */
3290 if (linfo.li_line_range == 0)
3291 {
1306a742 3292 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
058037d3
NC		 3293 return 0;
3294 }
b40bf0a2 3295 reset_state_machine (linfo.li_default_is_stmt);
19e6b90e 3296 }
19e6b90e
L		 3297 else
3298 {
b40bf0a2 3299 unsigned char * hdrptr;
19e6b90e 3300
b40bf0a2
NC		 3301 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3302 & end_of_sequence)) == NULL)
3303 return 0;
19e6b90e 3304
b40bf0a2
NC		 3305 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
3306 printf (_(" Length: %ld\n"), (long) linfo.li_length);
3307 printf (_(" DWARF Version: %d\n"), linfo.li_version);
77ef8654 3308 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length);
b40bf0a2
NC		 3309 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
3310 if (linfo.li_version >= 4)
3311 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
3312 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
3313 printf (_(" Line Base: %d\n"), linfo.li_line_base);
3314 printf (_(" Line Range: %d\n"), linfo.li_line_range);
3315 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
19e6b90e 3316
0a9d414a
NC		 3317 /* PR 17512: file: 1665-6428-0.004. */
3318 if (linfo.li_line_range == 0)
3319 {
3320 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3321 linfo.li_line_range = 1;
3322 }
77ef8654 3323
b40bf0a2 3324 reset_state_machine (linfo.li_default_is_stmt);
19e6b90e 3325
b40bf0a2
NC		 3326 /* Display the contents of the Opcodes table. */
3327 standard_opcodes = hdrptr;
19e6b90e 3328
6937bb54
NC		 3329 /* PR 17512: file: 002-417945-0.004. */
3330 if (standard_opcodes + linfo.li_opcode_base >= end)
3331 {
3332 warn (_("Line Base extends beyond end of section\n"));
3333 return 0;
3334 }
3335
b40bf0a2 3336 printf (_("\n Opcodes:\n"));
19e6b90e 3337
b40bf0a2
NC		 3338 for (i = 1; i < linfo.li_opcode_base; i++)
3339 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
19e6b90e 3340
b40bf0a2
NC		 3341 /* Display the contents of the Directory table. */
3342 data = standard_opcodes + linfo.li_opcode_base - 1;
19e6b90e 3343
77145576 3344 if (linfo.li_version >= 5)
b40bf0a2 3345 {
77145576 3346 load_debug_section (line_str, file);
19e6b90e 3347
77145576
JK		 3348 data = display_formatted_table (data, start, end, &linfo, section,
3349 _("Directory"));
3350 data = display_formatted_table (data, start, end, &linfo, section,
3351 _("File name"));
3352 }
3353 else
3354 {
3355 if (*data == 0)
3356 printf (_("\n The Directory Table is empty.\n"));
3357 else
a233b20c 3358 {
77145576 3359 unsigned int last_dir_entry = 0;
6937bb54 3360
77145576
JK		 3361 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3362 (long)(data - start));
19e6b90e 3363
77145576
JK		 3364 while (data < end && *data != 0)
3365 {
3366 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
19e6b90e 3367
77145576
JK		 3368 data += strnlen ((char *) data, end - data) + 1;
3369 }
19e6b90e 3370
77145576
JK		 3371 /* PR 17512: file: 002-132094-0.004. */
3372 if (data >= end - 1)
3373 break;
3374 }
19e6b90e 3375
77145576
JK		 3376 /* Skip the NUL at the end of the table. */
3377 data++;
19e6b90e 3378
77145576
JK		 3379 /* Display the contents of the File Name table. */
3380 if (*data == 0)
3381 printf (_("\n The File Name Table is empty.\n"));
3382 else
3383 {
3384 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3385 (long)(data - start));
3386 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
19e6b90e 3387
77145576 3388 while (data < end && *data != 0)
b40bf0a2 3389 {
77145576
JK		 3390 unsigned char *name;
3391 unsigned int bytes_read;
3392
3393 printf (" %d\t", ++state_machine_regs.last_file_entry);
3394 name = data;
3395 data += strnlen ((char *) data, end - data) + 1;
3396
3397 printf ("%s\t",
3398 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3399 data += bytes_read;
3400 printf ("%s\t",
3401 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3402 data += bytes_read;
3403 printf ("%s\t",
3404 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
3405 data += bytes_read;
3406 printf ("%.*s\n", (int)(end - name), name);
3407
3408 if (data == end)
3409 {
3410 warn (_("Corrupt file name table entry\n"));
3411 break;
3412 }
b40bf0a2 3413 }
a233b20c 3414 }
77145576
JK		 3415
3416 /* Skip the NUL at the end of the table. */
3417 data++;
b40bf0a2 3418 }
19e6b90e 3419
b40bf0a2
NC		 3420 putchar ('\n');
3421 saved_linfo = linfo;
3422 }
19e6b90e 3423
b40bf0a2
NC		 3424 /* Now display the statements. */
3425 if (data >= end_of_sequence)
3426 printf (_(" No Line Number Statements.\n"));
3427 else
3428 {
3429 printf (_(" Line Number Statements:\n"));
19e6b90e 3430
b40bf0a2
NC		 3431 while (data < end_of_sequence)
3432 {
3433 unsigned char op_code;
3434 dwarf_signed_vma adv;
3435 dwarf_vma uladv;
3436 unsigned int bytes_read;
19e6b90e 3437
fe59e83d
CC		 3438 printf (" [0x%08lx]", (long)(data - start));
3439
b40bf0a2 3440 op_code = *data++;
19e6b90e 3441
b40bf0a2 3442 if (op_code >= linfo.li_opcode_base)
19e6b90e 3443 {
b40bf0a2
NC		 3444 op_code -= linfo.li_opcode_base;
3445 uladv = (op_code / linfo.li_line_range);
3446 if (linfo.li_max_ops_per_insn == 1)
3447 {
3448 uladv *= linfo.li_min_insn_length;
3449 state_machine_regs.address += uladv;
ba8826a8
AO		 3450 if (uladv)
3451 state_machine_regs.view = 0;
b40bf0a2 3452 printf (_(" Special opcode %d: "
ba8826a8 3453 "advance Address by %s to 0x%s%s"),
b40bf0a2 3454 op_code, dwarf_vmatoa ("u", uladv),
ba8826a8
AO		 3455 dwarf_vmatoa ("x", state_machine_regs.address),
3456 verbose_view && uladv
3457 ? _(" (reset view)") : "");
b40bf0a2
NC		 3458 }
3459 else
3460 {
ba8826a8
AO		 3461 unsigned addrdelta
3462 = ((state_machine_regs.op_index + uladv)
b40bf0a2
NC		 3463 / linfo.li_max_ops_per_insn)
3464 * linfo.li_min_insn_length;
ba8826a8
AO		 3465
3466 state_machine_regs.address += addrdelta;
b40bf0a2
NC		 3467 state_machine_regs.op_index
3468 = (state_machine_regs.op_index + uladv)
3469 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 3470 if (addrdelta)
3471 state_machine_regs.view = 0;
b40bf0a2 3472 printf (_(" Special opcode %d: "
ba8826a8 3473 "advance Address by %s to 0x%s[%d]%s"),
b40bf0a2
NC		 3474 op_code, dwarf_vmatoa ("u", uladv),
3475 dwarf_vmatoa ("x", state_machine_regs.address),
ba8826a8
AO		 3476 state_machine_regs.op_index,
3477 verbose_view && addrdelta
3478 ? _(" (reset view)") : "");
b40bf0a2
NC		 3479 }
3480 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3481 state_machine_regs.line += adv;
ba8826a8 3482 printf (_(" and Line by %s to %d"),
b40bf0a2 3483 dwarf_vmatoa ("d", adv), state_machine_regs.line);
ba8826a8
AO		 3484 if (verbose_view || state_machine_regs.view)
3485 printf (_(" (view %u)\n"), state_machine_regs.view);
3486 else
3487 putchar ('\n');
3488 state_machine_regs.view++;
19e6b90e 3489 }
b40bf0a2
NC		 3490 else switch (op_code)
3491 {
3492 case DW_LNS_extended_op:
3493 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3494 break;
3495
3496 case DW_LNS_copy:
ba8826a8
AO		 3497 printf (_(" Copy"));
3498 if (verbose_view || state_machine_regs.view)
3499 printf (_(" (view %u)\n"), state_machine_regs.view);
3500 else
3501 putchar ('\n');
3502 state_machine_regs.view++;
b40bf0a2
NC		 3503 break;
3504
3505 case DW_LNS_advance_pc:
3506 uladv = read_uleb128 (data, & bytes_read, end);
3507 data += bytes_read;
3508 if (linfo.li_max_ops_per_insn == 1)
3509 {
3510 uladv *= linfo.li_min_insn_length;
3511 state_machine_regs.address += uladv;
ba8826a8
AO		 3512 if (uladv)
3513 state_machine_regs.view = 0;
3514 printf (_(" Advance PC by %s to 0x%s%s\n"),
b40bf0a2 3515 dwarf_vmatoa ("u", uladv),
ba8826a8
AO		 3516 dwarf_vmatoa ("x", state_machine_regs.address),
3517 verbose_view && uladv
3518 ? _(" (reset view)") : "");
b40bf0a2
NC		 3519 }
3520 else
3521 {
ba8826a8
AO		 3522 unsigned addrdelta
3523 = ((state_machine_regs.op_index + uladv)
3524 / linfo.li_max_ops_per_insn)
b40bf0a2 3525 * linfo.li_min_insn_length;
ba8826a8
AO		 3526 state_machine_regs.address
3527 += addrdelta;
b40bf0a2
NC		 3528 state_machine_regs.op_index
3529 = (state_machine_regs.op_index + uladv)
3530 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 3531 if (addrdelta)
3532 state_machine_regs.view = 0;
3533 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
b40bf0a2
NC		 3534 dwarf_vmatoa ("u", uladv),
3535 dwarf_vmatoa ("x", state_machine_regs.address),
ba8826a8
AO		 3536 state_machine_regs.op_index,
3537 verbose_view && addrdelta
3538 ? _(" (reset view)") : "");
b40bf0a2
NC		 3539 }
3540 break;
3541
3542 case DW_LNS_advance_line:
3543 adv = read_sleb128 (data, & bytes_read, end);
3544 data += bytes_read;
3545 state_machine_regs.line += adv;
3546 printf (_(" Advance Line by %s to %d\n"),
3547 dwarf_vmatoa ("d", adv),
3548 state_machine_regs.line);
3549 break;
3550
3551 case DW_LNS_set_file:
3552 adv = read_uleb128 (data, & bytes_read, end);
3553 data += bytes_read;
3554 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3555 dwarf_vmatoa ("d", adv));
3556 state_machine_regs.file = adv;
3557 break;
3558
3559 case DW_LNS_set_column:
3560 uladv = read_uleb128 (data, & bytes_read, end);
3561 data += bytes_read;
3562 printf (_(" Set column to %s\n"),
3563 dwarf_vmatoa ("u", uladv));
3564 state_machine_regs.column = uladv;
3565 break;
3566
3567 case DW_LNS_negate_stmt:
3568 adv = state_machine_regs.is_stmt;
3569 adv = ! adv;
3570 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3571 state_machine_regs.is_stmt = adv;
3572 break;
3573
3574 case DW_LNS_set_basic_block:
3575 printf (_(" Set basic block\n"));
3576 state_machine_regs.basic_block = 1;
3577 break;
3578
3579 case DW_LNS_const_add_pc:
3580 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3581 if (linfo.li_max_ops_per_insn)
3582 {
3583 uladv *= linfo.li_min_insn_length;
3584 state_machine_regs.address += uladv;
ba8826a8
AO		 3585 if (uladv)
3586 state_machine_regs.view = 0;
3587 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
b40bf0a2 3588 dwarf_vmatoa ("u", uladv),
ba8826a8
AO		 3589 dwarf_vmatoa ("x", state_machine_regs.address),
3590 verbose_view && uladv
3591 ? _(" (reset view)") : "");
b40bf0a2
NC		 3592 }
3593 else
3594 {
ba8826a8
AO		 3595 unsigned addrdelta
3596 = ((state_machine_regs.op_index + uladv)
3597 / linfo.li_max_ops_per_insn)
b40bf0a2 3598 * linfo.li_min_insn_length;
ba8826a8
AO		 3599 state_machine_regs.address
3600 += addrdelta;
b40bf0a2
NC		 3601 state_machine_regs.op_index
3602 = (state_machine_regs.op_index + uladv)
3603 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 3604 if (addrdelta)
3605 state_machine_regs.view = 0;
3606 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
b40bf0a2
NC		 3607 dwarf_vmatoa ("u", uladv),
3608 dwarf_vmatoa ("x", state_machine_regs.address),
ba8826a8
AO		 3609 state_machine_regs.op_index,
3610 verbose_view && addrdelta
3611 ? _(" (reset view)") : "");
b40bf0a2
NC		 3612 }
3613 break;
3614
3615 case DW_LNS_fixed_advance_pc:
3616 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3617 state_machine_regs.address += uladv;
3618 state_machine_regs.op_index = 0;
3619 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3620 dwarf_vmatoa ("u", uladv),
3621 dwarf_vmatoa ("x", state_machine_regs.address));
ba8826a8 3622 /* Do NOT reset view. */
b40bf0a2
NC		 3623 break;
3624
3625 case DW_LNS_set_prologue_end:
3626 printf (_(" Set prologue_end to true\n"));
3627 break;
3628
3629 case DW_LNS_set_epilogue_begin:
3630 printf (_(" Set epilogue_begin to true\n"));
3631 break;
3632
3633 case DW_LNS_set_isa:
3634 uladv = read_uleb128 (data, & bytes_read, end);
3635 data += bytes_read;
3636 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3637 break;
3638
3639 default:
3640 printf (_(" Unknown opcode %d with operands: "), op_code);
3641
3642 if (standard_opcodes != NULL)
3643 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3644 {
3645 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3646 &bytes_read, end)),
3647 i == 1 ? "" : ", ");
3648 data += bytes_read;
3649 }
3650 putchar ('\n');
3651 break;
3652 }
19e6b90e 3653 }
b40bf0a2 3654 putchar ('\n');
19e6b90e 3655 }
19e6b90e
L		 3656 }
3657
3658 return 1;
3659}
3660
a262ae96
NC		 3661typedef struct
3662{
467c65bc
NC		 3663 unsigned char *name;
3664 unsigned int directory_index;
3665 unsigned int modification_date;
3666 unsigned int length;
a262ae96
NC		 3667} File_Entry;
3668
3669/* Output a decoded representation of the .debug_line section. */
3670
3671static int
3672display_debug_lines_decoded (struct dwarf_section *section,
3673 unsigned char *data,
77145576 3674 unsigned char *end, void *fileptr)
a262ae96 3675{
b40bf0a2
NC		 3676 static DWARF2_Internal_LineInfo saved_linfo;
3677
a262ae96 3678 printf (_("Decoded dump of debug contents of section %s:\n\n"),
b4eb7656 3679 section->name);
a262ae96
NC		 3680
3681 while (data < end)
3682 {
3683 /* This loop amounts to one iteration per compilation unit. */
91d6fa6a 3684 DWARF2_Internal_LineInfo linfo;
a262ae96
NC		 3685 unsigned char *standard_opcodes;
3686 unsigned char *end_of_sequence;
a262ae96
NC		 3687 int i;
3688 File_Entry *file_table = NULL;
143a3db0 3689 unsigned int n_files = 0;
a262ae96 3690 unsigned char **directory_table = NULL;
77145576 3691 dwarf_vma n_directories = 0;
a262ae96 3692
4925cdd7
NC		 3693 if (const_strneq (section->name, ".debug_line.")
3694 /* Note: the following does not apply to .debug_line.dwo sections.
3695 These are full debug_line sections. */
3696 && strcmp (section->name, ".debug_line.dwo") != 0)
b4eb7656 3697 {
4925cdd7 3698 /* See comment in display_debug_lines_raw(). */
b40bf0a2
NC		 3699 end_of_sequence = end;
3700 standard_opcodes = NULL;
3701 linfo = saved_linfo;
058037d3
NC		 3702 /* PR 17531: file: 0522b371. */
3703 if (linfo.li_line_range == 0)
3704 {
1306a742 3705 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
058037d3
NC		 3706 return 0;
3707 }
b40bf0a2 3708 reset_state_machine (linfo.li_default_is_stmt);
b4eb7656 3709 }
a262ae96 3710 else
b4eb7656 3711 {
b40bf0a2 3712 unsigned char *hdrptr;
a262ae96 3713
b40bf0a2
NC		 3714 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3715 & end_of_sequence)) == NULL)
a233b20c 3716 return 0;
0c588247 3717
058037d3
NC		 3718 /* PR 17531: file: 0522b371. */
3719 if (linfo.li_line_range == 0)
3720 {
3721 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3722 linfo.li_line_range = 1;
3723 }
b40bf0a2 3724 reset_state_machine (linfo.li_default_is_stmt);
a262ae96 3725
b40bf0a2
NC		 3726 /* Save a pointer to the contents of the Opcodes table. */
3727 standard_opcodes = hdrptr;
a262ae96 3728
b40bf0a2
NC		 3729 /* Traverse the Directory table just to count entries. */
3730 data = standard_opcodes + linfo.li_opcode_base - 1;
d8024a91
NC		 3731 /* PR 20440 */
3732 if (data >= end)
3733 {
3734 warn (_("opcode base of %d extends beyond end of section\n"),
3735 linfo.li_opcode_base);
3736 return 0;
3737 }
3738
77145576 3739 if (linfo.li_version >= 5)
b40bf0a2 3740 {
77145576
JK		 3741 unsigned char *format_start, format_count, *format;
3742 dwarf_vma formati, entryi;
3743 unsigned int bytes_read;
a262ae96 3744
77145576
JK		 3745 load_debug_section (line_str, fileptr);
3746
3747 /* Skip directories format. */
3748 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3749 format_start = data;
3750 for (formati = 0; formati < format_count; formati++)
b40bf0a2 3751 {
77145576
JK		 3752 read_uleb128 (data, & bytes_read, end);
3753 data += bytes_read;
3754 read_uleb128 (data, & bytes_read, end);
3755 data += bytes_read;
b40bf0a2 3756 }
a262ae96 3757
77145576
JK		 3758 n_directories = read_uleb128 (data, & bytes_read, end);
3759 data += bytes_read;
3760 if (data == end)
d8024a91 3761 {
77145576 3762 warn (_("Corrupt directories list\n"));
d8024a91
NC		 3763 break;
3764 }
3765
b40bf0a2
NC		 3766 directory_table = (unsigned char **)
3767 xmalloc (n_directories * sizeof (unsigned char *));
a262ae96 3768
77145576 3769 for (entryi = 0; entryi < n_directories; entryi++)
b40bf0a2 3770 {
77145576 3771 unsigned char **pathp = &directory_table[entryi];
a262ae96 3772
77145576
JK		 3773 format = format_start;
3774 for (formati = 0; formati < format_count; formati++)
3775 {
3776 dwarf_vma content_type, form;
3777 dwarf_vma uvalue;
3778
3779 content_type = read_uleb128 (format, & bytes_read, end);
3780 format += bytes_read;
3781 form = read_uleb128 (format, & bytes_read, end);
3782 format += bytes_read;
3783 if (data == end)
3784 {
3785 warn (_("Corrupt directories list\n"));
3786 break;
3787 }
3788 switch (content_type)
3789 {
3790 case DW_LNCT_path:
3791 switch (form)
3792 {
3793 case DW_FORM_string:
3794 *pathp = data;
3795 break;
3796 case DW_FORM_line_strp:
3797 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3798 end);
3799 /* Remove const by the cast. */
3800 *pathp = (unsigned char *)
3801 fetch_indirect_line_string (uvalue);
3802 break;
3803 }
3804 break;
3805 }
3806 data = read_and_display_attr_value (0, form, 0, data, end,
3807 0, 0,
3808 linfo.li_offset_size,
3809 linfo.li_version,
3810 NULL, 1, section,
3811 NULL, '\t');
3812 }
3813 if (data == end)
3814 {
3815 warn (_("Corrupt directories list\n"));
3816 break;
3817 }
3818 }
a262ae96 3819
77145576
JK		 3820 /* Skip files format. */
3821 SAFE_BYTE_GET_AND_INC (format_count, data, 1, end);
3822 format_start = data;
3823 for (formati = 0; formati < format_count; formati++)
b40bf0a2 3824 {
b40bf0a2
NC		 3825 read_uleb128 (data, & bytes_read, end);
3826 data += bytes_read;
3827 read_uleb128 (data, & bytes_read, end);
3828 data += bytes_read;
b40bf0a2 3829 }
a262ae96 3830
77145576
JK		 3831 n_files = read_uleb128 (data, & bytes_read, end);
3832 data += bytes_read;
3833 if (data == end)
d8024a91 3834 {
77145576 3835 warn (_("Corrupt file name list\n"));
d8024a91
NC		 3836 break;
3837 }
3838
77145576
JK		 3839 file_table = (File_Entry *) xcalloc (1, n_files
3840 * sizeof (File_Entry));
a262ae96 3841
77145576 3842 for (entryi = 0; entryi < n_files; entryi++)
b40bf0a2 3843 {
77145576 3844 File_Entry *file = &file_table[entryi];
a262ae96 3845
77145576
JK		 3846 format = format_start;
3847 for (formati = 0; formati < format_count; formati++)
3848 {
3849 dwarf_vma content_type, form;
3850 dwarf_vma uvalue;
3851
3852 content_type = read_uleb128 (format, & bytes_read, end);
3853 format += bytes_read;
3854 form = read_uleb128 (format, & bytes_read, end);
3855 format += bytes_read;
3856 if (data == end)
3857 {
3858 warn (_("Corrupt file name list\n"));
3859 break;
3860 }
3861 switch (content_type)
3862 {
3863 case DW_LNCT_path:
3864 switch (form)
3865 {
3866 case DW_FORM_string:
3867 file->name = data;
3868 break;
3869 case DW_FORM_line_strp:
3870 SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size,
3871 end);
3872 /* Remove const by the cast. */
3873 file->name = (unsigned char *)
3874 fetch_indirect_line_string (uvalue);
3875 break;
3876 }
3877 break;
3878 case DW_LNCT_directory_index:
3879 switch (form)
3880 {
3881 case DW_FORM_data1:
3882 SAFE_BYTE_GET (file->directory_index, data, 1,
3883 end);
3884 break;
3885 case DW_FORM_data2:
3886 SAFE_BYTE_GET (file->directory_index, data, 2,
3887 end);
3888 break;
3889 case DW_FORM_udata:
3890 file->directory_index = read_uleb128 (data, NULL,
3891 end);
3892 break;
3893 }
3894 break;
3895 }
3896 data = read_and_display_attr_value (0, form, 0, data, end,
3897 0, 0,
3898 linfo.li_offset_size,
3899 linfo.li_version,
3900 NULL, 1, section,
3901 NULL, '\t');
3902 }
3903 if (data == end)
3904 {
3905 warn (_("Corrupt file name list\n"));
3906 break;
3907 }
3908 }
3909 }
3910 else
3911 {
3912 if (*data != 0)
b40bf0a2 3913 {
77145576
JK		 3914 unsigned char *ptr_directory_table = data;
3915
3916 while (data < end && *data != 0)
3917 {
3918 data += strnlen ((char *) data, end - data) + 1;
3919 n_directories++;
3920 }
3921
3922 /* PR 20440 */
3923 if (data >= end)
3924 {
3925 warn (_("directory table ends unexpectedly\n"));
3926 n_directories = 0;
3927 break;
3928 }
3929
3930 /* Go through the directory table again to save the directories. */
3931 directory_table = (unsigned char **)
3932 xmalloc (n_directories * sizeof (unsigned char *));
3933
3934 i = 0;
3935 while (*ptr_directory_table != 0)
3936 {
3937 directory_table[i] = ptr_directory_table;
3938 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3939 ptr_directory_table - end) + 1;
3940 i++;
3941 }
b40bf0a2 3942 }
77145576
JK		 3943 /* Skip the NUL at the end of the table. */
3944 data++;
3945
3946 /* Traverse the File Name table just to count the entries. */
3947 if (data < end && *data != 0)
b40bf0a2 3948 {
77145576
JK		 3949 unsigned char *ptr_file_name_table = data;
3950
3951 while (data < end && *data != 0)
db9537d2 3952 {
77145576
JK		 3953 unsigned int bytes_read;
3954
3955 /* Skip Name, directory index, last modification time and length
3956 of file. */
3957 data += strnlen ((char *) data, end - data) + 1;
3958 read_uleb128 (data, & bytes_read, end);
3959 data += bytes_read;
3960 read_uleb128 (data, & bytes_read, end);
3961 data += bytes_read;
3962 read_uleb128 (data, & bytes_read, end);
3963 data += bytes_read;
3964
3965 n_files++;
db9537d2 3966 }
a262ae96 3967
77145576
JK		 3968 if (data >= end)
3969 {
3970 warn (_("file table ends unexpectedly\n"));
3971 n_files = 0;
3972 break;
3973 }
3974
3975 /* Go through the file table again to save the strings. */
3976 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
0c588247 3977
77145576
JK		 3978 i = 0;
3979 while (*ptr_file_name_table != 0)
3980 {
3981 unsigned int bytes_read;
3982
3983 file_table[i].name = ptr_file_name_table;
3984 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3985 end - ptr_file_name_table) + 1;
3986
3987 /* We are not interested in directory, time or size. */
3988 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3989 & bytes_read, end);
3990 ptr_file_name_table += bytes_read;
3991 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3992 & bytes_read, end);
3993 ptr_file_name_table += bytes_read;
3994 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3995 ptr_file_name_table += bytes_read;
3996 i++;
3997 }
3998 i = 0;
b40bf0a2 3999 }
77145576
JK		 4000
4001 /* Skip the NUL at the end of the table. */
4002 data++;
b40bf0a2 4003 }
cc5914eb 4004
77145576 4005 /* Print the Compilation Unit's name and a header. */
f082820d
AM		 4006 if (file_table == NULL)
4007 ;
4008 else if (directory_table == NULL)
4009 printf (_("CU: %s:\n"), file_table[0].name);
77145576
JK		 4010 else
4011 {
4012 unsigned int ix = file_table[0].directory_index;
4013 const char *directory;
4014
4015 if (ix == 0)
4016 directory = ".";
4017 /* PR 20439 */
4018 else if (n_directories == 0)
4019 directory = _("<unknown>");
4020 else if (ix > n_directories)
4021 {
4022 warn (_("directory index %u > number of directories %s\n"),
4023 ix, dwarf_vmatoa ("u", n_directories));
4024 directory = _("<corrupt>");
4025 }
4026 else
4027 directory = (char *) directory_table[ix - 1];
4028
4029 if (do_wide || strlen (directory) < 76)
4030 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
4031 else
4032 printf ("%s:\n", file_table[0].name);
77145576 4033 }
a262ae96 4034
ba8826a8 4035 printf (_("File name Line number Starting address View\n"));
b40bf0a2
NC		 4036 saved_linfo = linfo;
4037 }
a262ae96
NC		 4038
4039 /* This loop iterates through the Dwarf Line Number Program. */
4040 while (data < end_of_sequence)
b4eb7656 4041 {
a262ae96 4042 unsigned char op_code;
ba8826a8 4043 int xop;
b4eb7656
AM		 4044 int adv;
4045 unsigned long int uladv;
4046 unsigned int bytes_read;
4047 int is_special_opcode = 0;
a262ae96 4048
b4eb7656 4049 op_code = *data++;
ba8826a8 4050 xop = op_code;
a262ae96 4051
b4eb7656 4052 if (op_code >= linfo.li_opcode_base)
a262ae96 4053 {
91d6fa6a 4054 op_code -= linfo.li_opcode_base;
a233b20c
JJ		 4055 uladv = (op_code / linfo.li_line_range);
4056 if (linfo.li_max_ops_per_insn == 1)
4057 {
4058 uladv *= linfo.li_min_insn_length;
4059 state_machine_regs.address += uladv;
ba8826a8
AO		 4060 if (uladv)
4061 state_machine_regs.view = 0;
a233b20c
JJ		 4062 }
4063 else
4064 {
ba8826a8
AO		 4065 unsigned addrdelta
4066 = ((state_machine_regs.op_index + uladv)
4067 / linfo.li_max_ops_per_insn)
b40bf0a2 4068 * linfo.li_min_insn_length;
ba8826a8
AO		 4069 state_machine_regs.address
4070 += addrdelta;
a233b20c
JJ		 4071 state_machine_regs.op_index
4072 = (state_machine_regs.op_index + uladv)
b40bf0a2 4073 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 4074 if (addrdelta)
4075 state_machine_regs.view = 0;
a233b20c 4076 }
a262ae96 4077
b4eb7656
AM		 4078 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
4079 state_machine_regs.line += adv;
4080 is_special_opcode = 1;
ba8826a8 4081 /* Increment view after printing this row. */
b4eb7656
AM		 4082 }
4083 else switch (op_code)
b40bf0a2
NC		 4084 {
4085 case DW_LNS_extended_op:
4086 {
4087 unsigned int ext_op_code_len;
4088 unsigned char ext_op_code;
4089 unsigned char *op_code_data = data;
4090
4091 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
4092 end_of_sequence);
4093 op_code_data += bytes_read;
4094
4095 if (ext_op_code_len == 0)
4096 {
f41e4712 4097 warn (_("Badly formed extended line op encountered!\n"));
b40bf0a2
NC		 4098 break;
4099 }
4100 ext_op_code_len += bytes_read;
4101 ext_op_code = *op_code_data++;
ba8826a8
AO		 4102 xop = ext_op_code;
4103 xop = -xop;
b40bf0a2
NC		 4104
4105 switch (ext_op_code)
4106 {
4107 case DW_LNE_end_sequence:
ba8826a8 4108 /* Reset stuff after printing this row. */
b40bf0a2
NC		 4109 break;
4110 case DW_LNE_set_address:
4111 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
87bc83b3
CC		 4112 op_code_data,
4113 ext_op_code_len - bytes_read - 1,
b40bf0a2
NC		 4114 end);
4115 state_machine_regs.op_index = 0;
ba8826a8 4116 state_machine_regs.view = 0;
b40bf0a2
NC		 4117 break;
4118 case DW_LNE_define_file:
4119 {
4120 file_table = (File_Entry *) xrealloc
4121 (file_table, (n_files + 1) * sizeof (File_Entry));
4122
4123 ++state_machine_regs.last_file_entry;
4124 /* Source file name. */
4125 file_table[n_files].name = op_code_data;
4126 op_code_data += strlen ((char *) op_code_data) + 1;
4127 /* Directory index. */
4128 file_table[n_files].directory_index =
4129 read_uleb128 (op_code_data, & bytes_read,
4130 end_of_sequence);
4131 op_code_data += bytes_read;
4132 /* Last modification time. */
4133 file_table[n_files].modification_date =
4134 read_uleb128 (op_code_data, & bytes_read,
4135 end_of_sequence);
4136 op_code_data += bytes_read;
4137 /* File length. */
4138 file_table[n_files].length =
4139 read_uleb128 (op_code_data, & bytes_read,
4140 end_of_sequence);
4141
4142 n_files++;
4143 break;
4144 }
4145 case DW_LNE_set_discriminator:
4146 case DW_LNE_HP_set_sequence:
4147 /* Simply ignored. */
4148 break;
4149
4150 default:
4151 printf (_("UNKNOWN (%u): length %d\n"),
4152 ext_op_code, ext_op_code_len - bytes_read);
4153 break;
4154 }
4155 data += ext_op_code_len;
4156 break;
4157 }
4158 case DW_LNS_copy:
ba8826a8 4159 /* Increment view after printing this row. */
b40bf0a2
NC		 4160 break;
4161
4162 case DW_LNS_advance_pc:
4163 uladv = read_uleb128 (data, & bytes_read, end);
4164 data += bytes_read;
4165 if (linfo.li_max_ops_per_insn == 1)
4166 {
4167 uladv *= linfo.li_min_insn_length;
4168 state_machine_regs.address += uladv;
ba8826a8
AO		 4169 if (uladv)
4170 state_machine_regs.view = 0;
b40bf0a2
NC		 4171 }
4172 else
4173 {
ba8826a8
AO		 4174 unsigned addrdelta
4175 = ((state_machine_regs.op_index + uladv)
4176 / linfo.li_max_ops_per_insn)
b40bf0a2 4177 * linfo.li_min_insn_length;
ba8826a8
AO		 4178 state_machine_regs.address
4179 += addrdelta;
b40bf0a2
NC		 4180 state_machine_regs.op_index
4181 = (state_machine_regs.op_index + uladv)
4182 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 4183 if (addrdelta)
4184 state_machine_regs.view = 0;
b40bf0a2
NC		 4185 }
4186 break;
4187
4188 case DW_LNS_advance_line:
4189 adv = read_sleb128 (data, & bytes_read, end);
4190 data += bytes_read;
4191 state_machine_regs.line += adv;
4192 break;
4193
4194 case DW_LNS_set_file:
4195 adv = read_uleb128 (data, & bytes_read, end);
4196 data += bytes_read;
4197 state_machine_regs.file = adv;
4198
db9537d2
NC		 4199 {
4200 unsigned file = state_machine_regs.file - 1;
4201 unsigned dir;
4202
4203 if (file_table == NULL || n_files == 0)
4204 printf (_("\n [Use file table entry %d]\n"), file);
4205 /* PR 20439 */
4206 else if (file >= n_files)
4207 {
4208 warn (_("file index %u > number of files %u\n"), file + 1, n_files);
4209 printf (_("\n <over large file table index %u>"), file);
4210 }
4211 else if ((dir = file_table[file].directory_index) == 0)
4212 /* If directory index is 0, that means current directory. */
4213 printf ("\n./%s:[++]\n", file_table[file].name);
4214 else if (directory_table == NULL || n_directories == 0)
4215 printf (_("\n [Use file %s in directory table entry %d]\n"),
4216 file_table[file].name, dir);
4217 /* PR 20439 */
4218 else if (dir > n_directories)
4219 {
77145576
JK		 4220 warn (_("directory index %u > number of directories %s\n"),
4221 dir, dwarf_vmatoa ("u", n_directories));
db9537d2
NC		 4222 printf (_("\n <over large directory table entry %u>\n"), dir);
4223 }
4224 else
4225 printf ("\n%s/%s:\n",
4226 /* The directory index starts counting at 1. */
4227 directory_table[dir - 1], file_table[file].name);
4228 }
b40bf0a2
NC		 4229 break;
4230
4231 case DW_LNS_set_column:
4232 uladv = read_uleb128 (data, & bytes_read, end);
4233 data += bytes_read;
4234 state_machine_regs.column = uladv;
4235 break;
4236
4237 case DW_LNS_negate_stmt:
4238 adv = state_machine_regs.is_stmt;
4239 adv = ! adv;
4240 state_machine_regs.is_stmt = adv;
4241 break;
4242
4243 case DW_LNS_set_basic_block:
4244 state_machine_regs.basic_block = 1;
4245 break;
4246
4247 case DW_LNS_const_add_pc:
4248 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
4249 if (linfo.li_max_ops_per_insn == 1)
4250 {
4251 uladv *= linfo.li_min_insn_length;
4252 state_machine_regs.address += uladv;
ba8826a8
AO		 4253 if (uladv)
4254 state_machine_regs.view = 0;
b40bf0a2
NC		 4255 }
4256 else
4257 {
ba8826a8
AO		 4258 unsigned addrdelta
4259 = ((state_machine_regs.op_index + uladv)
4260 / linfo.li_max_ops_per_insn)
b40bf0a2 4261 * linfo.li_min_insn_length;
ba8826a8
AO		 4262 state_machine_regs.address
4263 += addrdelta;
b40bf0a2
NC		 4264 state_machine_regs.op_index
4265 = (state_machine_regs.op_index + uladv)
4266 % linfo.li_max_ops_per_insn;
ba8826a8
AO		 4267 if (addrdelta)
4268 state_machine_regs.view = 0;
b40bf0a2
NC		 4269 }
4270 break;
4271
4272 case DW_LNS_fixed_advance_pc:
4273 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
4274 state_machine_regs.address += uladv;
4275 state_machine_regs.op_index = 0;
ba8826a8 4276 /* Do NOT reset view. */
b40bf0a2
NC		 4277 break;
4278
4279 case DW_LNS_set_prologue_end:
4280 break;
4281
4282 case DW_LNS_set_epilogue_begin:
4283 break;
4284
4285 case DW_LNS_set_isa:
4286 uladv = read_uleb128 (data, & bytes_read, end);
4287 data += bytes_read;
4288 printf (_(" Set ISA to %lu\n"), uladv);
4289 break;
4290
4291 default:
4292 printf (_(" Unknown opcode %d with operands: "), op_code);
4293
4294 if (standard_opcodes != NULL)
4295 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
4296 {
4297 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
4298 &bytes_read, end)),
4299 i == 1 ? "" : ", ");
4300 data += bytes_read;
4301 }
4302 putchar ('\n');
4303 break;
4304 }
a262ae96 4305
b4eb7656
AM		 4306 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4307 to the DWARF address/line matrix. */
ba8826a8
AO		 4308 if ((is_special_opcode) || (xop == -DW_LNE_end_sequence)
4309 || (xop == DW_LNS_copy))
b4eb7656
AM		 4310 {
4311 const unsigned int MAX_FILENAME_LENGTH = 35;
4312 char *fileName;
4313 char *newFileName = NULL;
4314 size_t fileNameLength;
b40bf0a2
NC		 4315
4316 if (file_table)
db9537d2
NC		 4317 {
4318 unsigned indx = state_machine_regs.file - 1;
4319 /* PR 20439 */
4320 if (indx >= n_files)
4321 {
4322 warn (_("corrupt file index %u encountered\n"), indx);
4323 fileName = _("<corrupt>");
4324 }
4325 else
4326 fileName = (char *) file_table[indx].name;
4327 }
b40bf0a2 4328 else
db9537d2 4329 fileName = _("<unknown>");
b40bf0a2
NC		 4330
4331 fileNameLength = strlen (fileName);
a262ae96 4332
b4eb7656
AM		 4333 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
4334 {
4335 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
4336 /* Truncate file name */
4337 strncpy (newFileName,
4338 fileName + fileNameLength - MAX_FILENAME_LENGTH,
4339 MAX_FILENAME_LENGTH + 1);
4340 }
4341 else
4342 {
4343 newFileName = (char *) xmalloc (fileNameLength + 1);
4344 strncpy (newFileName, fileName, fileNameLength + 1);
4345 }
4346
4347 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
4348 {
a233b20c 4349 if (linfo.li_max_ops_per_insn == 1)
ba8826a8 4350 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x",
467c65bc 4351 newFileName, state_machine_regs.line,
a233b20c
JJ		 4352 state_machine_regs.address);
4353 else
ba8826a8 4354 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]",
467c65bc 4355 newFileName, state_machine_regs.line,
a233b20c
JJ		 4356 state_machine_regs.address,
4357 state_machine_regs.op_index);
b4eb7656
AM		 4358 }
4359 else
4360 {
a233b20c 4361 if (linfo.li_max_ops_per_insn == 1)
ba8826a8 4362 printf ("%s %11d %#18" DWARF_VMA_FMT "x",
467c65bc 4363 newFileName, state_machine_regs.line,
a233b20c
JJ		 4364 state_machine_regs.address);
4365 else
ba8826a8 4366 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]",
467c65bc 4367 newFileName, state_machine_regs.line,
a233b20c
JJ		 4368 state_machine_regs.address,
4369 state_machine_regs.op_index);
b4eb7656 4370 }
a262ae96 4371
ba8826a8
AO		 4372 if (state_machine_regs.view)
4373 printf (" %6u\n", state_machine_regs.view);
4374 else
4375 putchar ('\n');
4376 state_machine_regs.view++;
4377
4378 if (xop == -DW_LNE_end_sequence)
4379 {
4380 reset_state_machine (linfo.li_default_is_stmt);
4381 putchar ('\n');
4382 }
a262ae96 4383
b4eb7656
AM		 4384 free (newFileName);
4385 }
4386 }
b40bf0a2
NC		 4387
4388 if (file_table)
4389 {
4390 free (file_table);
4391 file_table = NULL;
4392 n_files = 0;
4393 }
4394
4395 if (directory_table)
4396 {
4397 free (directory_table);
4398 directory_table = NULL;
4399 n_directories = 0;
4400 }
4401
a262ae96
NC		 4402 putchar ('\n');
4403 }
4404
4405 return 1;
4406}
4407
4408static int
77145576 4409display_debug_lines (struct dwarf_section *section, void *file)
a262ae96
NC		 4410{
4411 unsigned char *data = section->start;
4412 unsigned char *end = data + section->size;
4cb93e3b
TG		 4413 int retValRaw = 1;
4414 int retValDecoded = 1;
a262ae96 4415
008f4c78
NC		 4416 if (do_debug_lines == 0)
4417 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
4418
4cb93e3b 4419 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
77145576 4420 retValRaw = display_debug_lines_raw (section, data, end, file);
a262ae96 4421
4cb93e3b 4422 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
77145576 4423 retValDecoded = display_debug_lines_decoded (section, data, end, file);
a262ae96 4424
4cb93e3b 4425 if (!retValRaw || !retValDecoded)
a262ae96
NC		 4426 return 0;
4427
4428 return 1;
4429}
4430
6e3d6dc1
NC		 4431static debug_info *
4432find_debug_info_for_offset (unsigned long offset)
4433{
4434 unsigned int i;
4435
4436 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
4437 return NULL;
4438
4439 for (i = 0; i < num_debug_info_entries; i++)
4440 if (debug_information[i].cu_offset == offset)
4441 return debug_information + i;
4442
4443 return NULL;
4444}
4445
459d52c8
DE		 4446static const char *
4447get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
4448{
4449 /* See gdb/gdb-index.h. */
4450 static const char * const kinds[] =
4451 {
4452 N_ ("no info"),
4453 N_ ("type"),
4454 N_ ("variable"),
4455 N_ ("function"),
4456 N_ ("other"),
4457 N_ ("unused5"),
4458 N_ ("unused6"),
4459 N_ ("unused7")
4460 };
4461
4462 return _ (kinds[kind]);
4463}
4464
19e6b90e 4465static int
459d52c8
DE		 4466display_debug_pubnames_worker (struct dwarf_section *section,
4467 void *file ATTRIBUTE_UNUSED,
4468 int is_gnu)
19e6b90e 4469{
91d6fa6a 4470 DWARF2_Internal_PubNames names;
19e6b90e
L		 4471 unsigned char *start = section->start;
4472 unsigned char *end = start + section->size;
4473
6e3d6dc1
NC		 4474 /* It does not matter if this load fails,
4475 we test for that later on. */
4476 load_debug_info (file);
4477
19e6b90e
L		 4478 printf (_("Contents of the %s section:\n\n"), section->name);
4479
4480 while (start < end)
4481 {
4482 unsigned char *data;
362beea4 4483 unsigned char *adr;
834f871c 4484 dwarf_vma offset;
bf5117e3 4485 unsigned int offset_size, initial_length_size;
19e6b90e
L		 4486
4487 data = start;
4488
0c588247 4489 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
91d6fa6a 4490 if (names.pn_length == 0xffffffff)
19e6b90e 4491 {
0c588247 4492 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
19e6b90e
L		 4493 offset_size = 8;
4494 initial_length_size = 12;
4495 }
4496 else
4497 {
4498 offset_size = 4;
4499 initial_length_size = 4;
4500 }
4501
0c588247
NC		 4502 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
4503 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
6e3d6dc1
NC		 4504
4505 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4506 && num_debug_info_entries > 0
91d6fa6a 4507 && find_debug_info_for_offset (names.pn_offset) == NULL)
6e3d6dc1 4508 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 4509 (unsigned long) names.pn_offset, section->name);
cecf136e 4510
0c588247 4511 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
19e6b90e 4512
362beea4 4513 adr = start + names.pn_length + initial_length_size;
058037d3 4514 /* PR 17531: file: 7615b6b2. */
57028622
NC		 4515 if ((dwarf_signed_vma) names.pn_length < 0
4516 /* PR 17531: file: a5dbeaa7. */
362beea4 4517 || adr < start)
058037d3
NC		 4518 {
4519 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
4520 start = end;
4521 }
4522 else
362beea4 4523 start = adr;
b4eb7656 4524
058037d3
NC		 4525 printf (_(" Length: %ld\n"),
4526 (long) names.pn_length);
4527 printf (_(" Version: %d\n"),
4528 names.pn_version);
4529 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4530 (unsigned long) names.pn_offset);
4531 printf (_(" Size of area in .debug_info section: %ld\n"),
4532 (long) names.pn_size);
19e6b90e 4533
91d6fa6a 4534 if (names.pn_version != 2 && names.pn_version != 3)
19e6b90e
L		 4535 {
4536 static int warned = 0;
4537
4538 if (! warned)
4539 {
4540 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4541 warned = 1;
4542 }
4543
4544 continue;
4545 }
4546
459d52c8
DE		 4547 if (is_gnu)
4548 printf (_("\n Offset Kind Name\n"));
4549 else
4550 printf (_("\n Offset\tName\n"));
19e6b90e
L		 4551
4552 do
4553 {
f41e4712
NC		 4554 bfd_size_type maxprint;
4555
0c588247 4556 SAFE_BYTE_GET (offset, data, offset_size, end);
19e6b90e
L		 4557
4558 if (offset != 0)
4559 {
4560 data += offset_size;
f41e4712
NC		 4561 if (data >= end)
4562 break;
4563 maxprint = (end - data) - 1;
b4eb7656 4564
459d52c8
DE		 4565 if (is_gnu)
4566 {
4567 unsigned int kind_data;
4568 gdb_index_symbol_kind kind;
4569 const char *kind_name;
4570 int is_static;
4571
4572 SAFE_BYTE_GET (kind_data, data, 1, end);
4573 data++;
f41e4712 4574 maxprint --;
459d52c8
DE		 4575 /* GCC computes the kind as the upper byte in the CU index
4576 word, and then right shifts it by the CU index size.
4577 Left shift KIND to where the gdb-index.h accessor macros
4578 can use it. */
4579 kind_data <<= GDB_INDEX_CU_BITSIZE;
4580 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
4581 kind_name = get_gdb_index_symbol_kind_name (kind);
4582 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
f41e4712 4583 printf (" %-6lx %s,%-10s %.*s\n",
834f871c 4584 (unsigned long) offset, is_static ? _("s") : _("g"),
f41e4712 4585 kind_name, (int) maxprint, data);
459d52c8
DE		 4586 }
4587 else
b4eb7656
AM		 4588 printf (" %-6lx\t%.*s\n",
4589 (unsigned long) offset, (int) maxprint, data);
f41e4712
NC		 4590
4591 data += strnlen ((char *) data, maxprint) + 1;
4592 if (data >= end)
4593 break;
19e6b90e
L		 4594 }
4595 }
4596 while (offset != 0);
4597 }
4598
4599 printf ("\n");
4600 return 1;
4601}
4602
459d52c8
DE		 4603static int
4604display_debug_pubnames (struct dwarf_section *section, void *file)
4605{
4606 return display_debug_pubnames_worker (section, file, 0);
4607}
4608
4609static int
4610display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
4611{
4612 return display_debug_pubnames_worker (section, file, 1);
4613}
4614
19e6b90e
L		 4615static int
4616display_debug_macinfo (struct dwarf_section *section,
4617 void *file ATTRIBUTE_UNUSED)
4618{
4619 unsigned char *start = section->start;
4620 unsigned char *end = start + section->size;
4621 unsigned char *curr = start;
4622 unsigned int bytes_read;
4623 enum dwarf_macinfo_record_type op;
4624
4625 printf (_("Contents of the %s section:\n\n"), section->name);
4626
4627 while (curr < end)
4628 {
4629 unsigned int lineno;
0c588247 4630 const unsigned char *string;
19e6b90e 4631
3f5e193b 4632 op = (enum dwarf_macinfo_record_type) *curr;
19e6b90e
L		 4633 curr++;
4634
4635 switch (op)
4636 {
4637 case DW_MACINFO_start_file:
4638 {
4639 unsigned int filenum;
4640
f6f0e17b 4641 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 4642 curr += bytes_read;
f6f0e17b 4643 filenum = read_uleb128 (curr, & bytes_read, end);
19e6b90e
L		 4644 curr += bytes_read;
4645
4646 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4647 lineno, filenum);
4648 }
4649 break;
4650
4651 case DW_MACINFO_end_file:
4652 printf (_(" DW_MACINFO_end_file\n"));
4653 break;
4654
4655 case DW_MACINFO_define:
f6f0e17b 4656 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 4657 curr += bytes_read;
0c588247
NC		 4658 string = curr;
4659 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 4660 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4661 lineno, string);
4662 break;
4663
4664 case DW_MACINFO_undef:
f6f0e17b 4665 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 4666 curr += bytes_read;
0c588247
NC		 4667 string = curr;
4668 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 4669 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4670 lineno, string);
4671 break;
4672
4673 case DW_MACINFO_vendor_ext:
4674 {
4675 unsigned int constant;
4676
f6f0e17b 4677 constant = read_uleb128 (curr, & bytes_read, end);
19e6b90e 4678 curr += bytes_read;
0c588247
NC		 4679 string = curr;
4680 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 4681 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4682 constant, string);
4683 }
4684 break;
4685 }
4686 }
4687
4688 return 1;
4689}
4690
4ccf1e31
JJ		 4691/* Given LINE_OFFSET into the .debug_line section, attempt to return
4692 filename and dirname corresponding to file name table entry with index
4693 FILEIDX. Return NULL on failure. */
4694
4695static unsigned char *
f6f0e17b
NC		 4696get_line_filename_and_dirname (dwarf_vma line_offset,
4697 dwarf_vma fileidx,
4ccf1e31
JJ		 4698 unsigned char **dir_name)
4699{
4700 struct dwarf_section *section = &debug_displays [line].section;
4701 unsigned char *hdrptr, *dirtable, *file_name;
4702 unsigned int offset_size, initial_length_size;
4703 unsigned int version, opcode_base, bytes_read;
4704 dwarf_vma length, diridx;
f6f0e17b 4705 const unsigned char * end;
4ccf1e31
JJ		 4706
4707 *dir_name = NULL;
4708 if (section->start == NULL
4709 || line_offset >= section->size
4710 || fileidx == 0)
4711 return NULL;
4712
4713 hdrptr = section->start + line_offset;
f6f0e17b 4714 end = section->start + section->size;
0c588247
NC		 4715
4716 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4ccf1e31
JJ		 4717 if (length == 0xffffffff)
4718 {
4719 /* This section is 64-bit DWARF 3. */
0c588247 4720 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4ccf1e31
JJ		 4721 offset_size = 8;
4722 initial_length_size = 12;
4723 }
4724 else
4725 {
4726 offset_size = 4;
4727 initial_length_size = 4;
4728 }
4729 if (length + initial_length_size > section->size)
4730 return NULL;
0c588247
NC		 4731
4732 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4ccf1e31
JJ		 4733 if (version != 2 && version != 3 && version != 4)
4734 return NULL;
4735 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
4736 if (version >= 4)
4737 hdrptr++; /* Skip max_ops_per_insn. */
4738 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
0c588247
NC		 4739
4740 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4ccf1e31
JJ		 4741 if (opcode_base == 0)
4742 return NULL;
0c588247 4743
4ccf1e31
JJ		 4744 hdrptr += opcode_base - 1;
4745 dirtable = hdrptr;
4746 /* Skip over dirname table. */
4747 while (*hdrptr != '\0')
0c588247 4748 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4ccf1e31
JJ		 4749 hdrptr++; /* Skip the NUL at the end of the table. */
4750 /* Now skip over preceding filename table entries. */
4751 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
4752 {
0c588247 4753 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
f6f0e17b 4754 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31 4755 hdrptr += bytes_read;
f6f0e17b 4756 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31 4757 hdrptr += bytes_read;
f6f0e17b 4758 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31
JJ		 4759 hdrptr += bytes_read;
4760 }
f6f0e17b 4761 if (hdrptr == end || *hdrptr == '\0')
4ccf1e31
JJ		 4762 return NULL;
4763 file_name = hdrptr;
0c588247 4764 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
f6f0e17b 4765 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31
JJ		 4766 if (diridx == 0)
4767 return file_name;
4768 for (; *dirtable != '\0' && diridx > 1; diridx--)
0c588247 4769 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4ccf1e31
JJ		 4770 if (*dirtable == '\0')
4771 return NULL;
4772 *dir_name = dirtable;
4773 return file_name;
4774}
4775
4776static int
4777display_debug_macro (struct dwarf_section *section,
4778 void *file)
4779{
4780 unsigned char *start = section->start;
4781 unsigned char *end = start + section->size;
4782 unsigned char *curr = start;
4783 unsigned char *extended_op_buf[256];
4784 unsigned int bytes_read;
4785
4786 load_debug_section (str, file);
4787 load_debug_section (line, file);
4788
4789 printf (_("Contents of the %s section:\n\n"), section->name);
4790
4791 while (curr < end)
4792 {
4793 unsigned int lineno, version, flags;
4794 unsigned int offset_size = 4;
0c588247 4795 const unsigned char *string;
4ccf1e31
JJ		 4796 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4797 unsigned char **extended_ops = NULL;
4798
0c588247 4799 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
7a7e1061 4800 if (version != 4 && version != 5)
4ccf1e31 4801 {
7a7e1061 4802 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
4ccf1e31
JJ		 4803 section->name);
4804 return 0;
4805 }
4806
0c588247 4807 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4ccf1e31
JJ		 4808 if (flags & 1)
4809 offset_size = 8;
4810 printf (_(" Offset: 0x%lx\n"),
4811 (unsigned long) sec_offset);
4812 printf (_(" Version: %d\n"), version);
4813 printf (_(" Offset size: %d\n"), offset_size);
4814 if (flags & 2)
4815 {
0c588247 4816 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4ccf1e31
JJ		 4817 printf (_(" Offset into .debug_line: 0x%lx\n"),
4818 (unsigned long) line_offset);
4819 }
4820 if (flags & 4)
4821 {
0c588247 4822 unsigned int i, count, op;
4ccf1e31 4823 dwarf_vma nargs, n;
0c588247
NC		 4824
4825 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
bf5117e3 4826
4ccf1e31
JJ		 4827 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4828 extended_ops = extended_op_buf;
4829 if (count)
4830 {
4831 printf (_(" Extension opcode arguments:\n"));
4832 for (i = 0; i < count; i++)
4833 {
0c588247 4834 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4ccf1e31 4835 extended_ops[op] = curr;
f6f0e17b 4836 nargs = read_uleb128 (curr, &bytes_read, end);
4ccf1e31
JJ		 4837 curr += bytes_read;
4838 if (nargs == 0)
7a7e1061 4839 printf (_(" DW_MACRO_%02x has no arguments\n"), op);
4ccf1e31
JJ		 4840 else
4841 {
7a7e1061 4842 printf (_(" DW_MACRO_%02x arguments: "), op);
4ccf1e31
JJ		 4843 for (n = 0; n < nargs; n++)
4844 {
0c588247
NC		 4845 unsigned int form;
4846
4847 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4ccf1e31
JJ		 4848 printf ("%s%s", get_FORM_name (form),
4849 n == nargs - 1 ? "\n" : ", ");
4850 switch (form)
4851 {
4852 case DW_FORM_data1:
4853 case DW_FORM_data2:
4854 case DW_FORM_data4:
4855 case DW_FORM_data8:
4856 case DW_FORM_sdata:
4857 case DW_FORM_udata:
4858 case DW_FORM_block:
4859 case DW_FORM_block1:
4860 case DW_FORM_block2:
4861 case DW_FORM_block4:
4862 case DW_FORM_flag:
4863 case DW_FORM_string:
4864 case DW_FORM_strp:
4865 case DW_FORM_sec_offset:
4866 break;
4867 default:
4868 error (_("Invalid extension opcode form %s\n"),
4869 get_FORM_name (form));
4870 return 0;
4871 }
4872 }
4873 }
4874 }
4875 }
4876 }
4877 printf ("\n");
4878
4879 while (1)
4880 {
4881 unsigned int op;
4882
4883 if (curr >= end)
4884 {
4885 error (_(".debug_macro section not zero terminated\n"));
4886 return 0;
4887 }
4888
0c588247 4889 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4ccf1e31
JJ		 4890 if (op == 0)
4891 break;
4892
4893 switch (op)
4894 {
7a7e1061 4895 case DW_MACRO_start_file:
4ccf1e31
JJ		 4896 {
4897 unsigned int filenum;
4898 unsigned char *file_name = NULL, *dir_name = NULL;
4899
f6f0e17b 4900 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4901 curr += bytes_read;
f6f0e17b 4902 filenum = read_uleb128 (curr, &bytes_read, end);
4ccf1e31
JJ		 4903 curr += bytes_read;
4904
4905 if ((flags & 2) == 0)
7a7e1061 4906 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
4ccf1e31
JJ		 4907 else
4908 file_name
4909 = get_line_filename_and_dirname (line_offset, filenum,
4910 &dir_name);
4911 if (file_name == NULL)
7a7e1061 4912 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
4ccf1e31
JJ		 4913 lineno, filenum);
4914 else
7a7e1061 4915 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4ccf1e31
JJ		 4916 lineno, filenum,
4917 dir_name != NULL ? (const char *) dir_name : "",
4918 dir_name != NULL ? "/" : "", file_name);
4919 }
4920 break;
4921
7a7e1061
JK		 4922 case DW_MACRO_end_file:
4923 printf (_(" DW_MACRO_end_file\n"));
4ccf1e31
JJ		 4924 break;
4925
7a7e1061 4926 case DW_MACRO_define:
f6f0e17b 4927 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4928 curr += bytes_read;
0c588247
NC		 4929 string = curr;
4930 curr += strnlen ((char *) string, end - string) + 1;
7a7e1061 4931 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
4ccf1e31
JJ		 4932 lineno, string);
4933 break;
4934
7a7e1061 4935 case DW_MACRO_undef:
f6f0e17b 4936 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4937 curr += bytes_read;
0c588247
NC		 4938 string = curr;
4939 curr += strnlen ((char *) string, end - string) + 1;
7a7e1061 4940 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
4ccf1e31
JJ		 4941 lineno, string);
4942 break;
4943
7a7e1061 4944 case DW_MACRO_define_strp:
f6f0e17b 4945 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4946 curr += bytes_read;
0c588247 4947 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4ccf1e31 4948 string = fetch_indirect_string (offset);
7a7e1061 4949 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
4ccf1e31
JJ		 4950 lineno, string);
4951 break;
4952
7a7e1061 4953 case DW_MACRO_undef_strp:
f6f0e17b 4954 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4955 curr += bytes_read;
0c588247 4956 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4ccf1e31 4957 string = fetch_indirect_string (offset);
7a7e1061 4958 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
4ccf1e31
JJ		 4959 lineno, string);
4960 break;
4961
7a7e1061 4962 case DW_MACRO_import:
0c588247 4963 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
7a7e1061 4964 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
4ccf1e31
JJ		 4965 (unsigned long) offset);
4966 break;
4967
7a7e1061 4968 case DW_MACRO_define_sup:
f6f0e17b 4969 lineno = read_uleb128 (curr, &bytes_read, end);
a081f3cd 4970 curr += bytes_read;
0c588247 4971 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
7a7e1061 4972 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
a081f3cd
JJ		 4973 lineno, (unsigned long) offset);
4974 break;
4975
7a7e1061 4976 case DW_MACRO_undef_sup:
f6f0e17b 4977 lineno = read_uleb128 (curr, &bytes_read, end);
a081f3cd 4978 curr += bytes_read;
0c588247 4979 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
7a7e1061 4980 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
a081f3cd
JJ		 4981 lineno, (unsigned long) offset);
4982 break;
4983
7a7e1061 4984 case DW_MACRO_import_sup:
0c588247 4985 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
7a7e1061 4986 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
a081f3cd
JJ		 4987 (unsigned long) offset);
4988 break;
4989
4ccf1e31
JJ		 4990 default:
4991 if (extended_ops == NULL || extended_ops[op] == NULL)
4992 {
4993 error (_(" Unknown macro opcode %02x seen\n"), op);
4994 return 0;
4995 }
4996 else
4997 {
4998 /* Skip over unhandled opcodes. */
4999 dwarf_vma nargs, n;
5000 unsigned char *desc = extended_ops[op];
f6f0e17b 5001 nargs = read_uleb128 (desc, &bytes_read, end);
4ccf1e31
JJ		 5002 desc += bytes_read;
5003 if (nargs == 0)
5004 {
7a7e1061 5005 printf (_(" DW_MACRO_%02x\n"), op);
4ccf1e31
JJ		 5006 break;
5007 }
7a7e1061 5008 printf (_(" DW_MACRO_%02x -"), op);
4ccf1e31
JJ		 5009 for (n = 0; n < nargs; n++)
5010 {
0c588247
NC		 5011 int val;
5012
77145576 5013 /* DW_FORM_implicit_const is not expected here. */
0c588247 5014 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4ccf1e31 5015 curr
77145576 5016 = read_and_display_attr_value (0, val, 0,
f6f0e17b 5017 curr, end, 0, 0, offset_size,
341f9135 5018 version, NULL, 0, NULL,
ef0b5f1c 5019 NULL, ' ');
4ccf1e31
JJ		 5020 if (n != nargs - 1)
5021 printf (",");
5022 }
5023 printf ("\n");
5024 }
5025 break;
5026 }
5027 }
5028
5029 printf ("\n");
b4eb7656 5030 }
4ccf1e31
JJ		 5031
5032 return 1;
5033}
5034
19e6b90e
L		 5035static int
5036display_debug_abbrev (struct dwarf_section *section,
5037 void *file ATTRIBUTE_UNUSED)
5038{
5039 abbrev_entry *entry;
5040 unsigned char *start = section->start;
5041 unsigned char *end = start + section->size;
5042
5043 printf (_("Contents of the %s section:\n\n"), section->name);
5044
5045 do
5046 {
7282333f
AM		 5047 unsigned char *last;
5048
19e6b90e
L		 5049 free_abbrevs ();
5050
7282333f 5051 last = start;
19e6b90e
L		 5052 start = process_abbrev_section (start, end);
5053
5054 if (first_abbrev == NULL)
5055 continue;
5056
7282333f 5057 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
19e6b90e
L		 5058
5059 for (entry = first_abbrev; entry; entry = entry->next)
5060 {
5061 abbrev_attr *attr;
5062
cc5914eb 5063 printf (" %ld %s [%s]\n",
19e6b90e
L		 5064 entry->entry,
5065 get_TAG_name (entry->tag),
5066 entry->children ? _("has children") : _("no children"));
5067
5068 for (attr = entry->first_attr; attr; attr = attr->next)
77145576
JK		 5069 {
5070 printf (" %-18s %s",
5071 get_AT_name (attr->attribute),
5072 get_FORM_name (attr->form));
5073 if (attr->form == DW_FORM_implicit_const)
5074 printf (": %" BFD_VMA_FMT "d", attr->implicit_const);
5075 putchar ('\n');
5076 }
19e6b90e
L		 5077 }
5078 }
5079 while (start);
5080
5081 printf ("\n");
5082
5083 return 1;
5084}
5085
42bcef4a
AB		 5086/* Return true when ADDR is the maximum address, when addresses are
5087 POINTER_SIZE bytes long. */
5088
5089static bfd_boolean
5090is_max_address (dwarf_vma addr, unsigned int pointer_size)
5091{
5092 dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
5093 return ((addr & mask) == mask);
5094}
5095
9f272209
AO		 5096/* Display a view pair list starting at *VSTART_PTR and ending at
5097 VLISTEND within SECTION. */
5098
5099static void
5100display_view_pair_list (struct dwarf_section *section,
5101 unsigned char **vstart_ptr,
5102 unsigned int debug_info_entry,
5103 unsigned char *vlistend)
5104{
5105 unsigned char *vstart = *vstart_ptr;
5106 unsigned char *section_end = section->start + section->size;
5107 unsigned int pointer_size = debug_information [debug_info_entry].pointer_size;
5108
5109 if (vlistend < section_end)
5110 section_end = vlistend;
5111
5112 putchar ('\n');
5113
5114 while (vstart < section_end)
5115 {
5116 dwarf_vma off = vstart - section->start;
5117 dwarf_vma vbegin, vend;
5118
5119 unsigned int bytes_read;
5120 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5121 vstart += bytes_read;
5122 if (vstart == section_end)
5123 {
5124 vstart -= bytes_read;
5125 break;
5126 }
5127
5128 vend = read_uleb128 (vstart, &bytes_read, section_end);
5129 vstart += bytes_read;
5130
5131 printf (" %8.8lx ", (unsigned long) off);
5132
5133 print_dwarf_view (vbegin, pointer_size, 1);
5134 print_dwarf_view (vend, pointer_size, 1);
5135 printf (_("location view pair\n"));
5136 }
5137
5138 putchar ('\n');
5139 *vstart_ptr = vstart;
5140}
5141
4723351a
CC		 5142/* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5143
5144static void
5145display_loc_list (struct dwarf_section *section,
b4eb7656
AM		 5146 unsigned char **start_ptr,
5147 unsigned int debug_info_entry,
359ca075
JK		 5148 dwarf_vma offset,
5149 dwarf_vma base_address,
9f272209 5150 unsigned char **vstart_ptr,
b4eb7656 5151 int has_frame_base)
4723351a 5152{
9f272209 5153 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
4723351a 5154 unsigned char *section_end = section->start + section->size;
82b1b41b
NC		 5155 unsigned long cu_offset;
5156 unsigned int pointer_size;
5157 unsigned int offset_size;
5158 int dwarf_version;
4723351a
CC		 5159
5160 dwarf_vma begin;
5161 dwarf_vma end;
5162 unsigned short length;
5163 int need_frame_base;
5164
82b1b41b
NC		 5165 if (debug_info_entry >= num_debug_info_entries)
5166 {
5167 warn (_("No debug information available for loc lists of entry: %u\n"),
5168 debug_info_entry);
5169 return;
5170 }
b4eb7656 5171
82b1b41b
NC		 5172 cu_offset = debug_information [debug_info_entry].cu_offset;
5173 pointer_size = debug_information [debug_info_entry].pointer_size;
5174 offset_size = debug_information [debug_info_entry].offset_size;
5175 dwarf_version = debug_information [debug_info_entry].dwarf_version;
b4eb7656 5176
f41e4712
NC		 5177 if (pointer_size < 2 || pointer_size > 8)
5178 {
5179 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5180 pointer_size, debug_info_entry);
5181 return;
5182 }
5183
4723351a
CC		 5184 while (1)
5185 {
359ca075 5186 dwarf_vma off = offset + (start - *start_ptr);
9f272209 5187 dwarf_vma vbegin = vm1, vend = vm1;
d1c4b12b 5188
4723351a 5189 if (start + 2 * pointer_size > section_end)
b4eb7656
AM		 5190 {
5191 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5192 (unsigned long) offset);
b4eb7656
AM		 5193 break;
5194 }
4723351a 5195
359ca075 5196 printf (" %8.8lx ", (unsigned long) off);
fab128ef 5197
0c588247
NC		 5198 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
5199 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4723351a 5200
4723351a 5201 if (begin == 0 && end == 0)
b4eb7656 5202 {
d1c4b12b
NC		 5203 /* PR 18374: In a object file we can have a location list that
5204 starts with a begin and end of 0 because there are relocations
5205 that need to be applied to the addresses. Actually applying
5206 the relocations now does not help as they will probably resolve
5207 to 0, since the object file has not been fully linked. Real
5208 end of list markers will not have any relocations against them. */
5209 if (! reloc_at (section, off)
5210 && ! reloc_at (section, off + pointer_size))
5211 {
5212 printf (_("<End of list>\n"));
5213 break;
5214 }
b4eb7656 5215 }
4723351a
CC		 5216
5217 /* Check base address specifiers. */
42bcef4a
AB		 5218 if (is_max_address (begin, pointer_size)
5219 && !is_max_address (end, pointer_size))
b4eb7656
AM		 5220 {
5221 base_address = end;
5222 print_dwarf_vma (begin, pointer_size);
5223 print_dwarf_vma (end, pointer_size);
5224 printf (_("(base address)\n"));
5225 continue;
5226 }
4723351a 5227
9f272209
AO		 5228 if (vstart)
5229 {
5230 unsigned int bytes_read;
5231
5232 off = offset + (vstart - *start_ptr);
5233
5234 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5235 vstart += bytes_read;
5236 print_dwarf_view (vbegin, pointer_size, 1);
5237
5238 vend = read_uleb128 (vstart, &bytes_read, section_end);
5239 vstart += bytes_read;
5240 print_dwarf_view (vend, pointer_size, 1);
5241
5242 printf (_("views at %8.8lx for:\n %*s "),
5243 (unsigned long) off, 8, "");
5244 }
5245
4723351a 5246 if (start + 2 > section_end)
b4eb7656
AM		 5247 {
5248 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5249 (unsigned long) offset);
b4eb7656
AM		 5250 break;
5251 }
4723351a 5252
0c588247 5253 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4723351a
CC		 5254
5255 if (start + length > section_end)
b4eb7656
AM		 5256 {
5257 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5258 (unsigned long) offset);
b4eb7656
AM		 5259 break;
5260 }
4723351a
CC		 5261
5262 print_dwarf_vma (begin + base_address, pointer_size);
5263 print_dwarf_vma (end + base_address, pointer_size);
5264
5265 putchar ('(');
5266 need_frame_base = decode_location_expression (start,
b4eb7656
AM		 5267 pointer_size,
5268 offset_size,
5269 dwarf_version,
5270 length,
5271 cu_offset, section);
4723351a
CC		 5272 putchar (')');
5273
5274 if (need_frame_base && !has_frame_base)
b4eb7656 5275 printf (_(" [without DW_AT_frame_base]"));
4723351a 5276
9f272209 5277 if (begin == end && vbegin == vend)
b4eb7656 5278 fputs (_(" (start == end)"), stdout);
9f272209 5279 else if (begin > end || (begin == end && vbegin > vend))
b4eb7656 5280 fputs (_(" (start > end)"), stdout);
4723351a
CC		 5281
5282 putchar ('\n');
5283
5284 start += length;
5285 }
5286
5287 *start_ptr = start;
9f272209 5288 *vstart_ptr = vstart;
4723351a
CC		 5289}
5290
77145576
JK		 5291/* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5292
5293static void
5294display_loclists_list (struct dwarf_section *section,
5295 unsigned char **start_ptr,
5296 unsigned int debug_info_entry,
5297 dwarf_vma offset,
5298 dwarf_vma base_address,
9f272209 5299 unsigned char **vstart_ptr,
77145576
JK		 5300 int has_frame_base)
5301{
9f272209 5302 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
77145576
JK		 5303 unsigned char *section_end = section->start + section->size;
5304 unsigned long cu_offset;
5305 unsigned int pointer_size;
5306 unsigned int offset_size;
5307 int dwarf_version;
5308 unsigned int bytes_read;
5309
9dfd0db9 5310 /* Initialize it due to a false compiler warning. */
9f272209
AO		 5311 dwarf_vma begin = -1, vbegin = -1;
5312 dwarf_vma end = -1, vend = -1;
77145576
JK		 5313 dwarf_vma length;
5314 int need_frame_base;
5315
5316 if (debug_info_entry >= num_debug_info_entries)
5317 {
5318 warn (_("No debug information available for "
5319 "loclists lists of entry: %u\n"),
5320 debug_info_entry);
5321 return;
5322 }
5323
5324 cu_offset = debug_information [debug_info_entry].cu_offset;
5325 pointer_size = debug_information [debug_info_entry].pointer_size;
5326 offset_size = debug_information [debug_info_entry].offset_size;
5327 dwarf_version = debug_information [debug_info_entry].dwarf_version;
5328
5329 if (pointer_size < 2 || pointer_size > 8)
5330 {
5331 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5332 pointer_size, debug_info_entry);
5333 return;
5334 }
5335
5336 while (1)
5337 {
5338 dwarf_vma off = offset + (start - *start_ptr);
5339 enum dwarf_location_list_entry_type llet;
5340
5341 if (start + 1 > section_end)
5342 {
5343 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5344 (unsigned long) offset);
5345 break;
5346 }
5347
5348 printf (" %8.8lx ", (unsigned long) off);
5349
5350 SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end);
5351
9f272209
AO		 5352 if (vstart && llet == DW_LLE_offset_pair)
5353 {
5354 off = offset + (vstart - *start_ptr);
5355
5356 vbegin = read_uleb128 (vstart, &bytes_read, section_end);
5357 vstart += bytes_read;
5358 print_dwarf_view (vbegin, pointer_size, 1);
5359
5360 vend = read_uleb128 (vstart, &bytes_read, section_end);
5361 vstart += bytes_read;
5362 print_dwarf_view (vend, pointer_size, 1);
5363
5364 printf (_("views at %8.8lx for:\n %*s "),
5365 (unsigned long) off, 8, "");
5366 }
5367
77145576
JK		 5368 switch (llet)
5369 {
5370 case DW_LLE_end_of_list:
5371 printf (_("<End of list>\n"));
5372 break;
5373 case DW_LLE_offset_pair:
5374 begin = read_uleb128 (start, &bytes_read, section_end);
5375 start += bytes_read;
5376 end = read_uleb128 (start, &bytes_read, section_end);
5377 start += bytes_read;
5378 break;
5379 case DW_LLE_base_address:
5380 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size,
5381 section_end);
5382 print_dwarf_vma (base_address, pointer_size);
5383 printf (_("(base address)\n"));
5384 break;
9f272209
AO		 5385#ifdef DW_LLE_view_pair
5386 case DW_LLE_view_pair:
5387 if (vstart)
5388 printf (_("View pair entry in loclist with locviews attribute\n"));
5389 vbegin = read_uleb128 (start, &bytes_read, section_end);
5390 start += bytes_read;
5391 print_dwarf_view (vbegin, pointer_size, 1);
5392
5393 vend = read_uleb128 (start, &bytes_read, section_end);
5394 start += bytes_read;
5395 print_dwarf_view (vend, pointer_size, 1);
5396
5397 printf (_("views for:\n"));
5398 continue;
5399#endif
77145576
JK		 5400 default:
5401 error (_("Invalid location list entry type %d\n"), llet);
5402 return;
5403 }
5404 if (llet == DW_LLE_end_of_list)
5405 break;
5406 if (llet != DW_LLE_offset_pair)
5407 continue;
5408
5409 if (start + 2 > section_end)
5410 {
5411 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5412 (unsigned long) offset);
5413 break;
5414 }
5415
5416 length = read_uleb128 (start, &bytes_read, section_end);
5417 start += bytes_read;
5418
5419 print_dwarf_vma (begin + base_address, pointer_size);
5420 print_dwarf_vma (end + base_address, pointer_size);
5421
5422 putchar ('(');
5423 need_frame_base = decode_location_expression (start,
5424 pointer_size,
5425 offset_size,
5426 dwarf_version,
5427 length,
5428 cu_offset, section);
5429 putchar (')');
5430
5431 if (need_frame_base && !has_frame_base)
5432 printf (_(" [without DW_AT_frame_base]"));
5433
9f272209 5434 if (begin == end && vbegin == vend)
77145576 5435 fputs (_(" (start == end)"), stdout);
9f272209 5436 else if (begin > end || (begin == end && vbegin > vend))
77145576
JK		 5437 fputs (_(" (start > end)"), stdout);
5438
5439 putchar ('\n');
5440
5441 start += length;
9f272209 5442 vbegin = vend = -1;
77145576
JK		 5443 }
5444
9f272209
AO		 5445 if (vbegin != vm1 || vend != vm1)
5446 printf (_("Trailing view pair not used in a range"));
5447
77145576 5448 *start_ptr = start;
9f272209 5449 *vstart_ptr = vstart;
77145576
JK		 5450}
5451
fab128ef
CC		 5452/* Print a .debug_addr table index in decimal, surrounded by square brackets,
5453 right-adjusted in a field of length LEN, and followed by a space. */
5454
5455static void
5456print_addr_index (unsigned int idx, unsigned int len)
5457{
5458 static char buf[15];
5459 snprintf (buf, sizeof (buf), "[%d]", idx);
341f9135 5460 printf ("%*s ", len, buf);
fab128ef
CC		 5461}
5462
4723351a
CC		 5463/* Display a location list from a .dwo section. It uses address indexes rather
5464 than embedded addresses. This code closely follows display_loc_list, but the
5465 two are sufficiently different that combining things is very ugly. */
5466
5467static void
5468display_loc_list_dwo (struct dwarf_section *section,
b4eb7656
AM		 5469 unsigned char **start_ptr,
5470 unsigned int debug_info_entry,
359ca075 5471 dwarf_vma offset,
9f272209 5472 unsigned char **vstart_ptr,
b4eb7656 5473 int has_frame_base)
4723351a 5474{
9f272209 5475 unsigned char *start = *start_ptr, *vstart = *vstart_ptr;
4723351a 5476 unsigned char *section_end = section->start + section->size;
82b1b41b
NC		 5477 unsigned long cu_offset;
5478 unsigned int pointer_size;
5479 unsigned int offset_size;
5480 int dwarf_version;
4723351a
CC		 5481 int entry_type;
5482 unsigned short length;
5483 int need_frame_base;
fab128ef 5484 unsigned int idx;
4723351a
CC		 5485 unsigned int bytes_read;
5486
82b1b41b
NC		 5487 if (debug_info_entry >= num_debug_info_entries)
5488 {
5489 warn (_("No debug information for loc lists of entry: %u\n"),
5490 debug_info_entry);
5491 return;
5492 }
5493
5494 cu_offset = debug_information [debug_info_entry].cu_offset;
5495 pointer_size = debug_information [debug_info_entry].pointer_size;
5496 offset_size = debug_information [debug_info_entry].offset_size;
5497 dwarf_version = debug_information [debug_info_entry].dwarf_version;
5498
f41e4712
NC		 5499 if (pointer_size < 2 || pointer_size > 8)
5500 {
5501 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5502 pointer_size, debug_info_entry);
5503 return;
5504 }
5505
4723351a
CC		 5506 while (1)
5507 {
359ca075 5508 printf (" %8.8lx ", (unsigned long) (offset + (start - *start_ptr)));
4723351a 5509
fab128ef 5510 if (start >= section_end)
b4eb7656
AM		 5511 {
5512 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5513 (unsigned long) offset);
b4eb7656
AM		 5514 break;
5515 }
4723351a 5516
0c588247 5517 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
9f272209
AO		 5518
5519 if (vstart)
5520 switch (entry_type)
5521 {
5522 default:
5523 break;
5524
5525 case 2:
5526 case 3:
5527 case 4:
5528 {
5529 dwarf_vma view;
5530 dwarf_vma off = offset + (vstart - *start_ptr);
5531
5532 view = read_uleb128 (vstart, &bytes_read, section_end);
5533 vstart += bytes_read;
5534 print_dwarf_view (view, 8, 1);
5535
5536 view = read_uleb128 (vstart, &bytes_read, section_end);
5537 vstart += bytes_read;
5538 print_dwarf_view (view, 8, 1);
5539
5540 printf (_("views at %8.8lx for:\n %*s "),
5541 (unsigned long) off, 8, "");
5542
5543 }
5544 break;
5545 }
5546
4723351a 5547 switch (entry_type)
b4eb7656
AM		 5548 {
5549 case 0: /* A terminating entry. */
5550 *start_ptr = start;
9f272209 5551 *vstart_ptr = vstart;
b4eb7656
AM		 5552 printf (_("<End of list>\n"));
5553 return;
5554 case 1: /* A base-address entry. */
5555 idx = read_uleb128 (start, &bytes_read, section_end);
5556 start += bytes_read;
5557 print_addr_index (idx, 8);
9f272209 5558 printf ("%*s", 9 + (vstart ? 2 * 6 : 0), "");
b4eb7656
AM		 5559 printf (_("(base address selection entry)\n"));
5560 continue;
5561 case 2: /* A start/end entry. */
5562 idx = read_uleb128 (start, &bytes_read, section_end);
5563 start += bytes_read;
5564 print_addr_index (idx, 8);
5565 idx = read_uleb128 (start, &bytes_read, section_end);
5566 start += bytes_read;
5567 print_addr_index (idx, 8);
5568 break;
5569 case 3: /* A start/length entry. */
5570 idx = read_uleb128 (start, &bytes_read, section_end);
5571 start += bytes_read;
5572 print_addr_index (idx, 8);
5573 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5574 printf ("%08x ", idx);
5575 break;
5576 case 4: /* An offset pair entry. */
5577 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5578 printf ("%08x ", idx);
5579 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
5580 printf ("%08x ", idx);
5581 break;
5582 default:
5583 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
5584 *start_ptr = start;
9f272209 5585 *vstart_ptr = vstart;
b4eb7656
AM		 5586 return;
5587 }
4723351a
CC		 5588
5589 if (start + 2 > section_end)
b4eb7656
AM		 5590 {
5591 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5592 (unsigned long) offset);
b4eb7656
AM		 5593 break;
5594 }
4723351a 5595
0c588247 5596 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4723351a 5597 if (start + length > section_end)
b4eb7656
AM		 5598 {
5599 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
359ca075 5600 (unsigned long) offset);
b4eb7656
AM		 5601 break;
5602 }
4723351a
CC		 5603
5604 putchar ('(');
5605 need_frame_base = decode_location_expression (start,
b4eb7656
AM		 5606 pointer_size,
5607 offset_size,
5608 dwarf_version,
5609 length,
5610 cu_offset, section);
4723351a
CC		 5611 putchar (')');
5612
5613 if (need_frame_base && !has_frame_base)
b4eb7656 5614 printf (_(" [without DW_AT_frame_base]"));
4723351a
CC		 5615
5616 putchar ('\n');
5617
5618 start += length;
5619 }
5620
5621 *start_ptr = start;
9f272209 5622 *vstart_ptr = vstart;
4723351a
CC		 5623}
5624
9f272209
AO		 5625/* Sort array of indexes in ascending order of loc_offsets[idx] and
5626 loc_views. */
51d0d03f 5627
9f272209 5628static dwarf_vma *loc_offsets, *loc_views;
51d0d03f
JJ		 5629
5630static int
5631loc_offsets_compar (const void *ap, const void *bp)
5632{
5633 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
5634 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
5635
9f272209
AO		 5636 int ret = (a > b) - (b > a);
5637 if (ret)
5638 return ret;
5639
5640 a = loc_views[*(const unsigned int *) ap];
5641 b = loc_views[*(const unsigned int *) bp];
5642
5643 ret = (a > b) - (b > a);
5644
5645 return ret;
51d0d03f
JJ		 5646}
5647
19e6b90e
L		 5648static int
5649display_debug_loc (struct dwarf_section *section, void *file)
5650{
9f272209 5651 unsigned char *start = section->start, *vstart = NULL;
19e6b90e
L		 5652 unsigned long bytes;
5653 unsigned char *section_begin = start;
5654 unsigned int num_loc_list = 0;
5655 unsigned long last_offset = 0;
9f272209 5656 unsigned long last_view = 0;
19e6b90e
L		 5657 unsigned int first = 0;
5658 unsigned int i;
5659 unsigned int j;
5660 int seen_first_offset = 0;
51d0d03f 5661 int locs_sorted = 1;
9f272209 5662 unsigned char *next = start, *vnext = vstart;
51d0d03f 5663 unsigned int *array = NULL;
4723351a
CC		 5664 const char *suffix = strrchr (section->name, '.');
5665 int is_dwo = 0;
77145576
JK		 5666 int is_loclists = strstr (section->name, "debug_loclists") != NULL;
5667 dwarf_vma expected_start = 0;
4723351a
CC		 5668
5669 if (suffix && strcmp (suffix, ".dwo") == 0)
5670 is_dwo = 1;
19e6b90e
L		 5671
5672 bytes = section->size;
19e6b90e
L		 5673
5674 if (bytes == 0)
5675 {
5676 printf (_("\nThe %s section is empty.\n"), section->name);
5677 return 0;
5678 }
5679
77145576
JK		 5680 if (is_loclists)
5681 {
5682 unsigned char *hdrptr = section_begin;
5683 dwarf_vma ll_length;
5684 unsigned short ll_version;
5685 unsigned char *end = section_begin + section->size;
5686 unsigned char address_size, segment_selector_size;
5687 uint32_t offset_entry_count;
5688
5689 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end);
5690 if (ll_length == 0xffffffff)
5691 SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end);
5692
5693 SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end);
5694 if (ll_version != 5)
5695 {
5696 warn (_("The %s section contains corrupt or "
5697 "unsupported version number: %d.\n"),
5698 section->name, ll_version);
5699 return 0;
5700 }
5701
5702 SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end);
5703
5704 SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end);
5705 if (segment_selector_size != 0)
5706 {
5707 warn (_("The %s section contains "
5708 "unsupported segment selector size: %d.\n"),
5709 section->name, segment_selector_size);
5710 return 0;
5711 }
5712
5713 SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end);
5714 if (offset_entry_count != 0)
5715 {
5716 warn (_("The %s section contains "
5717 "unsupported offset entry count: %d.\n"),
5718 section->name, offset_entry_count);
5719 return 0;
5720 }
5721
5722 expected_start = hdrptr - section_begin;
5723 }
5724
1febe64d
NC		 5725 if (load_debug_info (file) == 0)
5726 {
5727 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5728 section->name);
5729 return 0;
5730 }
19e6b90e
L		 5731
5732 /* Check the order of location list in .debug_info section. If
5733 offsets of location lists are in the ascending order, we can
5734 use `debug_information' directly. */
5735 for (i = 0; i < num_debug_info_entries; i++)
5736 {
5737 unsigned int num;
5738
5739 num = debug_information [i].num_loc_offsets;
51d0d03f
JJ		 5740 if (num > num_loc_list)
5741 num_loc_list = num;
19e6b90e
L		 5742
5743 /* Check if we can use `debug_information' directly. */
51d0d03f 5744 if (locs_sorted && num != 0)
19e6b90e
L		 5745 {
5746 if (!seen_first_offset)
5747 {
5748 /* This is the first location list. */
5749 last_offset = debug_information [i].loc_offsets [0];
9f272209 5750 last_view = debug_information [i].loc_views [0];
19e6b90e
L		 5751 first = i;
5752 seen_first_offset = 1;
5753 j = 1;
5754 }
5755 else
5756 j = 0;
5757
5758 for (; j < num; j++)
5759 {
5760 if (last_offset >
9f272209
AO		 5761 debug_information [i].loc_offsets [j]
5762 || (last_offset == debug_information [i].loc_offsets [j]
5763 && last_view > debug_information [i].loc_views [j]))
19e6b90e 5764 {
51d0d03f 5765 locs_sorted = 0;
19e6b90e
L		 5766 break;
5767 }
5768 last_offset = debug_information [i].loc_offsets [j];
9f272209 5769 last_view = debug_information [i].loc_views [j];
19e6b90e
L		 5770 }
5771 }
5772 }
5773
19e6b90e
L		 5774 if (!seen_first_offset)
5775 error (_("No location lists in .debug_info section!\n"));
5776
d4bfc77b 5777 if (debug_information [first].num_loc_offsets > 0
9f272209
AO		 5778 && debug_information [first].loc_offsets [0] != expected_start
5779 && debug_information [first].loc_views [0] != expected_start)
47704ddf
KT		 5780 warn (_("Location lists in %s section start at 0x%s\n"),
5781 section->name,
5782 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
19e6b90e 5783
51d0d03f
JJ		 5784 if (!locs_sorted)
5785 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
19e6b90e 5786 printf (_("Contents of the %s section:\n\n"), section->name);
d1c4b12b
NC		 5787 if (reloc_at (section, 0))
5788 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
5789 printf (_(" Offset Begin End Expression\n"));
19e6b90e
L		 5790
5791 seen_first_offset = 0;
5792 for (i = first; i < num_debug_info_entries; i++)
5793 {
9f272209 5794 dwarf_vma offset, voffset;
359ca075 5795 dwarf_vma base_address;
d1c4b12b 5796 unsigned int k;
19e6b90e
L		 5797 int has_frame_base;
5798
51d0d03f
JJ		 5799 if (!locs_sorted)
5800 {
5801 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
5802 array[k] = k;
5803 loc_offsets = debug_information [i].loc_offsets;
9f272209 5804 loc_views = debug_information [i].loc_views;
51d0d03f
JJ		 5805 qsort (array, debug_information [i].num_loc_offsets,
5806 sizeof (*array), loc_offsets_compar);
5807 }
19e6b90e 5808
9f272209 5809 int adjacent_view_loclists = 1;
51d0d03f 5810 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
19e6b90e 5811 {
51d0d03f
JJ		 5812 j = locs_sorted ? k : array[k];
5813 if (k
9f272209 5814 && (debug_information [i].loc_offsets [locs_sorted
51d0d03f 5815 ? k - 1 : array [k - 1]]
9f272209
AO		 5816 == debug_information [i].loc_offsets [j])
5817 && (debug_information [i].loc_views [locs_sorted
5818 ? k - 1 : array [k - 1]]
5819 == debug_information [i].loc_views [j]))
51d0d03f 5820 continue;
19e6b90e 5821 has_frame_base = debug_information [i].have_frame_base [j];
d493b283 5822 offset = debug_information [i].loc_offsets [j];
19e6b90e 5823 next = section_begin + offset;
9f272209
AO		 5824 voffset = debug_information [i].loc_views [j];
5825 if (voffset != vm1)
5826 vnext = section_begin + voffset;
5827 else
5828 vnext = NULL;
19e6b90e
L		 5829 base_address = debug_information [i].base_address;
5830
9f272209
AO		 5831 if (vnext && vnext < next)
5832 {
5833 vstart = vnext;
5834 display_view_pair_list (section, &vstart, i, next);
5835 if (start == vnext)
5836 start = vstart;
5837 }
5838
5839 if (!seen_first_offset || !adjacent_view_loclists)
19e6b90e
L		 5840 seen_first_offset = 1;
5841 else
5842 {
5843 if (start < next)
5844 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e 5845 (unsigned long) (start - section_begin),
c8071705 5846 (unsigned long) offset);
19e6b90e
L		 5847 else if (start > next)
5848 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e 5849 (unsigned long) (start - section_begin),
c8071705 5850 (unsigned long) offset);
19e6b90e
L		 5851 }
5852 start = next;
9f272209 5853 vstart = vnext;
19e6b90e
L		 5854
5855 if (offset >= bytes)
5856 {
5857 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
359ca075 5858 (unsigned long) offset);
19e6b90e
L		 5859 continue;
5860 }
5861
9f272209
AO		 5862 if (vnext && voffset >= bytes)
5863 {
5864 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
5865 (unsigned long) voffset);
5866 continue;
5867 }
5868
77145576
JK		 5869 if (!is_loclists)
5870 {
5871 if (is_dwo)
5872 display_loc_list_dwo (section, &start, i, offset,
9f272209 5873 &vstart, has_frame_base);
77145576
JK		 5874 else
5875 display_loc_list (section, &start, i, offset, base_address,
9f272209 5876 &vstart, has_frame_base);
77145576 5877 }
b4eb7656 5878 else
77145576
JK		 5879 {
5880 if (is_dwo)
5881 warn (_("DWO is not yet supported.\n"));
5882 else
5883 display_loclists_list (section, &start, i, offset, base_address,
9f272209
AO		 5884 &vstart, has_frame_base);
5885 }
5886
5887 /* FIXME: this arrangement is quite simplistic. Nothing
5888 requires locview lists to be adjacent to corresponding
5889 loclists, and a single loclist could be augmented by
5890 different locview lists, and vice-versa, unlikely as it
5891 is that it would make sense to do so. Hopefully we'll
5892 have view pair support built into loclists before we ever
5893 need to address all these possibilities. */
5894 if (adjacent_view_loclists && vnext
5895 && vnext != start && vstart != next)
5896 {
5897 adjacent_view_loclists = 0;
5898 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
77145576 5899 }
9f272209
AO		 5900
5901 if (vnext && vnext == start)
5902 display_view_pair_list (section, &start, i, vstart);
19e6b90e
L		 5903 }
5904 }
031cd65f 5905
4723351a 5906 if (start < section->start + section->size)
031cd65f 5907 warn (_("There are %ld unused bytes at the end of section %s\n"),
4723351a 5908 (long) (section->start + section->size - start), section->name);
98fb390a 5909 putchar ('\n');
51d0d03f 5910 free (array);
19e6b90e
L		 5911 return 1;
5912}
5913
5914static int
5915display_debug_str (struct dwarf_section *section,
5916 void *file ATTRIBUTE_UNUSED)
5917{
5918 unsigned char *start = section->start;
5919 unsigned long bytes = section->size;
5920 dwarf_vma addr = section->address;
5921
5922 if (bytes == 0)
5923 {
5924 printf (_("\nThe %s section is empty.\n"), section->name);
5925 return 0;
5926 }
5927
5928 printf (_("Contents of the %s section:\n\n"), section->name);
5929
5930 while (bytes)
5931 {
5932 int j;
5933 int k;
5934 int lbytes;
5935
5936 lbytes = (bytes > 16 ? 16 : bytes);
5937
5938 printf (" 0x%8.8lx ", (unsigned long) addr);
5939
5940 for (j = 0; j < 16; j++)
5941 {
5942 if (j < lbytes)
5943 printf ("%2.2x", start[j]);
5944 else
5945 printf (" ");
5946
5947 if ((j & 3) == 3)
5948 printf (" ");
5949 }
5950
5951 for (j = 0; j < lbytes; j++)
5952 {
5953 k = start[j];
5954 if (k >= ' ' && k < 0x80)
5955 printf ("%c", k);
5956 else
5957 printf (".");
5958 }
5959
5960 putchar ('\n');
5961
5962 start += lbytes;
5963 addr += lbytes;
5964 bytes -= lbytes;
5965 }
5966
5967 putchar ('\n');
5968
5969 return 1;
5970}
5971
19e6b90e
L		 5972static int
5973display_debug_info (struct dwarf_section *section, void *file)
5974{
4723351a 5975 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
19e6b90e
L		 5976}
5977
2b6f5997
CC		 5978static int
5979display_debug_types (struct dwarf_section *section, void *file)
5980{
4723351a 5981 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
6f875884
TG		 5982}
5983
5984static int
5985display_trace_info (struct dwarf_section *section, void *file)
5986{
4723351a 5987 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
2b6f5997 5988}
19e6b90e
L		 5989
5990static int
5991display_debug_aranges (struct dwarf_section *section,
5992 void *file ATTRIBUTE_UNUSED)
5993{
5994 unsigned char *start = section->start;
5995 unsigned char *end = start + section->size;
5996
80c35038 5997 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e 5998
6e3d6dc1
NC		 5999 /* It does not matter if this load fails,
6000 we test for that later on. */
6001 load_debug_info (file);
6002
19e6b90e
L		 6003 while (start < end)
6004 {
6005 unsigned char *hdrptr;
6006 DWARF2_Internal_ARange arange;
91d6fa6a 6007 unsigned char *addr_ranges;
2d9472a2
NC		 6008 dwarf_vma length;
6009 dwarf_vma address;
53b8873b 6010 unsigned char address_size;
19e6b90e 6011 int excess;
bf5117e3
NC		 6012 unsigned int offset_size;
6013 unsigned int initial_length_size;
19e6b90e
L		 6014
6015 hdrptr = start;
6016
0c588247 6017 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
19e6b90e
L		 6018 if (arange.ar_length == 0xffffffff)
6019 {
0c588247 6020 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
19e6b90e
L		 6021 offset_size = 8;
6022 initial_length_size = 12;
6023 }
6024 else
6025 {
6026 offset_size = 4;
6027 initial_length_size = 4;
6028 }
6029
0c588247
NC		 6030 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
6031 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
19e6b90e 6032
6e3d6dc1
NC		 6033 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
6034 && num_debug_info_entries > 0
6035 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
6036 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 6037 (unsigned long) arange.ar_info_offset, section->name);
6e3d6dc1 6038
0c588247
NC		 6039 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
6040 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
19e6b90e
L		 6041
6042 if (arange.ar_version != 2 && arange.ar_version != 3)
6043 {
67f101ee
NC		 6044 /* PR 19872: A version number of 0 probably means that there is
6045 padding at the end of the .debug_aranges section. Gold puts
6046 it there when performing an incremental link, for example.
6047 So do not generate a warning in this case. */
6048 if (arange.ar_version)
6049 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
19e6b90e
L		 6050 break;
6051 }
6052
47704ddf
KT		 6053 printf (_(" Length: %ld\n"),
6054 (long) arange.ar_length);
19e6b90e 6055 printf (_(" Version: %d\n"), arange.ar_version);
47704ddf
KT		 6056 printf (_(" Offset into .debug_info: 0x%lx\n"),
6057 (unsigned long) arange.ar_info_offset);
19e6b90e
L		 6058 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6059 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6060
53b8873b
NC		 6061 address_size = arange.ar_pointer_size + arange.ar_segment_size;
6062
f41e4712
NC		 6063 /* PR 17512: file: 001-108546-0.001:0.1. */
6064 if (address_size == 0 || address_size > 8)
b3681d67
L		 6065 {
6066 error (_("Invalid address size in %s section!\n"),
6067 section->name);
6068 break;
6069 }
6070
53b8873b
NC		 6071 /* The DWARF spec does not require that the address size be a power
6072 of two, but we do. This will have to change if we ever encounter
6073 an uneven architecture. */
6074 if ((address_size & (address_size - 1)) != 0)
6075 {
6076 warn (_("Pointer size + Segment size is not a power of two.\n"));
6077 break;
6078 }
cecf136e 6079
209c9a13
NC		 6080 if (address_size > 4)
6081 printf (_("\n Address Length\n"));
6082 else
6083 printf (_("\n Address Length\n"));
19e6b90e 6084
91d6fa6a 6085 addr_ranges = hdrptr;
19e6b90e 6086
53b8873b
NC		 6087 /* Must pad to an alignment boundary that is twice the address size. */
6088 excess = (hdrptr - start) % (2 * address_size);
19e6b90e 6089 if (excess)
91d6fa6a 6090 addr_ranges += (2 * address_size) - excess;
19e6b90e 6091
ffc0f143
NC		 6092 hdrptr = start + arange.ar_length + initial_length_size;
6093 if (hdrptr < start || hdrptr > end)
6094 {
6095 error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
6096 break;
6097 }
6098 start = hdrptr;
1617e571 6099
91d6fa6a 6100 while (addr_ranges + 2 * address_size <= start)
19e6b90e 6101 {
0c588247
NC		 6102 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
6103 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
19e6b90e 6104
80c35038 6105 printf (" ");
2d9472a2
NC		 6106 print_dwarf_vma (address, address_size);
6107 print_dwarf_vma (length, address_size);
6108 putchar ('\n');
19e6b90e 6109 }
19e6b90e
L		 6110 }
6111
6112 printf ("\n");
6113
6114 return 1;
6115}
6116
4723351a
CC		 6117/* Comparison function for qsort. */
6118static int
6119comp_addr_base (const void * v0, const void * v1)
6120{
6121 debug_info * info0 = (debug_info *) v0;
6122 debug_info * info1 = (debug_info *) v1;
6123 return info0->addr_base - info1->addr_base;
6124}
6125
6126/* Display the debug_addr section. */
6127static int
6128display_debug_addr (struct dwarf_section *section,
b4eb7656 6129 void *file)
4723351a
CC		 6130{
6131 debug_info **debug_addr_info;
6132 unsigned char *entry;
6133 unsigned char *end;
6134 unsigned int i;
6135 unsigned int count;
6136
6137 if (section->size == 0)
6138 {
6139 printf (_("\nThe %s section is empty.\n"), section->name);
6140 return 0;
6141 }
6142
6143 if (load_debug_info (file) == 0)
6144 {
6145 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6146 section->name);
6147 return 0;
6148 }
6149
6150 printf (_("Contents of the %s section:\n\n"), section->name);
6151
1306a742
NC		 6152 /* PR 17531: file: cf38d01b.
6153 We use xcalloc because a corrupt file may not have initialised all of the
6154 fields in the debug_info structure, which means that the sort below might
6155 try to move uninitialised data. */
6156 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
b4eb7656 6157 sizeof (debug_info *));
4723351a
CC		 6158
6159 count = 0;
6160 for (i = 0; i < num_debug_info_entries; i++)
82b1b41b 6161 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
1306a742
NC		 6162 {
6163 /* PR 17531: file: cf38d01b. */
6164 if (debug_information[i].addr_base >= section->size)
6165 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6166 (unsigned long) debug_information[i].addr_base, i);
6167 else
6168 debug_addr_info [count++] = debug_information + i;
6169 }
4723351a
CC		 6170
6171 /* Add a sentinel to make iteration convenient. */
6172 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
6173 debug_addr_info [count]->addr_base = section->size;
4723351a 6174 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
1306a742 6175
4723351a
CC		 6176 for (i = 0; i < count; i++)
6177 {
6178 unsigned int idx;
fab128ef 6179 unsigned int address_size = debug_addr_info [i]->pointer_size;
4723351a
CC		 6180
6181 printf (_(" For compilation unit at offset 0x%s:\n"),
b4eb7656 6182 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4723351a 6183
fab128ef 6184 printf (_("\tIndex\tAddress\n"));
4723351a
CC		 6185 entry = section->start + debug_addr_info [i]->addr_base;
6186 end = section->start + debug_addr_info [i + 1]->addr_base;
6187 idx = 0;
6188 while (entry < end)
b4eb7656
AM		 6189 {
6190 dwarf_vma base = byte_get (entry, address_size);
6191 printf (_("\t%d:\t"), idx);
6192 print_dwarf_vma (base, address_size);
6193 printf ("\n");
6194 entry += address_size;
6195 idx++;
6196 }
4723351a
CC		 6197 }
6198 printf ("\n");
6199
6200 free (debug_addr_info);
6201 return 1;
6202}
6203
6204/* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6205static int
6206display_debug_str_offsets (struct dwarf_section *section,
b4eb7656 6207 void *file ATTRIBUTE_UNUSED)
4723351a
CC		 6208{
6209 if (section->size == 0)
6210 {
6211 printf (_("\nThe %s section is empty.\n"), section->name);
6212 return 0;
6213 }
6214 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6215 what the offset size is for this section. */
6216 return 1;
6217}
6218
01a8f077
JK		 6219/* Each debug_information[x].range_lists[y] gets this representation for
6220 sorting purposes. */
6221
6222struct range_entry
467c65bc
NC		 6223{
6224 /* The debug_information[x].range_lists[y] value. */
359ca075 6225 dwarf_vma ranges_offset;
01a8f077 6226
467c65bc
NC		 6227 /* Original debug_information to find parameters of the data. */
6228 debug_info *debug_info_p;
6229};
01a8f077
JK		 6230
6231/* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6232
6233static int
6234range_entry_compar (const void *ap, const void *bp)
6235{
3f5e193b
NC		 6236 const struct range_entry *a_re = (const struct range_entry *) ap;
6237 const struct range_entry *b_re = (const struct range_entry *) bp;
359ca075
JK		 6238 const dwarf_vma a = a_re->ranges_offset;
6239 const dwarf_vma b = b_re->ranges_offset;
01a8f077
JK		 6240
6241 return (a > b) - (b > a);
6242}
6243
77145576
JK		 6244static void
6245display_debug_ranges_list (unsigned char *start, unsigned char *finish,
6246 unsigned int pointer_size, unsigned long offset,
6247 unsigned long base_address)
6248{
6249 while (start < finish)
6250 {
6251 dwarf_vma begin;
6252 dwarf_vma end;
6253
6254 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6255 if (start >= finish)
6256 break;
6257 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6258
6259 printf (" %8.8lx ", offset);
6260
6261 if (begin == 0 && end == 0)
6262 {
6263 printf (_("<End of list>\n"));
6264 break;
6265 }
6266
6267 /* Check base address specifiers. */
6268 if (is_max_address (begin, pointer_size)
6269 && !is_max_address (end, pointer_size))
6270 {
6271 base_address = end;
6272 print_dwarf_vma (begin, pointer_size);
6273 print_dwarf_vma (end, pointer_size);
6274 printf ("(base address)\n");
6275 continue;
6276 }
6277
6278 print_dwarf_vma (begin + base_address, pointer_size);
6279 print_dwarf_vma (end + base_address, pointer_size);
6280
6281 if (begin == end)
6282 fputs (_("(start == end)"), stdout);
6283 else if (begin > end)
6284 fputs (_("(start > end)"), stdout);
6285
6286 putchar ('\n');
6287 }
6288}
6289
6290static void
6291display_debug_rnglists_list (unsigned char *start, unsigned char *finish,
6292 unsigned int pointer_size, unsigned long offset,
6293 unsigned long base_address)
6294{
6295 unsigned char *next = start;
6296
6297 while (1)
6298 {
6299 unsigned long off = offset + (start - next);
6300 enum dwarf_range_list_entry rlet;
9dfd0db9
JK		 6301 /* Initialize it due to a false compiler warning. */
6302 dwarf_vma begin = -1, length, end = -1;
77145576
JK		 6303 unsigned int bytes_read;
6304
6305 if (start + 1 > finish)
6306 {
6307 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6308 offset);
6309 break;
6310 }
6311
6312 printf (" %8.8lx ", off);
6313
6314 SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish);
6315
6316 switch (rlet)
6317 {
6318 case DW_RLE_end_of_list:
6319 printf (_("<End of list>\n"));
6320 break;
6321 case DW_RLE_base_address:
6322 SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish);
6323 print_dwarf_vma (base_address, pointer_size);
6324 printf (_("(base address)\n"));
6325 break;
6326 case DW_RLE_start_length:
6327 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6328 length = read_uleb128 (start, &bytes_read, finish);
6329 start += bytes_read;
6330 end = begin + length;
6331 break;
6332 case DW_RLE_offset_pair:
6333 begin = read_uleb128 (start, &bytes_read, finish);
6334 start += bytes_read;
6335 end = read_uleb128 (start, &bytes_read, finish);
6336 start += bytes_read;
6337 break;
6338 case DW_RLE_start_end:
6339 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
6340 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish);
6341 break;
6342 default:
6343 error (_("Invalid range list entry type %d\n"), rlet);
6344 rlet = DW_RLE_end_of_list;
6345 break;
6346 }
6347 if (rlet == DW_RLE_end_of_list)
6348 break;
6349 if (rlet == DW_RLE_base_address)
6350 continue;
6351
6352 print_dwarf_vma (begin + base_address, pointer_size);
6353 print_dwarf_vma (end + base_address, pointer_size);
6354
6355 if (begin == end)
6356 fputs (_("(start == end)"), stdout);
6357 else if (begin > end)
6358 fputs (_("(start > end)"), stdout);
6359
6360 putchar ('\n');
6361 }
6362}
6363
19e6b90e
L		 6364static int
6365display_debug_ranges (struct dwarf_section *section,
6366 void *file ATTRIBUTE_UNUSED)
6367{
6368 unsigned char *start = section->start;
a2ff7a4b 6369 unsigned char *last_start = start;
f6f0e17b 6370 unsigned long bytes = section->size;
19e6b90e 6371 unsigned char *section_begin = start;
f6f0e17b 6372 unsigned char *finish = start + bytes;
01a8f077
JK		 6373 unsigned int num_range_list, i;
6374 struct range_entry *range_entries, *range_entry_fill;
77145576
JK		 6375 int is_rnglists = strstr (section->name, "debug_rnglists") != NULL;
6376 /* Initialize it due to a false compiler warning. */
6377 unsigned char address_size = 0;
19e6b90e 6378
19e6b90e
L		 6379 if (bytes == 0)
6380 {
6381 printf (_("\nThe %s section is empty.\n"), section->name);
6382 return 0;
6383 }
6384
77145576
JK		 6385 if (is_rnglists)
6386 {
6387 dwarf_vma initial_length;
6388 unsigned int initial_length_size;
6389 unsigned char segment_selector_size;
6390 unsigned int offset_size, offset_entry_count;
6391 unsigned short version;
6392
6393 /* Get and check the length of the block. */
6394 SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish);
6395
6396 if (initial_length == 0xffffffff)
6397 {
6398 /* This section is 64-bit DWARF 3. */
6399 SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish);
6400 offset_size = 8;
6401 initial_length_size = 12;
6402 }
6403 else
6404 {
6405 offset_size = 4;
6406 initial_length_size = 4;
6407 }
6408
6409 if (initial_length + initial_length_size > section->size)
6410 {
6411 /* If the length field has a relocation against it, then we should
6412 not complain if it is inaccurate (and probably negative).
6413 It is copied from .debug_line handling code. */
6414 if (reloc_at (section, (start - section->start) - offset_size))
6415 {
6416 initial_length = (finish - start) - initial_length_size;
6417 }
6418 else
6419 {
6420 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6421 (long) initial_length);
6422 return 0;
6423 }
6424 }
6425
6426 /* Get and check the version number. */
6427 SAFE_BYTE_GET_AND_INC (version, start, 2, finish);
6428
6429 if (version != 5)
6430 {
6431 warn (_("Only DWARF version 5 debug_rnglists info "
6432 "is currently supported.\n"));
6433 return 0;
6434 }
6435
6436 SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish);
6437
6438 SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish);
6439 if (segment_selector_size != 0)
6440 {
6441 warn (_("The %s section contains "
6442 "unsupported segment selector size: %d.\n"),
6443 section->name, segment_selector_size);
6444 return 0;
6445 }
6446
6447 SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish);
6448 if (offset_entry_count != 0)
6449 {
6450 warn (_("The %s section contains "
6451 "unsupported offset entry count: %u.\n"),
6452 section->name, offset_entry_count);
6453 return 0;
6454 }
6455 }
6456
1febe64d
NC		 6457 if (load_debug_info (file) == 0)
6458 {
6459 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6460 section->name);
6461 return 0;
6462 }
19e6b90e 6463
01a8f077 6464 num_range_list = 0;
19e6b90e 6465 for (i = 0; i < num_debug_info_entries; i++)
01a8f077 6466 num_range_list += debug_information [i].num_range_lists;
19e6b90e 6467
01a8f077 6468 if (num_range_list == 0)
4723351a
CC		 6469 {
6470 /* This can happen when the file was compiled with -gsplit-debug
b4eb7656 6471 which removes references to range lists from the primary .o file. */
4723351a
CC		 6472 printf (_("No range lists in .debug_info section.\n"));
6473 return 1;
6474 }
19e6b90e 6475
3f5e193b
NC		 6476 range_entries = (struct range_entry *)
6477 xmalloc (sizeof (*range_entries) * num_range_list);
01a8f077 6478 range_entry_fill = range_entries;
19e6b90e 6479
01a8f077
JK		 6480 for (i = 0; i < num_debug_info_entries; i++)
6481 {
6482 debug_info *debug_info_p = &debug_information[i];
6483 unsigned int j;
6484
6485 for (j = 0; j < debug_info_p->num_range_lists; j++)
6486 {
6487 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
6488 range_entry_fill->debug_info_p = debug_info_p;
6489 range_entry_fill++;
19e6b90e
L		 6490 }
6491 }
6492
01a8f077
JK		 6493 qsort (range_entries, num_range_list, sizeof (*range_entries),
6494 range_entry_compar);
19e6b90e 6495
d493b283 6496 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
19e6b90e 6497 warn (_("Range lists in %s section start at 0x%lx\n"),
359ca075 6498 section->name, (unsigned long) range_entries[0].ranges_offset);
19e6b90e
L		 6499
6500 printf (_("Contents of the %s section:\n\n"), section->name);
6501 printf (_(" Offset Begin End\n"));
6502
01a8f077 6503 for (i = 0; i < num_range_list; i++)
19e6b90e 6504 {
01a8f077
JK		 6505 struct range_entry *range_entry = &range_entries[i];
6506 debug_info *debug_info_p = range_entry->debug_info_p;
19e6b90e 6507 unsigned int pointer_size;
359ca075 6508 dwarf_vma offset;
01a8f077 6509 unsigned char *next;
359ca075 6510 dwarf_vma base_address;
19e6b90e 6511
77145576 6512 pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size);
d493b283 6513 offset = range_entry->ranges_offset;
01a8f077
JK		 6514 next = section_begin + offset;
6515 base_address = debug_info_p->base_address;
cecf136e 6516
f41e4712
NC		 6517 /* PR 17512: file: 001-101485-0.001:0.1. */
6518 if (pointer_size < 2 || pointer_size > 8)
6519 {
6520 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
359ca075 6521 pointer_size, (unsigned long) offset);
f41e4712
NC		 6522 continue;
6523 }
b4eb7656 6524
4723351a 6525 if (dwarf_check != 0 && i > 0)
19e6b90e 6526 {
01a8f077
JK		 6527 if (start < next)
6528 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6529 (unsigned long) (start - section_begin),
6530 (unsigned long) (next - section_begin), section->name);
6531 else if (start > next)
a2ff7a4b
AM		 6532 {
6533 if (next == last_start)
6534 continue;
6535 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6536 (unsigned long) (start - section_begin),
6537 (unsigned long) (next - section_begin), section->name);
6538 }
01a8f077
JK		 6539 }
6540 start = next;
a2ff7a4b 6541 last_start = next;
19e6b90e 6542
77145576
JK		 6543 (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list)
6544 (start, finish, pointer_size, offset, base_address);
19e6b90e
L		 6545 }
6546 putchar ('\n');
01a8f077
JK		 6547
6548 free (range_entries);
6549
19e6b90e
L		 6550 return 1;
6551}
6552
6553typedef struct Frame_Chunk
6554{
6555 struct Frame_Chunk *next;
6556 unsigned char *chunk_start;
a1165289 6557 unsigned int ncols;
19e6b90e
L		 6558 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6559 short int *col_type;
6560 int *col_offset;
6561 char *augmentation;
6562 unsigned int code_factor;
6563 int data_factor;
bf5117e3
NC		 6564 dwarf_vma pc_begin;
6565 dwarf_vma pc_range;
19e6b90e 6566 int cfa_reg;
c8071705 6567 dwarf_vma cfa_offset;
a1165289 6568 unsigned int ra;
19e6b90e
L		 6569 unsigned char fde_encoding;
6570 unsigned char cfa_exp;
604282a7
JJ		 6571 unsigned char ptr_size;
6572 unsigned char segment_size;
19e6b90e
L		 6573}
6574Frame_Chunk;
6575
665ce1f6
L		 6576static const char *const *dwarf_regnames;
6577static unsigned int dwarf_regnames_count;
6578
19e6b90e
L		 6579/* A marker for a col_type that means this column was never referenced
6580 in the frame info. */
6581#define DW_CFA_unreferenced (-1)
6582
a1165289 6583/* Return 0 if no more space is needed, 1 if more space is needed,
665ce1f6
L		 6584 -1 for invalid reg. */
6585
6586static int
6587frame_need_space (Frame_Chunk *fc, unsigned int reg)
19e6b90e 6588{
a1165289 6589 unsigned int prev = fc->ncols;
19e6b90e 6590
665ce1f6
L		 6591 if (reg < (unsigned int) fc->ncols)
6592 return 0;
6593
6594 if (dwarf_regnames_count
6595 && reg > dwarf_regnames_count)
6596 return -1;
19e6b90e
L		 6597
6598 fc->ncols = reg + 1;
a1165289
NC		 6599 /* PR 17512: file: 10450-2643-0.004.
6600 If reg == -1 then this can happen... */
6601 if (fc->ncols == 0)
6602 return -1;
6603
06614111
NC		 6604 /* PR 17512: file: 2844a11d. */
6605 if (fc->ncols > 1024)
6606 {
6607 error (_("Unfeasibly large register number: %u\n"), reg);
6608 fc->ncols = 0;
6609 /* FIXME: 1024 is an arbitrary limit. Increase it if
6610 we ever encounter a valid binary that exceeds it. */
6611 return -1;
6612 }
6613
3f5e193b 6614 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
b4eb7656 6615 sizeof (short int));
3f5e193b 6616 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
b4eb7656 6617 /* PR 17512: file:002-10025-0.005. */
041830e0
NC		 6618 if (fc->col_type == NULL || fc->col_offset == NULL)
6619 {
6620 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6621 fc->ncols);
6622 fc->ncols = 0;
6623 return -1;
6624 }
19e6b90e
L		 6625
6626 while (prev < fc->ncols)
6627 {
6628 fc->col_type[prev] = DW_CFA_unreferenced;
6629 fc->col_offset[prev] = 0;
6630 prev++;
6631 }
665ce1f6 6632 return 1;
19e6b90e
L		 6633}
6634
2dc4cec1
L		 6635static const char *const dwarf_regnames_i386[] =
6636{
43234a1e
L		 6637 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6638 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6639 "eip", "eflags", NULL, /* 8 - 10 */
6640 "st0", "st1", "st2", "st3", /* 11 - 14 */
6641 "st4", "st5", "st6", "st7", /* 15 - 18 */
6642 NULL, NULL, /* 19 - 20 */
6643 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6644 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6645 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6646 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6647 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6648 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
6649 "tr", "ldtr", /* 48 - 49 */
6650 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
6651 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
6652 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
6653 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
6654 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
6655 NULL, NULL, NULL, /* 90 - 92 */
6656 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
2dc4cec1
L		 6657};
6658
3d875af5
L		 6659static const char *const dwarf_regnames_iamcu[] =
6660{
6661 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6662 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6663 "eip", "eflags", NULL, /* 8 - 10 */
6664 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */
6665 NULL, NULL, /* 19 - 20 */
6666 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */
6667 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */
6668 NULL, NULL, NULL, /* 37 - 39 */
6669 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
6670 "tr", "ldtr", /* 48 - 49 */
6671 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
6672 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
6673 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
6674 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
6675 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
6676 NULL, NULL, NULL, /* 90 - 92 */
6677 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */
6678};
6679
b129eb0e
RH		 6680void
6681init_dwarf_regnames_i386 (void)
6682{
6683 dwarf_regnames = dwarf_regnames_i386;
6684 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
6685}
6686
3d875af5
L		 6687void
6688init_dwarf_regnames_iamcu (void)
6689{
6690 dwarf_regnames = dwarf_regnames_iamcu;
6691 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
6692}
6693
2dc4cec1
L		 6694static const char *const dwarf_regnames_x86_64[] =
6695{
6696 "rax", "rdx", "rcx", "rbx",
6697 "rsi", "rdi", "rbp", "rsp",
6698 "r8", "r9", "r10", "r11",
6699 "r12", "r13", "r14", "r15",
6700 "rip",
6701 "xmm0", "xmm1", "xmm2", "xmm3",
6702 "xmm4", "xmm5", "xmm6", "xmm7",
6703 "xmm8", "xmm9", "xmm10", "xmm11",
6704 "xmm12", "xmm13", "xmm14", "xmm15",
6705 "st0", "st1", "st2", "st3",
6706 "st4", "st5", "st6", "st7",
6707 "mm0", "mm1", "mm2", "mm3",
6708 "mm4", "mm5", "mm6", "mm7",
6709 "rflags",
6710 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
6711 "fs.base", "gs.base", NULL, NULL,
6712 "tr", "ldtr",
43234a1e
L		 6713 "mxcsr", "fcw", "fsw",
6714 "xmm16", "xmm17", "xmm18", "xmm19",
6715 "xmm20", "xmm21", "xmm22", "xmm23",
6716 "xmm24", "xmm25", "xmm26", "xmm27",
6717 "xmm28", "xmm29", "xmm30", "xmm31",
6718 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
6719 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
6720 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
6721 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
6722 NULL, NULL, NULL, /* 115 - 117 */
6723 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
2dc4cec1
L		 6724};
6725
b129eb0e
RH		 6726void
6727init_dwarf_regnames_x86_64 (void)
6728{
6729 dwarf_regnames = dwarf_regnames_x86_64;
6730 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
6731}
6732
4ee22035
RH		 6733static const char *const dwarf_regnames_aarch64[] =
6734{
b4eb7656
AM		 6735 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
6736 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
4ee22035
RH		 6737 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
6738 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
6739 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
6740 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6741 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6742 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
b4eb7656
AM		 6743 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
6744 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
4ee22035
RH		 6745 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
6746 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6747};
6748
6749void
6750init_dwarf_regnames_aarch64 (void)
6751{
6752 dwarf_regnames = dwarf_regnames_aarch64;
6753 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
6754}
6755
d6bb17b0
AA		 6756static const char *const dwarf_regnames_s390[] =
6757{
6758 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
6759 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6760 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
6761 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
6762 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
6763 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6764 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
6765 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
6766 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
6767 "pswm", "pswa",
6768 NULL, NULL,
6769 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
6770 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
6771};
6772
6773void
6774init_dwarf_regnames_s390 (void)
6775{
6776 dwarf_regnames = dwarf_regnames_s390;
6777 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390);
6778}
6779
2dc4cec1
L		 6780void
6781init_dwarf_regnames (unsigned int e_machine)
6782{
6783 switch (e_machine)
6784 {
6785 case EM_386:
b129eb0e 6786 init_dwarf_regnames_i386 ();
2dc4cec1
L		 6787 break;
6788
3d875af5
L		 6789 case EM_IAMCU:
6790 init_dwarf_regnames_iamcu ();
6791 break;
6792
2dc4cec1 6793 case EM_X86_64:
7f502d6c 6794 case EM_L1OM:
7a9068fe 6795 case EM_K1OM:
b129eb0e 6796 init_dwarf_regnames_x86_64 ();
2dc4cec1
L		 6797 break;
6798
4ee22035
RH		 6799 case EM_AARCH64:
6800 init_dwarf_regnames_aarch64 ();
6801 break;
6802
d6bb17b0
AA		 6803 case EM_S390:
6804 init_dwarf_regnames_s390 ();
6805 break;
6806
2dc4cec1
L		 6807 default:
6808 break;
6809 }
6810}
6811
6812static const char *
6813regname (unsigned int regno, int row)
6814{
6815 static char reg[64];
7f2c8a1d 6816
2dc4cec1
L		 6817 if (dwarf_regnames
6818 && regno < dwarf_regnames_count
6819 && dwarf_regnames [regno] != NULL)
6820 {
6821 if (row)
6822 return dwarf_regnames [regno];
6823 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
6824 dwarf_regnames [regno]);
6825 }
6826 else
6827 snprintf (reg, sizeof (reg), "r%d", regno);
6828 return reg;
6829}
6830
19e6b90e 6831static void
a1165289 6832frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
19e6b90e 6833{
a1165289 6834 unsigned int r;
19e6b90e
L		 6835 char tmp[100];
6836
d8024a91 6837 if (*max_regs != fc->ncols)
19e6b90e
L		 6838 *max_regs = fc->ncols;
6839
6840 if (*need_col_headers)
6841 {
91d6fa6a 6842 static const char *sloc = " LOC";
2dc4cec1 6843
19e6b90e
L		 6844 *need_col_headers = 0;
6845
91d6fa6a 6846 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
19e6b90e
L		 6847
6848 for (r = 0; r < *max_regs; r++)
6849 if (fc->col_type[r] != DW_CFA_unreferenced)
6850 {
6851 if (r == fc->ra)
50751e18 6852 printf ("ra ");
19e6b90e 6853 else
2dc4cec1 6854 printf ("%-5s ", regname (r, 1));
19e6b90e
L		 6855 }
6856
6857 printf ("\n");
6858 }
6859
bf5117e3 6860 print_dwarf_vma (fc->pc_begin, eh_addr_size);
19e6b90e
L		 6861 if (fc->cfa_exp)
6862 strcpy (tmp, "exp");
6863 else
c8071705 6864 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
19e6b90e
L		 6865 printf ("%-8s ", tmp);
6866
6867 for (r = 0; r < fc->ncols; r++)
6868 {
6869 if (fc->col_type[r] != DW_CFA_unreferenced)
6870 {
6871 switch (fc->col_type[r])
6872 {
6873 case DW_CFA_undefined:
6874 strcpy (tmp, "u");
6875 break;
6876 case DW_CFA_same_value:
6877 strcpy (tmp, "s");
6878 break;
6879 case DW_CFA_offset:
6880 sprintf (tmp, "c%+d", fc->col_offset[r]);
6881 break;
12eae2d3
JJ		 6882 case DW_CFA_val_offset:
6883 sprintf (tmp, "v%+d", fc->col_offset[r]);
6884 break;
19e6b90e 6885 case DW_CFA_register:
2dc4cec1 6886 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
19e6b90e
L		 6887 break;
6888 case DW_CFA_expression:
6889 strcpy (tmp, "exp");
6890 break;
12eae2d3
JJ		 6891 case DW_CFA_val_expression:
6892 strcpy (tmp, "vexp");
6893 break;
19e6b90e
L		 6894 default:
6895 strcpy (tmp, "n/a");
6896 break;
6897 }
2dc4cec1 6898 printf ("%-5s ", tmp);
19e6b90e
L		 6899 }
6900 }
6901 printf ("\n");
6902}
6903
49727e46 6904#define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
19e6b90e 6905
49727e46
AM		 6906static unsigned char *
6907read_cie (unsigned char *start, unsigned char *end,
6908 Frame_Chunk **p_cie, int *p_version,
6909 unsigned long *p_aug_len, unsigned char **p_aug)
6910{
6911 int version;
6912 Frame_Chunk *fc;
6913 unsigned int length_return;
6914 unsigned char *augmentation_data = NULL;
6915 unsigned long augmentation_data_len = 0;
6916
041830e0 6917 * p_cie = NULL;
f41e4712
NC		 6918 /* PR 17512: file: 001-228113-0.004. */
6919 if (start >= end)
6920 return end;
6921
49727e46
AM		 6922 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6923 memset (fc, 0, sizeof (Frame_Chunk));
6924
6925 fc->col_type = (short int *) xmalloc (sizeof (short int));
6926 fc->col_offset = (int *) xmalloc (sizeof (int));
6927
6928 version = *start++;
6929
6930 fc->augmentation = (char *) start;
f41e4712
NC		 6931 /* PR 17512: file: 001-228113-0.004.
6932 Skip past augmentation name, but avoid running off the end of the data. */
6933 while (start < end)
6934 if (* start ++ == '\0')
6935 break;
6936 if (start == end)
6937 {
6938 warn (_("No terminator for augmentation name\n"));
6939 return start;
6940 }
49727e46
AM		 6941
6942 if (strcmp (fc->augmentation, "eh") == 0)
6943 start += eh_addr_size;
6944
6945 if (version >= 4)
6946 {
6947 GET (fc->ptr_size, 1);
77ef8654
NC		 6948 if (fc->ptr_size < 1 || fc->ptr_size > 8)
6949 {
6950 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
6951 return end;
6952 }
6953
49727e46 6954 GET (fc->segment_size, 1);
77ef8654
NC		 6955 /* PR 17512: file: e99d2804. */
6956 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
6957 {
6958 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
6959 return end;
6960 }
6961
49727e46
AM		 6962 eh_addr_size = fc->ptr_size;
6963 }
6964 else
6965 {
6966 fc->ptr_size = eh_addr_size;
6967 fc->segment_size = 0;
6968 }
7f2c8a1d
NC		 6969 READ_ULEB (fc->code_factor);
6970 READ_SLEB (fc->data_factor);
49727e46
AM		 6971 if (version == 1)
6972 {
6973 GET (fc->ra, 1);
6974 }
6975 else
6976 {
7f2c8a1d 6977 READ_ULEB (fc->ra);
49727e46
AM		 6978 }
6979
6980 if (fc->augmentation[0] == 'z')
6981 {
7f2c8a1d 6982 READ_ULEB (augmentation_data_len);
49727e46
AM		 6983 augmentation_data = start;
6984 start += augmentation_data_len;
a1165289
NC		 6985 /* PR 17512: file: 11042-2589-0.004. */
6986 if (start > end)
6987 {
7f2c8a1d
NC		 6988 warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"),
6989 augmentation_data_len, (long)((end - start) + augmentation_data_len));
a1165289
NC		 6990 return end;
6991 }
49727e46
AM		 6992 }
6993
6994 if (augmentation_data_len)
6995 {
058037d3
NC		 6996 unsigned char *p;
6997 unsigned char *q;
6998 unsigned char *qend;
b4eb7656 6999
49727e46
AM		 7000 p = (unsigned char *) fc->augmentation + 1;
7001 q = augmentation_data;
058037d3
NC		 7002 qend = q + augmentation_data_len;
7003
7004 /* PR 17531: file: 015adfaa. */
7005 if (qend < q)
7006 {
7007 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
7008 augmentation_data_len = 0;
7009 }
49727e46 7010
a1165289 7011 while (p < end && q < augmentation_data + augmentation_data_len)
49727e46
AM		 7012 {
7013 if (*p == 'L')
7014 q++;
7015 else if (*p == 'P')
7016 q += 1 + size_of_encoded_value (*q);
7017 else if (*p == 'R')
7018 fc->fde_encoding = *q++;
7019 else if (*p == 'S')
7020 ;
7021 else
7022 break;
7023 p++;
7024 }
c361b9ac
NC		 7025 /* Note - it is OK if this loop terminates with q < qend.
7026 Padding may have been inserted to align the end of the CIE. */
49727e46
AM		 7027 }
7028
7029 *p_cie = fc;
7030 if (p_version)
7031 *p_version = version;
7032 if (p_aug_len)
7033 {
7034 *p_aug_len = augmentation_data_len;
7035 *p_aug = augmentation_data;
7036 }
7037 return start;
7038}
7039
19e6b90e
L		 7040static int
7041display_debug_frames (struct dwarf_section *section,
7042 void *file ATTRIBUTE_UNUSED)
7043{
7044 unsigned char *start = section->start;
7045 unsigned char *end = start + section->size;
7046 unsigned char *section_start = start;
49727e46 7047 Frame_Chunk *chunks = 0, *forward_refs = 0;
19e6b90e
L		 7048 Frame_Chunk *remembered_state = 0;
7049 Frame_Chunk *rs;
7050 int is_eh = strcmp (section->name, ".eh_frame") == 0;
7051 unsigned int length_return;
a1165289 7052 unsigned int max_regs = 0;
665ce1f6 7053 const char *bad_reg = _("bad register: ");
77ef8654 7054 unsigned int saved_eh_addr_size = eh_addr_size;
19e6b90e 7055
80c35038 7056 printf (_("Contents of the %s section:\n"), section->name);
19e6b90e
L		 7057
7058 while (start < end)
7059 {
7060 unsigned char *saved_start;
7061 unsigned char *block_end;
bf5117e3
NC		 7062 dwarf_vma length;
7063 dwarf_vma cie_id;
19e6b90e
L		 7064 Frame_Chunk *fc;
7065 Frame_Chunk *cie;
7066 int need_col_headers = 1;
7067 unsigned char *augmentation_data = NULL;
7068 unsigned long augmentation_data_len = 0;
bf5117e3
NC		 7069 unsigned int encoded_ptr_size = saved_eh_addr_size;
7070 unsigned int offset_size;
7071 unsigned int initial_length_size;
5b6312fd 7072 bfd_boolean all_nops;
19e6b90e
L		 7073
7074 saved_start = start;
19e6b90e 7075
0c588247 7076 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
041830e0 7077
19e6b90e
L		 7078 if (length == 0)
7079 {
7080 printf ("\n%08lx ZERO terminator\n\n",
7081 (unsigned long)(saved_start - section_start));
6937bb54
NC		 7082 /* Skip any zero terminators that directly follow.
7083 A corrupt section size could have loaded a whole
7084 slew of zero filled memory bytes. eg
7085 PR 17512: file: 070-19381-0.004. */
7086 while (start < end && * start == 0)
7087 ++ start;
b758e50f 7088 continue;
19e6b90e
L		 7089 }
7090
7091 if (length == 0xffffffff)
7092 {
0c588247 7093 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
19e6b90e
L		 7094 offset_size = 8;
7095 initial_length_size = 12;
7096 }
7097 else
7098 {
7099 offset_size = 4;
7100 initial_length_size = 4;
7101 }
7102
7103 block_end = saved_start + length + initial_length_size;
041830e0 7104 if (block_end > end || block_end < start)
53b8873b 7105 {
bf5117e3
NC		 7106 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7107 dwarf_vmatoa_1 (NULL, length, offset_size),
7108 (unsigned long) (saved_start - section_start));
53b8873b
NC		 7109 block_end = end;
7110 }
0c588247
NC		 7111
7112 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
19e6b90e 7113
846a11e4
NC		 7114 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
7115 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
19e6b90e
L		 7116 {
7117 int version;
a1165289 7118 unsigned int mreg;
19e6b90e 7119
49727e46
AM		 7120 start = read_cie (start, end, &cie, &version,
7121 &augmentation_data_len, &augmentation_data);
041830e0
NC		 7122 /* PR 17512: file: 027-135133-0.005. */
7123 if (cie == NULL)
7124 break;
a1165289 7125
49727e46 7126 fc = cie;
19e6b90e
L		 7127 fc->next = chunks;
7128 chunks = fc;
7129 fc->chunk_start = saved_start;
a1165289 7130 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 7131 if (mreg < fc->ra)
7132 mreg = fc->ra;
06614111
NC		 7133 if (frame_need_space (fc, mreg) < 0)
7134 break;
49727e46
AM		 7135 if (fc->fde_encoding)
7136 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
19e6b90e 7137
bf5117e3
NC		 7138 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
7139 print_dwarf_vma (length, fc->ptr_size);
9c41109d 7140 print_dwarf_vma (cie_id, offset_size);
bf5117e3 7141
19e6b90e 7142 if (do_debug_frames_interp)
bf5117e3
NC		 7143 {
7144 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
7145 fc->code_factor, fc->data_factor, fc->ra);
7146 }
19e6b90e
L		 7147 else
7148 {
bf5117e3 7149 printf ("CIE\n");
19e6b90e
L		 7150 printf (" Version: %d\n", version);
7151 printf (" Augmentation: \"%s\"\n", fc->augmentation);
604282a7
JJ		 7152 if (version >= 4)
7153 {
7154 printf (" Pointer Size: %u\n", fc->ptr_size);
7155 printf (" Segment Size: %u\n", fc->segment_size);
7156 }
19e6b90e
L		 7157 printf (" Code alignment factor: %u\n", fc->code_factor);
7158 printf (" Data alignment factor: %d\n", fc->data_factor);
7159 printf (" Return address column: %d\n", fc->ra);
7160
7161 if (augmentation_data_len)
7162 {
7163 unsigned long i;
a1165289 7164
19e6b90e
L		 7165 printf (" Augmentation data: ");
7166 for (i = 0; i < augmentation_data_len; ++i)
a1165289
NC		 7167 /* FIXME: If do_wide is FALSE, then we should
7168 add carriage returns at 80 columns... */
19e6b90e
L		 7169 printf (" %02x", augmentation_data[i]);
7170 putchar ('\n');
7171 }
7172 putchar ('\n');
7173 }
19e6b90e
L		 7174 }
7175 else
7176 {
7177 unsigned char *look_for;
7178 static Frame_Chunk fde_fc;
604282a7 7179 unsigned long segment_selector;
19e6b90e 7180
49727e46
AM		 7181 if (is_eh)
7182 {
7183 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
7184 look_for = start - 4 - ((cie_id ^ sign) - sign);
7185 }
7186 else
7187 look_for = section_start + cie_id;
19e6b90e 7188
49727e46
AM		 7189 if (look_for <= saved_start)
7190 {
7191 for (cie = chunks; cie ; cie = cie->next)
7192 if (cie->chunk_start == look_for)
7193 break;
7194 }
7195 else
7196 {
7197 for (cie = forward_refs; cie ; cie = cie->next)
7198 if (cie->chunk_start == look_for)
7199 break;
7200 if (!cie)
7201 {
7202 unsigned int off_size;
7203 unsigned char *cie_scan;
19e6b90e 7204
49727e46
AM		 7205 cie_scan = look_for;
7206 off_size = 4;
7207 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
7208 if (length == 0xffffffff)
7209 {
7210 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
7211 off_size = 8;
7212 }
7213 if (length != 0)
7214 {
7215 dwarf_vma c_id;
7216
7217 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
7218 if (is_eh
7219 ? c_id == 0
7220 : ((off_size == 4 && c_id == DW_CIE_ID)
7221 || (off_size == 8 && c_id == DW64_CIE_ID)))
7222 {
7223 int version;
a1165289 7224 unsigned int mreg;
49727e46
AM		 7225
7226 read_cie (cie_scan, end, &cie, &version,
7227 &augmentation_data_len, &augmentation_data);
a1165289
NC		 7228 /* PR 17512: file: 3450-2098-0.004. */
7229 if (cie == NULL)
7230 {
7231 warn (_("Failed to read CIE information\n"));
7232 break;
7233 }
49727e46
AM		 7234 cie->next = forward_refs;
7235 forward_refs = cie;
7236 cie->chunk_start = look_for;
a1165289 7237 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 7238 if (mreg < cie->ra)
7239 mreg = cie->ra;
06614111
NC		 7240 if (frame_need_space (cie, mreg) < 0)
7241 {
7242 warn (_("Invalid max register\n"));
7243 break;
7244 }
49727e46
AM		 7245 if (cie->fde_encoding)
7246 encoded_ptr_size
7247 = size_of_encoded_value (cie->fde_encoding);
7248 }
7249 }
7250 }
7251 }
7252
7253 fc = &fde_fc;
7254 memset (fc, 0, sizeof (Frame_Chunk));
19e6b90e
L		 7255
7256 if (!cie)
7257 {
bf5117e3
NC		 7258 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7259 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
7260 (unsigned long) (saved_start - section_start));
19e6b90e 7261 fc->ncols = 0;
3f5e193b
NC		 7262 fc->col_type = (short int *) xmalloc (sizeof (short int));
7263 fc->col_offset = (int *) xmalloc (sizeof (int));
06614111
NC		 7264 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
7265 {
7266 warn (_("Invalid max register\n"));
7267 break;
7268 }
19e6b90e
L		 7269 cie = fc;
7270 fc->augmentation = "";
7271 fc->fde_encoding = 0;
604282a7
JJ		 7272 fc->ptr_size = eh_addr_size;
7273 fc->segment_size = 0;
19e6b90e
L		 7274 }
7275 else
7276 {
7277 fc->ncols = cie->ncols;
3f5e193b
NC		 7278 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
7279 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
19e6b90e
L		 7280 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7281 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7282 fc->augmentation = cie->augmentation;
604282a7
JJ		 7283 fc->ptr_size = cie->ptr_size;
7284 eh_addr_size = cie->ptr_size;
7285 fc->segment_size = cie->segment_size;
19e6b90e
L		 7286 fc->code_factor = cie->code_factor;
7287 fc->data_factor = cie->data_factor;
7288 fc->cfa_reg = cie->cfa_reg;
7289 fc->cfa_offset = cie->cfa_offset;
7290 fc->ra = cie->ra;
06614111
NC		 7291 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
7292 {
7293 warn (_("Invalid max register\n"));
7294 break;
7295 }
19e6b90e
L		 7296 fc->fde_encoding = cie->fde_encoding;
7297 }
7298
7299 if (fc->fde_encoding)
7300 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7301
604282a7
JJ		 7302 segment_selector = 0;
7303 if (fc->segment_size)
c8071705
NC		 7304 {
7305 if (fc->segment_size > sizeof (segment_selector))
7306 {
7307 /* PR 17512: file: 9e196b3e. */
7308 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
7309 fc->segment_size = 4;
7310 }
7311 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
7312 }
041830e0
NC		 7313
7314 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
19e6b90e 7315
0c588247
NC		 7316 /* FIXME: It appears that sometimes the final pc_range value is
7317 encoded in less than encoded_ptr_size bytes. See the x86_64
7318 run of the "objcopy on compressed debug sections" test for an
7319 example of this. */
7320 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
bf5117e3 7321
19e6b90e
L		 7322 if (cie->augmentation[0] == 'z')
7323 {
7f2c8a1d 7324 READ_ULEB (augmentation_data_len);
19e6b90e
L		 7325 augmentation_data = start;
7326 start += augmentation_data_len;
0a9d414a 7327 /* PR 17512: file: 722-8446-0.004. */
53774b7e 7328 if (start >= end || ((signed long) augmentation_data_len) < 0)
0a9d414a
NC		 7329 {
7330 warn (_("Corrupt augmentation data length: %lx\n"),
7331 augmentation_data_len);
7332 start = end;
7333 augmentation_data = NULL;
7334 augmentation_data_len = 0;
7335 }
19e6b90e
L		 7336 }
7337
bf5117e3
NC		 7338 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7339 (unsigned long)(saved_start - section_start),
7340 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
9c41109d 7341 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
604282a7 7342 (unsigned long)(cie->chunk_start - section_start));
bf5117e3 7343
604282a7
JJ		 7344 if (fc->segment_size)
7345 printf ("%04lx:", segment_selector);
bf5117e3
NC		 7346
7347 printf ("%s..%s\n",
7348 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
7349 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
7350
19e6b90e
L		 7351 if (! do_debug_frames_interp && augmentation_data_len)
7352 {
7353 unsigned long i;
7354
7355 printf (" Augmentation data: ");
7356 for (i = 0; i < augmentation_data_len; ++i)
7357 printf (" %02x", augmentation_data[i]);
7358 putchar ('\n');
7359 putchar ('\n');
7360 }
7361 }
7362
7363 /* At this point, fc is the current chunk, cie (if any) is set, and
7364 we're about to interpret instructions for the chunk. */
7365 /* ??? At present we need to do this always, since this sizes the
7366 fc->col_type and fc->col_offset arrays, which we write into always.
7367 We should probably split the interpreted and non-interpreted bits
7368 into two different routines, since there's so much that doesn't
7369 really overlap between them. */
7370 if (1 || do_debug_frames_interp)
7371 {
7372 /* Start by making a pass over the chunk, allocating storage
7373 and taking note of what registers are used. */
7374 unsigned char *tmp = start;
7375
7376 while (start < block_end)
7377 {
041830e0
NC		 7378 unsigned int reg, op, opa;
7379 unsigned long temp;
5929c344 7380 unsigned char * new_start;
19e6b90e
L		 7381
7382 op = *start++;
7383 opa = op & 0x3f;
7384 if (op & 0xc0)
7385 op &= 0xc0;
7386
7387 /* Warning: if you add any more cases to this switch, be
7388 sure to add them to the corresponding switch below. */
7389 switch (op)
7390 {
7391 case DW_CFA_advance_loc:
7392 break;
7393 case DW_CFA_offset:
7f2c8a1d 7394 SKIP_ULEB ();
665ce1f6
L		 7395 if (frame_need_space (fc, opa) >= 0)
7396 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 7397 break;
7398 case DW_CFA_restore:
665ce1f6
L		 7399 if (frame_need_space (fc, opa) >= 0)
7400 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 7401 break;
7402 case DW_CFA_set_loc:
7403 start += encoded_ptr_size;
7404 break;
7405 case DW_CFA_advance_loc1:
7406 start += 1;
7407 break;
7408 case DW_CFA_advance_loc2:
7409 start += 2;
7410 break;
7411 case DW_CFA_advance_loc4:
7412 start += 4;
7413 break;
7414 case DW_CFA_offset_extended:
12eae2d3 7415 case DW_CFA_val_offset:
7f2c8a1d
NC		 7416 READ_ULEB (reg);
7417 SKIP_ULEB ();
665ce1f6
L		 7418 if (frame_need_space (fc, reg) >= 0)
7419 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7420 break;
7421 case DW_CFA_restore_extended:
7f2c8a1d 7422 READ_ULEB (reg);
665ce1f6
L		 7423 if (frame_need_space (fc, reg) >= 0)
7424 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7425 break;
7426 case DW_CFA_undefined:
7f2c8a1d 7427 READ_ULEB (reg);
665ce1f6
L		 7428 if (frame_need_space (fc, reg) >= 0)
7429 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7430 break;
7431 case DW_CFA_same_value:
7f2c8a1d 7432 READ_ULEB (reg);
665ce1f6
L		 7433 if (frame_need_space (fc, reg) >= 0)
7434 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7435 break;
7436 case DW_CFA_register:
7f2c8a1d
NC		 7437 READ_ULEB (reg);
7438 SKIP_ULEB ();
665ce1f6
L		 7439 if (frame_need_space (fc, reg) >= 0)
7440 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7441 break;
7442 case DW_CFA_def_cfa:
7f2c8a1d
NC		 7443 SKIP_ULEB ();
7444 SKIP_ULEB ();
19e6b90e
L		 7445 break;
7446 case DW_CFA_def_cfa_register:
7f2c8a1d 7447 SKIP_ULEB ();
19e6b90e
L		 7448 break;
7449 case DW_CFA_def_cfa_offset:
7f2c8a1d 7450 SKIP_ULEB ();
19e6b90e
L		 7451 break;
7452 case DW_CFA_def_cfa_expression:
7f2c8a1d 7453 READ_ULEB (temp);
5929c344
NC		 7454 new_start = start + temp;
7455 if (new_start < start)
041830e0
NC		 7456 {
7457 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
7458 start = block_end;
7459 }
7460 else
5929c344 7461 start = new_start;
19e6b90e
L		 7462 break;
7463 case DW_CFA_expression:
12eae2d3 7464 case DW_CFA_val_expression:
7f2c8a1d
NC		 7465 READ_ULEB (reg);
7466 READ_ULEB (temp);
5929c344
NC		 7467 new_start = start + temp;
7468 if (new_start < start)
041830e0 7469 {
b4eb7656 7470 /* PR 17512: file:306-192417-0.005. */
041830e0
NC		 7471 warn (_("Corrupt CFA expression value: %lu\n"), temp);
7472 start = block_end;
7473 }
7474 else
5929c344 7475 start = new_start;
665ce1f6
L		 7476 if (frame_need_space (fc, reg) >= 0)
7477 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7478 break;
7479 case DW_CFA_offset_extended_sf:
12eae2d3 7480 case DW_CFA_val_offset_sf:
7f2c8a1d
NC		 7481 READ_ULEB (reg);
7482 SKIP_SLEB ();
665ce1f6
L		 7483 if (frame_need_space (fc, reg) >= 0)
7484 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 7485 break;
7486 case DW_CFA_def_cfa_sf:
7f2c8a1d
NC		 7487 SKIP_ULEB ();
7488 SKIP_SLEB ();
19e6b90e
L		 7489 break;
7490 case DW_CFA_def_cfa_offset_sf:
7f2c8a1d 7491 SKIP_SLEB ();
19e6b90e
L		 7492 break;
7493 case DW_CFA_MIPS_advance_loc8:
7494 start += 8;
7495 break;
7496 case DW_CFA_GNU_args_size:
7f2c8a1d 7497 SKIP_ULEB ();
19e6b90e
L		 7498 break;
7499 case DW_CFA_GNU_negative_offset_extended:
7f2c8a1d
NC		 7500 READ_ULEB (reg);
7501 SKIP_ULEB ();
665ce1f6
L		 7502 if (frame_need_space (fc, reg) >= 0)
7503 fc->col_type[reg] = DW_CFA_undefined;
7504 break;
19e6b90e
L		 7505 default:
7506 break;
7507 }
7508 }
7509 start = tmp;
7510 }
7511
5b6312fd
NC		 7512 all_nops = TRUE;
7513
19e6b90e
L		 7514 /* Now we know what registers are used, make a second pass over
7515 the chunk, this time actually printing out the info. */
7516
7517 while (start < block_end)
7518 {
362beea4 7519 unsigned char * tmp;
19e6b90e 7520 unsigned op, opa;
7f2c8a1d
NC		 7521 unsigned long ul, roffs;
7522 /* Note: It is tempting to use an unsigned long for 'reg' but there
7523 are various functions, notably frame_space_needed() that assume that
7524 reg is an unsigned int. */
7525 unsigned int reg;
7526 dwarf_signed_vma l;
bf5117e3 7527 dwarf_vma ofs;
19e6b90e 7528 dwarf_vma vma;
665ce1f6 7529 const char *reg_prefix = "";
19e6b90e
L		 7530
7531 op = *start++;
7532 opa = op & 0x3f;
7533 if (op & 0xc0)
7534 op &= 0xc0;
7535
5b6312fd
NC		 7536 /* Make a note if something other than DW_CFA_nop happens. */
7537 if (op != DW_CFA_nop)
7538 all_nops = FALSE;
7539
19e6b90e
L		 7540 /* Warning: if you add any more cases to this switch, be
7541 sure to add them to the corresponding switch above. */
7542 switch (op)
7543 {
7544 case DW_CFA_advance_loc:
7545 if (do_debug_frames_interp)
7546 frame_display_row (fc, &need_col_headers, &max_regs);
7547 else
bf5117e3 7548 printf (" DW_CFA_advance_loc: %d to %s\n",
19e6b90e 7549 opa * fc->code_factor,
b4eb7656 7550 dwarf_vmatoa_1 (NULL,
bf5117e3
NC		 7551 fc->pc_begin + opa * fc->code_factor,
7552 fc->ptr_size));
19e6b90e
L		 7553 fc->pc_begin += opa * fc->code_factor;
7554 break;
7555
7556 case DW_CFA_offset:
7f2c8a1d 7557 READ_ULEB (roffs);
665ce1f6
L		 7558 if (opa >= (unsigned int) fc->ncols)
7559 reg_prefix = bad_reg;
7560 if (! do_debug_frames_interp || *reg_prefix != '\0')
7561 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7562 reg_prefix, regname (opa, 0),
7563 roffs * fc->data_factor);
7564 if (*reg_prefix == '\0')
7565 {
7566 fc->col_type[opa] = DW_CFA_offset;
7567 fc->col_offset[opa] = roffs * fc->data_factor;
7568 }
19e6b90e
L		 7569 break;
7570
7571 case DW_CFA_restore:
50751e18 7572 if (opa >= (unsigned int) fc->ncols)
665ce1f6
L		 7573 reg_prefix = bad_reg;
7574 if (! do_debug_frames_interp || *reg_prefix != '\0')
7575 printf (" DW_CFA_restore: %s%s\n",
7576 reg_prefix, regname (opa, 0));
50751e18
AK		 7577 if (*reg_prefix != '\0')
7578 break;
7579
7580 if (opa >= (unsigned int) cie->ncols
7581 || (do_debug_frames_interp
7582 && cie->col_type[opa] == DW_CFA_unreferenced))
7583 {
7584 fc->col_type[opa] = DW_CFA_undefined;
7585 fc->col_offset[opa] = 0;
7586 }
7587 else
665ce1f6
L		 7588 {
7589 fc->col_type[opa] = cie->col_type[opa];
7590 fc->col_offset[opa] = cie->col_offset[opa];
7591 }
19e6b90e
L		 7592 break;
7593
7594 case DW_CFA_set_loc:
6937bb54 7595 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
19e6b90e
L		 7596 if (do_debug_frames_interp)
7597 frame_display_row (fc, &need_col_headers, &max_regs);
7598 else
bf5117e3
NC		 7599 printf (" DW_CFA_set_loc: %s\n",
7600 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
19e6b90e
L		 7601 fc->pc_begin = vma;
7602 break;
7603
7604 case DW_CFA_advance_loc1:
0c588247 7605 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
19e6b90e
L		 7606 if (do_debug_frames_interp)
7607 frame_display_row (fc, &need_col_headers, &max_regs);
7608 else
bf5117e3
NC		 7609 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7610 (unsigned long) (ofs * fc->code_factor),
7611 dwarf_vmatoa_1 (NULL,
7612 fc->pc_begin + ofs * fc->code_factor,
7613 fc->ptr_size));
19e6b90e
L		 7614 fc->pc_begin += ofs * fc->code_factor;
7615 break;
7616
7617 case DW_CFA_advance_loc2:
6937bb54 7618 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
19e6b90e
L		 7619 if (do_debug_frames_interp)
7620 frame_display_row (fc, &need_col_headers, &max_regs);
7621 else
bf5117e3
NC		 7622 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7623 (unsigned long) (ofs * fc->code_factor),
7624 dwarf_vmatoa_1 (NULL,
7625 fc->pc_begin + ofs * fc->code_factor,
7626 fc->ptr_size));
19e6b90e
L		 7627 fc->pc_begin += ofs * fc->code_factor;
7628 break;
7629
7630 case DW_CFA_advance_loc4:
6937bb54 7631 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
19e6b90e
L		 7632 if (do_debug_frames_interp)
7633 frame_display_row (fc, &need_col_headers, &max_regs);
7634 else
bf5117e3
NC		 7635 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7636 (unsigned long) (ofs * fc->code_factor),
7637 dwarf_vmatoa_1 (NULL,
7638 fc->pc_begin + ofs * fc->code_factor,
7639 fc->ptr_size));
19e6b90e
L		 7640 fc->pc_begin += ofs * fc->code_factor;
7641 break;
7642
7643 case DW_CFA_offset_extended:
7f2c8a1d
NC		 7644 READ_ULEB (reg);
7645 READ_ULEB (roffs);
665ce1f6
L		 7646 if (reg >= (unsigned int) fc->ncols)
7647 reg_prefix = bad_reg;
7648 if (! do_debug_frames_interp || *reg_prefix != '\0')
7649 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7650 reg_prefix, regname (reg, 0),
7651 roffs * fc->data_factor);
7652 if (*reg_prefix == '\0')
7653 {
7654 fc->col_type[reg] = DW_CFA_offset;
7655 fc->col_offset[reg] = roffs * fc->data_factor;
7656 }
19e6b90e
L		 7657 break;
7658
12eae2d3 7659 case DW_CFA_val_offset:
7f2c8a1d
NC		 7660 READ_ULEB (reg);
7661 READ_ULEB (roffs);
665ce1f6
L		 7662 if (reg >= (unsigned int) fc->ncols)
7663 reg_prefix = bad_reg;
7664 if (! do_debug_frames_interp || *reg_prefix != '\0')
084303b8 7665 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
665ce1f6
L		 7666 reg_prefix, regname (reg, 0),
7667 roffs * fc->data_factor);
7668 if (*reg_prefix == '\0')
7669 {
7670 fc->col_type[reg] = DW_CFA_val_offset;
7671 fc->col_offset[reg] = roffs * fc->data_factor;
7672 }
12eae2d3
JJ		 7673 break;
7674
19e6b90e 7675 case DW_CFA_restore_extended:
7f2c8a1d 7676 READ_ULEB (reg);
50751e18 7677 if (reg >= (unsigned int) fc->ncols)
665ce1f6
L		 7678 reg_prefix = bad_reg;
7679 if (! do_debug_frames_interp || *reg_prefix != '\0')
7680 printf (" DW_CFA_restore_extended: %s%s\n",
7681 reg_prefix, regname (reg, 0));
50751e18
AK		 7682 if (*reg_prefix != '\0')
7683 break;
7684
7685 if (reg >= (unsigned int) cie->ncols)
7686 {
7687 fc->col_type[reg] = DW_CFA_undefined;
7688 fc->col_offset[reg] = 0;
7689 }
7690 else
665ce1f6
L		 7691 {
7692 fc->col_type[reg] = cie->col_type[reg];
7693 fc->col_offset[reg] = cie->col_offset[reg];
7694 }
19e6b90e
L		 7695 break;
7696
7697 case DW_CFA_undefined:
7f2c8a1d 7698 READ_ULEB (reg);
665ce1f6
L		 7699 if (reg >= (unsigned int) fc->ncols)
7700 reg_prefix = bad_reg;
7701 if (! do_debug_frames_interp || *reg_prefix != '\0')
7702 printf (" DW_CFA_undefined: %s%s\n",
7703 reg_prefix, regname (reg, 0));
7704 if (*reg_prefix == '\0')
7705 {
7706 fc->col_type[reg] = DW_CFA_undefined;
7707 fc->col_offset[reg] = 0;
7708 }
19e6b90e
L		 7709 break;
7710
7711 case DW_CFA_same_value:
7f2c8a1d 7712 READ_ULEB (reg);
665ce1f6
L		 7713 if (reg >= (unsigned int) fc->ncols)
7714 reg_prefix = bad_reg;
7715 if (! do_debug_frames_interp || *reg_prefix != '\0')
7716 printf (" DW_CFA_same_value: %s%s\n",
7717 reg_prefix, regname (reg, 0));
7718 if (*reg_prefix == '\0')
7719 {
7720 fc->col_type[reg] = DW_CFA_same_value;
7721 fc->col_offset[reg] = 0;
7722 }
19e6b90e
L		 7723 break;
7724
7725 case DW_CFA_register:
7f2c8a1d
NC		 7726 READ_ULEB (reg);
7727 READ_ULEB (roffs);
665ce1f6
L		 7728 if (reg >= (unsigned int) fc->ncols)
7729 reg_prefix = bad_reg;
7730 if (! do_debug_frames_interp || *reg_prefix != '\0')
2dc4cec1 7731 {
665ce1f6
L		 7732 printf (" DW_CFA_register: %s%s in ",
7733 reg_prefix, regname (reg, 0));
2dc4cec1
L		 7734 puts (regname (roffs, 0));
7735 }
665ce1f6
L		 7736 if (*reg_prefix == '\0')
7737 {
7738 fc->col_type[reg] = DW_CFA_register;
7739 fc->col_offset[reg] = roffs;
7740 }
19e6b90e
L		 7741 break;
7742
7743 case DW_CFA_remember_state:
7744 if (! do_debug_frames_interp)
7745 printf (" DW_CFA_remember_state\n");
3f5e193b 7746 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
b4eb7656 7747 rs->cfa_offset = fc->cfa_offset;
d71ad7fc
RC		 7748 rs->cfa_reg = fc->cfa_reg;
7749 rs->ra = fc->ra;
7750 rs->cfa_exp = fc->cfa_exp;
19e6b90e 7751 rs->ncols = fc->ncols;
3f5e193b 7752 rs->col_type = (short int *) xcmalloc (rs->ncols,
b4eb7656 7753 sizeof (* rs->col_type));
d71ad7fc
RC		 7754 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
7755 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
7756 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
19e6b90e
L		 7757 rs->next = remembered_state;
7758 remembered_state = rs;
7759 break;
7760
7761 case DW_CFA_restore_state:
7762 if (! do_debug_frames_interp)
7763 printf (" DW_CFA_restore_state\n");
7764 rs = remembered_state;
7765 if (rs)
7766 {
7767 remembered_state = rs->next;
d71ad7fc
RC		 7768 fc->cfa_offset = rs->cfa_offset;
7769 fc->cfa_reg = rs->cfa_reg;
b4eb7656
AM		 7770 fc->ra = rs->ra;
7771 fc->cfa_exp = rs->cfa_exp;
06614111
NC		 7772 if (frame_need_space (fc, rs->ncols - 1) < 0)
7773 {
1306a742 7774 warn (_("Invalid column number in saved frame state\n"));
06614111
NC		 7775 fc->ncols = 0;
7776 break;
7777 }
d71ad7fc 7778 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
19e6b90e 7779 memcpy (fc->col_offset, rs->col_offset,
d71ad7fc 7780 rs->ncols * sizeof (* rs->col_offset));
19e6b90e
L		 7781 free (rs->col_type);
7782 free (rs->col_offset);
7783 free (rs);
7784 }
7785 else if (do_debug_frames_interp)
7786 printf ("Mismatched DW_CFA_restore_state\n");
7787 break;
7788
7789 case DW_CFA_def_cfa:
7f2c8a1d
NC		 7790 READ_SLEB (fc->cfa_reg);
7791 READ_ULEB (fc->cfa_offset);
19e6b90e
L		 7792 fc->cfa_exp = 0;
7793 if (! do_debug_frames_interp)
2dc4cec1 7794 printf (" DW_CFA_def_cfa: %s ofs %d\n",
c8071705 7795 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
19e6b90e
L		 7796 break;
7797
7798 case DW_CFA_def_cfa_register:
7f2c8a1d 7799 READ_SLEB (fc->cfa_reg);
19e6b90e
L		 7800 fc->cfa_exp = 0;
7801 if (! do_debug_frames_interp)
2dc4cec1
L		 7802 printf (" DW_CFA_def_cfa_register: %s\n",
7803 regname (fc->cfa_reg, 0));
19e6b90e
L		 7804 break;
7805
7806 case DW_CFA_def_cfa_offset:
7f2c8a1d 7807 READ_ULEB (fc->cfa_offset);
19e6b90e 7808 if (! do_debug_frames_interp)
c8071705 7809 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
19e6b90e
L		 7810 break;
7811
7812 case DW_CFA_nop:
7813 if (! do_debug_frames_interp)
7814 printf (" DW_CFA_nop\n");
7815 break;
7816
7817 case DW_CFA_def_cfa_expression:
7f2c8a1d 7818 READ_ULEB (ul);
7460c0ab 7819 if (start >= block_end || ul > (unsigned long) (block_end - start))
6937bb54 7820 {
a1165289 7821 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 7822 break;
7823 }
19e6b90e
L		 7824 if (! do_debug_frames_interp)
7825 {
7826 printf (" DW_CFA_def_cfa_expression (");
b7807392
JJ		 7827 decode_location_expression (start, eh_addr_size, 0, -1,
7828 ul, 0, section);
19e6b90e
L		 7829 printf (")\n");
7830 }
7831 fc->cfa_exp = 1;
7832 start += ul;
7833 break;
7834
7835 case DW_CFA_expression:
7f2c8a1d
NC		 7836 READ_ULEB (reg);
7837 READ_ULEB (ul);
665ce1f6
L		 7838 if (reg >= (unsigned int) fc->ncols)
7839 reg_prefix = bad_reg;
6937bb54 7840 /* PR 17512: file: 069-133014-0.006. */
06614111 7841 /* PR 17512: file: 98c02eb4. */
362beea4
NC		 7842 tmp = start + ul;
7843 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 7844 {
a1165289 7845 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 7846 break;
7847 }
665ce1f6 7848 if (! do_debug_frames_interp || *reg_prefix != '\0')
19e6b90e 7849 {
665ce1f6
L		 7850 printf (" DW_CFA_expression: %s%s (",
7851 reg_prefix, regname (reg, 0));
b7807392 7852 decode_location_expression (start, eh_addr_size, 0, -1,
f1c4cc75 7853 ul, 0, section);
19e6b90e
L		 7854 printf (")\n");
7855 }
665ce1f6
L		 7856 if (*reg_prefix == '\0')
7857 fc->col_type[reg] = DW_CFA_expression;
362beea4 7858 start = tmp;
19e6b90e
L		 7859 break;
7860
12eae2d3 7861 case DW_CFA_val_expression:
7f2c8a1d
NC		 7862 READ_ULEB (reg);
7863 READ_ULEB (ul);
665ce1f6
L		 7864 if (reg >= (unsigned int) fc->ncols)
7865 reg_prefix = bad_reg;
362beea4
NC		 7866 tmp = start + ul;
7867 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 7868 {
a1165289 7869 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6937bb54
NC		 7870 break;
7871 }
665ce1f6 7872 if (! do_debug_frames_interp || *reg_prefix != '\0')
12eae2d3 7873 {
665ce1f6
L		 7874 printf (" DW_CFA_val_expression: %s%s (",
7875 reg_prefix, regname (reg, 0));
b7807392
JJ		 7876 decode_location_expression (start, eh_addr_size, 0, -1,
7877 ul, 0, section);
12eae2d3
JJ		 7878 printf (")\n");
7879 }
665ce1f6
L		 7880 if (*reg_prefix == '\0')
7881 fc->col_type[reg] = DW_CFA_val_expression;
362beea4 7882 start = tmp;
12eae2d3
JJ		 7883 break;
7884
19e6b90e 7885 case DW_CFA_offset_extended_sf:
7f2c8a1d
NC		 7886 READ_ULEB (reg);
7887 READ_SLEB (l);
665ce1f6
L		 7888 if (frame_need_space (fc, reg) < 0)
7889 reg_prefix = bad_reg;
7890 if (! do_debug_frames_interp || *reg_prefix != '\0')
7891 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
7892 reg_prefix, regname (reg, 0),
c8071705 7893 (long)(l * fc->data_factor));
665ce1f6
L		 7894 if (*reg_prefix == '\0')
7895 {
7896 fc->col_type[reg] = DW_CFA_offset;
7897 fc->col_offset[reg] = l * fc->data_factor;
7898 }
19e6b90e
L		 7899 break;
7900
12eae2d3 7901 case DW_CFA_val_offset_sf:
7f2c8a1d
NC		 7902 READ_ULEB (reg);
7903 READ_SLEB (l);
665ce1f6
L		 7904 if (frame_need_space (fc, reg) < 0)
7905 reg_prefix = bad_reg;
7906 if (! do_debug_frames_interp || *reg_prefix != '\0')
084303b8 7907 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
665ce1f6 7908 reg_prefix, regname (reg, 0),
c8071705 7909 (long)(l * fc->data_factor));
665ce1f6
L		 7910 if (*reg_prefix == '\0')
7911 {
7912 fc->col_type[reg] = DW_CFA_val_offset;
7913 fc->col_offset[reg] = l * fc->data_factor;
7914 }
12eae2d3
JJ		 7915 break;
7916
19e6b90e 7917 case DW_CFA_def_cfa_sf:
7f2c8a1d
NC		 7918 READ_SLEB (fc->cfa_reg);
7919 READ_ULEB (fc->cfa_offset);
19e6b90e
L		 7920 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
7921 fc->cfa_exp = 0;
7922 if (! do_debug_frames_interp)
2dc4cec1 7923 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
c8071705 7924 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
19e6b90e
L		 7925 break;
7926
7927 case DW_CFA_def_cfa_offset_sf:
7f2c8a1d 7928 READ_ULEB (fc->cfa_offset);
c8071705 7929 fc->cfa_offset *= fc->data_factor;
19e6b90e 7930 if (! do_debug_frames_interp)
c8071705 7931 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
19e6b90e
L		 7932 break;
7933
7934 case DW_CFA_MIPS_advance_loc8:
6937bb54 7935 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
19e6b90e
L		 7936 if (do_debug_frames_interp)
7937 frame_display_row (fc, &need_col_headers, &max_regs);
7938 else
bf5117e3
NC		 7939 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
7940 (unsigned long) (ofs * fc->code_factor),
7941 dwarf_vmatoa_1 (NULL,
7942 fc->pc_begin + ofs * fc->code_factor,
7943 fc->ptr_size));
19e6b90e
L		 7944 fc->pc_begin += ofs * fc->code_factor;
7945 break;
7946
7947 case DW_CFA_GNU_window_save:
7948 if (! do_debug_frames_interp)
7949 printf (" DW_CFA_GNU_window_save\n");
7950 break;
7951
7952 case DW_CFA_GNU_args_size:
7f2c8a1d 7953 READ_ULEB (ul);
19e6b90e
L		 7954 if (! do_debug_frames_interp)
7955 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
7956 break;
7957
7958 case DW_CFA_GNU_negative_offset_extended:
7f2c8a1d
NC		 7959 READ_ULEB (reg);
7960 READ_SLEB (l);
7961 l = - l;
665ce1f6
L		 7962 if (frame_need_space (fc, reg) < 0)
7963 reg_prefix = bad_reg;
7964 if (! do_debug_frames_interp || *reg_prefix != '\0')
7965 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
7966 reg_prefix, regname (reg, 0),
c8071705 7967 (long)(l * fc->data_factor));
665ce1f6
L		 7968 if (*reg_prefix == '\0')
7969 {
7970 fc->col_type[reg] = DW_CFA_offset;
7971 fc->col_offset[reg] = l * fc->data_factor;
7972 }
19e6b90e
L		 7973 break;
7974
7975 default:
53b8873b
NC		 7976 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
7977 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
7978 else
f41e4712 7979 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
19e6b90e
L		 7980 start = block_end;
7981 }
7982 }
7983
5b6312fd
NC		 7984 /* Interpret the CFA - as long as it is not completely full of NOPs. */
7985 if (do_debug_frames_interp && ! all_nops)
19e6b90e
L		 7986 frame_display_row (fc, &need_col_headers, &max_regs);
7987
7988 start = block_end;
604282a7 7989 eh_addr_size = saved_eh_addr_size;
19e6b90e
L		 7990 }
7991
7992 printf ("\n");
7993
7994 return 1;
7995}
7996
7997#undef GET
19e6b90e 7998
61364358
JK		 7999static int
8000display_debug_names (struct dwarf_section *section, void *file)
8001{
8002 unsigned char *hdrptr = section->start;
8003 dwarf_vma unit_length;
8004 unsigned char *unit_start;
8005 const unsigned char *const section_end = section->start + section->size;
8006 unsigned char *unit_end;
8007
8008 printf (_("Contents of the %s section:\n"), section->name);
8009
8010 load_debug_section (str, file);
8011
8012 for (; hdrptr < section_end; hdrptr = unit_end)
8013 {
8014 unsigned int offset_size;
8015 uint16_t dwarf_version, padding;
8016 uint32_t comp_unit_count, local_type_unit_count, foreign_type_unit_count;
8017 uint32_t bucket_count, name_count, abbrev_table_size;
8018 uint32_t augmentation_string_size;
8019 unsigned int i;
8020
8021 unit_start = hdrptr;
8022
8023 /* Get and check the length of the block. */
8024 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 4, section_end);
8025
8026 if (unit_length == 0xffffffff)
8027 {
8028 /* This section is 64-bit DWARF. */
8029 SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 8, section_end);
8030 offset_size = 8;
8031 }
8032 else
8033 offset_size = 4;
8034 unit_end = hdrptr + unit_length;
8035
8036 if ((hdrptr - section->start) + unit_length > section->size)
8037 {
8038 warn (_("The length field (0x%lx) for unit 0x%lx in the debug_names "
8039 "header is wrong - the section is too small\n"),
8040 (long) unit_length, (long) (unit_start - section->start));
8041 return 0;
8042 }
8043
8044 /* Get and check the version number. */
8045 SAFE_BYTE_GET_AND_INC (dwarf_version, hdrptr, 2, unit_end);
8046 printf (_("Version %ld\n"), (long) dwarf_version);
8047
8048 /* Prior versions did not exist, and future versions may not be
8049 backwards compatible. */
8050 if (dwarf_version != 5)
8051 {
8052 warn (_("Only DWARF version 5 .debug_names "
8053 "is currently supported.\n"));
8054 return 0;
8055 }
8056
8057 SAFE_BYTE_GET_AND_INC (padding, hdrptr, 2, unit_end);
8058 if (padding != 0)
8059 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8060 padding);
8061
8062 SAFE_BYTE_GET_AND_INC (comp_unit_count, hdrptr, 4, unit_end);
8063 if (comp_unit_count == 0)
8064 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8065
8066 SAFE_BYTE_GET_AND_INC (local_type_unit_count, hdrptr, 4, unit_end);
8067 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count, hdrptr, 4, unit_end);
8068 SAFE_BYTE_GET_AND_INC (bucket_count, hdrptr, 4, unit_end);
8069 SAFE_BYTE_GET_AND_INC (name_count, hdrptr, 4, unit_end);
8070 SAFE_BYTE_GET_AND_INC (abbrev_table_size, hdrptr, 4, unit_end);
8071
8072 SAFE_BYTE_GET_AND_INC (augmentation_string_size, hdrptr, 4, unit_end);
8073 if (augmentation_string_size % 4 != 0)
8074 {
8075 warn (_("Augmentation string length %u must be rounded up "
8076 "to a multiple of 4 in .debug_names.\n"),
8077 augmentation_string_size);
8078 augmentation_string_size += (-augmentation_string_size) & 3;
8079 }
8080 printf (_("Augmentation string:"));
8081 for (i = 0; i < augmentation_string_size; i++)
8082 {
8083 unsigned char uc;
8084
8085 SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end);
8086 printf (" %02x", uc);
8087 }
8088 putchar ('\n');
8089 putchar ('\n');
8090
8091 printf (_("CU table:\n"));
8092 for (i = 0; i < comp_unit_count; i++)
8093 {
8094 uint64_t cu_offset;
8095
8096 SAFE_BYTE_GET_AND_INC (cu_offset, hdrptr, offset_size, unit_end);
8097 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) cu_offset);
8098 }
8099 putchar ('\n');
8100
8101 printf (_("TU table:\n"));
8102 for (i = 0; i < local_type_unit_count; i++)
8103 {
8104 uint64_t tu_offset;
8105
8106 SAFE_BYTE_GET_AND_INC (tu_offset, hdrptr, offset_size, unit_end);
8107 printf (_("[%3u] 0x%lx\n"), i, (unsigned long) tu_offset);
8108 }
8109 putchar ('\n');
8110
8111 printf (_("Foreign TU table:\n"));
8112 for (i = 0; i < foreign_type_unit_count; i++)
8113 {
8114 uint64_t signature;
8115
8116 SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, unit_end);
8117 printf (_("[%3u] "), i);
8118 print_dwarf_vma (signature, 8);
8119 putchar ('\n');
8120 }
8121 putchar ('\n');
8122
8123 const uint32_t *const hash_table_buckets = (uint32_t *) hdrptr;
8124 hdrptr += bucket_count * sizeof (uint32_t);
8125 const uint32_t *const hash_table_hashes = (uint32_t *) hdrptr;
8126 hdrptr += name_count * sizeof (uint32_t);
8127 unsigned char *const name_table_string_offsets = hdrptr;
8128 hdrptr += name_count * offset_size;
8129 unsigned char *const name_table_entry_offsets = hdrptr;
8130 hdrptr += name_count * offset_size;
8131 unsigned char *const abbrev_table = hdrptr;
8132 hdrptr += abbrev_table_size;
8133 const unsigned char *const abbrev_table_end = hdrptr;
8134 unsigned char *const entry_pool = hdrptr;
8135 if (hdrptr > unit_end)
8136 {
8137 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8138 "for unit 0x%lx in the debug_names\n"),
8139 (long) (hdrptr - section->start),
8140 (long) (unit_end - section->start),
8141 (long) (unit_start - section->start));
8142 return 0;
8143 }
8144
8145 size_t buckets_filled = 0;
8146 size_t bucketi;
8147 for (bucketi = 0; bucketi < bucket_count; bucketi++)
8148 {
8149 const uint32_t bucket = hash_table_buckets[bucketi];
8150
8151 if (bucket != 0)
8152 ++buckets_filled;
8153 }
8154 printf (_("Used %zu of %lu buckets.\n"), buckets_filled,
8155 (unsigned long) bucket_count);
8156
0a79bef4 8157 uint32_t hash_prev = 0;
61364358
JK		 8158 size_t hash_clash_count = 0;
8159 size_t longest_clash = 0;
8160 size_t this_length = 0;
8161 size_t hashi;
8162 for (hashi = 0; hashi < name_count; hashi++)
8163 {
8164 const uint32_t hash_this = hash_table_hashes[hashi];
8165
8166 if (hashi > 0)
8167 {
8168 if (hash_prev % bucket_count == hash_this % bucket_count)
8169 {
8170 ++hash_clash_count;
8171 ++this_length;
8172 longest_clash = MAX (longest_clash, this_length);
8173 }
8174 else
8175 this_length = 0;
8176 }
8177 hash_prev = hash_this;
8178 }
8179 printf (_("Out of %lu items there are %zu bucket clashes"
8180 " (longest of %zu entries).\n"),
8181 (unsigned long) name_count, hash_clash_count, longest_clash);
8182 assert (name_count == buckets_filled + hash_clash_count);
8183
8184 struct abbrev_lookup_entry
8185 {
8186 dwarf_vma abbrev_tag;
8187 unsigned char *abbrev_lookup_ptr;
8188 };
8189 struct abbrev_lookup_entry *abbrev_lookup = NULL;
8190 size_t abbrev_lookup_used = 0;
8191 size_t abbrev_lookup_allocated = 0;
8192
8193 unsigned char *abbrevptr = abbrev_table;
8194 for (;;)
8195 {
8196 unsigned int bytes_read;
8197 const dwarf_vma abbrev_tag = read_uleb128 (abbrevptr, &bytes_read,
8198 abbrev_table_end);
8199 abbrevptr += bytes_read;
8200 if (abbrev_tag == 0)
8201 break;
8202 if (abbrev_lookup_used == abbrev_lookup_allocated)
8203 {
8204 abbrev_lookup_allocated = MAX (0x100,
8205 abbrev_lookup_allocated * 2);
8206 abbrev_lookup = xrealloc (abbrev_lookup,
8207 (abbrev_lookup_allocated
8208 * sizeof (*abbrev_lookup)));
8209 }
8210 assert (abbrev_lookup_used < abbrev_lookup_allocated);
8211 struct abbrev_lookup_entry *entry;
8212 for (entry = abbrev_lookup;
8213 entry < abbrev_lookup + abbrev_lookup_used;
8214 entry++)
8215 if (entry->abbrev_tag == abbrev_tag)
8216 {
8217 warn (_("Duplicate abbreviation tag %lu "
8218 "in unit 0x%lx in the debug_names\n"),
8219 (long) abbrev_tag, (long) (unit_start - section->start));
8220 break;
8221 }
8222 entry = &abbrev_lookup[abbrev_lookup_used++];
8223 entry->abbrev_tag = abbrev_tag;
8224 entry->abbrev_lookup_ptr = abbrevptr;
8225
8226 /* Skip DWARF tag. */
8227 read_uleb128 (abbrevptr, &bytes_read, abbrev_table_end);
8228 abbrevptr += bytes_read;
8229 for (;;)
8230 {
1d827a72
L		 8231 const dwarf_vma xindex = read_uleb128 (abbrevptr,
8232 &bytes_read,
8233 abbrev_table_end);
61364358
JK		 8234 abbrevptr += bytes_read;
8235 const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8236 abbrev_table_end);
8237 abbrevptr += bytes_read;
1d827a72 8238 if (xindex == 0 && form == 0)
61364358
JK		 8239 break;
8240 }
8241 }
8242
8243 printf (_("\nSymbol table:\n"));
8244 uint32_t namei;
8245 for (namei = 0; namei < name_count; ++namei)
8246 {
8247 uint64_t string_offset, entry_offset;
8248
8249 SAFE_BYTE_GET (string_offset,
8250 name_table_string_offsets + namei * offset_size,
8251 offset_size, unit_end);
8252 SAFE_BYTE_GET (entry_offset,
8253 name_table_entry_offsets + namei * offset_size,
8254 offset_size, unit_end);
8255
8256 printf ("[%3u] #%08x %s:", namei, hash_table_hashes[namei],
8257 fetch_indirect_string (string_offset));
8258
8259 unsigned char *entryptr = entry_pool + entry_offset;
8260
8261 // We need to scan first whether there is a single or multiple
8262 // entries. TAGNO is -2 for the first entry, it is -1 for the
8263 // initial tag read of the second entry, then it becomes 0 for the
8264 // first entry for real printing etc.
8265 int tagno = -2;
8266 /* Initialize it due to a false compiler warning. */
8267 dwarf_vma second_abbrev_tag = -1;
8268 for (;;)
8269 {
8270 unsigned int bytes_read;
8271 const dwarf_vma abbrev_tag = read_uleb128 (entryptr, &bytes_read,
8272 unit_end);
8273 entryptr += bytes_read;
8274 if (tagno == -1)
8275 {
8276 second_abbrev_tag = abbrev_tag;
8277 tagno = 0;
8278 entryptr = entry_pool + entry_offset;
8279 continue;
8280 }
8281 if (abbrev_tag == 0)
8282 break;
8283 if (tagno >= 0)
8284 printf ("%s<%lu>",
8285 (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"),
8286 (unsigned long) abbrev_tag);
8287
8288 const struct abbrev_lookup_entry *entry;
8289 for (entry = abbrev_lookup;
8290 entry < abbrev_lookup + abbrev_lookup_used;
8291 entry++)
8292 if (entry->abbrev_tag == abbrev_tag)
8293 break;
8294 if (entry >= abbrev_lookup + abbrev_lookup_used)
8295 {
8296 warn (_("Undefined abbreviation tag %lu "
8297 "in unit 0x%lx in the debug_names\n"),
8298 (long) abbrev_tag,
8299 (long) (unit_start - section->start));
8300 break;
8301 }
8302 abbrevptr = entry->abbrev_lookup_ptr;
8303 const dwarf_vma dwarf_tag = read_uleb128 (abbrevptr, &bytes_read,
8304 abbrev_table_end);
8305 abbrevptr += bytes_read;
8306 if (tagno >= 0)
8307 printf (" %s", get_TAG_name (dwarf_tag));
8308 for (;;)
8309 {
1d827a72
L		 8310 const dwarf_vma xindex = read_uleb128 (abbrevptr,
8311 &bytes_read,
8312 abbrev_table_end);
61364358
JK		 8313 abbrevptr += bytes_read;
8314 const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read,
8315 abbrev_table_end);
8316 abbrevptr += bytes_read;
1d827a72 8317 if (xindex == 0 && form == 0)
61364358
JK		 8318 break;
8319
8320 if (tagno >= 0)
1d827a72 8321 printf (" %s", get_IDX_name (xindex));
61364358
JK		 8322 entryptr = read_and_display_attr_value (0, form, 0, entryptr,
8323 unit_end, 0, 0,
8324 offset_size,
8325 dwarf_version, NULL,
8326 (tagno < 0), NULL,
8327 NULL, '=');
8328 }
8329 ++tagno;
8330 }
8331 if (tagno <= 0)
8332 printf (_(" <no entries>"));
8333 putchar ('\n');
8334 }
8335
8336 free (abbrev_lookup);
8337 }
8338
8339 return 1;
8340}
8341
5bbdf3d5
DE		 8342static int
8343display_gdb_index (struct dwarf_section *section,
8344 void *file ATTRIBUTE_UNUSED)
8345{
8346 unsigned char *start = section->start;
8347 uint32_t version;
8348 uint32_t cu_list_offset, tu_list_offset;
8349 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
8350 unsigned int cu_list_elements, tu_list_elements;
8351 unsigned int address_table_size, symbol_table_slots;
8352 unsigned char *cu_list, *tu_list;
8353 unsigned char *address_table, *symbol_table, *constant_pool;
8354 unsigned int i;
8355
8356 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8357
8358 printf (_("Contents of the %s section:\n"), section->name);
8359
8360 if (section->size < 6 * sizeof (uint32_t))
8361 {
8362 warn (_("Truncated header in the %s section.\n"), section->name);
8363 return 0;
8364 }
8365
8366 version = byte_get_little_endian (start, 4);
da88a764 8367 printf (_("Version %ld\n"), (long) version);
5bbdf3d5
DE		 8368
8369 /* Prior versions are obsolete, and future versions may not be
8370 backwards compatible. */
aa170720 8371 if (version < 3 || version > 8)
5bbdf3d5 8372 {
da88a764 8373 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5bbdf3d5
DE		 8374 return 0;
8375 }
8d6eee87
TT		 8376 if (version < 4)
8377 warn (_("The address table data in version 3 may be wrong.\n"));
8378 if (version < 5)
8379 warn (_("Version 4 does not support case insensitive lookups.\n"));
8380 if (version < 6)
8381 warn (_("Version 5 does not include inlined functions.\n"));
8382 if (version < 7)
8383 warn (_("Version 6 does not include symbol attributes.\n"));
aa170720
DE		 8384 /* Version 7 indices generated by Gold have bad type unit references,
8385 PR binutils/15021. But we don't know if the index was generated by
8386 Gold or not, so to avoid worrying users with gdb-generated indices
8387 we say nothing for version 7 here. */
5bbdf3d5
DE		 8388
8389 cu_list_offset = byte_get_little_endian (start + 4, 4);
8390 tu_list_offset = byte_get_little_endian (start + 8, 4);
8391 address_table_offset = byte_get_little_endian (start + 12, 4);
8392 symbol_table_offset = byte_get_little_endian (start + 16, 4);
8393 constant_pool_offset = byte_get_little_endian (start + 20, 4);
8394
8395 if (cu_list_offset > section->size
8396 || tu_list_offset > section->size
8397 || address_table_offset > section->size
8398 || symbol_table_offset > section->size
8399 || constant_pool_offset > section->size)
8400 {
8401 warn (_("Corrupt header in the %s section.\n"), section->name);
8402 return 0;
8403 }
8404
53774b7e
NC		 8405 /* PR 17531: file: 418d0a8a. */
8406 if (tu_list_offset < cu_list_offset)
8407 {
8408 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8409 tu_list_offset, cu_list_offset);
8410 return 0;
8411 }
8412
5bbdf3d5 8413 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
53774b7e
NC		 8414
8415 if (address_table_offset < tu_list_offset)
8416 {
8417 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8418 address_table_offset, tu_list_offset);
8419 return 0;
8420 }
8421
5bbdf3d5 8422 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
53774b7e
NC		 8423
8424 /* PR 17531: file: 18a47d3d. */
8425 if (symbol_table_offset < address_table_offset)
8426 {
13bace4a 8427 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
53774b7e
NC		 8428 symbol_table_offset, address_table_offset);
8429 return 0;
8430 }
8431
5bbdf3d5 8432 address_table_size = symbol_table_offset - address_table_offset;
53774b7e
NC		 8433
8434 if (constant_pool_offset < symbol_table_offset)
8435 {
8436 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8437 constant_pool_offset, symbol_table_offset);
8438 return 0;
8439 }
8440
5bbdf3d5
DE		 8441 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
8442
8443 cu_list = start + cu_list_offset;
8444 tu_list = start + tu_list_offset;
8445 address_table = start + address_table_offset;
8446 symbol_table = start + symbol_table_offset;
8447 constant_pool = start + constant_pool_offset;
8448
28d909e5 8449 if (address_table + address_table_size > section->start + section->size)
acff9664 8450 {
1306a742 8451 warn (_("Address table extends beyond end of section.\n"));
acff9664
NC		 8452 return 0;
8453 }
b4eb7656 8454
5bbdf3d5
DE		 8455 printf (_("\nCU table:\n"));
8456 for (i = 0; i < cu_list_elements; i += 2)
8457 {
8458 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
8459 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
8460
8461 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
8462 (unsigned long) cu_offset,
8463 (unsigned long) (cu_offset + cu_length - 1));
8464 }
8465
8466 printf (_("\nTU table:\n"));
8467 for (i = 0; i < tu_list_elements; i += 3)
8468 {
8469 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
8470 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
8471 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
8472
8473 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
8474 (unsigned long) tu_offset,
8475 (unsigned long) type_offset);
8476 print_dwarf_vma (signature, 8);
8477 printf ("\n");
8478 }
8479
8480 printf (_("\nAddress table:\n"));
acff9664
NC		 8481 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
8482 i += 2 * 8 + 4)
5bbdf3d5
DE		 8483 {
8484 uint64_t low = byte_get_little_endian (address_table + i, 8);
8485 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
8486 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
8487
8488 print_dwarf_vma (low, 8);
8489 print_dwarf_vma (high, 8);
da88a764 8490 printf (_("%lu\n"), (unsigned long) cu_index);
5bbdf3d5
DE		 8491 }
8492
8493 printf (_("\nSymbol table:\n"));
8494 for (i = 0; i < symbol_table_slots; ++i)
8495 {
8496 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
8497 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
8498 uint32_t num_cus, cu;
8499
8500 if (name_offset != 0
8501 || cu_vector_offset != 0)
8502 {
8503 unsigned int j;
362beea4 8504 unsigned char * adr;
5bbdf3d5 8505
362beea4 8506 adr = constant_pool + name_offset;
53774b7e 8507 /* PR 17531: file: 5b7b07ad. */
362beea4 8508 if (adr < constant_pool || adr >= section->start + section->size)
53774b7e
NC		 8509 {
8510 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
8511 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8512 name_offset, i);
8513 }
8514 else
acff9664
NC		 8515 printf ("[%3u] %.*s:", i,
8516 (int) (section->size - (constant_pool_offset + name_offset)),
8517 constant_pool + name_offset);
53774b7e 8518
362beea4
NC		 8519 adr = constant_pool + cu_vector_offset;
8520 if (adr < constant_pool || adr >= section->start + section->size - 3)
53774b7e
NC		 8521 {
8522 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
8523 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8524 cu_vector_offset, i);
8525 continue;
8526 }
57028622 8527
362beea4 8528 num_cus = byte_get_little_endian (adr, 4);
53774b7e 8529
362beea4 8530 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
acff9664 8531 if (num_cus * 4 < num_cus
362beea4
NC		 8532 || adr >= section->start + section->size
8533 || adr < constant_pool)
53774b7e
NC		 8534 {
8535 printf ("<invalid number of CUs: %d>\n", num_cus);
acff9664 8536 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
53774b7e
NC		 8537 num_cus, i);
8538 continue;
8539 }
8540
8d6eee87
TT		 8541 if (num_cus > 1)
8542 printf ("\n");
f3853b34 8543
5bbdf3d5
DE		 8544 for (j = 0; j < num_cus; ++j)
8545 {
7c1cef97 8546 int is_static;
8d6eee87
TT		 8547 gdb_index_symbol_kind kind;
8548
5bbdf3d5 8549 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
7c1cef97 8550 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
8d6eee87
TT		 8551 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
8552 cu = GDB_INDEX_CU_VALUE (cu);
5bbdf3d5 8553 /* Convert to TU number if it's for a type unit. */
ad6b52dd 8554 if (cu >= cu_list_elements / 2)
8d6eee87
TT		 8555 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
8556 (unsigned long) (cu - cu_list_elements / 2));
5bbdf3d5 8557 else
8d6eee87
TT		 8558 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
8559
459d52c8
DE		 8560 printf (" [%s, %s]",
8561 is_static ? _("static") : _("global"),
8562 get_gdb_index_symbol_kind_name (kind));
8d6eee87
TT		 8563 if (num_cus > 1)
8564 printf ("\n");
5bbdf3d5 8565 }
8d6eee87
TT		 8566 if (num_cus <= 1)
8567 printf ("\n");
5bbdf3d5
DE		 8568 }
8569 }
8570
8571 return 1;
8572}
8573
657d0d47
CC		 8574/* Pre-allocate enough space for the CU/TU sets needed. */
8575
8576static void
8577prealloc_cu_tu_list (unsigned int nshndx)
8578{
8579 if (shndx_pool == NULL)
8580 {
8581 shndx_pool_size = nshndx;
8582 shndx_pool_used = 0;
8583 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
8584 sizeof (unsigned int));
8585 }
8586 else
8587 {
8588 shndx_pool_size = shndx_pool_used + nshndx;
8589 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
8590 sizeof (unsigned int));
8591 }
8592}
8593
8594static void
8595add_shndx_to_cu_tu_entry (unsigned int shndx)
8596{
8597 if (shndx_pool_used >= shndx_pool_size)
8598 {
8599 error (_("Internal error: out of space in the shndx pool.\n"));
8600 return;
8601 }
8602 shndx_pool [shndx_pool_used++] = shndx;
8603}
8604
8605static void
8606end_cu_tu_entry (void)
8607{
8608 if (shndx_pool_used >= shndx_pool_size)
8609 {
8610 error (_("Internal error: out of space in the shndx pool.\n"));
8611 return;
8612 }
8613 shndx_pool [shndx_pool_used++] = 0;
8614}
8615
341f9135
CC		 8616/* Return the short name of a DWARF section given by a DW_SECT enumerator. */
8617
8618static const char *
8619get_DW_SECT_short_name (unsigned int dw_sect)
8620{
8621 static char buf[16];
8622
8623 switch (dw_sect)
8624 {
8625 case DW_SECT_INFO:
8626 return "info";
8627 case DW_SECT_TYPES:
8628 return "types";
8629 case DW_SECT_ABBREV:
8630 return "abbrev";
8631 case DW_SECT_LINE:
8632 return "line";
8633 case DW_SECT_LOC:
8634 return "loc";
8635 case DW_SECT_STR_OFFSETS:
8636 return "str_off";
8637 case DW_SECT_MACINFO:
8638 return "macinfo";
8639 case DW_SECT_MACRO:
8640 return "macro";
8641 default:
b4eb7656 8642 break;
341f9135
CC		 8643 }
8644
8645 snprintf (buf, sizeof (buf), "%d", dw_sect);
8646 return buf;
8647}
8648
8649/* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
8650 These sections are extensions for Fission.
8651 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
657d0d47
CC		 8652
8653static int
8654process_cu_tu_index (struct dwarf_section *section, int do_display)
8655{
8656 unsigned char *phdr = section->start;
8657 unsigned char *limit = phdr + section->size;
8658 unsigned char *phash;
8659 unsigned char *pindex;
8660 unsigned char *ppool;
8661 unsigned int version;
341f9135 8662 unsigned int ncols = 0;
657d0d47
CC		 8663 unsigned int nused;
8664 unsigned int nslots;
8665 unsigned int i;
341f9135
CC		 8666 unsigned int j;
8667 dwarf_vma signature_high;
8668 dwarf_vma signature_low;
8669 char buf[64];
657d0d47 8670
6937bb54
NC		 8671 /* PR 17512: file: 002-168123-0.004. */
8672 if (phdr == NULL)
8673 {
8674 warn (_("Section %s is empty\n"), section->name);
8675 return 0;
8676 }
8677 /* PR 17512: file: 002-376-0.004. */
8678 if (section->size < 24)
8679 {
72c61a0d 8680 warn (_("Section %s is too small to contain a CU/TU header\n"),
6937bb54
NC		 8681 section->name);
8682 return 0;
8683 }
8684
8685 SAFE_BYTE_GET (version, phdr, 4, limit);
341f9135 8686 if (version >= 2)
6937bb54
NC		 8687 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
8688 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
8689 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
8690
657d0d47
CC		 8691 phash = phdr + 16;
8692 pindex = phash + nslots * 8;
8693 ppool = pindex + nslots * 4;
8694
57028622 8695 /* PR 17531: file: 45d69832. */
03a91817 8696 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
57028622
NC		 8697 {
8698 warn (_("Section %s is too small for %d slots\n"),
8699 section->name, nslots);
8700 return 0;
8701 }
8702
657d0d47
CC		 8703 if (do_display)
8704 {
8705 printf (_("Contents of the %s section:\n\n"), section->name);
8706 printf (_(" Version: %d\n"), version);
341f9135
CC		 8707 if (version >= 2)
8708 printf (_(" Number of columns: %d\n"), ncols);
657d0d47
CC		 8709 printf (_(" Number of used entries: %d\n"), nused);
8710 printf (_(" Number of slots: %d\n\n"), nslots);
8711 }
8712
03a91817 8713 if (ppool > limit || ppool < phdr)
657d0d47
CC		 8714 {
8715 warn (_("Section %s too small for %d hash table entries\n"),
8716 section->name, nslots);
8717 return 0;
8718 }
8719
341f9135 8720 if (version == 1)
657d0d47 8721 {
341f9135
CC		 8722 if (!do_display)
8723 prealloc_cu_tu_list ((limit - ppool) / 4);
8724 for (i = 0; i < nslots; i++)
657d0d47 8725 {
341f9135
CC		 8726 unsigned char *shndx_list;
8727 unsigned int shndx;
8728
6937bb54 8729 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
341f9135 8730 if (signature_high != 0 || signature_low != 0)
657d0d47 8731 {
6937bb54 8732 SAFE_BYTE_GET (j, pindex, 4, limit);
341f9135 8733 shndx_list = ppool + j * 4;
f3853b34
NC		 8734 /* PR 17531: file: 705e010d. */
8735 if (shndx_list < ppool)
8736 {
8737 warn (_("Section index pool located before start of section\n"));
8738 return 0;
8739 }
8740
341f9135
CC		 8741 if (do_display)
8742 printf (_(" [%3d] Signature: 0x%s Sections: "),
8743 i, dwarf_vmatoa64 (signature_high, signature_low,
8744 buf, sizeof (buf)));
8745 for (;;)
657d0d47 8746 {
341f9135
CC		 8747 if (shndx_list >= limit)
8748 {
8749 warn (_("Section %s too small for shndx pool\n"),
8750 section->name);
8751 return 0;
8752 }
6937bb54 8753 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
341f9135
CC		 8754 if (shndx == 0)
8755 break;
8756 if (do_display)
8757 printf (" %d", shndx);
8758 else
8759 add_shndx_to_cu_tu_entry (shndx);
8760 shndx_list += 4;
657d0d47 8761 }
657d0d47 8762 if (do_display)
341f9135 8763 printf ("\n");
657d0d47 8764 else
341f9135
CC		 8765 end_cu_tu_entry ();
8766 }
8767 phash += 8;
8768 pindex += 4;
8769 }
8770 }
8771 else if (version == 2)
8772 {
8773 unsigned int val;
8774 unsigned int dw_sect;
8775 unsigned char *ph = phash;
8776 unsigned char *pi = pindex;
8777 unsigned char *poffsets = ppool + ncols * 4;
8778 unsigned char *psizes = poffsets + nused * ncols * 4;
8779 unsigned char *pend = psizes + nused * ncols * 4;
8780 bfd_boolean is_tu_index;
8781 struct cu_tu_set *this_set = NULL;
8782 unsigned int row;
8783 unsigned char *prow;
8784
8785 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
8786
362beea4 8787 /* PR 17531: file: 0dd159bf.
b4eb7656 8788 Check for wraparound with an overlarge ncols value. */
c8071705 8789 if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
362beea4
NC		 8790 {
8791 warn (_("Overlarge number of columns: %x\n"), ncols);
8792 return 0;
8793 }
8794
341f9135
CC		 8795 if (pend > limit)
8796 {
8797 warn (_("Section %s too small for offset and size tables\n"),
8798 section->name);
8799 return 0;
8800 }
8801
8802 if (do_display)
8803 {
8804 printf (_(" Offset table\n"));
8805 printf (" slot %-16s ",
8806 is_tu_index ? _("signature") : _("dwo_id"));
8807 }
8808 else
8809 {
8810 if (is_tu_index)
8811 {
8812 tu_count = nused;
72c61a0d 8813 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135 8814 this_set = tu_sets;
657d0d47 8815 }
657d0d47 8816 else
341f9135
CC		 8817 {
8818 cu_count = nused;
72c61a0d 8819 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135
CC		 8820 this_set = cu_sets;
8821 }
8822 }
6937bb54 8823
341f9135
CC		 8824 if (do_display)
8825 {
8826 for (j = 0; j < ncols; j++)
8827 {
6937bb54 8828 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
341f9135
CC		 8829 printf (" %8s", get_DW_SECT_short_name (dw_sect));
8830 }
8831 printf ("\n");
8832 }
6937bb54 8833
341f9135
CC		 8834 for (i = 0; i < nslots; i++)
8835 {
6937bb54
NC		 8836 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8837
8838 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 8839 if (row != 0)
8840 {
591f7597 8841 /* PR 17531: file: a05f6ab3. */
ef77750e 8842 if (row > nused)
591f7597
NC		 8843 {
8844 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
8845 row, nused);
8846 return 0;
8847 }
8848
341f9135
CC		 8849 if (!do_display)
8850 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6937bb54 8851
341f9135 8852 prow = poffsets + (row - 1) * ncols * 4;
ffc0f143
NC		 8853 /* PR 17531: file: b8ce60a8. */
8854 if (prow < poffsets || prow > limit)
8855 {
8856 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
8857 row, ncols);
8858 return 0;
8859 }
3aade688 8860
341f9135
CC		 8861 if (do_display)
8862 printf (_(" [%3d] 0x%s"),
8863 i, dwarf_vmatoa64 (signature_high, signature_low,
8864 buf, sizeof (buf)));
8865 for (j = 0; j < ncols; j++)
8866 {
6937bb54 8867 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 8868 if (do_display)
8869 printf (" %8d", val);
8870 else
8871 {
6937bb54 8872 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 8873
8874 /* PR 17531: file: 10796eb3. */
8875 if (dw_sect >= DW_SECT_MAX)
8876 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8877 else
8878 this_set [row - 1].section_offsets [dw_sect] = val;
341f9135
CC		 8879 }
8880 }
6937bb54 8881
341f9135
CC		 8882 if (do_display)
8883 printf ("\n");
8884 }
8885 ph += 8;
8886 pi += 4;
8887 }
8888
8889 ph = phash;
8890 pi = pindex;
8891 if (do_display)
b4eb7656 8892 {
341f9135
CC		 8893 printf ("\n");
8894 printf (_(" Size table\n"));
8895 printf (" slot %-16s ",
8896 is_tu_index ? _("signature") : _("dwo_id"));
b4eb7656 8897 }
6937bb54 8898
341f9135
CC		 8899 for (j = 0; j < ncols; j++)
8900 {
6937bb54 8901 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
341f9135
CC		 8902 if (do_display)
8903 printf (" %8s", get_DW_SECT_short_name (val));
8904 }
6937bb54 8905
341f9135
CC		 8906 if (do_display)
8907 printf ("\n");
6937bb54 8908
341f9135
CC		 8909 for (i = 0; i < nslots; i++)
8910 {
6937bb54
NC		 8911 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
8912
8913 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 8914 if (row != 0)
8915 {
8916 prow = psizes + (row - 1) * ncols * 4;
6937bb54 8917
341f9135
CC		 8918 if (do_display)
8919 printf (_(" [%3d] 0x%s"),
8920 i, dwarf_vmatoa64 (signature_high, signature_low,
8921 buf, sizeof (buf)));
6937bb54 8922
341f9135
CC		 8923 for (j = 0; j < ncols; j++)
8924 {
6937bb54 8925 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 8926 if (do_display)
8927 printf (" %8d", val);
8928 else
8929 {
6937bb54 8930 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 8931 if (dw_sect >= DW_SECT_MAX)
8932 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
8933 else
341f9135
CC		 8934 this_set [row - 1].section_sizes [dw_sect] = val;
8935 }
8936 }
6937bb54 8937
341f9135
CC		 8938 if (do_display)
8939 printf ("\n");
8940 }
6937bb54 8941
341f9135
CC		 8942 ph += 8;
8943 pi += 4;
657d0d47 8944 }
657d0d47 8945 }
341f9135 8946 else if (do_display)
6937bb54 8947 printf (_(" Unsupported version (%d)\n"), version);
657d0d47
CC		 8948
8949 if (do_display)
8950 printf ("\n");
8951
8952 return 1;
8953}
8954
8955/* Load the CU and TU indexes if present. This will build a list of
8956 section sets that we can use to associate a .debug_info.dwo section
8957 with its associated .debug_abbrev.dwo section in a .dwp file. */
8958
43a444f9 8959static bfd_boolean
657d0d47
CC		 8960load_cu_tu_indexes (void *file)
8961{
43a444f9
NC		 8962 static int cu_tu_indexes_read = -1; /* Tri-state variable. */
8963
657d0d47
CC		 8964 /* If we have already loaded (or tried to load) the CU and TU indexes
8965 then do not bother to repeat the task. */
43a444f9
NC		 8966 if (cu_tu_indexes_read == -1)
8967 {
8968 cu_tu_indexes_read = TRUE;
8969
8970 if (load_debug_section (dwp_cu_index, file))
8971 if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0))
8972 cu_tu_indexes_read = FALSE;
8973
8974 if (load_debug_section (dwp_tu_index, file))
8975 if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0))
8976 cu_tu_indexes_read = FALSE;
8977 }
657d0d47 8978
43a444f9 8979 return (bfd_boolean) cu_tu_indexes_read;
657d0d47
CC		 8980}
8981
8982/* Find the set of sections that includes section SHNDX. */
8983
8984unsigned int *
8985find_cu_tu_set (void *file, unsigned int shndx)
8986{
8987 unsigned int i;
8988
43a444f9
NC		 8989 if (! load_cu_tu_indexes (file))
8990 return NULL;
657d0d47
CC		 8991
8992 /* Find SHNDX in the shndx pool. */
8993 for (i = 0; i < shndx_pool_used; i++)
8994 if (shndx_pool [i] == shndx)
8995 break;
8996
8997 if (i >= shndx_pool_used)
8998 return NULL;
8999
9000 /* Now backup to find the first entry in the set. */
9001 while (i > 0 && shndx_pool [i - 1] != 0)
9002 i--;
9003
9004 return shndx_pool + i;
9005}
9006
9007/* Display a .debug_cu_index or .debug_tu_index section. */
9008
9009static int
9010display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
9011{
9012 return process_cu_tu_index (section, 1);
9013}
9014
19e6b90e
L		 9015static int
9016display_debug_not_supported (struct dwarf_section *section,
9017 void *file ATTRIBUTE_UNUSED)
9018{
9019 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9020 section->name);
9021
9022 return 1;
9023}
9024
1306a742
NC		 9025/* Like malloc, but takes two parameters like calloc.
9026 Verifies that the first parameter is not too large.
82b1b41b 9027 Note: does *not* initialise the allocated memory to zero. */
19e6b90e
L		 9028void *
9029cmalloc (size_t nmemb, size_t size)
9030{
9031 /* Check for overflow. */
9032 if (nmemb >= ~(size_t) 0 / size)
9033 return NULL;
82b1b41b
NC		 9034
9035 return xmalloc (nmemb * size);
19e6b90e
L		 9036}
9037
1306a742
NC		 9038/* Like xmalloc, but takes two parameters like calloc.
9039 Verifies that the first parameter is not too large.
9040 Note: does *not* initialise the allocated memory to zero. */
72c61a0d 9041void *
1306a742 9042xcmalloc (size_t nmemb, size_t size)
72c61a0d
NC		 9043{
9044 /* Check for overflow. */
9045 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 9046 {
9047 fprintf (stderr,
9048 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9049 (long) nmemb);
9050 xexit (1);
9051 }
72c61a0d 9052
1306a742 9053 return xmalloc (nmemb * size);
72c61a0d
NC		 9054}
9055
1306a742
NC		 9056/* Like xrealloc, but takes three parameters.
9057 Verifies that the second parameter is not too large.
9058 Note: does *not* initialise any new memory to zero. */
19e6b90e 9059void *
1306a742 9060xcrealloc (void *ptr, size_t nmemb, size_t size)
19e6b90e
L		 9061{
9062 /* Check for overflow. */
9063 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 9064 {
9065 fprintf (stderr,
9066 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9067 (long) nmemb);
9068 xexit (1);
9069 }
82b1b41b 9070
1306a742 9071 return xrealloc (ptr, nmemb * size);
19e6b90e
L		 9072}
9073
1306a742 9074/* Like xcalloc, but verifies that the first parameter is not too large. */
19e6b90e 9075void *
1306a742 9076xcalloc2 (size_t nmemb, size_t size)
19e6b90e
L		 9077{
9078 /* Check for overflow. */
9079 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 9080 {
9081 fprintf (stderr,
9082 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9083 (long) nmemb);
9084 xexit (1);
9085 }
82b1b41b 9086
1306a742 9087 return xcalloc (nmemb, size);
19e6b90e
L		 9088}
9089
19e6b90e
L		 9090void
9091free_debug_memory (void)
9092{
3f5e193b 9093 unsigned int i;
19e6b90e
L		 9094
9095 free_abbrevs ();
9096
9097 for (i = 0; i < max; i++)
3f5e193b 9098 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 9099
cc86f28f 9100 if (debug_information != NULL)
19e6b90e 9101 {
cc86f28f 9102 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
19e6b90e 9103 {
cc86f28f 9104 for (i = 0; i < num_debug_info_entries; i++)
19e6b90e 9105 {
cc86f28f
NC		 9106 if (!debug_information [i].max_loc_offsets)
9107 {
9108 free (debug_information [i].loc_offsets);
9109 free (debug_information [i].have_frame_base);
9110 }
9111 if (!debug_information [i].max_range_lists)
9112 free (debug_information [i].range_lists);
19e6b90e 9113 }
19e6b90e
L		 9114 }
9115 free (debug_information);
9116 debug_information = NULL;
82b1b41b 9117 alloc_num_debug_info_entries = num_debug_info_entries = 0;
19e6b90e 9118 }
19e6b90e
L		 9119}
9120
4cb93e3b
TG		 9121void
9122dwarf_select_sections_by_names (const char *names)
9123{
9124 typedef struct
9125 {
9126 const char * option;
9127 int * variable;
f9f0e732 9128 int val;
4cb93e3b
TG		 9129 }
9130 debug_dump_long_opts;
9131
9132 static const debug_dump_long_opts opts_table [] =
9133 {
9134 /* Please keep this table alpha- sorted. */
9135 { "Ranges", & do_debug_ranges, 1 },
9136 { "abbrev", & do_debug_abbrevs, 1 },
657d0d47 9137 { "addr", & do_debug_addr, 1 },
4cb93e3b 9138 { "aranges", & do_debug_aranges, 1 },
657d0d47
CC		 9139 { "cu_index", & do_debug_cu_index, 1 },
9140 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4cb93e3b
TG		 9141 { "frames", & do_debug_frames, 1 },
9142 { "frames-interp", & do_debug_frames_interp, 1 },
657d0d47
CC		 9143 /* The special .gdb_index section. */
9144 { "gdb_index", & do_gdb_index, 1 },
4cb93e3b
TG		 9145 { "info", & do_debug_info, 1 },
9146 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
4cb93e3b
TG		 9147 { "loc", & do_debug_loc, 1 },
9148 { "macro", & do_debug_macinfo, 1 },
9149 { "pubnames", & do_debug_pubnames, 1 },
357da287 9150 { "pubtypes", & do_debug_pubtypes, 1 },
222c2bf0 9151 /* This entry is for compatibility
4cb93e3b
TG		 9152 with earlier versions of readelf. */
9153 { "ranges", & do_debug_aranges, 1 },
657d0d47 9154 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4cb93e3b 9155 { "str", & do_debug_str, 1 },
6f875884
TG		 9156 /* These trace_* sections are used by Itanium VMS. */
9157 { "trace_abbrev", & do_trace_abbrevs, 1 },
9158 { "trace_aranges", & do_trace_aranges, 1 },
9159 { "trace_info", & do_trace_info, 1 },
4cb93e3b
TG		 9160 { NULL, NULL, 0 }
9161 };
9162
9163 const char *p;
467c65bc 9164
4cb93e3b
TG		 9165 p = names;
9166 while (*p)
9167 {
9168 const debug_dump_long_opts * entry;
467c65bc 9169
4cb93e3b
TG		 9170 for (entry = opts_table; entry->option; entry++)
9171 {
9172 size_t len = strlen (entry->option);
467c65bc 9173
4cb93e3b
TG		 9174 if (strncmp (p, entry->option, len) == 0
9175 && (p[len] == ',' || p[len] == '\0'))
9176 {
9177 * entry->variable |= entry->val;
467c65bc 9178
4cb93e3b
TG		 9179 /* The --debug-dump=frames-interp option also
9180 enables the --debug-dump=frames option. */
9181 if (do_debug_frames_interp)
9182 do_debug_frames = 1;
9183
9184 p += len;
9185 break;
9186 }
9187 }
467c65bc 9188
4cb93e3b
TG		 9189 if (entry->option == NULL)
9190 {
9191 warn (_("Unrecognized debug option '%s'\n"), p);
9192 p = strchr (p, ',');
9193 if (p == NULL)
9194 break;
9195 }
467c65bc 9196
4cb93e3b
TG		 9197 if (*p == ',')
9198 p++;
9199 }
9200}
9201
9202void
9203dwarf_select_sections_by_letters (const char *letters)
9204{
91d6fa6a 9205 unsigned int lindex = 0;
4cb93e3b 9206
91d6fa6a
NC		 9207 while (letters[lindex])
9208 switch (letters[lindex++])
4cb93e3b
TG		 9209 {
9210 case 'i':
9211 do_debug_info = 1;
9212 break;
467c65bc 9213
4cb93e3b
TG		 9214 case 'a':
9215 do_debug_abbrevs = 1;
9216 break;
467c65bc 9217
4cb93e3b
TG		 9218 case 'l':
9219 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
9220 break;
467c65bc 9221
4cb93e3b
TG		 9222 case 'L':
9223 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
9224 break;
467c65bc 9225
4cb93e3b
TG		 9226 case 'p':
9227 do_debug_pubnames = 1;
9228 break;
467c65bc 9229
f9f0e732
NC		 9230 case 't':
9231 do_debug_pubtypes = 1;
9232 break;
467c65bc 9233
4cb93e3b
TG		 9234 case 'r':
9235 do_debug_aranges = 1;
9236 break;
467c65bc 9237
4cb93e3b
TG		 9238 case 'R':
9239 do_debug_ranges = 1;
9240 break;
467c65bc 9241
4cb93e3b
TG		 9242 case 'F':
9243 do_debug_frames_interp = 1;
1a0670f3 9244 /* Fall through. */
4cb93e3b
TG		 9245 case 'f':
9246 do_debug_frames = 1;
9247 break;
467c65bc 9248
4cb93e3b
TG		 9249 case 'm':
9250 do_debug_macinfo = 1;
9251 break;
467c65bc 9252
4cb93e3b
TG		 9253 case 's':
9254 do_debug_str = 1;
9255 break;
467c65bc 9256
4cb93e3b
TG		 9257 case 'o':
9258 do_debug_loc = 1;
9259 break;
467c65bc 9260
4cb93e3b 9261 default:
7cc78d07 9262 warn (_("Unrecognized debug option '%s'\n"), letters);
4cb93e3b
TG		 9263 break;
9264 }
9265}
9266
9267void
9268dwarf_select_sections_all (void)
9269{
9270 do_debug_info = 1;
9271 do_debug_abbrevs = 1;
9272 do_debug_lines = FLAG_DEBUG_LINES_RAW;
9273 do_debug_pubnames = 1;
f9f0e732 9274 do_debug_pubtypes = 1;
4cb93e3b
TG		 9275 do_debug_aranges = 1;
9276 do_debug_ranges = 1;
9277 do_debug_frames = 1;
9278 do_debug_macinfo = 1;
9279 do_debug_str = 1;
9280 do_debug_loc = 1;
5bbdf3d5 9281 do_gdb_index = 1;
6f875884
TG		 9282 do_trace_info = 1;
9283 do_trace_abbrevs = 1;
9284 do_trace_aranges = 1;
657d0d47
CC		 9285 do_debug_addr = 1;
9286 do_debug_cu_index = 1;
4cb93e3b
TG		 9287}
9288
19e6b90e
L		 9289struct dwarf_section_display debug_displays[] =
9290{
d1c4b12b
NC		 9291 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9292 display_debug_abbrev, &do_debug_abbrevs, FALSE },
9293 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9294 display_debug_aranges, &do_debug_aranges, TRUE },
9295 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9296 display_debug_frames, &do_debug_frames, TRUE },
9297 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9298 display_debug_info, &do_debug_info, TRUE },
9299 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9300 display_debug_lines, &do_debug_lines, TRUE },
9301 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9302 display_debug_pubnames, &do_debug_pubnames, FALSE },
9303 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9304 display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
9305 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9306 display_debug_frames, &do_debug_frames, TRUE },
9307 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9308 display_debug_macinfo, &do_debug_macinfo, FALSE },
9309 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9310 display_debug_macro, &do_debug_macinfo, TRUE },
9311 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9312 display_debug_str, &do_debug_str, FALSE },
77145576
JK		 9313 { { ".debug_line_str", ".zdebug_line_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9314 display_debug_str, &do_debug_str, FALSE },
d1c4b12b
NC		 9315 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9316 display_debug_loc, &do_debug_loc, TRUE },
77145576
JK		 9317 { { ".debug_loclists", ".zdebug_loclists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9318 display_debug_loc, &do_debug_loc, TRUE },
d1c4b12b
NC		 9319 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9320 display_debug_pubnames, &do_debug_pubtypes, FALSE },
9321 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9322 display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
9323 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9324 display_debug_ranges, &do_debug_ranges, TRUE },
77145576
JK		 9325 { { ".debug_rnglists", ".zdebug_rnglists", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9326 display_debug_ranges, &do_debug_ranges, TRUE },
d1c4b12b
NC		 9327 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9328 display_debug_not_supported, NULL, FALSE },
9329 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9330 display_debug_not_supported, NULL, FALSE },
9331 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
9332 display_debug_types, &do_debug_info, TRUE },
9333 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9334 display_debug_not_supported, NULL, FALSE },
9335 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9336 display_gdb_index, &do_gdb_index, FALSE },
61364358
JK		 9337 { { ".debug_names", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9338 display_debug_names, &do_gdb_index, FALSE },
d1c4b12b
NC		 9339 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
9340 display_trace_info, &do_trace_info, TRUE },
9341 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9342 display_debug_abbrev, &do_trace_abbrevs, FALSE },
9343 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9344 display_debug_aranges, &do_trace_aranges, FALSE },
9345 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9346 display_debug_info, &do_debug_info, TRUE },
9347 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9348 display_debug_abbrev, &do_debug_abbrevs, FALSE },
9349 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
9350 display_debug_types, &do_debug_info, TRUE },
9351 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9352 display_debug_lines, &do_debug_lines, TRUE },
9353 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9354 display_debug_loc, &do_debug_loc, TRUE },
9355 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9356 display_debug_macro, &do_debug_macinfo, TRUE },
9357 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9358 display_debug_macinfo, &do_debug_macinfo, FALSE },
9359 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9360 display_debug_str, &do_debug_str, TRUE },
9361 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9362 display_debug_str_offsets, NULL, FALSE },
9363 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9364 display_debug_str_offsets, NULL, FALSE },
9365 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9366 display_debug_addr, &do_debug_addr, TRUE },
9367 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9368 display_cu_index, &do_debug_cu_index, FALSE },
9369 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
9370 display_cu_index, &do_debug_cu_index, FALSE },
19e6b90e 9371};
b451e98a
JK		 9372
9373/* A static assertion. */
9374extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1];
GDB Binutils - Deliverables
This page took 1.332602 seconds and 4 git commands to generate.