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