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