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