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