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