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