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