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