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