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