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