projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Correct ld.texinfo cross reference
[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 ? */
287 if (shift >= sizeof (result))
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))
65879393 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)
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 {
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
f6f0e17b 531 opc = read_uleb128 (data, & bytes_read, edata);
43294ab7
TG		 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",
f6f0e17b 542 read_uleb128 (data, & bytes_read, edata)));
43294ab7
TG		 543 data += bytes_read;
544 break;
545 case DW_LNE_HP_SFC_associate:
546 printf (" DW_LNE_HP_SFC_associate ");
9cf03b7e 547 printf ("(%s",
43294ab7 548 dwarf_vmatoa ("u",
f6f0e17b 549 read_uleb128 (data, & bytes_read, edata)));
43294ab7 550 data += bytes_read;
9cf03b7e 551 printf (",%s",
43294ab7 552 dwarf_vmatoa ("u",
f6f0e17b 553 read_uleb128 (data, & bytes_read, edata)));
43294ab7 554 data += bytes_read;
9cf03b7e 555 printf (",%s)\n",
43294ab7 556 dwarf_vmatoa ("u",
f6f0e17b 557 read_uleb128 (data, & bytes_read, edata)));
43294ab7
TG		 558 data += bytes_read;
559 break;
560 default:
9cf03b7e 561 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);
43294ab7
TG		 562 data = edata;
563 break;
564 }
565 }
566 }
567 break;
cecf136e 568
19e6b90e 569 default:
7e665af3
TG		 570 {
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");
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"),
661 section->name, dwarf_vmatoa ("x", offset));
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;
4723351a 1370 case DW_OP_GNU_addr_index:
f6f0e17b 1371 uvalue = read_uleb128 (data, &bytes_read, end);
4723351a
CC		 1372 data += bytes_read;
1373 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue));
1374 break;
aae628c1 1375 case DW_OP_GNU_const_index:
f6f0e17b 1376 uvalue = read_uleb128 (data, &bytes_read, end);
aae628c1
CC		 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
1748 /* PR 17531: file: 5b5f0592. */
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)
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),
341f9135 1775 fetch_indexed_string (uvalue, this_set, offset_size, dwo));
4723351a
CC		 1776 }
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)
1804 printf (_(" (addr_index: 0x%s): %s"),
1805 dwarf_vmatoa ("x", uvalue),
1806 fetch_indexed_value (uvalue * pointer_size, pointer_size));
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:
212b6063
JK		 1834 if ((dwarf_version < 4
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 *)
3f5e193b 1846 xcrealloc (debug_info_p->loc_offsets,
91d6fa6a 1847 lmax, sizeof (*debug_info_p->loc_offsets));
3f5e193b
NC		 1848 debug_info_p->have_frame_base = (int *)
1849 xcrealloc (debug_info_p->have_frame_base,
91d6fa6a
NC		 1850 lmax, sizeof (*debug_info_p->have_frame_base));
1851 debug_info_p->max_loc_offsets = lmax;
19e6b90e 1852 }
341f9135
CC		 1853 if (this_set != NULL)
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
CC		 1866 case DW_AT_GNU_addr_base:
1867 debug_info_p->addr_base = uvalue;
1868 break;
1869
1870 case DW_AT_GNU_ranges_base:
1871 debug_info_p->ranges_base = uvalue;
1872 break;
1873
19e6b90e 1874 case DW_AT_ranges:
212b6063
JK		 1875 if ((dwarf_version < 4
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 *)
3f5e193b 1887 xcrealloc (debug_info_p->range_lists,
91d6fa6a
NC		 1888 lmax, sizeof (*debug_info_p->range_lists));
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;
2009
19e6b90e
L		 2010 default:
2011 if (uvalue >= DW_ATE_lo_user
2012 && uvalue <= DW_ATE_hi_user)
9cf03b7e 2013 printf (_("(user defined type)"));
19e6b90e 2014 else
9cf03b7e 2015 printf (_("(unknown type)"));
19e6b90e
L		 2016 break;
2017 }
2018 break;
2019
2020 case DW_AT_accessibility:
2e9e81a8 2021 printf ("\t");
19e6b90e
L		 2022 switch (uvalue)
2023 {
2024 case DW_ACCESS_public: printf ("(public)"); break;
2025 case DW_ACCESS_protected: printf ("(protected)"); break;
2026 case DW_ACCESS_private: printf ("(private)"); break;
2027 default:
9cf03b7e 2028 printf (_("(unknown accessibility)"));
19e6b90e
L		 2029 break;
2030 }
2031 break;
2032
2033 case DW_AT_visibility:
2e9e81a8 2034 printf ("\t");
19e6b90e
L		 2035 switch (uvalue)
2036 {
2037 case DW_VIS_local: printf ("(local)"); break;
2038 case DW_VIS_exported: printf ("(exported)"); break;
2039 case DW_VIS_qualified: printf ("(qualified)"); break;
9cf03b7e 2040 default: printf (_("(unknown visibility)")); break;
19e6b90e
L		 2041 }
2042 break;
2043
2044 case DW_AT_virtuality:
2e9e81a8 2045 printf ("\t");
19e6b90e
L		 2046 switch (uvalue)
2047 {
2048 case DW_VIRTUALITY_none: printf ("(none)"); break;
2049 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
2050 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
9cf03b7e 2051 default: printf (_("(unknown virtuality)")); break;
19e6b90e
L		 2052 }
2053 break;
2054
2055 case DW_AT_identifier_case:
2e9e81a8 2056 printf ("\t");
19e6b90e
L		 2057 switch (uvalue)
2058 {
2059 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
2060 case DW_ID_up_case: printf ("(up_case)"); break;
2061 case DW_ID_down_case: printf ("(down_case)"); break;
2062 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
9cf03b7e 2063 default: printf (_("(unknown case)")); break;
19e6b90e
L		 2064 }
2065 break;
2066
2067 case DW_AT_calling_convention:
2e9e81a8 2068 printf ("\t");
19e6b90e
L		 2069 switch (uvalue)
2070 {
2071 case DW_CC_normal: printf ("(normal)"); break;
2072 case DW_CC_program: printf ("(program)"); break;
2073 case DW_CC_nocall: printf ("(nocall)"); break;
2074 default:
2075 if (uvalue >= DW_CC_lo_user
2076 && uvalue <= DW_CC_hi_user)
9cf03b7e 2077 printf (_("(user defined)"));
19e6b90e 2078 else
9cf03b7e 2079 printf (_("(unknown convention)"));
19e6b90e
L		 2080 }
2081 break;
2082
2083 case DW_AT_ordering:
2e9e81a8 2084 printf ("\t");
19e6b90e
L		 2085 switch (uvalue)
2086 {
9cf03b7e 2087 case -1: printf (_("(undefined)")); break;
19e6b90e
L		 2088 case 0: printf ("(row major)"); break;
2089 case 1: printf ("(column major)"); break;
2090 }
2091 break;
2092
2093 case DW_AT_frame_base:
2094 have_frame_base = 1;
2095 case DW_AT_location:
e2a0d921
NC		 2096 case DW_AT_string_length:
2097 case DW_AT_return_addr:
19e6b90e
L		 2098 case DW_AT_data_member_location:
2099 case DW_AT_vtable_elem_location:
e2a0d921
NC		 2100 case DW_AT_segment:
2101 case DW_AT_static_link:
2102 case DW_AT_use_location:
629e7ca8
JJ		 2103 case DW_AT_GNU_call_site_value:
2104 case DW_AT_GNU_call_site_data_value:
2105 case DW_AT_GNU_call_site_target:
2106 case DW_AT_GNU_call_site_target_clobbered:
212b6063
JK		 2107 if ((dwarf_version < 4
2108 && (form == DW_FORM_data4 || form == DW_FORM_data8))
932fd279 2109 || form == DW_FORM_sec_offset)
2e9e81a8 2110 printf (_(" (location list)"));
e2a0d921 2111 /* Fall through. */
19e6b90e
L		 2112 case DW_AT_allocated:
2113 case DW_AT_associated:
2114 case DW_AT_data_location:
2115 case DW_AT_stride:
2116 case DW_AT_upper_bound:
cecf136e 2117 case DW_AT_lower_bound:
19e6b90e
L		 2118 if (block_start)
2119 {
2120 int need_frame_base;
2121
2e9e81a8 2122 printf ("\t(");
19e6b90e
L		 2123 need_frame_base = decode_location_expression (block_start,
2124 pointer_size,
b7807392
JJ		 2125 offset_size,
2126 dwarf_version,
19e6b90e 2127 uvalue,
f1c4cc75 2128 cu_offset, section);
19e6b90e
L		 2129 printf (")");
2130 if (need_frame_base && !have_frame_base)
2131 printf (_(" [without DW_AT_frame_base]"));
2132 }
19e6b90e
L		 2133 break;
2134
ec4d4525
NC		 2135 case DW_AT_import:
2136 {
a081f3cd
JJ		 2137 if (form == DW_FORM_ref_sig8
2138 || form == DW_FORM_GNU_ref_alt)
2b6f5997
CC		 2139 break;
2140
ec4d4525
NC		 2141 if (form == DW_FORM_ref1
2142 || form == DW_FORM_ref2
a7a0b6a5
JK		 2143 || form == DW_FORM_ref4
2144 || form == DW_FORM_ref_udata)
ec4d4525
NC		 2145 uvalue += cu_offset;
2146
6e3d6dc1 2147 if (uvalue >= section->size)
f3853b34 2148 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
47704ddf
KT		 2149 dwarf_vmatoa ("x", uvalue),
2150 (unsigned long) (orig_data - section->start));
6e3d6dc1
NC		 2151 else
2152 {
2153 unsigned long abbrev_number;
2154 abbrev_entry * entry;
2155
f6f0e17b 2156 abbrev_number = read_uleb128 (section->start + uvalue, NULL, end);
cecf136e 2157
2e9e81a8 2158 printf (_("\t[Abbrev Number: %ld"), abbrev_number);
afd6e1ff
JJ		 2159 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2160 use different abbrev table, and we don't track .debug_info chunks
2161 yet. */
2162 if (form != DW_FORM_ref_addr)
2163 {
2164 for (entry = first_abbrev; entry != NULL; entry = entry->next)
2165 if (entry->entry == abbrev_number)
2166 break;
2167 if (entry != NULL)
2168 printf (" (%s)", get_TAG_name (entry->tag));
2169 }
6e3d6dc1
NC		 2170 printf ("]");
2171 }
ec4d4525
NC		 2172 }
2173 break;
2174
19e6b90e
L		 2175 default:
2176 break;
2177 }
2178
2179 return data;
2180}
2181
a19c41a7 2182static const char *
19e6b90e
L		 2183get_AT_name (unsigned long attribute)
2184{
a19c41a7 2185 const char *name;
e2a0d921 2186
399c99f7
L		 2187 if (attribute == 0)
2188 return "DW_AT value: 0";
2189
a19c41a7
TT		 2190 /* One value is shared by the MIPS and HP extensions: */
2191 if (attribute == DW_AT_MIPS_fde)
2192 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
19e6b90e 2193
a19c41a7
TT		 2194 name = get_DW_AT_name (attribute);
2195
2196 if (name == NULL)
2197 {
2198 static char buffer[100];
2199
2200 snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"),
2201 attribute);
2202 return buffer;
19e6b90e 2203 }
a19c41a7
TT		 2204
2205 return name;
19e6b90e
L		 2206}
2207
2208static unsigned char *
6e3d6dc1
NC		 2209read_and_display_attr (unsigned long attribute,
2210 unsigned long form,
ec4d4525 2211 unsigned char * data,
f6f0e17b 2212 unsigned char * end,
467c65bc
NC		 2213 dwarf_vma cu_offset,
2214 dwarf_vma pointer_size,
2215 dwarf_vma offset_size,
6e3d6dc1
NC		 2216 int dwarf_version,
2217 debug_info * debug_info_p,
2218 int do_loc,
341f9135
CC		 2219 struct dwarf_section * section,
2220 struct cu_tu_set * this_set)
19e6b90e
L		 2221{
2222 if (!do_loc)
750f03b7 2223 printf (" %-18s:", get_AT_name (attribute));
f6f0e17b
NC		 2224 data = read_and_display_attr_value (attribute, form, data, end,
2225 cu_offset, pointer_size, offset_size,
19e6b90e 2226 dwarf_version, debug_info_p,
341f9135 2227 do_loc, section, this_set);
19e6b90e
L		 2228 if (!do_loc)
2229 printf ("\n");
2230 return data;
2231}
2232
19e6b90e
L		 2233/* Process the contents of a .debug_info section. If do_loc is non-zero
2234 then we are scanning for location lists and we do not want to display
2b6f5997
CC		 2235 anything to the user. If do_types is non-zero, we are processing
2236 a .debug_types section instead of a .debug_info section. */
19e6b90e
L		 2237
2238static int
6e3d6dc1
NC		 2239process_debug_info (struct dwarf_section *section,
2240 void *file,
6f875884 2241 enum dwarf_section_display_enum abbrev_sec,
2b6f5997
CC		 2242 int do_loc,
2243 int do_types)
19e6b90e
L		 2244{
2245 unsigned char *start = section->start;
2246 unsigned char *end = start + section->size;
2247 unsigned char *section_begin;
2248 unsigned int unit;
2249 unsigned int num_units = 0;
2250
2251 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2252 && num_debug_info_entries == 0
2253 && ! do_types)
19e6b90e 2254 {
767221a9 2255 dwarf_vma length;
19e6b90e
L		 2256
2257 /* First scan the section to get the number of comp units. */
2258 for (section_begin = start, num_units = 0; section_begin < end;
2259 num_units ++)
2260 {
2261 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2262 will be the length. For a 64-bit DWARF section, it'll be
2263 the escape code 0xffffffff followed by an 8 byte length. */
0c588247 2264 SAFE_BYTE_GET (length, section_begin, 4, end);
19e6b90e
L		 2265
2266 if (length == 0xffffffff)
2267 {
0c588247 2268 SAFE_BYTE_GET (length, section_begin + 4, 8, end);
19e6b90e
L		 2269 section_begin += length + 12;
2270 }
ec4d4525
NC		 2271 else if (length >= 0xfffffff0 && length < 0xffffffff)
2272 {
767221a9
NC		 2273 warn (_("Reserved length value (0x%s) found in section %s\n"),
2274 dwarf_vmatoa ("x", length), section->name);
ec4d4525
NC		 2275 return 0;
2276 }
19e6b90e
L		 2277 else
2278 section_begin += length + 4;
aca88567
NC		 2279
2280 /* Negative values are illegal, they may even cause infinite
2281 looping. This can happen if we can't accurately apply
f3853b34
NC		 2282 relocations to an object file, or if the file is corrupt. */
2283 if ((signed long) length <= 0 || section_begin < start)
aca88567 2284 {
767221a9
NC		 2285 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2286 dwarf_vmatoa ("x", length), section->name);
aca88567
NC		 2287 return 0;
2288 }
19e6b90e
L		 2289 }
2290
2291 if (num_units == 0)
2292 {
f41e4712 2293 error (_("No comp units in %s section ?\n"), section->name);
19e6b90e
L		 2294 return 0;
2295 }
2296
2297 /* Then allocate an array to hold the information. */
3f5e193b 2298 debug_information = (debug_info *) cmalloc (num_units,
1306a742 2299 sizeof (* debug_information));
19e6b90e
L		 2300 if (debug_information == NULL)
2301 {
f41e4712 2302 error (_("Not enough memory for a debug info array of %u entries\n"),
19e6b90e 2303 num_units);
82b1b41b 2304 alloc_num_debug_info_entries = num_debug_info_entries = 0;
19e6b90e
L		 2305 return 0;
2306 }
03a91817
NC		 2307 /* PR 17531: file: 92ca3797.
2308 We cannot rely upon the debug_information array being initialised
2309 before it is used. A corrupt file could easily contain references
2310 to a unit for which information has not been made available. So
2311 we ensure that the array is zeroed here. */
2312 memset (debug_information, 0, num_units * sizeof * debug_information);
2313
82b1b41b 2314 alloc_num_debug_info_entries = num_units;
19e6b90e
L		 2315 }
2316
2317 if (!do_loc)
2318 {
fd2f0033
TT		 2319 if (dwarf_start_die == 0)
2320 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e
L		 2321
2322 load_debug_section (str, file);
4723351a
CC		 2323 load_debug_section (str_dwo, file);
2324 load_debug_section (str_index, file);
2325 load_debug_section (str_index_dwo, file);
2326 load_debug_section (debug_addr, file);
19e6b90e
L		 2327 }
2328
6f875884
TG		 2329 load_debug_section (abbrev_sec, file);
2330 if (debug_displays [abbrev_sec].section.start == NULL)
19e6b90e
L		 2331 {
2332 warn (_("Unable to locate %s section!\n"),
6f875884 2333 debug_displays [abbrev_sec].section.name);
19e6b90e
L		 2334 return 0;
2335 }
2336
2337 for (section_begin = start, unit = 0; start < end; unit++)
2338 {
2339 DWARF2_Internal_CompUnit compunit;
2340 unsigned char *hdrptr;
19e6b90e 2341 unsigned char *tags;
fd2f0033 2342 int level, last_level, saved_level;
467c65bc 2343 dwarf_vma cu_offset;
bf5117e3 2344 unsigned int offset_size;
19e6b90e 2345 int initial_length_size;
74bc6052
CC		 2346 dwarf_vma signature_high = 0;
2347 dwarf_vma signature_low = 0;
767221a9 2348 dwarf_vma type_offset = 0;
341f9135
CC		 2349 struct cu_tu_set *this_set;
2350 dwarf_vma abbrev_base;
2351 size_t abbrev_size;
19e6b90e
L		 2352
2353 hdrptr = start;
2354
0c588247 2355 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
19e6b90e
L		 2356
2357 if (compunit.cu_length == 0xffffffff)
2358 {
0c588247 2359 SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
19e6b90e
L		 2360 offset_size = 8;
2361 initial_length_size = 12;
2362 }
2363 else
2364 {
2365 offset_size = 4;
2366 initial_length_size = 4;
2367 }
2368
0c588247 2369 SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
19e6b90e
L		 2370
2371 cu_offset = start - section_begin;
19e6b90e 2372
341f9135
CC		 2373 this_set = find_cu_tu_set_v2 (cu_offset, do_types);
2374
0c588247 2375 SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
19e6b90e 2376
341f9135
CC		 2377 if (this_set == NULL)
2378 {
2379 abbrev_base = 0;
2380 abbrev_size = debug_displays [abbrev_sec].section.size;
2381 }
2382 else
2383 {
2384 abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
2385 abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
2386 }
2387
0c588247 2388 SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
f41e4712
NC		 2389 /* PR 17512: file: 001-108546-0.001:0.1. */
2390 if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8)
2391 {
2392 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2393 compunit.cu_pointer_size, offset_size);
2394 compunit.cu_pointer_size = offset_size;
2395 }
2b6f5997
CC		 2396
2397 if (do_types)
2398 {
0c588247 2399 SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end);
f048b142 2400 hdrptr += 8;
0c588247 2401 SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end);
2b6f5997
CC		 2402 }
2403
19e6b90e 2404 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2405 && num_debug_info_entries == 0
2406 && ! do_types)
19e6b90e
L		 2407 {
2408 debug_information [unit].cu_offset = cu_offset;
2409 debug_information [unit].pointer_size
2410 = compunit.cu_pointer_size;
b7807392
JJ		 2411 debug_information [unit].offset_size = offset_size;
2412 debug_information [unit].dwarf_version = compunit.cu_version;
19e6b90e 2413 debug_information [unit].base_address = 0;
4723351a
CC		 2414 debug_information [unit].addr_base = DEBUG_INFO_UNAVAILABLE;
2415 debug_information [unit].ranges_base = DEBUG_INFO_UNAVAILABLE;
19e6b90e
L		 2416 debug_information [unit].loc_offsets = NULL;
2417 debug_information [unit].have_frame_base = NULL;
2418 debug_information [unit].max_loc_offsets = 0;
2419 debug_information [unit].num_loc_offsets = 0;
2420 debug_information [unit].range_lists = NULL;
2421 debug_information [unit].max_range_lists= 0;
2422 debug_information [unit].num_range_lists = 0;
2423 }
2424
fd2f0033 2425 if (!do_loc && dwarf_start_die == 0)
19e6b90e 2426 {
47704ddf
KT		 2427 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2428 dwarf_vmatoa ("x", cu_offset));
2429 printf (_(" Length: 0x%s (%s)\n"),
2430 dwarf_vmatoa ("x", compunit.cu_length),
49e7b350 2431 offset_size == 8 ? "64-bit" : "32-bit");
19e6b90e 2432 printf (_(" Version: %d\n"), compunit.cu_version);
7282333f
AM		 2433 printf (_(" Abbrev Offset: 0x%s\n"),
2434 dwarf_vmatoa ("x", compunit.cu_abbrev_offset));
19e6b90e 2435 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
2b6f5997
CC		 2436 if (do_types)
2437 {
74bc6052
CC		 2438 char buf[64];
2439
2440 printf (_(" Signature: 0x%s\n"),
2441 dwarf_vmatoa64 (signature_high, signature_low,
2442 buf, sizeof (buf)));
2443 printf (_(" Type Offset: 0x%s\n"),
2444 dwarf_vmatoa ("x", type_offset));
2b6f5997 2445 }
341f9135
CC		 2446 if (this_set != NULL)
2447 {
2448 dwarf_vma *offsets = this_set->section_offsets;
2449 size_t *sizes = this_set->section_sizes;
2450
2451 printf (_(" Section contributions:\n"));
2452 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2453 dwarf_vmatoa ("x", offsets [DW_SECT_ABBREV]),
2454 dwarf_vmatoa ("x", sizes [DW_SECT_ABBREV]));
2455 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2456 dwarf_vmatoa ("x", offsets [DW_SECT_LINE]),
2457 dwarf_vmatoa ("x", sizes [DW_SECT_LINE]));
2458 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2459 dwarf_vmatoa ("x", offsets [DW_SECT_LOC]),
2460 dwarf_vmatoa ("x", sizes [DW_SECT_LOC]));
2461 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2462 dwarf_vmatoa ("x", offsets [DW_SECT_STR_OFFSETS]),
2463 dwarf_vmatoa ("x", sizes [DW_SECT_STR_OFFSETS]));
2464 }
19e6b90e
L		 2465 }
2466
460c89ff
NS		 2467 if (cu_offset + compunit.cu_length + initial_length_size
2468 > section->size)
2469 {
47704ddf
KT		 2470 warn (_("Debug info is corrupted, length of CU at %s"
2471 " extends beyond end of section (length = %s)\n"),
2472 dwarf_vmatoa ("x", cu_offset),
2473 dwarf_vmatoa ("x", compunit.cu_length));
57028622 2474 num_units = unit;
460c89ff
NS		 2475 break;
2476 }
2477 tags = hdrptr;
2478 start += compunit.cu_length + initial_length_size;
2479
57028622
NC		 2480 if (start > end)
2481 {
2482 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2483 dwarf_vmatoa ("x", cu_offset));
2484 start = end;
2485 }
2486
932fd279
JJ		 2487 if (compunit.cu_version != 2
2488 && compunit.cu_version != 3
2489 && compunit.cu_version != 4)
19e6b90e 2490 {
47704ddf
KT		 2491 warn (_("CU at offset %s contains corrupt or "
2492 "unsupported version number: %d.\n"),
2493 dwarf_vmatoa ("x", cu_offset), compunit.cu_version);
19e6b90e
L		 2494 continue;
2495 }
2496
2497 free_abbrevs ();
2498
d493b283 2499 /* Process the abbrevs used by this compilation unit. */
341f9135 2500 if (compunit.cu_abbrev_offset >= abbrev_size)
ec4d4525
NC		 2501 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2502 (unsigned long) compunit.cu_abbrev_offset,
341f9135 2503 (unsigned long) abbrev_size);
72c61a0d 2504 /* PR 17531: file:4bcd9ce9. */
a0a3b04c
L		 2505 else if ((abbrev_base + abbrev_size)
2506 > debug_displays [abbrev_sec].section.size)
2507 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2508 (unsigned long) abbrev_base + abbrev_size,
2509 (unsigned long) debug_displays [abbrev_sec].section.size);
460c89ff
NS		 2510 else
2511 process_abbrev_section
341f9135
CC		 2512 (((unsigned char *) debug_displays [abbrev_sec].section.start
2513 + abbrev_base + compunit.cu_abbrev_offset),
2514 ((unsigned char *) debug_displays [abbrev_sec].section.start
2515 + abbrev_base + abbrev_size));
19e6b90e
L		 2516
2517 level = 0;
fd2f0033
TT		 2518 last_level = level;
2519 saved_level = -1;
19e6b90e
L		 2520 while (tags < start)
2521 {
2522 unsigned int bytes_read;
2523 unsigned long abbrev_number;
ec4d4525 2524 unsigned long die_offset;
19e6b90e
L		 2525 abbrev_entry *entry;
2526 abbrev_attr *attr;
fd2f0033 2527 int do_printing = 1;
19e6b90e 2528
ec4d4525
NC		 2529 die_offset = tags - section_begin;
2530
f6f0e17b 2531 abbrev_number = read_uleb128 (tags, & bytes_read, start);
19e6b90e
L		 2532 tags += bytes_read;
2533
eb7cc021
JK		 2534 /* A null DIE marks the end of a list of siblings or it may also be
2535 a section padding. */
19e6b90e
L		 2536 if (abbrev_number == 0)
2537 {
eb7cc021
JK		 2538 /* Check if it can be a section padding for the last CU. */
2539 if (level == 0 && start == end)
2540 {
2541 unsigned char *chk;
2542
2543 for (chk = tags; chk < start; chk++)
2544 if (*chk != 0)
2545 break;
2546 if (chk == start)
2547 break;
2548 }
2549
4337774f
TT		 2550 if (!do_loc && die_offset >= dwarf_start_die
2551 && (dwarf_cutoff_level == -1
2552 || level < dwarf_cutoff_level))
399c99f7
L		 2553 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2554 level, die_offset);
2555
19e6b90e 2556 --level;
ec4d4525
NC		 2557 if (level < 0)
2558 {
2559 static unsigned num_bogus_warns = 0;
2560
2561 if (num_bogus_warns < 3)
2562 {
4723351a
CC		 2563 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2564 die_offset, section->name);
ec4d4525
NC		 2565 num_bogus_warns ++;
2566 if (num_bogus_warns == 3)
2567 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2568 }
2569 }
fd2f0033
TT		 2570 if (dwarf_start_die != 0 && level < saved_level)
2571 return 1;
19e6b90e
L		 2572 continue;
2573 }
2574
4b78141a 2575 if (!do_loc)
fd2f0033
TT		 2576 {
2577 if (dwarf_start_die != 0 && die_offset < dwarf_start_die)
2578 do_printing = 0;
2579 else
2580 {
2581 if (dwarf_start_die != 0 && die_offset == dwarf_start_die)
2582 saved_level = level;
2583 do_printing = (dwarf_cutoff_level == -1
2584 || level < dwarf_cutoff_level);
2585 if (do_printing)
2586 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2587 level, die_offset, abbrev_number);
2588 else if (dwarf_cutoff_level == -1
2589 || last_level < dwarf_cutoff_level)
2590 printf (_(" <%d><%lx>: ...\n"), level, die_offset);
2591 last_level = level;
2592 }
2593 }
cecf136e 2594
19e6b90e
L		 2595 /* Scan through the abbreviation list until we reach the
2596 correct entry. */
2597 for (entry = first_abbrev;
2598 entry && entry->entry != abbrev_number;
2599 entry = entry->next)
2600 continue;
2601
2602 if (entry == NULL)
2603 {
fd2f0033 2604 if (!do_loc && do_printing)
4b78141a
NC		 2605 {
2606 printf ("\n");
2607 fflush (stdout);
2608 }
f3853b34 2609 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
cc86f28f 2610 die_offset, abbrev_number);
19e6b90e
L		 2611 return 0;
2612 }
2613
fd2f0033 2614 if (!do_loc && do_printing)
cc5914eb 2615 printf (" (%s)\n", get_TAG_name (entry->tag));
cecf136e 2616
19e6b90e
L		 2617 switch (entry->tag)
2618 {
2619 default:
2620 need_base_address = 0;
2621 break;
2622 case DW_TAG_compile_unit:
2623 need_base_address = 1;
2624 break;
2625 case DW_TAG_entry_point:
19e6b90e
L		 2626 case DW_TAG_subprogram:
2627 need_base_address = 0;
2628 /* Assuming that there is no DW_AT_frame_base. */
2629 have_frame_base = 0;
2630 break;
2631 }
2632
399c99f7
L		 2633 for (attr = entry->first_attr;
2634 attr && attr->attribute;
2635 attr = attr->next)
4b78141a 2636 {
fd2f0033
TT		 2637 debug_info *arg;
2638
2639 if (! do_loc && do_printing)
4b78141a 2640 /* Show the offset from where the tag was extracted. */
fd2f0033
TT		 2641 printf (" <%lx>", (unsigned long)(tags - section_begin));
2642
82b1b41b
NC		 2643 if (debug_information && unit < alloc_num_debug_info_entries)
2644 arg = debug_information + unit;
2645 else
2646 arg = NULL;
f3853b34 2647
4b78141a
NC		 2648 tags = read_and_display_attr (attr->attribute,
2649 attr->form,
341f9135 2650 tags,
f6f0e17b 2651 end,
341f9135 2652 cu_offset,
4b78141a
NC		 2653 compunit.cu_pointer_size,
2654 offset_size,
2655 compunit.cu_version,
fd2f0033 2656 arg,
341f9135
CC		 2657 do_loc || ! do_printing,
2658 section,
2659 this_set);
4b78141a 2660 }
cecf136e 2661
19e6b90e
L		 2662 if (entry->children)
2663 ++level;
2664 }
2665 }
cecf136e 2666
19e6b90e
L		 2667 /* Set num_debug_info_entries here so that it can be used to check if
2668 we need to process .debug_loc and .debug_ranges sections. */
2669 if ((do_loc || do_debug_loc || do_debug_ranges)
2b6f5997
CC		 2670 && num_debug_info_entries == 0
2671 && ! do_types)
82b1b41b
NC		 2672 {
2673 if (num_units > alloc_num_debug_info_entries)
2674 num_debug_info_entries = alloc_num_debug_info_entries;
2675 else
2676 num_debug_info_entries = num_units;
2677 }
cecf136e 2678
19e6b90e 2679 if (!do_loc)
467c65bc 2680 printf ("\n");
cecf136e 2681
19e6b90e
L		 2682 return 1;
2683}
2684
2685/* Locate and scan the .debug_info section in the file and record the pointer
2686 sizes and offsets for the compilation units in it. Usually an executable
2687 will have just one pointer size, but this is not guaranteed, and so we try
2688 not to make any assumptions. Returns zero upon failure, or the number of
2689 compilation units upon success. */
2690
2691static unsigned int
2692load_debug_info (void * file)
2693{
2694 /* Reset the last pointer size so that we can issue correct error
2695 messages if we are displaying the contents of more than one section. */
2696 last_pointer_size = 0;
2697 warned_about_missing_comp_units = FALSE;
2698
1febe64d 2699 /* If we have already tried and failed to load the .debug_info
657d0d47 2700 section then do not bother to repeat the task. */
cc86f28f 2701 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
1febe64d
NC		 2702 return 0;
2703
19e6b90e
L		 2704 /* If we already have the information there is nothing else to do. */
2705 if (num_debug_info_entries > 0)
2706 return num_debug_info_entries;
2707
341f9135
CC		 2708 /* If this is a DWARF package file, load the CU and TU indexes. */
2709 load_cu_tu_indexes (file);
2710
19e6b90e 2711 if (load_debug_section (info, file)
6f875884 2712 && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0))
19e6b90e 2713 return num_debug_info_entries;
82b1b41b
NC		 2714
2715 if (load_debug_section (info_dwo, file)
2716 && process_debug_info (&debug_displays [info_dwo].section, file,
2717 abbrev_dwo, 1, 0))
4723351a 2718 return num_debug_info_entries;
1febe64d 2719
cc86f28f 2720 num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
1febe64d 2721 return 0;
19e6b90e
L		 2722}
2723
b40bf0a2
NC		 2724/* Read a DWARF .debug_line section header starting at DATA.
2725 Upon success returns an updated DATA pointer and the LINFO
2726 structure and the END_OF_SEQUENCE pointer will be filled in.
2727 Otherwise returns NULL. */
19e6b90e 2728
b40bf0a2
NC		 2729static unsigned char *
2730read_debug_line_header (struct dwarf_section * section,
2731 unsigned char * data,
2732 unsigned char * end,
2733 DWARF2_Internal_LineInfo * linfo,
2734 unsigned char ** end_of_sequence)
2735{
2736 unsigned char *hdrptr;
2737 unsigned int offset_size;
2738 unsigned int initial_length_size;
19e6b90e 2739
b40bf0a2
NC		 2740 /* Extract information from the Line Number Program Header.
2741 (section 6.2.4 in the Dwarf3 doc). */
6937bb54 2742 hdrptr = data;
19e6b90e 2743
b40bf0a2
NC		 2744 /* Get and check the length of the block. */
2745 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 4, end);
19e6b90e 2746
b40bf0a2 2747 if (linfo->li_length == 0xffffffff)
f41e4712
NC		 2748 {
2749 /* This section is 64-bit DWARF 3. */
b40bf0a2 2750 SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end);
f41e4712
NC		 2751 offset_size = 8;
2752 initial_length_size = 12;
2753 }
2754 else
2755 {
2756 offset_size = 4;
2757 initial_length_size = 4;
2758 }
19e6b90e 2759
b40bf0a2 2760 if (linfo->li_length + initial_length_size > section->size)
f41e4712 2761 {
b40bf0a2
NC		 2762 /* If the length is just a bias against the initial_length_size then
2763 this means that the field has a relocation against it which has not
2764 been applied. (Ie we are dealing with an object file, not a linked
2765 binary). Do not complain but instead assume that the rest of the
2766 section applies to this particular header. */
2767 if (linfo->li_length == - initial_length_size)
2768 {
2769 linfo->li_length = section->size - initial_length_size;
2770 }
2771 else
2772 {
f41e4712 2773 warn (_("The line info appears to be corrupt - the section is too small\n"));
b40bf0a2
NC		 2774 return NULL;
2775 }
f41e4712 2776 }
19e6b90e 2777
b40bf0a2
NC		 2778 /* Get and check the version number. */
2779 SAFE_BYTE_GET_AND_INC (linfo->li_version, hdrptr, 2, end);
2780
2781 if (linfo->li_version != 2
2782 && linfo->li_version != 3
2783 && linfo->li_version != 4)
f41e4712
NC		 2784 {
2785 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
b40bf0a2 2786 return NULL;
f41e4712 2787 }
19e6b90e 2788
b40bf0a2
NC		 2789 SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end);
2790 SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end);
0c588247 2791
b40bf0a2 2792 if (linfo->li_version >= 4)
f41e4712 2793 {
b40bf0a2 2794 SAFE_BYTE_GET_AND_INC (linfo->li_max_ops_per_insn, hdrptr, 1, end);
0c588247 2795
b40bf0a2 2796 if (linfo->li_max_ops_per_insn == 0)
f41e4712
NC		 2797 {
2798 warn (_("Invalid maximum operations per insn.\n"));
b40bf0a2 2799 return NULL;
a233b20c 2800 }
f41e4712
NC		 2801 }
2802 else
b40bf0a2 2803 linfo->li_max_ops_per_insn = 1;
0c588247 2804
b40bf0a2 2805 SAFE_BYTE_GET_AND_INC (linfo->li_default_is_stmt, hdrptr, 1, end);
65879393 2806 SAFE_SIGNED_BYTE_GET_AND_INC (linfo->li_line_base, hdrptr, 1, end);
b40bf0a2
NC		 2807 SAFE_BYTE_GET_AND_INC (linfo->li_line_range, hdrptr, 1, end);
2808 SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end);
19e6b90e 2809
b40bf0a2 2810 * end_of_sequence = data + linfo->li_length + initial_length_size;
6937bb54
NC		 2811 /* PR 17512: file:002-117414-0.004. */
2812 if (* end_of_sequence > end)
2813 {
4c219c2e
AM		 2814 warn (_("Line length %s extends beyond end of section\n"),
2815 dwarf_vmatoa ("u", linfo->li_length));
6937bb54
NC		 2816 * end_of_sequence = end;
2817 return NULL;
2818 }
2819
b40bf0a2
NC		 2820 return hdrptr;
2821}
19e6b90e 2822
b40bf0a2
NC		 2823static int
2824display_debug_lines_raw (struct dwarf_section *section,
2825 unsigned char *data,
2826 unsigned char *end)
2827{
2828 unsigned char *start = section->start;
19e6b90e 2829
b40bf0a2
NC		 2830 printf (_("Raw dump of debug contents of section %s:\n\n"),
2831 section->name);
19e6b90e 2832
b40bf0a2
NC		 2833 while (data < end)
2834 {
2835 static DWARF2_Internal_LineInfo saved_linfo;
2836 DWARF2_Internal_LineInfo linfo;
2837 unsigned char *standard_opcodes;
2838 unsigned char *end_of_sequence;
fe59e83d
CC		 2839 unsigned int last_dir_entry = 0;
2840 int i;
19e6b90e 2841
4925cdd7
NC		 2842 if (const_strneq (section->name, ".debug_line.")
2843 /* Note: the following does not apply to .debug_line.dwo sections.
2844 These are full debug_line sections. */
2845 && strcmp (section->name, ".debug_line.dwo") != 0)
19e6b90e 2846 {
b40bf0a2
NC		 2847 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2848 section containing just the Line Number Statements. They are
2849 created by the assembler and intended to be used alongside gcc's
2850 -ffunction-sections command line option. When the linker's
2851 garbage collection decides to discard a .text.<foo> section it
2852 can then also discard the line number information in .debug_line.<foo>.
2853
4925cdd7 2854 Since the section is a fragment it does not have the details
b40bf0a2 2855 needed to fill out a LineInfo structure, so instead we use the
4925cdd7 2856 details from the last full debug_line section that we processed. */
b40bf0a2
NC		 2857 end_of_sequence = end;
2858 standard_opcodes = NULL;
2859 linfo = saved_linfo;
058037d3
NC		 2860 /* PR 17531: file: 0522b371. */
2861 if (linfo.li_line_range == 0)
2862 {
1306a742 2863 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
058037d3
NC		 2864 return 0;
2865 }
b40bf0a2 2866 reset_state_machine (linfo.li_default_is_stmt);
19e6b90e 2867 }
19e6b90e
L		 2868 else
2869 {
b40bf0a2 2870 unsigned char * hdrptr;
19e6b90e 2871
b40bf0a2
NC		 2872 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
2873 & end_of_sequence)) == NULL)
2874 return 0;
19e6b90e 2875
b40bf0a2
NC		 2876 printf (_(" Offset: 0x%lx\n"), (long)(data - start));
2877 printf (_(" Length: %ld\n"), (long) linfo.li_length);
2878 printf (_(" DWARF Version: %d\n"), linfo.li_version);
77ef8654 2879 printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length);
b40bf0a2
NC		 2880 printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length);
2881 if (linfo.li_version >= 4)
2882 printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn);
2883 printf (_(" Initial value of 'is_stmt': %d\n"), linfo.li_default_is_stmt);
2884 printf (_(" Line Base: %d\n"), linfo.li_line_base);
2885 printf (_(" Line Range: %d\n"), linfo.li_line_range);
2886 printf (_(" Opcode Base: %d\n"), linfo.li_opcode_base);
19e6b90e 2887
0a9d414a
NC		 2888 /* PR 17512: file: 1665-6428-0.004. */
2889 if (linfo.li_line_range == 0)
2890 {
2891 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2892 linfo.li_line_range = 1;
2893 }
77ef8654 2894
b40bf0a2 2895 reset_state_machine (linfo.li_default_is_stmt);
19e6b90e 2896
b40bf0a2
NC		 2897 /* Display the contents of the Opcodes table. */
2898 standard_opcodes = hdrptr;
19e6b90e 2899
6937bb54
NC		 2900 /* PR 17512: file: 002-417945-0.004. */
2901 if (standard_opcodes + linfo.li_opcode_base >= end)
2902 {
2903 warn (_("Line Base extends beyond end of section\n"));
2904 return 0;
2905 }
2906
b40bf0a2 2907 printf (_("\n Opcodes:\n"));
19e6b90e 2908
b40bf0a2
NC		 2909 for (i = 1; i < linfo.li_opcode_base; i++)
2910 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
19e6b90e 2911
b40bf0a2
NC		 2912 /* Display the contents of the Directory table. */
2913 data = standard_opcodes + linfo.li_opcode_base - 1;
19e6b90e 2914
b40bf0a2
NC		 2915 if (*data == 0)
2916 printf (_("\n The Directory Table is empty.\n"));
2917 else
2918 {
fe59e83d
CC		 2919 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2920 (long)(data - start));
19e6b90e 2921
6937bb54 2922 while (data < end && *data != 0)
a233b20c 2923 {
6937bb54 2924 printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data);
b40bf0a2
NC		 2925
2926 data += strnlen ((char *) data, end - data) + 1;
a233b20c 2927 }
6937bb54
NC		 2928
2929 /* PR 17512: file: 002-132094-0.004. */
2930 if (data >= end - 1)
2931 break;
b40bf0a2 2932 }
19e6b90e 2933
b40bf0a2
NC		 2934 /* Skip the NUL at the end of the table. */
2935 data++;
19e6b90e 2936
b40bf0a2
NC		 2937 /* Display the contents of the File Name table. */
2938 if (*data == 0)
2939 printf (_("\n The File Name Table is empty.\n"));
2940 else
2941 {
fe59e83d
CC		 2942 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2943 (long)(data - start));
b40bf0a2 2944 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
19e6b90e 2945
6937bb54 2946 while (data < end && *data != 0)
b40bf0a2
NC		 2947 {
2948 unsigned char *name;
2949 unsigned int bytes_read;
19e6b90e 2950
b40bf0a2
NC		 2951 printf (" %d\t", ++state_machine_regs.last_file_entry);
2952 name = data;
2953 data += strnlen ((char *) data, end - data) + 1;
19e6b90e 2954
b40bf0a2
NC		 2955 printf ("%s\t",
2956 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2957 data += bytes_read;
2958 printf ("%s\t",
2959 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2960 data += bytes_read;
2961 printf ("%s\t",
2962 dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));
2963 data += bytes_read;
6937bb54 2964 printf ("%.*s\n", (int)(end - name), name);
19e6b90e 2965
b40bf0a2
NC		 2966 if (data == end)
2967 {
2968 warn (_("Corrupt file name table entry\n"));
2969 break;
2970 }
a233b20c 2971 }
b40bf0a2 2972 }
19e6b90e 2973
b40bf0a2
NC		 2974 /* Skip the NUL at the end of the table. */
2975 data++;
2976 putchar ('\n');
2977 saved_linfo = linfo;
2978 }
19e6b90e 2979
b40bf0a2
NC		 2980 /* Now display the statements. */
2981 if (data >= end_of_sequence)
2982 printf (_(" No Line Number Statements.\n"));
2983 else
2984 {
2985 printf (_(" Line Number Statements:\n"));
19e6b90e 2986
b40bf0a2
NC		 2987 while (data < end_of_sequence)
2988 {
2989 unsigned char op_code;
2990 dwarf_signed_vma adv;
2991 dwarf_vma uladv;
2992 unsigned int bytes_read;
19e6b90e 2993
fe59e83d
CC		 2994 printf (" [0x%08lx]", (long)(data - start));
2995
b40bf0a2 2996 op_code = *data++;
19e6b90e 2997
b40bf0a2 2998 if (op_code >= linfo.li_opcode_base)
19e6b90e 2999 {
b40bf0a2
NC		 3000 op_code -= linfo.li_opcode_base;
3001 uladv = (op_code / linfo.li_line_range);
3002 if (linfo.li_max_ops_per_insn == 1)
3003 {
3004 uladv *= linfo.li_min_insn_length;
3005 state_machine_regs.address += uladv;
3006 printf (_(" Special opcode %d: "
3007 "advance Address by %s to 0x%s"),
3008 op_code, dwarf_vmatoa ("u", uladv),
3009 dwarf_vmatoa ("x", state_machine_regs.address));
3010 }
3011 else
3012 {
3013 state_machine_regs.address
3014 += ((state_machine_regs.op_index + uladv)
3015 / linfo.li_max_ops_per_insn)
3016 * linfo.li_min_insn_length;
3017 state_machine_regs.op_index
3018 = (state_machine_regs.op_index + uladv)
3019 % linfo.li_max_ops_per_insn;
3020 printf (_(" Special opcode %d: "
3021 "advance Address by %s to 0x%s[%d]"),
3022 op_code, dwarf_vmatoa ("u", uladv),
3023 dwarf_vmatoa ("x", state_machine_regs.address),
3024 state_machine_regs.op_index);
3025 }
3026 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
3027 state_machine_regs.line += adv;
3028 printf (_(" and Line by %s to %d\n"),
3029 dwarf_vmatoa ("d", adv), state_machine_regs.line);
19e6b90e 3030 }
b40bf0a2
NC		 3031 else switch (op_code)
3032 {
3033 case DW_LNS_extended_op:
3034 data += process_extended_line_op (data, linfo.li_default_is_stmt, end);
3035 break;
3036
3037 case DW_LNS_copy:
3038 printf (_(" Copy\n"));
3039 break;
3040
3041 case DW_LNS_advance_pc:
3042 uladv = read_uleb128 (data, & bytes_read, end);
3043 data += bytes_read;
3044 if (linfo.li_max_ops_per_insn == 1)
3045 {
3046 uladv *= linfo.li_min_insn_length;
3047 state_machine_regs.address += uladv;
3048 printf (_(" Advance PC by %s to 0x%s\n"),
3049 dwarf_vmatoa ("u", uladv),
3050 dwarf_vmatoa ("x", state_machine_regs.address));
3051 }
3052 else
3053 {
3054 state_machine_regs.address
3055 += ((state_machine_regs.op_index + uladv)
3056 / linfo.li_max_ops_per_insn)
3057 * linfo.li_min_insn_length;
3058 state_machine_regs.op_index
3059 = (state_machine_regs.op_index + uladv)
3060 % linfo.li_max_ops_per_insn;
3061 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3062 dwarf_vmatoa ("u", uladv),
3063 dwarf_vmatoa ("x", state_machine_regs.address),
3064 state_machine_regs.op_index);
3065 }
3066 break;
3067
3068 case DW_LNS_advance_line:
3069 adv = read_sleb128 (data, & bytes_read, end);
3070 data += bytes_read;
3071 state_machine_regs.line += adv;
3072 printf (_(" Advance Line by %s to %d\n"),
3073 dwarf_vmatoa ("d", adv),
3074 state_machine_regs.line);
3075 break;
3076
3077 case DW_LNS_set_file:
3078 adv = read_uleb128 (data, & bytes_read, end);
3079 data += bytes_read;
3080 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3081 dwarf_vmatoa ("d", adv));
3082 state_machine_regs.file = adv;
3083 break;
3084
3085 case DW_LNS_set_column:
3086 uladv = read_uleb128 (data, & bytes_read, end);
3087 data += bytes_read;
3088 printf (_(" Set column to %s\n"),
3089 dwarf_vmatoa ("u", uladv));
3090 state_machine_regs.column = uladv;
3091 break;
3092
3093 case DW_LNS_negate_stmt:
3094 adv = state_machine_regs.is_stmt;
3095 adv = ! adv;
3096 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv));
3097 state_machine_regs.is_stmt = adv;
3098 break;
3099
3100 case DW_LNS_set_basic_block:
3101 printf (_(" Set basic block\n"));
3102 state_machine_regs.basic_block = 1;
3103 break;
3104
3105 case DW_LNS_const_add_pc:
3106 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3107 if (linfo.li_max_ops_per_insn)
3108 {
3109 uladv *= linfo.li_min_insn_length;
3110 state_machine_regs.address += uladv;
3111 printf (_(" Advance PC by constant %s to 0x%s\n"),
3112 dwarf_vmatoa ("u", uladv),
3113 dwarf_vmatoa ("x", state_machine_regs.address));
3114 }
3115 else
3116 {
3117 state_machine_regs.address
3118 += ((state_machine_regs.op_index + uladv)
3119 / linfo.li_max_ops_per_insn)
3120 * linfo.li_min_insn_length;
3121 state_machine_regs.op_index
3122 = (state_machine_regs.op_index + uladv)
3123 % linfo.li_max_ops_per_insn;
3124 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3125 dwarf_vmatoa ("u", uladv),
3126 dwarf_vmatoa ("x", state_machine_regs.address),
3127 state_machine_regs.op_index);
3128 }
3129 break;
3130
3131 case DW_LNS_fixed_advance_pc:
3132 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3133 state_machine_regs.address += uladv;
3134 state_machine_regs.op_index = 0;
3135 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3136 dwarf_vmatoa ("u", uladv),
3137 dwarf_vmatoa ("x", state_machine_regs.address));
3138 break;
3139
3140 case DW_LNS_set_prologue_end:
3141 printf (_(" Set prologue_end to true\n"));
3142 break;
3143
3144 case DW_LNS_set_epilogue_begin:
3145 printf (_(" Set epilogue_begin to true\n"));
3146 break;
3147
3148 case DW_LNS_set_isa:
3149 uladv = read_uleb128 (data, & bytes_read, end);
3150 data += bytes_read;
3151 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv));
3152 break;
3153
3154 default:
3155 printf (_(" Unknown opcode %d with operands: "), op_code);
3156
3157 if (standard_opcodes != NULL)
3158 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3159 {
3160 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3161 &bytes_read, end)),
3162 i == 1 ? "" : ", ");
3163 data += bytes_read;
3164 }
3165 putchar ('\n');
3166 break;
3167 }
19e6b90e 3168 }
b40bf0a2 3169 putchar ('\n');
19e6b90e 3170 }
19e6b90e
L		 3171 }
3172
3173 return 1;
3174}
3175
a262ae96
NC		 3176typedef struct
3177{
467c65bc
NC		 3178 unsigned char *name;
3179 unsigned int directory_index;
3180 unsigned int modification_date;
3181 unsigned int length;
a262ae96
NC		 3182} File_Entry;
3183
3184/* Output a decoded representation of the .debug_line section. */
3185
3186static int
3187display_debug_lines_decoded (struct dwarf_section *section,
3188 unsigned char *data,
3189 unsigned char *end)
3190{
b40bf0a2
NC		 3191 static DWARF2_Internal_LineInfo saved_linfo;
3192
a262ae96
NC		 3193 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3194 section->name);
3195
3196 while (data < end)
3197 {
3198 /* This loop amounts to one iteration per compilation unit. */
91d6fa6a 3199 DWARF2_Internal_LineInfo linfo;
a262ae96
NC		 3200 unsigned char *standard_opcodes;
3201 unsigned char *end_of_sequence;
a262ae96
NC		 3202 int i;
3203 File_Entry *file_table = NULL;
143a3db0 3204 unsigned int n_files = 0;
a262ae96 3205 unsigned char **directory_table = NULL;
143a3db0 3206 unsigned int n_directories = 0;
a262ae96 3207
4925cdd7
NC		 3208 if (const_strneq (section->name, ".debug_line.")
3209 /* Note: the following does not apply to .debug_line.dwo sections.
3210 These are full debug_line sections. */
3211 && strcmp (section->name, ".debug_line.dwo") != 0)
a262ae96 3212 {
4925cdd7 3213 /* See comment in display_debug_lines_raw(). */
b40bf0a2
NC		 3214 end_of_sequence = end;
3215 standard_opcodes = NULL;
3216 linfo = saved_linfo;
058037d3
NC		 3217 /* PR 17531: file: 0522b371. */
3218 if (linfo.li_line_range == 0)
3219 {
1306a742 3220 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
058037d3
NC		 3221 return 0;
3222 }
b40bf0a2 3223 reset_state_machine (linfo.li_default_is_stmt);
a262ae96
NC		 3224 }
3225 else
3226 {
b40bf0a2 3227 unsigned char *hdrptr;
a262ae96 3228
b40bf0a2
NC		 3229 if ((hdrptr = read_debug_line_header (section, data, end, & linfo,
3230 & end_of_sequence)) == NULL)
a233b20c 3231 return 0;
0c588247 3232
058037d3
NC		 3233 /* PR 17531: file: 0522b371. */
3234 if (linfo.li_line_range == 0)
3235 {
3236 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3237 linfo.li_line_range = 1;
3238 }
b40bf0a2 3239 reset_state_machine (linfo.li_default_is_stmt);
a262ae96 3240
b40bf0a2
NC		 3241 /* Save a pointer to the contents of the Opcodes table. */
3242 standard_opcodes = hdrptr;
a262ae96 3243
b40bf0a2
NC		 3244 /* Traverse the Directory table just to count entries. */
3245 data = standard_opcodes + linfo.li_opcode_base - 1;
3246 if (*data != 0)
3247 {
3248 unsigned char *ptr_directory_table = data;
a262ae96 3249
b40bf0a2
NC		 3250 while (*data != 0)
3251 {
3252 data += strnlen ((char *) data, end - data) + 1;
3253 n_directories++;
3254 }
a262ae96 3255
b40bf0a2
NC		 3256 /* Go through the directory table again to save the directories. */
3257 directory_table = (unsigned char **)
3258 xmalloc (n_directories * sizeof (unsigned char *));
a262ae96 3259
b40bf0a2
NC		 3260 i = 0;
3261 while (*ptr_directory_table != 0)
3262 {
3263 directory_table[i] = ptr_directory_table;
3264 ptr_directory_table += strnlen ((char *) ptr_directory_table,
3265 ptr_directory_table - end) + 1;
3266 i++;
3267 }
a262ae96 3268 }
b40bf0a2
NC		 3269 /* Skip the NUL at the end of the table. */
3270 data++;
a262ae96 3271
b40bf0a2
NC		 3272 /* Traverse the File Name table just to count the entries. */
3273 if (*data != 0)
3274 {
3275 unsigned char *ptr_file_name_table = data;
a262ae96 3276
b40bf0a2
NC		 3277 while (*data != 0)
3278 {
3279 unsigned int bytes_read;
a262ae96 3280
b40bf0a2
NC		 3281 /* Skip Name, directory index, last modification time and length
3282 of file. */
3283 data += strnlen ((char *) data, end - data) + 1;
3284 read_uleb128 (data, & bytes_read, end);
3285 data += bytes_read;
3286 read_uleb128 (data, & bytes_read, end);
3287 data += bytes_read;
3288 read_uleb128 (data, & bytes_read, end);
3289 data += bytes_read;
a262ae96 3290
b40bf0a2
NC		 3291 n_files++;
3292 }
a262ae96 3293
b40bf0a2
NC		 3294 /* Go through the file table again to save the strings. */
3295 file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry));
a262ae96 3296
b40bf0a2
NC		 3297 i = 0;
3298 while (*ptr_file_name_table != 0)
3299 {
3300 unsigned int bytes_read;
3301
3302 file_table[i].name = ptr_file_name_table;
3303 ptr_file_name_table += strnlen ((char *) ptr_file_name_table,
3304 end - ptr_file_name_table) + 1;
3305
3306 /* We are not interested in directory, time or size. */
3307 file_table[i].directory_index = read_uleb128 (ptr_file_name_table,
3308 & bytes_read, end);
3309 ptr_file_name_table += bytes_read;
3310 file_table[i].modification_date = read_uleb128 (ptr_file_name_table,
3311 & bytes_read, end);
3312 ptr_file_name_table += bytes_read;
3313 file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end);
3314 ptr_file_name_table += bytes_read;
3315 i++;
3316 }
3317 i = 0;
a262ae96 3318
b40bf0a2
NC		 3319 /* Print the Compilation Unit's name and a header. */
3320 if (directory_table == NULL)
3321 {
3322 printf (_("CU: %s:\n"), file_table[0].name);
3323 printf (_("File name Line number Starting address\n"));
3324 }
3325 else
3326 {
3327 unsigned int ix = file_table[0].directory_index;
3328 const char *directory = ix ? (char *)directory_table[ix - 1] : ".";
a262ae96 3329
b40bf0a2
NC		 3330 if (do_wide || strlen (directory) < 76)
3331 printf (_("CU: %s/%s:\n"), directory, file_table[0].name);
3332 else
3333 printf ("%s:\n", file_table[0].name);
0c588247 3334
b40bf0a2
NC		 3335 printf (_("File name Line number Starting address\n"));
3336 }
3337 }
cc5914eb 3338
b40bf0a2
NC		 3339 /* Skip the NUL at the end of the table. */
3340 data++;
a262ae96 3341
b40bf0a2
NC		 3342 saved_linfo = linfo;
3343 }
a262ae96
NC		 3344
3345 /* This loop iterates through the Dwarf Line Number Program. */
3346 while (data < end_of_sequence)
3347 {
3348 unsigned char op_code;
3349 int adv;
3350 unsigned long int uladv;
3351 unsigned int bytes_read;
3352 int is_special_opcode = 0;
3353
3354 op_code = *data++;
a262ae96 3355
91d6fa6a 3356 if (op_code >= linfo.li_opcode_base)
a262ae96 3357 {
91d6fa6a 3358 op_code -= linfo.li_opcode_base;
a233b20c
JJ		 3359 uladv = (op_code / linfo.li_line_range);
3360 if (linfo.li_max_ops_per_insn == 1)
3361 {
3362 uladv *= linfo.li_min_insn_length;
3363 state_machine_regs.address += uladv;
3364 }
3365 else
3366 {
3367 state_machine_regs.address
3368 += ((state_machine_regs.op_index + uladv)
3369 / linfo.li_max_ops_per_insn)
b40bf0a2 3370 * linfo.li_min_insn_length;
a233b20c
JJ		 3371 state_machine_regs.op_index
3372 = (state_machine_regs.op_index + uladv)
b40bf0a2 3373 % linfo.li_max_ops_per_insn;
a233b20c 3374 }
a262ae96 3375
91d6fa6a 3376 adv = (op_code % linfo.li_line_range) + linfo.li_line_base;
a262ae96
NC		 3377 state_machine_regs.line += adv;
3378 is_special_opcode = 1;
3379 }
3380 else switch (op_code)
b40bf0a2
NC		 3381 {
3382 case DW_LNS_extended_op:
3383 {
3384 unsigned int ext_op_code_len;
3385 unsigned char ext_op_code;
3386 unsigned char *op_code_data = data;
3387
3388 ext_op_code_len = read_uleb128 (op_code_data, &bytes_read,
3389 end_of_sequence);
3390 op_code_data += bytes_read;
3391
3392 if (ext_op_code_len == 0)
3393 {
f41e4712 3394 warn (_("Badly formed extended line op encountered!\n"));
b40bf0a2
NC		 3395 break;
3396 }
3397 ext_op_code_len += bytes_read;
3398 ext_op_code = *op_code_data++;
3399
3400 switch (ext_op_code)
3401 {
3402 case DW_LNE_end_sequence:
3403 reset_state_machine (linfo.li_default_is_stmt);
3404 break;
3405 case DW_LNE_set_address:
3406 SAFE_BYTE_GET_AND_INC (state_machine_regs.address,
87bc83b3
CC		 3407 op_code_data,
3408 ext_op_code_len - bytes_read - 1,
b40bf0a2
NC		 3409 end);
3410 state_machine_regs.op_index = 0;
3411 break;
3412 case DW_LNE_define_file:
3413 {
3414 file_table = (File_Entry *) xrealloc
3415 (file_table, (n_files + 1) * sizeof (File_Entry));
3416
3417 ++state_machine_regs.last_file_entry;
3418 /* Source file name. */
3419 file_table[n_files].name = op_code_data;
3420 op_code_data += strlen ((char *) op_code_data) + 1;
3421 /* Directory index. */
3422 file_table[n_files].directory_index =
3423 read_uleb128 (op_code_data, & bytes_read,
3424 end_of_sequence);
3425 op_code_data += bytes_read;
3426 /* Last modification time. */
3427 file_table[n_files].modification_date =
3428 read_uleb128 (op_code_data, & bytes_read,
3429 end_of_sequence);
3430 op_code_data += bytes_read;
3431 /* File length. */
3432 file_table[n_files].length =
3433 read_uleb128 (op_code_data, & bytes_read,
3434 end_of_sequence);
3435
3436 n_files++;
3437 break;
3438 }
3439 case DW_LNE_set_discriminator:
3440 case DW_LNE_HP_set_sequence:
3441 /* Simply ignored. */
3442 break;
3443
3444 default:
3445 printf (_("UNKNOWN (%u): length %d\n"),
3446 ext_op_code, ext_op_code_len - bytes_read);
3447 break;
3448 }
3449 data += ext_op_code_len;
3450 break;
3451 }
3452 case DW_LNS_copy:
3453 break;
3454
3455 case DW_LNS_advance_pc:
3456 uladv = read_uleb128 (data, & bytes_read, end);
3457 data += bytes_read;
3458 if (linfo.li_max_ops_per_insn == 1)
3459 {
3460 uladv *= linfo.li_min_insn_length;
3461 state_machine_regs.address += uladv;
3462 }
3463 else
3464 {
3465 state_machine_regs.address
3466 += ((state_machine_regs.op_index + uladv)
3467 / linfo.li_max_ops_per_insn)
3468 * linfo.li_min_insn_length;
3469 state_machine_regs.op_index
3470 = (state_machine_regs.op_index + uladv)
3471 % linfo.li_max_ops_per_insn;
3472 }
3473 break;
3474
3475 case DW_LNS_advance_line:
3476 adv = read_sleb128 (data, & bytes_read, end);
3477 data += bytes_read;
3478 state_machine_regs.line += adv;
3479 break;
3480
3481 case DW_LNS_set_file:
3482 adv = read_uleb128 (data, & bytes_read, end);
3483 data += bytes_read;
3484 state_machine_regs.file = adv;
3485
3486 if (file_table == NULL)
3487 printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1);
3488 else if (file_table[state_machine_regs.file - 1].directory_index == 0)
3489 /* If directory index is 0, that means current directory. */
3490 printf ("\n./%s:[++]\n",
3491 file_table[state_machine_regs.file - 1].name);
3492 else if (directory_table == NULL)
3493 printf (_("\n [Use directory table entry %d]\n"),
3494 file_table[state_machine_regs.file - 1].directory_index - 1);
3495 else
3496 /* The directory index starts counting at 1. */
3497 printf ("\n%s/%s:\n",
3498 directory_table[file_table[state_machine_regs.file - 1].directory_index - 1],
3499 file_table[state_machine_regs.file - 1].name);
3500 break;
3501
3502 case DW_LNS_set_column:
3503 uladv = read_uleb128 (data, & bytes_read, end);
3504 data += bytes_read;
3505 state_machine_regs.column = uladv;
3506 break;
3507
3508 case DW_LNS_negate_stmt:
3509 adv = state_machine_regs.is_stmt;
3510 adv = ! adv;
3511 state_machine_regs.is_stmt = adv;
3512 break;
3513
3514 case DW_LNS_set_basic_block:
3515 state_machine_regs.basic_block = 1;
3516 break;
3517
3518 case DW_LNS_const_add_pc:
3519 uladv = ((255 - linfo.li_opcode_base) / linfo.li_line_range);
3520 if (linfo.li_max_ops_per_insn == 1)
3521 {
3522 uladv *= linfo.li_min_insn_length;
3523 state_machine_regs.address += uladv;
3524 }
3525 else
3526 {
3527 state_machine_regs.address
3528 += ((state_machine_regs.op_index + uladv)
3529 / linfo.li_max_ops_per_insn)
3530 * linfo.li_min_insn_length;
3531 state_machine_regs.op_index
3532 = (state_machine_regs.op_index + uladv)
3533 % linfo.li_max_ops_per_insn;
3534 }
3535 break;
3536
3537 case DW_LNS_fixed_advance_pc:
3538 SAFE_BYTE_GET_AND_INC (uladv, data, 2, end);
3539 state_machine_regs.address += uladv;
3540 state_machine_regs.op_index = 0;
3541 break;
3542
3543 case DW_LNS_set_prologue_end:
3544 break;
3545
3546 case DW_LNS_set_epilogue_begin:
3547 break;
3548
3549 case DW_LNS_set_isa:
3550 uladv = read_uleb128 (data, & bytes_read, end);
3551 data += bytes_read;
3552 printf (_(" Set ISA to %lu\n"), uladv);
3553 break;
3554
3555 default:
3556 printf (_(" Unknown opcode %d with operands: "), op_code);
3557
3558 if (standard_opcodes != NULL)
3559 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
3560 {
3561 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data,
3562 &bytes_read, end)),
3563 i == 1 ? "" : ", ");
3564 data += bytes_read;
3565 }
3566 putchar ('\n');
3567 break;
3568 }
a262ae96
NC		 3569
3570 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3571 to the DWARF address/line matrix. */
3572 if ((is_special_opcode) || (op_code == DW_LNE_end_sequence)
3573 || (op_code == DW_LNS_copy))
3574 {
3575 const unsigned int MAX_FILENAME_LENGTH = 35;
b40bf0a2 3576 char *fileName;
a262ae96 3577 char *newFileName = NULL;
b40bf0a2
NC		 3578 size_t fileNameLength;
3579
3580 if (file_table)
3581 fileName = (char *) file_table[state_machine_regs.file - 1].name;
3582 else
3583 fileName = "<unknown>";
3584
3585 fileNameLength = strlen (fileName);
a262ae96
NC		 3586
3587 if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide))
3588 {
3f5e193b 3589 newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1);
a262ae96
NC		 3590 /* Truncate file name */
3591 strncpy (newFileName,
3592 fileName + fileNameLength - MAX_FILENAME_LENGTH,
3593 MAX_FILENAME_LENGTH + 1);
3594 }
3595 else
3596 {
3f5e193b 3597 newFileName = (char *) xmalloc (fileNameLength + 1);
a262ae96
NC		 3598 strncpy (newFileName, fileName, fileNameLength + 1);
3599 }
3600
3601 if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
3602 {
a233b20c 3603 if (linfo.li_max_ops_per_insn == 1)
467c65bc
NC		 3604 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n",
3605 newFileName, state_machine_regs.line,
a233b20c
JJ		 3606 state_machine_regs.address);
3607 else
467c65bc
NC		 3608 printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3609 newFileName, state_machine_regs.line,
a233b20c
JJ		 3610 state_machine_regs.address,
3611 state_machine_regs.op_index);
a262ae96
NC		 3612 }
3613 else
3614 {
a233b20c 3615 if (linfo.li_max_ops_per_insn == 1)
467c65bc
NC		 3616 printf ("%s %11d %#18" DWARF_VMA_FMT "x\n",
3617 newFileName, state_machine_regs.line,
a233b20c
JJ		 3618 state_machine_regs.address);
3619 else
467c65bc
NC		 3620 printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n",
3621 newFileName, state_machine_regs.line,
a233b20c
JJ		 3622 state_machine_regs.address,
3623 state_machine_regs.op_index);
a262ae96
NC		 3624 }
3625
3626 if (op_code == DW_LNE_end_sequence)
3627 printf ("\n");
3628
3629 free (newFileName);
3630 }
3631 }
b40bf0a2
NC		 3632
3633 if (file_table)
3634 {
3635 free (file_table);
3636 file_table = NULL;
3637 n_files = 0;
3638 }
3639
3640 if (directory_table)
3641 {
3642 free (directory_table);
3643 directory_table = NULL;
3644 n_directories = 0;
3645 }
3646
a262ae96
NC		 3647 putchar ('\n');
3648 }
3649
3650 return 1;
3651}
3652
3653static int
1c4cc746 3654display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
a262ae96
NC		 3655{
3656 unsigned char *data = section->start;
3657 unsigned char *end = data + section->size;
4cb93e3b
TG		 3658 int retValRaw = 1;
3659 int retValDecoded = 1;
a262ae96 3660
008f4c78
NC		 3661 if (do_debug_lines == 0)
3662 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
3663
4cb93e3b 3664 if (do_debug_lines & FLAG_DEBUG_LINES_RAW)
a262ae96
NC		 3665 retValRaw = display_debug_lines_raw (section, data, end);
3666
4cb93e3b 3667 if (do_debug_lines & FLAG_DEBUG_LINES_DECODED)
a262ae96
NC		 3668 retValDecoded = display_debug_lines_decoded (section, data, end);
3669
4cb93e3b 3670 if (!retValRaw || !retValDecoded)
a262ae96
NC		 3671 return 0;
3672
3673 return 1;
3674}
3675
6e3d6dc1
NC		 3676static debug_info *
3677find_debug_info_for_offset (unsigned long offset)
3678{
3679 unsigned int i;
3680
3681 if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE)
3682 return NULL;
3683
3684 for (i = 0; i < num_debug_info_entries; i++)
3685 if (debug_information[i].cu_offset == offset)
3686 return debug_information + i;
3687
3688 return NULL;
3689}
3690
459d52c8
DE		 3691static const char *
3692get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind)
3693{
3694 /* See gdb/gdb-index.h. */
3695 static const char * const kinds[] =
3696 {
3697 N_ ("no info"),
3698 N_ ("type"),
3699 N_ ("variable"),
3700 N_ ("function"),
3701 N_ ("other"),
3702 N_ ("unused5"),
3703 N_ ("unused6"),
3704 N_ ("unused7")
3705 };
3706
3707 return _ (kinds[kind]);
3708}
3709
19e6b90e 3710static int
459d52c8
DE		 3711display_debug_pubnames_worker (struct dwarf_section *section,
3712 void *file ATTRIBUTE_UNUSED,
3713 int is_gnu)
19e6b90e 3714{
91d6fa6a 3715 DWARF2_Internal_PubNames names;
19e6b90e
L		 3716 unsigned char *start = section->start;
3717 unsigned char *end = start + section->size;
3718
6e3d6dc1
NC		 3719 /* It does not matter if this load fails,
3720 we test for that later on. */
3721 load_debug_info (file);
3722
19e6b90e
L		 3723 printf (_("Contents of the %s section:\n\n"), section->name);
3724
3725 while (start < end)
3726 {
3727 unsigned char *data;
362beea4 3728 unsigned char *adr;
834f871c 3729 dwarf_vma offset;
bf5117e3 3730 unsigned int offset_size, initial_length_size;
19e6b90e
L		 3731
3732 data = start;
3733
0c588247 3734 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end);
91d6fa6a 3735 if (names.pn_length == 0xffffffff)
19e6b90e 3736 {
0c588247 3737 SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end);
19e6b90e
L		 3738 offset_size = 8;
3739 initial_length_size = 12;
3740 }
3741 else
3742 {
3743 offset_size = 4;
3744 initial_length_size = 4;
3745 }
3746
0c588247
NC		 3747 SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end);
3748 SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end);
6e3d6dc1
NC		 3749
3750 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
3751 && num_debug_info_entries > 0
91d6fa6a 3752 && find_debug_info_for_offset (names.pn_offset) == NULL)
6e3d6dc1 3753 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 3754 (unsigned long) names.pn_offset, section->name);
cecf136e 3755
0c588247 3756 SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end);
19e6b90e 3757
362beea4 3758 adr = start + names.pn_length + initial_length_size;
058037d3 3759 /* PR 17531: file: 7615b6b2. */
57028622
NC		 3760 if ((dwarf_signed_vma) names.pn_length < 0
3761 /* PR 17531: file: a5dbeaa7. */
362beea4 3762 || adr < start)
058037d3
NC		 3763 {
3764 warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length);
3765 start = end;
3766 }
3767 else
362beea4
NC		 3768 start = adr;
3769
058037d3
NC		 3770 printf (_(" Length: %ld\n"),
3771 (long) names.pn_length);
3772 printf (_(" Version: %d\n"),
3773 names.pn_version);
3774 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3775 (unsigned long) names.pn_offset);
3776 printf (_(" Size of area in .debug_info section: %ld\n"),
3777 (long) names.pn_size);
19e6b90e 3778
91d6fa6a 3779 if (names.pn_version != 2 && names.pn_version != 3)
19e6b90e
L		 3780 {
3781 static int warned = 0;
3782
3783 if (! warned)
3784 {
3785 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3786 warned = 1;
3787 }
3788
3789 continue;
3790 }
3791
459d52c8
DE		 3792 if (is_gnu)
3793 printf (_("\n Offset Kind Name\n"));
3794 else
3795 printf (_("\n Offset\tName\n"));
19e6b90e
L		 3796
3797 do
3798 {
f41e4712
NC		 3799 bfd_size_type maxprint;
3800
0c588247 3801 SAFE_BYTE_GET (offset, data, offset_size, end);
19e6b90e
L		 3802
3803 if (offset != 0)
3804 {
3805 data += offset_size;
f41e4712
NC		 3806 if (data >= end)
3807 break;
3808 maxprint = (end - data) - 1;
3809
459d52c8
DE		 3810 if (is_gnu)
3811 {
3812 unsigned int kind_data;
3813 gdb_index_symbol_kind kind;
3814 const char *kind_name;
3815 int is_static;
3816
3817 SAFE_BYTE_GET (kind_data, data, 1, end);
3818 data++;
f41e4712 3819 maxprint --;
459d52c8
DE		 3820 /* GCC computes the kind as the upper byte in the CU index
3821 word, and then right shifts it by the CU index size.
3822 Left shift KIND to where the gdb-index.h accessor macros
3823 can use it. */
3824 kind_data <<= GDB_INDEX_CU_BITSIZE;
3825 kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data);
3826 kind_name = get_gdb_index_symbol_kind_name (kind);
3827 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data);
f41e4712 3828 printf (" %-6lx %s,%-10s %.*s\n",
834f871c 3829 (unsigned long) offset, is_static ? _("s") : _("g"),
f41e4712 3830 kind_name, (int) maxprint, data);
459d52c8
DE		 3831 }
3832 else
834f871c 3833 printf (" %-6lx\t%.*s\n", (unsigned long) offset, (int) maxprint, data);
f41e4712
NC		 3834
3835 data += strnlen ((char *) data, maxprint) + 1;
3836 if (data >= end)
3837 break;
19e6b90e
L		 3838 }
3839 }
3840 while (offset != 0);
3841 }
3842
3843 printf ("\n");
3844 return 1;
3845}
3846
459d52c8
DE		 3847static int
3848display_debug_pubnames (struct dwarf_section *section, void *file)
3849{
3850 return display_debug_pubnames_worker (section, file, 0);
3851}
3852
3853static int
3854display_debug_gnu_pubnames (struct dwarf_section *section, void *file)
3855{
3856 return display_debug_pubnames_worker (section, file, 1);
3857}
3858
19e6b90e
L		 3859static int
3860display_debug_macinfo (struct dwarf_section *section,
3861 void *file ATTRIBUTE_UNUSED)
3862{
3863 unsigned char *start = section->start;
3864 unsigned char *end = start + section->size;
3865 unsigned char *curr = start;
3866 unsigned int bytes_read;
3867 enum dwarf_macinfo_record_type op;
3868
3869 printf (_("Contents of the %s section:\n\n"), section->name);
3870
3871 while (curr < end)
3872 {
3873 unsigned int lineno;
0c588247 3874 const unsigned char *string;
19e6b90e 3875
3f5e193b 3876 op = (enum dwarf_macinfo_record_type) *curr;
19e6b90e
L		 3877 curr++;
3878
3879 switch (op)
3880 {
3881 case DW_MACINFO_start_file:
3882 {
3883 unsigned int filenum;
3884
f6f0e17b 3885 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 3886 curr += bytes_read;
f6f0e17b 3887 filenum = read_uleb128 (curr, & bytes_read, end);
19e6b90e
L		 3888 curr += bytes_read;
3889
3890 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3891 lineno, filenum);
3892 }
3893 break;
3894
3895 case DW_MACINFO_end_file:
3896 printf (_(" DW_MACINFO_end_file\n"));
3897 break;
3898
3899 case DW_MACINFO_define:
f6f0e17b 3900 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 3901 curr += bytes_read;
0c588247
NC		 3902 string = curr;
3903 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 3904 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3905 lineno, string);
3906 break;
3907
3908 case DW_MACINFO_undef:
f6f0e17b 3909 lineno = read_uleb128 (curr, & bytes_read, end);
19e6b90e 3910 curr += bytes_read;
0c588247
NC		 3911 string = curr;
3912 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 3913 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3914 lineno, string);
3915 break;
3916
3917 case DW_MACINFO_vendor_ext:
3918 {
3919 unsigned int constant;
3920
f6f0e17b 3921 constant = read_uleb128 (curr, & bytes_read, end);
19e6b90e 3922 curr += bytes_read;
0c588247
NC		 3923 string = curr;
3924 curr += strnlen ((char *) string, end - string) + 1;
19e6b90e
L		 3925 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3926 constant, string);
3927 }
3928 break;
3929 }
3930 }
3931
3932 return 1;
3933}
3934
4ccf1e31
JJ		 3935/* Given LINE_OFFSET into the .debug_line section, attempt to return
3936 filename and dirname corresponding to file name table entry with index
3937 FILEIDX. Return NULL on failure. */
3938
3939static unsigned char *
f6f0e17b
NC		 3940get_line_filename_and_dirname (dwarf_vma line_offset,
3941 dwarf_vma fileidx,
4ccf1e31
JJ		 3942 unsigned char **dir_name)
3943{
3944 struct dwarf_section *section = &debug_displays [line].section;
3945 unsigned char *hdrptr, *dirtable, *file_name;
3946 unsigned int offset_size, initial_length_size;
3947 unsigned int version, opcode_base, bytes_read;
3948 dwarf_vma length, diridx;
f6f0e17b 3949 const unsigned char * end;
4ccf1e31
JJ		 3950
3951 *dir_name = NULL;
3952 if (section->start == NULL
3953 || line_offset >= section->size
3954 || fileidx == 0)
3955 return NULL;
3956
3957 hdrptr = section->start + line_offset;
f6f0e17b 3958 end = section->start + section->size;
0c588247
NC		 3959
3960 SAFE_BYTE_GET_AND_INC (length, hdrptr, 4, end);
4ccf1e31
JJ		 3961 if (length == 0xffffffff)
3962 {
3963 /* This section is 64-bit DWARF 3. */
0c588247 3964 SAFE_BYTE_GET_AND_INC (length, hdrptr, 8, end);
4ccf1e31
JJ		 3965 offset_size = 8;
3966 initial_length_size = 12;
3967 }
3968 else
3969 {
3970 offset_size = 4;
3971 initial_length_size = 4;
3972 }
3973 if (length + initial_length_size > section->size)
3974 return NULL;
0c588247
NC		 3975
3976 SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end);
4ccf1e31
JJ		 3977 if (version != 2 && version != 3 && version != 4)
3978 return NULL;
3979 hdrptr += offset_size + 1;/* Skip prologue_length and min_insn_length. */
3980 if (version >= 4)
3981 hdrptr++; /* Skip max_ops_per_insn. */
3982 hdrptr += 3; /* Skip default_is_stmt, line_base, line_range. */
0c588247
NC		 3983
3984 SAFE_BYTE_GET_AND_INC (opcode_base, hdrptr, 1, end);
4ccf1e31
JJ		 3985 if (opcode_base == 0)
3986 return NULL;
0c588247 3987
4ccf1e31
JJ		 3988 hdrptr += opcode_base - 1;
3989 dirtable = hdrptr;
3990 /* Skip over dirname table. */
3991 while (*hdrptr != '\0')
0c588247 3992 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
4ccf1e31
JJ		 3993 hdrptr++; /* Skip the NUL at the end of the table. */
3994 /* Now skip over preceding filename table entries. */
3995 for (; *hdrptr != '\0' && fileidx > 1; fileidx--)
3996 {
0c588247 3997 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
f6f0e17b 3998 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31 3999 hdrptr += bytes_read;
f6f0e17b 4000 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31 4001 hdrptr += bytes_read;
f6f0e17b 4002 read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31
JJ		 4003 hdrptr += bytes_read;
4004 }
f6f0e17b 4005 if (hdrptr == end || *hdrptr == '\0')
4ccf1e31
JJ		 4006 return NULL;
4007 file_name = hdrptr;
0c588247 4008 hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1;
f6f0e17b 4009 diridx = read_uleb128 (hdrptr, &bytes_read, end);
4ccf1e31
JJ		 4010 if (diridx == 0)
4011 return file_name;
4012 for (; *dirtable != '\0' && diridx > 1; diridx--)
0c588247 4013 dirtable += strnlen ((char *) dirtable, end - dirtable) + 1;
4ccf1e31
JJ		 4014 if (*dirtable == '\0')
4015 return NULL;
4016 *dir_name = dirtable;
4017 return file_name;
4018}
4019
4020static int
4021display_debug_macro (struct dwarf_section *section,
4022 void *file)
4023{
4024 unsigned char *start = section->start;
4025 unsigned char *end = start + section->size;
4026 unsigned char *curr = start;
4027 unsigned char *extended_op_buf[256];
4028 unsigned int bytes_read;
4029
4030 load_debug_section (str, file);
4031 load_debug_section (line, file);
4032
4033 printf (_("Contents of the %s section:\n\n"), section->name);
4034
4035 while (curr < end)
4036 {
4037 unsigned int lineno, version, flags;
4038 unsigned int offset_size = 4;
0c588247 4039 const unsigned char *string;
4ccf1e31
JJ		 4040 dwarf_vma line_offset = 0, sec_offset = curr - start, offset;
4041 unsigned char **extended_ops = NULL;
4042
0c588247 4043 SAFE_BYTE_GET_AND_INC (version, curr, 2, end);
4ccf1e31
JJ		 4044 if (version != 4)
4045 {
4046 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4047 section->name);
4048 return 0;
4049 }
4050
0c588247 4051 SAFE_BYTE_GET_AND_INC (flags, curr, 1, end);
4ccf1e31
JJ		 4052 if (flags & 1)
4053 offset_size = 8;
4054 printf (_(" Offset: 0x%lx\n"),
4055 (unsigned long) sec_offset);
4056 printf (_(" Version: %d\n"), version);
4057 printf (_(" Offset size: %d\n"), offset_size);
4058 if (flags & 2)
4059 {
0c588247 4060 SAFE_BYTE_GET_AND_INC (line_offset, curr, offset_size, end);
4ccf1e31
JJ		 4061 printf (_(" Offset into .debug_line: 0x%lx\n"),
4062 (unsigned long) line_offset);
4063 }
4064 if (flags & 4)
4065 {
0c588247 4066 unsigned int i, count, op;
4ccf1e31 4067 dwarf_vma nargs, n;
0c588247
NC		 4068
4069 SAFE_BYTE_GET_AND_INC (count, curr, 1, end);
bf5117e3 4070
4ccf1e31
JJ		 4071 memset (extended_op_buf, 0, sizeof (extended_op_buf));
4072 extended_ops = extended_op_buf;
4073 if (count)
4074 {
4075 printf (_(" Extension opcode arguments:\n"));
4076 for (i = 0; i < count; i++)
4077 {
0c588247 4078 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4ccf1e31 4079 extended_ops[op] = curr;
f6f0e17b 4080 nargs = read_uleb128 (curr, &bytes_read, end);
4ccf1e31
JJ		 4081 curr += bytes_read;
4082 if (nargs == 0)
4083 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op);
4084 else
4085 {
4086 printf (_(" DW_MACRO_GNU_%02x arguments: "), op);
4087 for (n = 0; n < nargs; n++)
4088 {
0c588247
NC		 4089 unsigned int form;
4090
4091 SAFE_BYTE_GET_AND_INC (form, curr, 1, end);
4ccf1e31
JJ		 4092 printf ("%s%s", get_FORM_name (form),
4093 n == nargs - 1 ? "\n" : ", ");
4094 switch (form)
4095 {
4096 case DW_FORM_data1:
4097 case DW_FORM_data2:
4098 case DW_FORM_data4:
4099 case DW_FORM_data8:
4100 case DW_FORM_sdata:
4101 case DW_FORM_udata:
4102 case DW_FORM_block:
4103 case DW_FORM_block1:
4104 case DW_FORM_block2:
4105 case DW_FORM_block4:
4106 case DW_FORM_flag:
4107 case DW_FORM_string:
4108 case DW_FORM_strp:
4109 case DW_FORM_sec_offset:
4110 break;
4111 default:
4112 error (_("Invalid extension opcode form %s\n"),
4113 get_FORM_name (form));
4114 return 0;
4115 }
4116 }
4117 }
4118 }
4119 }
4120 }
4121 printf ("\n");
4122
4123 while (1)
4124 {
4125 unsigned int op;
4126
4127 if (curr >= end)
4128 {
4129 error (_(".debug_macro section not zero terminated\n"));
4130 return 0;
4131 }
4132
0c588247 4133 SAFE_BYTE_GET_AND_INC (op, curr, 1, end);
4ccf1e31
JJ		 4134 if (op == 0)
4135 break;
4136
4137 switch (op)
4138 {
4139 case DW_MACRO_GNU_start_file:
4140 {
4141 unsigned int filenum;
4142 unsigned char *file_name = NULL, *dir_name = NULL;
4143
f6f0e17b 4144 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4145 curr += bytes_read;
f6f0e17b 4146 filenum = read_uleb128 (curr, &bytes_read, end);
4ccf1e31
JJ		 4147 curr += bytes_read;
4148
4149 if ((flags & 2) == 0)
4150 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4151 else
4152 file_name
4153 = get_line_filename_and_dirname (line_offset, filenum,
4154 &dir_name);
4155 if (file_name == NULL)
4156 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4157 lineno, filenum);
4158 else
4159 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4160 lineno, filenum,
4161 dir_name != NULL ? (const char *) dir_name : "",
4162 dir_name != NULL ? "/" : "", file_name);
4163 }
4164 break;
4165
4166 case DW_MACRO_GNU_end_file:
4167 printf (_(" DW_MACRO_GNU_end_file\n"));
4168 break;
4169
4170 case DW_MACRO_GNU_define:
f6f0e17b 4171 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4172 curr += bytes_read;
0c588247
NC		 4173 string = curr;
4174 curr += strnlen ((char *) string, end - string) + 1;
4ccf1e31
JJ		 4175 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4176 lineno, string);
4177 break;
4178
4179 case DW_MACRO_GNU_undef:
f6f0e17b 4180 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4181 curr += bytes_read;
0c588247
NC		 4182 string = curr;
4183 curr += strnlen ((char *) string, end - string) + 1;
4ccf1e31
JJ		 4184 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4185 lineno, string);
4186 break;
4187
4188 case DW_MACRO_GNU_define_indirect:
f6f0e17b 4189 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4190 curr += bytes_read;
0c588247 4191 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4ccf1e31
JJ		 4192 string = fetch_indirect_string (offset);
4193 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4194 lineno, string);
4195 break;
4196
4197 case DW_MACRO_GNU_undef_indirect:
f6f0e17b 4198 lineno = read_uleb128 (curr, &bytes_read, end);
4ccf1e31 4199 curr += bytes_read;
0c588247 4200 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4ccf1e31
JJ		 4201 string = fetch_indirect_string (offset);
4202 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4203 lineno, string);
4204 break;
4205
4206 case DW_MACRO_GNU_transparent_include:
0c588247 4207 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
4ccf1e31
JJ		 4208 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4209 (unsigned long) offset);
4210 break;
4211
a081f3cd 4212 case DW_MACRO_GNU_define_indirect_alt:
f6f0e17b 4213 lineno = read_uleb128 (curr, &bytes_read, end);
a081f3cd 4214 curr += bytes_read;
0c588247 4215 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
a081f3cd
JJ		 4216 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4217 lineno, (unsigned long) offset);
4218 break;
4219
4220 case DW_MACRO_GNU_undef_indirect_alt:
f6f0e17b 4221 lineno = read_uleb128 (curr, &bytes_read, end);
a081f3cd 4222 curr += bytes_read;
0c588247 4223 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
a081f3cd
JJ		 4224 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4225 lineno, (unsigned long) offset);
4226 break;
4227
4228 case DW_MACRO_GNU_transparent_include_alt:
0c588247 4229 SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end);
a081f3cd
JJ		 4230 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4231 (unsigned long) offset);
4232 break;
4233
4ccf1e31
JJ		 4234 default:
4235 if (extended_ops == NULL || extended_ops[op] == NULL)
4236 {
4237 error (_(" Unknown macro opcode %02x seen\n"), op);
4238 return 0;
4239 }
4240 else
4241 {
4242 /* Skip over unhandled opcodes. */
4243 dwarf_vma nargs, n;
4244 unsigned char *desc = extended_ops[op];
f6f0e17b 4245 nargs = read_uleb128 (desc, &bytes_read, end);
4ccf1e31
JJ		 4246 desc += bytes_read;
4247 if (nargs == 0)
4248 {
4249 printf (_(" DW_MACRO_GNU_%02x\n"), op);
4250 break;
4251 }
4252 printf (_(" DW_MACRO_GNU_%02x -"), op);
4253 for (n = 0; n < nargs; n++)
4254 {
0c588247
NC		 4255 int val;
4256
4257 SAFE_BYTE_GET_AND_INC (val, desc, 1, end);
4ccf1e31 4258 curr
0c588247 4259 = read_and_display_attr_value (0, val,
f6f0e17b 4260 curr, end, 0, 0, offset_size,
341f9135
CC		 4261 version, NULL, 0, NULL,
4262 NULL);
4ccf1e31
JJ		 4263 if (n != nargs - 1)
4264 printf (",");
4265 }
4266 printf ("\n");
4267 }
4268 break;
4269 }
4270 }
4271
4272 printf ("\n");
4273 }
4274
4275 return 1;
4276}
4277
19e6b90e
L		 4278static int
4279display_debug_abbrev (struct dwarf_section *section,
4280 void *file ATTRIBUTE_UNUSED)
4281{
4282 abbrev_entry *entry;
4283 unsigned char *start = section->start;
4284 unsigned char *end = start + section->size;
4285
4286 printf (_("Contents of the %s section:\n\n"), section->name);
4287
4288 do
4289 {
7282333f
AM		 4290 unsigned char *last;
4291
19e6b90e
L		 4292 free_abbrevs ();
4293
7282333f 4294 last = start;
19e6b90e
L		 4295 start = process_abbrev_section (start, end);
4296
4297 if (first_abbrev == NULL)
4298 continue;
4299
7282333f 4300 printf (_(" Number TAG (0x%lx)\n"), (long) (last - section->start));
19e6b90e
L		 4301
4302 for (entry = first_abbrev; entry; entry = entry->next)
4303 {
4304 abbrev_attr *attr;
4305
cc5914eb 4306 printf (" %ld %s [%s]\n",
19e6b90e
L		 4307 entry->entry,
4308 get_TAG_name (entry->tag),
4309 entry->children ? _("has children") : _("no children"));
4310
4311 for (attr = entry->first_attr; attr; attr = attr->next)
cc5914eb 4312 printf (" %-18s %s\n",
19e6b90e
L		 4313 get_AT_name (attr->attribute),
4314 get_FORM_name (attr->form));
4315 }
4316 }
4317 while (start);
4318
4319 printf ("\n");
4320
4321 return 1;
4322}
4323
4723351a
CC		 4324/* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4325
4326static void
4327display_loc_list (struct dwarf_section *section,
4328 unsigned char **start_ptr,
82b1b41b 4329 unsigned int debug_info_entry,
4723351a
CC		 4330 unsigned long offset,
4331 unsigned long base_address,
4332 int has_frame_base)
4333{
4334 unsigned char *start = *start_ptr;
4335 unsigned char *section_end = section->start + section->size;
82b1b41b
NC		 4336 unsigned long cu_offset;
4337 unsigned int pointer_size;
4338 unsigned int offset_size;
4339 int dwarf_version;
4723351a
CC		 4340
4341 dwarf_vma begin;
4342 dwarf_vma end;
4343 unsigned short length;
4344 int need_frame_base;
4345
82b1b41b
NC		 4346 if (debug_info_entry >= num_debug_info_entries)
4347 {
4348 warn (_("No debug information available for loc lists of entry: %u\n"),
4349 debug_info_entry);
4350 return;
4351 }
4352
4353 cu_offset = debug_information [debug_info_entry].cu_offset;
4354 pointer_size = debug_information [debug_info_entry].pointer_size;
4355 offset_size = debug_information [debug_info_entry].offset_size;
4356 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4357
f41e4712
NC		 4358 if (pointer_size < 2 || pointer_size > 8)
4359 {
4360 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4361 pointer_size, debug_info_entry);
4362 return;
4363 }
4364
4723351a
CC		 4365 while (1)
4366 {
4367 if (start + 2 * pointer_size > section_end)
4368 {
4369 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4370 offset);
4371 break;
4372 }
4373
fab128ef
CC		 4374 printf (" %8.8lx ", offset + (start - *start_ptr));
4375
4723351a
CC		 4376 /* Note: we use sign extension here in order to be sure that we can detect
4377 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4378 address will not affect the values that we display since we always show
4379 hex values, and always the bottom 32-bits. */
0c588247
NC		 4380 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end);
4381 SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end);
4723351a 4382
4723351a
CC		 4383 if (begin == 0 && end == 0)
4384 {
4385 printf (_("<End of list>\n"));
4386 break;
4387 }
4388
4389 /* Check base address specifiers. */
4390 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
4391 {
4392 base_address = end;
4393 print_dwarf_vma (begin, pointer_size);
4394 print_dwarf_vma (end, pointer_size);
4395 printf (_("(base address)\n"));
4396 continue;
4397 }
4398
4399 if (start + 2 > section_end)
4400 {
4401 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4402 offset);
4403 break;
4404 }
4405
0c588247 4406 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4723351a
CC		 4407
4408 if (start + length > section_end)
4409 {
4410 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4411 offset);
4412 break;
4413 }
4414
4415 print_dwarf_vma (begin + base_address, pointer_size);
4416 print_dwarf_vma (end + base_address, pointer_size);
4417
4418 putchar ('(');
4419 need_frame_base = decode_location_expression (start,
4420 pointer_size,
4421 offset_size,
4422 dwarf_version,
4423 length,
4424 cu_offset, section);
4425 putchar (')');
4426
4427 if (need_frame_base && !has_frame_base)
4428 printf (_(" [without DW_AT_frame_base]"));
4429
4430 if (begin == end)
4431 fputs (_(" (start == end)"), stdout);
4432 else if (begin > end)
4433 fputs (_(" (start > end)"), stdout);
4434
4435 putchar ('\n');
4436
4437 start += length;
4438 }
4439
4440 *start_ptr = start;
4441}
4442
fab128ef
CC		 4443/* Print a .debug_addr table index in decimal, surrounded by square brackets,
4444 right-adjusted in a field of length LEN, and followed by a space. */
4445
4446static void
4447print_addr_index (unsigned int idx, unsigned int len)
4448{
4449 static char buf[15];
4450 snprintf (buf, sizeof (buf), "[%d]", idx);
341f9135 4451 printf ("%*s ", len, buf);
fab128ef
CC		 4452}
4453
4723351a
CC		 4454/* Display a location list from a .dwo section. It uses address indexes rather
4455 than embedded addresses. This code closely follows display_loc_list, but the
4456 two are sufficiently different that combining things is very ugly. */
4457
4458static void
4459display_loc_list_dwo (struct dwarf_section *section,
4460 unsigned char **start_ptr,
82b1b41b 4461 unsigned int debug_info_entry,
4723351a
CC		 4462 unsigned long offset,
4463 int has_frame_base)
4464{
4465 unsigned char *start = *start_ptr;
4466 unsigned char *section_end = section->start + section->size;
82b1b41b
NC		 4467 unsigned long cu_offset;
4468 unsigned int pointer_size;
4469 unsigned int offset_size;
4470 int dwarf_version;
4723351a
CC		 4471 int entry_type;
4472 unsigned short length;
4473 int need_frame_base;
fab128ef 4474 unsigned int idx;
4723351a
CC		 4475 unsigned int bytes_read;
4476
82b1b41b
NC		 4477 if (debug_info_entry >= num_debug_info_entries)
4478 {
4479 warn (_("No debug information for loc lists of entry: %u\n"),
4480 debug_info_entry);
4481 return;
4482 }
4483
4484 cu_offset = debug_information [debug_info_entry].cu_offset;
4485 pointer_size = debug_information [debug_info_entry].pointer_size;
4486 offset_size = debug_information [debug_info_entry].offset_size;
4487 dwarf_version = debug_information [debug_info_entry].dwarf_version;
4488
f41e4712
NC		 4489 if (pointer_size < 2 || pointer_size > 8)
4490 {
4491 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4492 pointer_size, debug_info_entry);
4493 return;
4494 }
4495
4723351a
CC		 4496 while (1)
4497 {
fab128ef 4498 printf (" %8.8lx ", offset + (start - *start_ptr));
4723351a 4499
fab128ef 4500 if (start >= section_end)
4723351a
CC		 4501 {
4502 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4503 offset);
4504 break;
4505 }
4506
0c588247 4507 SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end);
4723351a
CC		 4508 switch (entry_type)
4509 {
4510 case 0: /* A terminating entry. */
4723351a 4511 *start_ptr = start;
fab128ef 4512 printf (_("<End of list>\n"));
4723351a
CC		 4513 return;
4514 case 1: /* A base-address entry. */
f6f0e17b 4515 idx = read_uleb128 (start, &bytes_read, section_end);
4723351a 4516 start += bytes_read;
fab128ef
CC		 4517 print_addr_index (idx, 8);
4518 printf (" ");
4519 printf (_("(base address selection entry)\n"));
4723351a 4520 continue;
fab128ef 4521 case 2: /* A start/end entry. */
f6f0e17b 4522 idx = read_uleb128 (start, &bytes_read, section_end);
fab128ef
CC		 4523 start += bytes_read;
4524 print_addr_index (idx, 8);
f6f0e17b 4525 idx = read_uleb128 (start, &bytes_read, section_end);
4723351a 4526 start += bytes_read;
fab128ef
CC		 4527 print_addr_index (idx, 8);
4528 break;
4529 case 3: /* A start/length entry. */
f6f0e17b 4530 idx = read_uleb128 (start, &bytes_read, section_end);
4723351a 4531 start += bytes_read;
fab128ef 4532 print_addr_index (idx, 8);
0c588247 4533 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
fab128ef
CC		 4534 printf ("%08x ", idx);
4535 break;
4536 case 4: /* An offset pair entry. */
0c588247 4537 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
fab128ef 4538 printf ("%08x ", idx);
0c588247 4539 SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end);
fab128ef 4540 printf ("%08x ", idx);
4723351a
CC		 4541 break;
4542 default:
fab128ef 4543 warn (_("Unknown location list entry type 0x%x.\n"), entry_type);
4723351a
CC		 4544 *start_ptr = start;
4545 return;
4546 }
4547
4548 if (start + 2 > section_end)
4549 {
4550 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4551 offset);
4552 break;
4553 }
4554
0c588247 4555 SAFE_BYTE_GET_AND_INC (length, start, 2, section_end);
4723351a
CC		 4556 if (start + length > section_end)
4557 {
4558 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4559 offset);
4560 break;
4561 }
4562
4563 putchar ('(');
4564 need_frame_base = decode_location_expression (start,
4565 pointer_size,
4566 offset_size,
4567 dwarf_version,
4568 length,
4569 cu_offset, section);
4570 putchar (')');
4571
4572 if (need_frame_base && !has_frame_base)
4573 printf (_(" [without DW_AT_frame_base]"));
4574
4575 putchar ('\n');
4576
4577 start += length;
4578 }
4579
4580 *start_ptr = start;
4581}
4582
51d0d03f
JJ		 4583/* Sort array of indexes in ascending order of loc_offsets[idx]. */
4584
4585static dwarf_vma *loc_offsets;
4586
4587static int
4588loc_offsets_compar (const void *ap, const void *bp)
4589{
4590 dwarf_vma a = loc_offsets[*(const unsigned int *) ap];
4591 dwarf_vma b = loc_offsets[*(const unsigned int *) bp];
4592
4593 return (a > b) - (b > a);
4594}
4595
19e6b90e
L		 4596static int
4597display_debug_loc (struct dwarf_section *section, void *file)
4598{
4599 unsigned char *start = section->start;
19e6b90e
L		 4600 unsigned long bytes;
4601 unsigned char *section_begin = start;
4602 unsigned int num_loc_list = 0;
4603 unsigned long last_offset = 0;
4604 unsigned int first = 0;
4605 unsigned int i;
4606 unsigned int j;
51d0d03f 4607 unsigned int k;
19e6b90e 4608 int seen_first_offset = 0;
51d0d03f 4609 int locs_sorted = 1;
19e6b90e 4610 unsigned char *next;
51d0d03f 4611 unsigned int *array = NULL;
4723351a
CC		 4612 const char *suffix = strrchr (section->name, '.');
4613 int is_dwo = 0;
4614
4615 if (suffix && strcmp (suffix, ".dwo") == 0)
4616 is_dwo = 1;
19e6b90e
L		 4617
4618 bytes = section->size;
19e6b90e
L		 4619
4620 if (bytes == 0)
4621 {
4622 printf (_("\nThe %s section is empty.\n"), section->name);
4623 return 0;
4624 }
4625
1febe64d
NC		 4626 if (load_debug_info (file) == 0)
4627 {
4628 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4629 section->name);
4630 return 0;
4631 }
19e6b90e
L		 4632
4633 /* Check the order of location list in .debug_info section. If
4634 offsets of location lists are in the ascending order, we can
4635 use `debug_information' directly. */
4636 for (i = 0; i < num_debug_info_entries; i++)
4637 {
4638 unsigned int num;
4639
4640 num = debug_information [i].num_loc_offsets;
51d0d03f
JJ		 4641 if (num > num_loc_list)
4642 num_loc_list = num;
19e6b90e
L		 4643
4644 /* Check if we can use `debug_information' directly. */
51d0d03f 4645 if (locs_sorted && num != 0)
19e6b90e
L		 4646 {
4647 if (!seen_first_offset)
4648 {
4649 /* This is the first location list. */
4650 last_offset = debug_information [i].loc_offsets [0];
4651 first = i;
4652 seen_first_offset = 1;
4653 j = 1;
4654 }
4655 else
4656 j = 0;
4657
4658 for (; j < num; j++)
4659 {
4660 if (last_offset >
4661 debug_information [i].loc_offsets [j])
4662 {
51d0d03f 4663 locs_sorted = 0;
19e6b90e
L		 4664 break;
4665 }
4666 last_offset = debug_information [i].loc_offsets [j];
4667 }
4668 }
4669 }
4670
19e6b90e
L		 4671 if (!seen_first_offset)
4672 error (_("No location lists in .debug_info section!\n"));
4673
d4bfc77b 4674 if (debug_information [first].num_loc_offsets > 0
d493b283 4675 && debug_information [first].loc_offsets [0] != 0)
47704ddf
KT		 4676 warn (_("Location lists in %s section start at 0x%s\n"),
4677 section->name,
4678 dwarf_vmatoa ("x", debug_information [first].loc_offsets [0]));
19e6b90e 4679
51d0d03f
JJ		 4680 if (!locs_sorted)
4681 array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
19e6b90e 4682 printf (_("Contents of the %s section:\n\n"), section->name);
fab128ef 4683 printf (_(" Offset Begin End Expression\n"));
19e6b90e
L		 4684
4685 seen_first_offset = 0;
4686 for (i = first; i < num_debug_info_entries; i++)
4687 {
19e6b90e 4688 unsigned long offset;
19e6b90e 4689 unsigned long base_address;
19e6b90e
L		 4690 int has_frame_base;
4691
51d0d03f
JJ		 4692 if (!locs_sorted)
4693 {
4694 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
4695 array[k] = k;
4696 loc_offsets = debug_information [i].loc_offsets;
4697 qsort (array, debug_information [i].num_loc_offsets,
4698 sizeof (*array), loc_offsets_compar);
4699 }
19e6b90e 4700
51d0d03f 4701 for (k = 0; k < debug_information [i].num_loc_offsets; k++)
19e6b90e 4702 {
51d0d03f
JJ		 4703 j = locs_sorted ? k : array[k];
4704 if (k
4705 && debug_information [i].loc_offsets [locs_sorted
4706 ? k - 1 : array [k - 1]]
4707 == debug_information [i].loc_offsets [j])
4708 continue;
19e6b90e 4709 has_frame_base = debug_information [i].have_frame_base [j];
d493b283 4710 offset = debug_information [i].loc_offsets [j];
19e6b90e
L		 4711 next = section_begin + offset;
4712 base_address = debug_information [i].base_address;
4713
4714 if (!seen_first_offset)
4715 seen_first_offset = 1;
4716 else
4717 {
4718 if (start < next)
4719 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e
AM		 4720 (unsigned long) (start - section_begin),
4721 (unsigned long) (next - section_begin));
19e6b90e
L		 4722 else if (start > next)
4723 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
0af1713e
AM		 4724 (unsigned long) (start - section_begin),
4725 (unsigned long) (next - section_begin));
19e6b90e
L		 4726 }
4727 start = next;
4728
4729 if (offset >= bytes)
4730 {
4731 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4732 offset);
4733 continue;
4734 }
4735
4723351a
CC		 4736 if (is_dwo)
4737 display_loc_list_dwo (section, &start, i, offset, has_frame_base);
4738 else
4739 display_loc_list (section, &start, i, offset, base_address,
4740 has_frame_base);
19e6b90e
L		 4741 }
4742 }
031cd65f 4743
4723351a 4744 if (start < section->start + section->size)
031cd65f 4745 warn (_("There are %ld unused bytes at the end of section %s\n"),
4723351a 4746 (long) (section->start + section->size - start), section->name);
98fb390a 4747 putchar ('\n');
51d0d03f 4748 free (array);
19e6b90e
L		 4749 return 1;
4750}
4751
4752static int
4753display_debug_str (struct dwarf_section *section,
4754 void *file ATTRIBUTE_UNUSED)
4755{
4756 unsigned char *start = section->start;
4757 unsigned long bytes = section->size;
4758 dwarf_vma addr = section->address;
4759
4760 if (bytes == 0)
4761 {
4762 printf (_("\nThe %s section is empty.\n"), section->name);
4763 return 0;
4764 }
4765
4766 printf (_("Contents of the %s section:\n\n"), section->name);
4767
4768 while (bytes)
4769 {
4770 int j;
4771 int k;
4772 int lbytes;
4773
4774 lbytes = (bytes > 16 ? 16 : bytes);
4775
4776 printf (" 0x%8.8lx ", (unsigned long) addr);
4777
4778 for (j = 0; j < 16; j++)
4779 {
4780 if (j < lbytes)
4781 printf ("%2.2x", start[j]);
4782 else
4783 printf (" ");
4784
4785 if ((j & 3) == 3)
4786 printf (" ");
4787 }
4788
4789 for (j = 0; j < lbytes; j++)
4790 {
4791 k = start[j];
4792 if (k >= ' ' && k < 0x80)
4793 printf ("%c", k);
4794 else
4795 printf (".");
4796 }
4797
4798 putchar ('\n');
4799
4800 start += lbytes;
4801 addr += lbytes;
4802 bytes -= lbytes;
4803 }
4804
4805 putchar ('\n');
4806
4807 return 1;
4808}
4809
19e6b90e
L		 4810static int
4811display_debug_info (struct dwarf_section *section, void *file)
4812{
4723351a 4813 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
19e6b90e
L		 4814}
4815
2b6f5997
CC		 4816static int
4817display_debug_types (struct dwarf_section *section, void *file)
4818{
4723351a 4819 return process_debug_info (section, file, section->abbrev_sec, 0, 1);
6f875884
TG		 4820}
4821
4822static int
4823display_trace_info (struct dwarf_section *section, void *file)
4824{
4723351a 4825 return process_debug_info (section, file, section->abbrev_sec, 0, 0);
2b6f5997 4826}
19e6b90e
L		 4827
4828static int
4829display_debug_aranges (struct dwarf_section *section,
4830 void *file ATTRIBUTE_UNUSED)
4831{
4832 unsigned char *start = section->start;
4833 unsigned char *end = start + section->size;
4834
80c35038 4835 printf (_("Contents of the %s section:\n\n"), section->name);
19e6b90e 4836
6e3d6dc1
NC		 4837 /* It does not matter if this load fails,
4838 we test for that later on. */
4839 load_debug_info (file);
4840
19e6b90e
L		 4841 while (start < end)
4842 {
4843 unsigned char *hdrptr;
4844 DWARF2_Internal_ARange arange;
91d6fa6a 4845 unsigned char *addr_ranges;
2d9472a2
NC		 4846 dwarf_vma length;
4847 dwarf_vma address;
53b8873b 4848 unsigned char address_size;
19e6b90e 4849 int excess;
bf5117e3
NC		 4850 unsigned int offset_size;
4851 unsigned int initial_length_size;
19e6b90e
L		 4852
4853 hdrptr = start;
4854
0c588247 4855 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 4, end);
19e6b90e
L		 4856 if (arange.ar_length == 0xffffffff)
4857 {
0c588247 4858 SAFE_BYTE_GET_AND_INC (arange.ar_length, hdrptr, 8, end);
19e6b90e
L		 4859 offset_size = 8;
4860 initial_length_size = 12;
4861 }
4862 else
4863 {
4864 offset_size = 4;
4865 initial_length_size = 4;
4866 }
4867
0c588247
NC		 4868 SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end);
4869 SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end);
19e6b90e 4870
6e3d6dc1
NC		 4871 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE
4872 && num_debug_info_entries > 0
4873 && find_debug_info_for_offset (arange.ar_info_offset) == NULL)
4874 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
47704ddf 4875 (unsigned long) arange.ar_info_offset, section->name);
6e3d6dc1 4876
0c588247
NC		 4877 SAFE_BYTE_GET_AND_INC (arange.ar_pointer_size, hdrptr, 1, end);
4878 SAFE_BYTE_GET_AND_INC (arange.ar_segment_size, hdrptr, 1, end);
19e6b90e
L		 4879
4880 if (arange.ar_version != 2 && arange.ar_version != 3)
4881 {
4882 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4883 break;
4884 }
4885
47704ddf
KT		 4886 printf (_(" Length: %ld\n"),
4887 (long) arange.ar_length);
19e6b90e 4888 printf (_(" Version: %d\n"), arange.ar_version);
47704ddf
KT		 4889 printf (_(" Offset into .debug_info: 0x%lx\n"),
4890 (unsigned long) arange.ar_info_offset);
19e6b90e
L		 4891 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4892 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4893
53b8873b
NC		 4894 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4895
f41e4712
NC		 4896 /* PR 17512: file: 001-108546-0.001:0.1. */
4897 if (address_size == 0 || address_size > 8)
b3681d67
L		 4898 {
4899 error (_("Invalid address size in %s section!\n"),
4900 section->name);
4901 break;
4902 }
4903
53b8873b
NC		 4904 /* The DWARF spec does not require that the address size be a power
4905 of two, but we do. This will have to change if we ever encounter
4906 an uneven architecture. */
4907 if ((address_size & (address_size - 1)) != 0)
4908 {
4909 warn (_("Pointer size + Segment size is not a power of two.\n"));
4910 break;
4911 }
cecf136e 4912
209c9a13
NC		 4913 if (address_size > 4)
4914 printf (_("\n Address Length\n"));
4915 else
4916 printf (_("\n Address Length\n"));
19e6b90e 4917
91d6fa6a 4918 addr_ranges = hdrptr;
19e6b90e 4919
53b8873b
NC		 4920 /* Must pad to an alignment boundary that is twice the address size. */
4921 excess = (hdrptr - start) % (2 * address_size);
19e6b90e 4922 if (excess)
91d6fa6a 4923 addr_ranges += (2 * address_size) - excess;
19e6b90e 4924
1617e571
AM		 4925 start += arange.ar_length + initial_length_size;
4926
91d6fa6a 4927 while (addr_ranges + 2 * address_size <= start)
19e6b90e 4928 {
0c588247
NC		 4929 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4930 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
19e6b90e 4931
80c35038 4932 printf (" ");
2d9472a2
NC		 4933 print_dwarf_vma (address, address_size);
4934 print_dwarf_vma (length, address_size);
4935 putchar ('\n');
19e6b90e 4936 }
19e6b90e
L		 4937 }
4938
4939 printf ("\n");
4940
4941 return 1;
4942}
4943
4723351a
CC		 4944/* Comparison function for qsort. */
4945static int
4946comp_addr_base (const void * v0, const void * v1)
4947{
4948 debug_info * info0 = (debug_info *) v0;
4949 debug_info * info1 = (debug_info *) v1;
4950 return info0->addr_base - info1->addr_base;
4951}
4952
4953/* Display the debug_addr section. */
4954static int
4955display_debug_addr (struct dwarf_section *section,
4956 void *file)
4957{
4958 debug_info **debug_addr_info;
4959 unsigned char *entry;
4960 unsigned char *end;
4961 unsigned int i;
4962 unsigned int count;
4963
4964 if (section->size == 0)
4965 {
4966 printf (_("\nThe %s section is empty.\n"), section->name);
4967 return 0;
4968 }
4969
4970 if (load_debug_info (file) == 0)
4971 {
4972 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4973 section->name);
4974 return 0;
4975 }
4976
4977 printf (_("Contents of the %s section:\n\n"), section->name);
4978
1306a742
NC		 4979 /* PR 17531: file: cf38d01b.
4980 We use xcalloc because a corrupt file may not have initialised all of the
4981 fields in the debug_info structure, which means that the sort below might
4982 try to move uninitialised data. */
4983 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
4984 sizeof (debug_info *));
4723351a
CC		 4985
4986 count = 0;
4987 for (i = 0; i < num_debug_info_entries; i++)
82b1b41b 4988 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
1306a742
NC		 4989 {
4990 /* PR 17531: file: cf38d01b. */
4991 if (debug_information[i].addr_base >= section->size)
4992 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4993 (unsigned long) debug_information[i].addr_base, i);
4994 else
4995 debug_addr_info [count++] = debug_information + i;
4996 }
4723351a
CC		 4997
4998 /* Add a sentinel to make iteration convenient. */
4999 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5000 debug_addr_info [count]->addr_base = section->size;
4723351a 5001 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
1306a742 5002
4723351a
CC		 5003 for (i = 0; i < count; i++)
5004 {
5005 unsigned int idx;
fab128ef 5006 unsigned int address_size = debug_addr_info [i]->pointer_size;
4723351a
CC		 5007
5008 printf (_(" For compilation unit at offset 0x%s:\n"),
5009 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
5010
fab128ef 5011 printf (_("\tIndex\tAddress\n"));
4723351a
CC		 5012 entry = section->start + debug_addr_info [i]->addr_base;
5013 end = section->start + debug_addr_info [i + 1]->addr_base;
5014 idx = 0;
5015 while (entry < end)
5016 {
fab128ef
CC		 5017 dwarf_vma base = byte_get (entry, address_size);
5018 printf (_("\t%d:\t"), idx);
5019 print_dwarf_vma (base, address_size);
5020 printf ("\n");
5021 entry += address_size;
4723351a
CC		 5022 idx++;
5023 }
5024 }
5025 printf ("\n");
5026
5027 free (debug_addr_info);
5028 return 1;
5029}
5030
5031/* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5032static int
5033display_debug_str_offsets (struct dwarf_section *section,
5034 void *file ATTRIBUTE_UNUSED)
5035{
5036 if (section->size == 0)
5037 {
5038 printf (_("\nThe %s section is empty.\n"), section->name);
5039 return 0;
5040 }
5041 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5042 what the offset size is for this section. */
5043 return 1;
5044}
5045
01a8f077
JK		 5046/* Each debug_information[x].range_lists[y] gets this representation for
5047 sorting purposes. */
5048
5049struct range_entry
467c65bc
NC		 5050{
5051 /* The debug_information[x].range_lists[y] value. */
5052 unsigned long ranges_offset;
01a8f077 5053
467c65bc
NC		 5054 /* Original debug_information to find parameters of the data. */
5055 debug_info *debug_info_p;
5056};
01a8f077
JK		 5057
5058/* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5059
5060static int
5061range_entry_compar (const void *ap, const void *bp)
5062{
3f5e193b
NC		 5063 const struct range_entry *a_re = (const struct range_entry *) ap;
5064 const struct range_entry *b_re = (const struct range_entry *) bp;
01a8f077
JK		 5065 const unsigned long a = a_re->ranges_offset;
5066 const unsigned long b = b_re->ranges_offset;
5067
5068 return (a > b) - (b > a);
5069}
5070
19e6b90e
L		 5071static int
5072display_debug_ranges (struct dwarf_section *section,
5073 void *file ATTRIBUTE_UNUSED)
5074{
5075 unsigned char *start = section->start;
a2ff7a4b 5076 unsigned char *last_start = start;
f6f0e17b 5077 unsigned long bytes = section->size;
19e6b90e 5078 unsigned char *section_begin = start;
f6f0e17b 5079 unsigned char *finish = start + bytes;
01a8f077
JK		 5080 unsigned int num_range_list, i;
5081 struct range_entry *range_entries, *range_entry_fill;
19e6b90e 5082
19e6b90e
L		 5083 if (bytes == 0)
5084 {
5085 printf (_("\nThe %s section is empty.\n"), section->name);
5086 return 0;
5087 }
5088
1febe64d
NC		 5089 if (load_debug_info (file) == 0)
5090 {
5091 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5092 section->name);
5093 return 0;
5094 }
19e6b90e 5095
01a8f077 5096 num_range_list = 0;
19e6b90e 5097 for (i = 0; i < num_debug_info_entries; i++)
01a8f077 5098 num_range_list += debug_information [i].num_range_lists;
19e6b90e 5099
01a8f077 5100 if (num_range_list == 0)
4723351a
CC		 5101 {
5102 /* This can happen when the file was compiled with -gsplit-debug
5103 which removes references to range lists from the primary .o file. */
5104 printf (_("No range lists in .debug_info section.\n"));
5105 return 1;
5106 }
19e6b90e 5107
3f5e193b
NC		 5108 range_entries = (struct range_entry *)
5109 xmalloc (sizeof (*range_entries) * num_range_list);
01a8f077 5110 range_entry_fill = range_entries;
19e6b90e 5111
01a8f077
JK		 5112 for (i = 0; i < num_debug_info_entries; i++)
5113 {
5114 debug_info *debug_info_p = &debug_information[i];
5115 unsigned int j;
5116
5117 for (j = 0; j < debug_info_p->num_range_lists; j++)
5118 {
5119 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5120 range_entry_fill->debug_info_p = debug_info_p;
5121 range_entry_fill++;
19e6b90e
L		 5122 }
5123 }
5124
01a8f077
JK		 5125 qsort (range_entries, num_range_list, sizeof (*range_entries),
5126 range_entry_compar);
19e6b90e 5127
d493b283 5128 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
19e6b90e 5129 warn (_("Range lists in %s section start at 0x%lx\n"),
01a8f077 5130 section->name, range_entries[0].ranges_offset);
19e6b90e
L		 5131
5132 printf (_("Contents of the %s section:\n\n"), section->name);
5133 printf (_(" Offset Begin End\n"));
5134
01a8f077 5135 for (i = 0; i < num_range_list; i++)
19e6b90e 5136 {
01a8f077
JK		 5137 struct range_entry *range_entry = &range_entries[i];
5138 debug_info *debug_info_p = range_entry->debug_info_p;
19e6b90e 5139 unsigned int pointer_size;
01a8f077
JK		 5140 unsigned long offset;
5141 unsigned char *next;
19e6b90e
L		 5142 unsigned long base_address;
5143
01a8f077 5144 pointer_size = debug_info_p->pointer_size;
d493b283 5145 offset = range_entry->ranges_offset;
01a8f077
JK		 5146 next = section_begin + offset;
5147 base_address = debug_info_p->base_address;
cecf136e 5148
f41e4712
NC		 5149 /* PR 17512: file: 001-101485-0.001:0.1. */
5150 if (pointer_size < 2 || pointer_size > 8)
5151 {
5152 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5153 pointer_size, offset);
5154 continue;
5155 }
5156
4723351a 5157 if (dwarf_check != 0 && i > 0)
19e6b90e 5158 {
01a8f077
JK		 5159 if (start < next)
5160 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5161 (unsigned long) (start - section_begin),
5162 (unsigned long) (next - section_begin), section->name);
5163 else if (start > next)
a2ff7a4b
AM		 5164 {
5165 if (next == last_start)
5166 continue;
5167 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5168 (unsigned long) (start - section_begin),
5169 (unsigned long) (next - section_begin), section->name);
5170 }
01a8f077
JK		 5171 }
5172 start = next;
a2ff7a4b 5173 last_start = next;
19e6b90e 5174
f6f0e17b 5175 while (start < finish)
01a8f077
JK		 5176 {
5177 dwarf_vma begin;
5178 dwarf_vma end;
5179
5180 /* Note: we use sign extension here in order to be sure that
5181 we can detect the -1 escape value. Sign extension into the
5182 top 32 bits of a 32-bit address will not affect the values
5183 that we display since we always show hex values, and always
5184 the bottom 32-bits. */
0c588247 5185 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
f6f0e17b
NC		 5186 if (start >= finish)
5187 break;
0c588247 5188 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
01a8f077
JK		 5189
5190 printf (" %8.8lx ", offset);
5191
5192 if (begin == 0 && end == 0)
19e6b90e 5193 {
01a8f077
JK		 5194 printf (_("<End of list>\n"));
5195 break;
19e6b90e 5196 }
19e6b90e 5197
01a8f077
JK		 5198 /* Check base address specifiers. */
5199 if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1)
19e6b90e 5200 {
01a8f077
JK		 5201 base_address = end;
5202 print_dwarf_vma (begin, pointer_size);
5203 print_dwarf_vma (end, pointer_size);
5204 printf ("(base address)\n");
5205 continue;
5206 }
19e6b90e 5207
01a8f077
JK		 5208 print_dwarf_vma (begin + base_address, pointer_size);
5209 print_dwarf_vma (end + base_address, pointer_size);
4a149252 5210
01a8f077
JK		 5211 if (begin == end)
5212 fputs (_("(start == end)"), stdout);
5213 else if (begin > end)
5214 fputs (_("(start > end)"), stdout);
19e6b90e 5215
01a8f077 5216 putchar ('\n');
19e6b90e
L		 5217 }
5218 }
5219 putchar ('\n');
01a8f077
JK		 5220
5221 free (range_entries);
5222
19e6b90e
L		 5223 return 1;
5224}
5225
5226typedef struct Frame_Chunk
5227{
5228 struct Frame_Chunk *next;
5229 unsigned char *chunk_start;
a1165289 5230 unsigned int ncols;
19e6b90e
L		 5231 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5232 short int *col_type;
5233 int *col_offset;
5234 char *augmentation;
5235 unsigned int code_factor;
5236 int data_factor;
bf5117e3
NC		 5237 dwarf_vma pc_begin;
5238 dwarf_vma pc_range;
19e6b90e
L		 5239 int cfa_reg;
5240 int cfa_offset;
a1165289 5241 unsigned int ra;
19e6b90e
L		 5242 unsigned char fde_encoding;
5243 unsigned char cfa_exp;
604282a7
JJ		 5244 unsigned char ptr_size;
5245 unsigned char segment_size;
19e6b90e
L		 5246}
5247Frame_Chunk;
5248
665ce1f6
L		 5249static const char *const *dwarf_regnames;
5250static unsigned int dwarf_regnames_count;
5251
19e6b90e
L		 5252/* A marker for a col_type that means this column was never referenced
5253 in the frame info. */
5254#define DW_CFA_unreferenced (-1)
5255
a1165289 5256/* Return 0 if no more space is needed, 1 if more space is needed,
665ce1f6
L		 5257 -1 for invalid reg. */
5258
5259static int
5260frame_need_space (Frame_Chunk *fc, unsigned int reg)
19e6b90e 5261{
a1165289 5262 unsigned int prev = fc->ncols;
19e6b90e 5263
665ce1f6
L		 5264 if (reg < (unsigned int) fc->ncols)
5265 return 0;
5266
5267 if (dwarf_regnames_count
5268 && reg > dwarf_regnames_count)
5269 return -1;
19e6b90e
L		 5270
5271 fc->ncols = reg + 1;
a1165289
NC		 5272 /* PR 17512: file: 10450-2643-0.004.
5273 If reg == -1 then this can happen... */
5274 if (fc->ncols == 0)
5275 return -1;
5276
06614111
NC		 5277 /* PR 17512: file: 2844a11d. */
5278 if (fc->ncols > 1024)
5279 {
5280 error (_("Unfeasibly large register number: %u\n"), reg);
5281 fc->ncols = 0;
5282 /* FIXME: 1024 is an arbitrary limit. Increase it if
5283 we ever encounter a valid binary that exceeds it. */
5284 return -1;
5285 }
5286
3f5e193b
NC		 5287 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
5288 sizeof (short int));
5289 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
041830e0
NC		 5290 /* PR 17512: file:002-10025-0.005. */
5291 if (fc->col_type == NULL || fc->col_offset == NULL)
5292 {
5293 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5294 fc->ncols);
5295 fc->ncols = 0;
5296 return -1;
5297 }
19e6b90e
L		 5298
5299 while (prev < fc->ncols)
5300 {
5301 fc->col_type[prev] = DW_CFA_unreferenced;
5302 fc->col_offset[prev] = 0;
5303 prev++;
5304 }
665ce1f6 5305 return 1;
19e6b90e
L		 5306}
5307
2dc4cec1
L		 5308static const char *const dwarf_regnames_i386[] =
5309{
43234a1e
L		 5310 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5311 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5312 "eip", "eflags", NULL, /* 8 - 10 */
5313 "st0", "st1", "st2", "st3", /* 11 - 14 */
5314 "st4", "st5", "st6", "st7", /* 15 - 18 */
5315 NULL, NULL, /* 19 - 20 */
5316 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5317 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5318 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5319 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5320 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5321 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5322 "tr", "ldtr", /* 48 - 49 */
5323 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5324 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5325 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5326 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5327 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5328 NULL, NULL, NULL, /* 90 - 92 */
5329 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
2dc4cec1
L		 5330};
5331
b129eb0e
RH		 5332void
5333init_dwarf_regnames_i386 (void)
5334{
5335 dwarf_regnames = dwarf_regnames_i386;
5336 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5337}
5338
2dc4cec1
L		 5339static const char *const dwarf_regnames_x86_64[] =
5340{
5341 "rax", "rdx", "rcx", "rbx",
5342 "rsi", "rdi", "rbp", "rsp",
5343 "r8", "r9", "r10", "r11",
5344 "r12", "r13", "r14", "r15",
5345 "rip",
5346 "xmm0", "xmm1", "xmm2", "xmm3",
5347 "xmm4", "xmm5", "xmm6", "xmm7",
5348 "xmm8", "xmm9", "xmm10", "xmm11",
5349 "xmm12", "xmm13", "xmm14", "xmm15",
5350 "st0", "st1", "st2", "st3",
5351 "st4", "st5", "st6", "st7",
5352 "mm0", "mm1", "mm2", "mm3",
5353 "mm4", "mm5", "mm6", "mm7",
5354 "rflags",
5355 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5356 "fs.base", "gs.base", NULL, NULL,
5357 "tr", "ldtr",
43234a1e
L		 5358 "mxcsr", "fcw", "fsw",
5359 "xmm16", "xmm17", "xmm18", "xmm19",
5360 "xmm20", "xmm21", "xmm22", "xmm23",
5361 "xmm24", "xmm25", "xmm26", "xmm27",
5362 "xmm28", "xmm29", "xmm30", "xmm31",
5363 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5364 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5365 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5366 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5367 NULL, NULL, NULL, /* 115 - 117 */
5368 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
2dc4cec1
L		 5369};
5370
b129eb0e
RH		 5371void
5372init_dwarf_regnames_x86_64 (void)
5373{
5374 dwarf_regnames = dwarf_regnames_x86_64;
5375 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5376}
5377
4ee22035
RH		 5378static const char *const dwarf_regnames_aarch64[] =
5379{
5380 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5381 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5382 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5383 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5384 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5385 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5386 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5387 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5388 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5389 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5390 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5391 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5392};
5393
5394void
5395init_dwarf_regnames_aarch64 (void)
5396{
5397 dwarf_regnames = dwarf_regnames_aarch64;
5398 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5399}
5400
2dc4cec1
L		 5401void
5402init_dwarf_regnames (unsigned int e_machine)
5403{
5404 switch (e_machine)
5405 {
5406 case EM_386:
5407 case EM_486:
b129eb0e 5408 init_dwarf_regnames_i386 ();
2dc4cec1
L		 5409 break;
5410
5411 case EM_X86_64:
7f502d6c 5412 case EM_L1OM:
7a9068fe 5413 case EM_K1OM:
b129eb0e 5414 init_dwarf_regnames_x86_64 ();
2dc4cec1
L		 5415 break;
5416
4ee22035
RH		 5417 case EM_AARCH64:
5418 init_dwarf_regnames_aarch64 ();
5419 break;
5420
2dc4cec1
L		 5421 default:
5422 break;
5423 }
5424}
5425
5426static const char *
5427regname (unsigned int regno, int row)
5428{
5429 static char reg[64];
5430 if (dwarf_regnames
5431 && regno < dwarf_regnames_count
5432 && dwarf_regnames [regno] != NULL)
5433 {
5434 if (row)
5435 return dwarf_regnames [regno];
5436 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5437 dwarf_regnames [regno]);
5438 }
5439 else
5440 snprintf (reg, sizeof (reg), "r%d", regno);
5441 return reg;
5442}
5443
19e6b90e 5444static void
a1165289 5445frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
19e6b90e 5446{
a1165289 5447 unsigned int r;
19e6b90e
L		 5448 char tmp[100];
5449
5450 if (*max_regs < fc->ncols)
5451 *max_regs = fc->ncols;
5452
5453 if (*need_col_headers)
5454 {
91d6fa6a 5455 static const char *sloc = " LOC";
2dc4cec1 5456
19e6b90e
L		 5457 *need_col_headers = 0;
5458
91d6fa6a 5459 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
19e6b90e
L		 5460
5461 for (r = 0; r < *max_regs; r++)
5462 if (fc->col_type[r] != DW_CFA_unreferenced)
5463 {
5464 if (r == fc->ra)
2dc4cec1 5465 printf ("ra ");
19e6b90e 5466 else
2dc4cec1 5467 printf ("%-5s ", regname (r, 1));
19e6b90e
L		 5468 }
5469
5470 printf ("\n");
5471 }
5472
bf5117e3 5473 print_dwarf_vma (fc->pc_begin, eh_addr_size);
19e6b90e
L		 5474 if (fc->cfa_exp)
5475 strcpy (tmp, "exp");
5476 else
2dc4cec1 5477 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset);
19e6b90e
L		 5478 printf ("%-8s ", tmp);
5479
5480 for (r = 0; r < fc->ncols; r++)
5481 {
5482 if (fc->col_type[r] != DW_CFA_unreferenced)
5483 {
5484 switch (fc->col_type[r])
5485 {
5486 case DW_CFA_undefined:
5487 strcpy (tmp, "u");
5488 break;
5489 case DW_CFA_same_value:
5490 strcpy (tmp, "s");
5491 break;
5492 case DW_CFA_offset:
5493 sprintf (tmp, "c%+d", fc->col_offset[r]);
5494 break;
12eae2d3
JJ		 5495 case DW_CFA_val_offset:
5496 sprintf (tmp, "v%+d", fc->col_offset[r]);
5497 break;
19e6b90e 5498 case DW_CFA_register:
2dc4cec1 5499 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
19e6b90e
L		 5500 break;
5501 case DW_CFA_expression:
5502 strcpy (tmp, "exp");
5503 break;
12eae2d3
JJ		 5504 case DW_CFA_val_expression:
5505 strcpy (tmp, "vexp");
5506 break;
19e6b90e
L		 5507 default:
5508 strcpy (tmp, "n/a");
5509 break;
5510 }
2dc4cec1 5511 printf ("%-5s ", tmp);
19e6b90e
L		 5512 }
5513 }
5514 printf ("\n");
5515}
5516
49727e46 5517#define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
f6f0e17b
NC		 5518#define LEB() read_uleb128 (start, & length_return, end); start += length_return
5519#define SLEB() read_sleb128 (start, & length_return, end); start += length_return
19e6b90e 5520
49727e46
AM		 5521static unsigned char *
5522read_cie (unsigned char *start, unsigned char *end,
5523 Frame_Chunk **p_cie, int *p_version,
5524 unsigned long *p_aug_len, unsigned char **p_aug)
5525{
5526 int version;
5527 Frame_Chunk *fc;
5528 unsigned int length_return;
5529 unsigned char *augmentation_data = NULL;
5530 unsigned long augmentation_data_len = 0;
5531
041830e0 5532 * p_cie = NULL;
f41e4712
NC		 5533 /* PR 17512: file: 001-228113-0.004. */
5534 if (start >= end)
5535 return end;
5536
49727e46
AM		 5537 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5538 memset (fc, 0, sizeof (Frame_Chunk));
5539
5540 fc->col_type = (short int *) xmalloc (sizeof (short int));
5541 fc->col_offset = (int *) xmalloc (sizeof (int));
5542
5543 version = *start++;
5544
5545 fc->augmentation = (char *) start;
f41e4712
NC		 5546 /* PR 17512: file: 001-228113-0.004.
5547 Skip past augmentation name, but avoid running off the end of the data. */
5548 while (start < end)
5549 if (* start ++ == '\0')
5550 break;
5551 if (start == end)
5552 {
5553 warn (_("No terminator for augmentation name\n"));
5554 return start;
5555 }
49727e46
AM		 5556
5557 if (strcmp (fc->augmentation, "eh") == 0)
5558 start += eh_addr_size;
5559
5560 if (version >= 4)
5561 {
5562 GET (fc->ptr_size, 1);
77ef8654
NC		 5563 if (fc->ptr_size < 1 || fc->ptr_size > 8)
5564 {
5565 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5566 return end;
5567 }
5568
49727e46 5569 GET (fc->segment_size, 1);
77ef8654
NC		 5570 /* PR 17512: file: e99d2804. */
5571 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5572 {
5573 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5574 return end;
5575 }
5576
49727e46
AM		 5577 eh_addr_size = fc->ptr_size;
5578 }
5579 else
5580 {
5581 fc->ptr_size = eh_addr_size;
5582 fc->segment_size = 0;
5583 }
5584 fc->code_factor = LEB ();
5585 fc->data_factor = SLEB ();
5586 if (version == 1)
5587 {
5588 GET (fc->ra, 1);
5589 }
5590 else
5591 {
5592 fc->ra = LEB ();
5593 }
5594
5595 if (fc->augmentation[0] == 'z')
5596 {
5597 augmentation_data_len = LEB ();
5598 augmentation_data = start;
5599 start += augmentation_data_len;
a1165289
NC		 5600 /* PR 17512: file: 11042-2589-0.004. */
5601 if (start > end)
5602 {
1306a742 5603 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
a1165289
NC		 5604 return end;
5605 }
49727e46
AM		 5606 }
5607
5608 if (augmentation_data_len)
5609 {
058037d3
NC		 5610 unsigned char *p;
5611 unsigned char *q;
5612 unsigned char *qend;
5613
49727e46
AM		 5614 p = (unsigned char *) fc->augmentation + 1;
5615 q = augmentation_data;
058037d3
NC		 5616 qend = q + augmentation_data_len;
5617
5618 /* PR 17531: file: 015adfaa. */
5619 if (qend < q)
5620 {
5621 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5622 augmentation_data_len = 0;
5623 }
49727e46 5624
a1165289 5625 while (p < end && q < augmentation_data + augmentation_data_len)
49727e46
AM		 5626 {
5627 if (*p == 'L')
5628 q++;
5629 else if (*p == 'P')
5630 q += 1 + size_of_encoded_value (*q);
5631 else if (*p == 'R')
5632 fc->fde_encoding = *q++;
5633 else if (*p == 'S')
5634 ;
5635 else
5636 break;
5637 p++;
5638 }
c361b9ac
NC		 5639 /* Note - it is OK if this loop terminates with q < qend.
5640 Padding may have been inserted to align the end of the CIE. */
49727e46
AM		 5641 }
5642
5643 *p_cie = fc;
5644 if (p_version)
5645 *p_version = version;
5646 if (p_aug_len)
5647 {
5648 *p_aug_len = augmentation_data_len;
5649 *p_aug = augmentation_data;
5650 }
5651 return start;
5652}
5653
19e6b90e
L		 5654static int
5655display_debug_frames (struct dwarf_section *section,
5656 void *file ATTRIBUTE_UNUSED)
5657{
5658 unsigned char *start = section->start;
5659 unsigned char *end = start + section->size;
5660 unsigned char *section_start = start;
49727e46 5661 Frame_Chunk *chunks = 0, *forward_refs = 0;
19e6b90e
L		 5662 Frame_Chunk *remembered_state = 0;
5663 Frame_Chunk *rs;
5664 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5665 unsigned int length_return;
a1165289 5666 unsigned int max_regs = 0;
665ce1f6 5667 const char *bad_reg = _("bad register: ");
77ef8654 5668 unsigned int saved_eh_addr_size = eh_addr_size;
19e6b90e 5669
80c35038 5670 printf (_("Contents of the %s section:\n"), section->name);
19e6b90e
L		 5671
5672 while (start < end)
5673 {
5674 unsigned char *saved_start;
5675 unsigned char *block_end;
bf5117e3
NC		 5676 dwarf_vma length;
5677 dwarf_vma cie_id;
19e6b90e
L		 5678 Frame_Chunk *fc;
5679 Frame_Chunk *cie;
5680 int need_col_headers = 1;
5681 unsigned char *augmentation_data = NULL;
5682 unsigned long augmentation_data_len = 0;
bf5117e3
NC		 5683 unsigned int encoded_ptr_size = saved_eh_addr_size;
5684 unsigned int offset_size;
5685 unsigned int initial_length_size;
19e6b90e
L		 5686
5687 saved_start = start;
19e6b90e 5688
0c588247 5689 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
041830e0 5690
19e6b90e
L		 5691 if (length == 0)
5692 {
5693 printf ("\n%08lx ZERO terminator\n\n",
5694 (unsigned long)(saved_start - section_start));
6937bb54
NC		 5695 /* Skip any zero terminators that directly follow.
5696 A corrupt section size could have loaded a whole
5697 slew of zero filled memory bytes. eg
5698 PR 17512: file: 070-19381-0.004. */
5699 while (start < end && * start == 0)
5700 ++ start;
b758e50f 5701 continue;
19e6b90e
L		 5702 }
5703
5704 if (length == 0xffffffff)
5705 {
0c588247 5706 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
19e6b90e
L		 5707 offset_size = 8;
5708 initial_length_size = 12;
5709 }
5710 else
5711 {
5712 offset_size = 4;
5713 initial_length_size = 4;
5714 }
5715
5716 block_end = saved_start + length + initial_length_size;
041830e0 5717 if (block_end > end || block_end < start)
53b8873b 5718 {
bf5117e3
NC		 5719 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5720 dwarf_vmatoa_1 (NULL, length, offset_size),
5721 (unsigned long) (saved_start - section_start));
53b8873b
NC		 5722 block_end = end;
5723 }
0c588247
NC		 5724
5725 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
19e6b90e 5726
846a11e4
NC		 5727 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5728 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
19e6b90e
L		 5729 {
5730 int version;
a1165289 5731 unsigned int mreg;
19e6b90e 5732
49727e46
AM		 5733 start = read_cie (start, end, &cie, &version,
5734 &augmentation_data_len, &augmentation_data);
041830e0
NC		 5735 /* PR 17512: file: 027-135133-0.005. */
5736 if (cie == NULL)
5737 break;
a1165289 5738
49727e46 5739 fc = cie;
19e6b90e
L		 5740 fc->next = chunks;
5741 chunks = fc;
5742 fc->chunk_start = saved_start;
a1165289 5743 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 5744 if (mreg < fc->ra)
5745 mreg = fc->ra;
06614111
NC		 5746 if (frame_need_space (fc, mreg) < 0)
5747 break;
49727e46
AM		 5748 if (fc->fde_encoding)
5749 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
19e6b90e 5750
bf5117e3
NC		 5751 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5752 print_dwarf_vma (length, fc->ptr_size);
9c41109d 5753 print_dwarf_vma (cie_id, offset_size);
bf5117e3 5754
19e6b90e 5755 if (do_debug_frames_interp)
bf5117e3
NC		 5756 {
5757 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5758 fc->code_factor, fc->data_factor, fc->ra);
5759 }
19e6b90e
L		 5760 else
5761 {
bf5117e3 5762 printf ("CIE\n");
19e6b90e
L		 5763 printf (" Version: %d\n", version);
5764 printf (" Augmentation: \"%s\"\n", fc->augmentation);
604282a7
JJ		 5765 if (version >= 4)
5766 {
5767 printf (" Pointer Size: %u\n", fc->ptr_size);
5768 printf (" Segment Size: %u\n", fc->segment_size);
5769 }
19e6b90e
L		 5770 printf (" Code alignment factor: %u\n", fc->code_factor);
5771 printf (" Data alignment factor: %d\n", fc->data_factor);
5772 printf (" Return address column: %d\n", fc->ra);
5773
5774 if (augmentation_data_len)
5775 {
5776 unsigned long i;
a1165289 5777
19e6b90e
L		 5778 printf (" Augmentation data: ");
5779 for (i = 0; i < augmentation_data_len; ++i)
a1165289
NC		 5780 /* FIXME: If do_wide is FALSE, then we should
5781 add carriage returns at 80 columns... */
19e6b90e
L		 5782 printf (" %02x", augmentation_data[i]);
5783 putchar ('\n');
5784 }
5785 putchar ('\n');
5786 }
19e6b90e
L		 5787 }
5788 else
5789 {
5790 unsigned char *look_for;
5791 static Frame_Chunk fde_fc;
604282a7 5792 unsigned long segment_selector;
19e6b90e 5793
49727e46
AM		 5794 if (is_eh)
5795 {
5796 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5797 look_for = start - 4 - ((cie_id ^ sign) - sign);
5798 }
5799 else
5800 look_for = section_start + cie_id;
19e6b90e 5801
49727e46
AM		 5802 if (look_for <= saved_start)
5803 {
5804 for (cie = chunks; cie ; cie = cie->next)
5805 if (cie->chunk_start == look_for)
5806 break;
5807 }
5808 else
5809 {
5810 for (cie = forward_refs; cie ; cie = cie->next)
5811 if (cie->chunk_start == look_for)
5812 break;
5813 if (!cie)
5814 {
5815 unsigned int off_size;
5816 unsigned char *cie_scan;
19e6b90e 5817
49727e46
AM		 5818 cie_scan = look_for;
5819 off_size = 4;
5820 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5821 if (length == 0xffffffff)
5822 {
5823 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5824 off_size = 8;
5825 }
5826 if (length != 0)
5827 {
5828 dwarf_vma c_id;
5829
5830 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5831 if (is_eh
5832 ? c_id == 0
5833 : ((off_size == 4 && c_id == DW_CIE_ID)
5834 || (off_size == 8 && c_id == DW64_CIE_ID)))
5835 {
5836 int version;
a1165289 5837 unsigned int mreg;
49727e46
AM		 5838
5839 read_cie (cie_scan, end, &cie, &version,
5840 &augmentation_data_len, &augmentation_data);
a1165289
NC		 5841 /* PR 17512: file: 3450-2098-0.004. */
5842 if (cie == NULL)
5843 {
5844 warn (_("Failed to read CIE information\n"));
5845 break;
5846 }
49727e46
AM		 5847 cie->next = forward_refs;
5848 forward_refs = cie;
5849 cie->chunk_start = look_for;
a1165289 5850 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 5851 if (mreg < cie->ra)
5852 mreg = cie->ra;
06614111
NC		 5853 if (frame_need_space (cie, mreg) < 0)
5854 {
5855 warn (_("Invalid max register\n"));
5856 break;
5857 }
49727e46
AM		 5858 if (cie->fde_encoding)
5859 encoded_ptr_size
5860 = size_of_encoded_value (cie->fde_encoding);
5861 }
5862 }
5863 }
5864 }
5865
5866 fc = &fde_fc;
5867 memset (fc, 0, sizeof (Frame_Chunk));
19e6b90e
L		 5868
5869 if (!cie)
5870 {
bf5117e3
NC		 5871 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5872 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5873 (unsigned long) (saved_start - section_start));
19e6b90e 5874 fc->ncols = 0;
3f5e193b
NC		 5875 fc->col_type = (short int *) xmalloc (sizeof (short int));
5876 fc->col_offset = (int *) xmalloc (sizeof (int));
06614111
NC		 5877 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5878 {
5879 warn (_("Invalid max register\n"));
5880 break;
5881 }
19e6b90e
L		 5882 cie = fc;
5883 fc->augmentation = "";
5884 fc->fde_encoding = 0;
604282a7
JJ		 5885 fc->ptr_size = eh_addr_size;
5886 fc->segment_size = 0;
19e6b90e
L		 5887 }
5888 else
5889 {
5890 fc->ncols = cie->ncols;
3f5e193b
NC		 5891 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5892 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
19e6b90e
L		 5893 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5894 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5895 fc->augmentation = cie->augmentation;
604282a7
JJ		 5896 fc->ptr_size = cie->ptr_size;
5897 eh_addr_size = cie->ptr_size;
5898 fc->segment_size = cie->segment_size;
19e6b90e
L		 5899 fc->code_factor = cie->code_factor;
5900 fc->data_factor = cie->data_factor;
5901 fc->cfa_reg = cie->cfa_reg;
5902 fc->cfa_offset = cie->cfa_offset;
5903 fc->ra = cie->ra;
06614111
NC		 5904 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5905 {
5906 warn (_("Invalid max register\n"));
5907 break;
5908 }
19e6b90e
L		 5909 fc->fde_encoding = cie->fde_encoding;
5910 }
5911
5912 if (fc->fde_encoding)
5913 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5914
604282a7
JJ		 5915 segment_selector = 0;
5916 if (fc->segment_size)
041830e0
NC		 5917 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5918
5919 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
19e6b90e 5920
0c588247
NC		 5921 /* FIXME: It appears that sometimes the final pc_range value is
5922 encoded in less than encoded_ptr_size bytes. See the x86_64
5923 run of the "objcopy on compressed debug sections" test for an
5924 example of this. */
5925 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
bf5117e3 5926
19e6b90e
L		 5927 if (cie->augmentation[0] == 'z')
5928 {
5929 augmentation_data_len = LEB ();
5930 augmentation_data = start;
5931 start += augmentation_data_len;
0a9d414a 5932 /* PR 17512: file: 722-8446-0.004. */
53774b7e 5933 if (start >= end || ((signed long) augmentation_data_len) < 0)
0a9d414a
NC		 5934 {
5935 warn (_("Corrupt augmentation data length: %lx\n"),
5936 augmentation_data_len);
5937 start = end;
5938 augmentation_data = NULL;
5939 augmentation_data_len = 0;
5940 }
19e6b90e
L		 5941 }
5942
bf5117e3
NC		 5943 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5944 (unsigned long)(saved_start - section_start),
5945 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
9c41109d 5946 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
604282a7 5947 (unsigned long)(cie->chunk_start - section_start));
bf5117e3 5948
604282a7
JJ		 5949 if (fc->segment_size)
5950 printf ("%04lx:", segment_selector);
bf5117e3
NC		 5951
5952 printf ("%s..%s\n",
5953 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
5954 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
5955
19e6b90e
L		 5956 if (! do_debug_frames_interp && augmentation_data_len)
5957 {
5958 unsigned long i;
5959
5960 printf (" Augmentation data: ");
5961 for (i = 0; i < augmentation_data_len; ++i)
5962 printf (" %02x", augmentation_data[i]);
5963 putchar ('\n');
5964 putchar ('\n');
5965 }
5966 }
5967
5968 /* At this point, fc is the current chunk, cie (if any) is set, and
5969 we're about to interpret instructions for the chunk. */
5970 /* ??? At present we need to do this always, since this sizes the
5971 fc->col_type and fc->col_offset arrays, which we write into always.
5972 We should probably split the interpreted and non-interpreted bits
5973 into two different routines, since there's so much that doesn't
5974 really overlap between them. */
5975 if (1 || do_debug_frames_interp)
5976 {
5977 /* Start by making a pass over the chunk, allocating storage
5978 and taking note of what registers are used. */
5979 unsigned char *tmp = start;
5980
5981 while (start < block_end)
5982 {
041830e0
NC		 5983 unsigned int reg, op, opa;
5984 unsigned long temp;
5929c344 5985 unsigned char * new_start;
19e6b90e
L		 5986
5987 op = *start++;
5988 opa = op & 0x3f;
5989 if (op & 0xc0)
5990 op &= 0xc0;
5991
5992 /* Warning: if you add any more cases to this switch, be
5993 sure to add them to the corresponding switch below. */
5994 switch (op)
5995 {
5996 case DW_CFA_advance_loc:
5997 break;
5998 case DW_CFA_offset:
5999 LEB ();
665ce1f6
L		 6000 if (frame_need_space (fc, opa) >= 0)
6001 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 6002 break;
6003 case DW_CFA_restore:
665ce1f6
L		 6004 if (frame_need_space (fc, opa) >= 0)
6005 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 6006 break;
6007 case DW_CFA_set_loc:
6008 start += encoded_ptr_size;
6009 break;
6010 case DW_CFA_advance_loc1:
6011 start += 1;
6012 break;
6013 case DW_CFA_advance_loc2:
6014 start += 2;
6015 break;
6016 case DW_CFA_advance_loc4:
6017 start += 4;
6018 break;
6019 case DW_CFA_offset_extended:
12eae2d3 6020 case DW_CFA_val_offset:
19e6b90e 6021 reg = LEB (); LEB ();
665ce1f6
L		 6022 if (frame_need_space (fc, reg) >= 0)
6023 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6024 break;
6025 case DW_CFA_restore_extended:
6026 reg = LEB ();
665ce1f6
L		 6027 if (frame_need_space (fc, reg) >= 0)
6028 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6029 break;
6030 case DW_CFA_undefined:
6031 reg = LEB ();
665ce1f6
L		 6032 if (frame_need_space (fc, reg) >= 0)
6033 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6034 break;
6035 case DW_CFA_same_value:
6036 reg = LEB ();
665ce1f6
L		 6037 if (frame_need_space (fc, reg) >= 0)
6038 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6039 break;
6040 case DW_CFA_register:
6041 reg = LEB (); LEB ();
665ce1f6
L		 6042 if (frame_need_space (fc, reg) >= 0)
6043 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6044 break;
6045 case DW_CFA_def_cfa:
6046 LEB (); LEB ();
6047 break;
6048 case DW_CFA_def_cfa_register:
6049 LEB ();
6050 break;
6051 case DW_CFA_def_cfa_offset:
6052 LEB ();
6053 break;
6054 case DW_CFA_def_cfa_expression:
91d6fa6a 6055 temp = LEB ();
5929c344
NC		 6056 new_start = start + temp;
6057 if (new_start < start)
041830e0
NC		 6058 {
6059 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6060 start = block_end;
6061 }
6062 else
5929c344 6063 start = new_start;
19e6b90e
L		 6064 break;
6065 case DW_CFA_expression:
12eae2d3 6066 case DW_CFA_val_expression:
19e6b90e 6067 reg = LEB ();
91d6fa6a 6068 temp = LEB ();
5929c344
NC		 6069 new_start = start + temp;
6070 if (new_start < start)
041830e0
NC		 6071 {
6072 /* PR 17512: file:306-192417-0.005. */
6073 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6074 start = block_end;
6075 }
6076 else
5929c344 6077 start = new_start;
665ce1f6
L		 6078 if (frame_need_space (fc, reg) >= 0)
6079 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6080 break;
6081 case DW_CFA_offset_extended_sf:
12eae2d3 6082 case DW_CFA_val_offset_sf:
19e6b90e 6083 reg = LEB (); SLEB ();
665ce1f6
L		 6084 if (frame_need_space (fc, reg) >= 0)
6085 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6086 break;
6087 case DW_CFA_def_cfa_sf:
6088 LEB (); SLEB ();
6089 break;
6090 case DW_CFA_def_cfa_offset_sf:
6091 SLEB ();
6092 break;
6093 case DW_CFA_MIPS_advance_loc8:
6094 start += 8;
6095 break;
6096 case DW_CFA_GNU_args_size:
6097 LEB ();
6098 break;
6099 case DW_CFA_GNU_negative_offset_extended:
6100 reg = LEB (); LEB ();
665ce1f6
L		 6101 if (frame_need_space (fc, reg) >= 0)
6102 fc->col_type[reg] = DW_CFA_undefined;
6103 break;
19e6b90e
L		 6104 default:
6105 break;
6106 }
6107 }
6108 start = tmp;
6109 }
6110
6111 /* Now we know what registers are used, make a second pass over
6112 the chunk, this time actually printing out the info. */
6113
6114 while (start < block_end)
6115 {
362beea4 6116 unsigned char * tmp;
19e6b90e
L		 6117 unsigned op, opa;
6118 unsigned long ul, reg, roffs;
bf5117e3
NC		 6119 long l;
6120 dwarf_vma ofs;
19e6b90e 6121 dwarf_vma vma;
665ce1f6 6122 const char *reg_prefix = "";
19e6b90e
L		 6123
6124 op = *start++;
6125 opa = op & 0x3f;
6126 if (op & 0xc0)
6127 op &= 0xc0;
6128
6129 /* Warning: if you add any more cases to this switch, be
6130 sure to add them to the corresponding switch above. */
6131 switch (op)
6132 {
6133 case DW_CFA_advance_loc:
6134 if (do_debug_frames_interp)
6135 frame_display_row (fc, &need_col_headers, &max_regs);
6136 else
bf5117e3 6137 printf (" DW_CFA_advance_loc: %d to %s\n",
19e6b90e 6138 opa * fc->code_factor,
bf5117e3
NC		 6139 dwarf_vmatoa_1 (NULL,
6140 fc->pc_begin + opa * fc->code_factor,
6141 fc->ptr_size));
19e6b90e
L		 6142 fc->pc_begin += opa * fc->code_factor;
6143 break;
6144
6145 case DW_CFA_offset:
6146 roffs = LEB ();
665ce1f6
L		 6147 if (opa >= (unsigned int) fc->ncols)
6148 reg_prefix = bad_reg;
6149 if (! do_debug_frames_interp || *reg_prefix != '\0')
6150 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6151 reg_prefix, regname (opa, 0),
6152 roffs * fc->data_factor);
6153 if (*reg_prefix == '\0')
6154 {
6155 fc->col_type[opa] = DW_CFA_offset;
6156 fc->col_offset[opa] = roffs * fc->data_factor;
6157 }
19e6b90e
L		 6158 break;
6159
6160 case DW_CFA_restore:
665ce1f6
L		 6161 if (opa >= (unsigned int) cie->ncols
6162 || opa >= (unsigned int) fc->ncols)
6163 reg_prefix = bad_reg;
6164 if (! do_debug_frames_interp || *reg_prefix != '\0')
6165 printf (" DW_CFA_restore: %s%s\n",
6166 reg_prefix, regname (opa, 0));
6167 if (*reg_prefix == '\0')
6168 {
6169 fc->col_type[opa] = cie->col_type[opa];
6170 fc->col_offset[opa] = cie->col_offset[opa];
b3f5b73b
ILT		 6171 if (do_debug_frames_interp
6172 && fc->col_type[opa] == DW_CFA_unreferenced)
6173 fc->col_type[opa] = DW_CFA_undefined;
665ce1f6 6174 }
19e6b90e
L		 6175 break;
6176
6177 case DW_CFA_set_loc:
6937bb54 6178 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
19e6b90e
L		 6179 if (do_debug_frames_interp)
6180 frame_display_row (fc, &need_col_headers, &max_regs);
6181 else
bf5117e3
NC		 6182 printf (" DW_CFA_set_loc: %s\n",
6183 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
19e6b90e
L		 6184 fc->pc_begin = vma;
6185 break;
6186
6187 case DW_CFA_advance_loc1:
0c588247 6188 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
19e6b90e
L		 6189 if (do_debug_frames_interp)
6190 frame_display_row (fc, &need_col_headers, &max_regs);
6191 else
bf5117e3
NC		 6192 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6193 (unsigned long) (ofs * fc->code_factor),
6194 dwarf_vmatoa_1 (NULL,
6195 fc->pc_begin + ofs * fc->code_factor,
6196 fc->ptr_size));
19e6b90e
L		 6197 fc->pc_begin += ofs * fc->code_factor;
6198 break;
6199
6200 case DW_CFA_advance_loc2:
6937bb54 6201 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
19e6b90e
L		 6202 if (do_debug_frames_interp)
6203 frame_display_row (fc, &need_col_headers, &max_regs);
6204 else
bf5117e3
NC		 6205 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6206 (unsigned long) (ofs * fc->code_factor),
6207 dwarf_vmatoa_1 (NULL,
6208 fc->pc_begin + ofs * fc->code_factor,
6209 fc->ptr_size));
19e6b90e
L		 6210 fc->pc_begin += ofs * fc->code_factor;
6211 break;
6212
6213 case DW_CFA_advance_loc4:
6937bb54 6214 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
19e6b90e
L		 6215 if (do_debug_frames_interp)
6216 frame_display_row (fc, &need_col_headers, &max_regs);
6217 else
bf5117e3
NC		 6218 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6219 (unsigned long) (ofs * fc->code_factor),
6220 dwarf_vmatoa_1 (NULL,
6221 fc->pc_begin + ofs * fc->code_factor,
6222 fc->ptr_size));
19e6b90e
L		 6223 fc->pc_begin += ofs * fc->code_factor;
6224 break;
6225
6226 case DW_CFA_offset_extended:
6227 reg = LEB ();
6228 roffs = LEB ();
665ce1f6
L		 6229 if (reg >= (unsigned int) fc->ncols)
6230 reg_prefix = bad_reg;
6231 if (! do_debug_frames_interp || *reg_prefix != '\0')
6232 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6233 reg_prefix, regname (reg, 0),
6234 roffs * fc->data_factor);
6235 if (*reg_prefix == '\0')
6236 {
6237 fc->col_type[reg] = DW_CFA_offset;
6238 fc->col_offset[reg] = roffs * fc->data_factor;
6239 }
19e6b90e
L		 6240 break;
6241
12eae2d3
JJ		 6242 case DW_CFA_val_offset:
6243 reg = LEB ();
6244 roffs = LEB ();
665ce1f6
L		 6245 if (reg >= (unsigned int) fc->ncols)
6246 reg_prefix = bad_reg;
6247 if (! do_debug_frames_interp || *reg_prefix != '\0')
6248 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6249 reg_prefix, regname (reg, 0),
6250 roffs * fc->data_factor);
6251 if (*reg_prefix == '\0')
6252 {
6253 fc->col_type[reg] = DW_CFA_val_offset;
6254 fc->col_offset[reg] = roffs * fc->data_factor;
6255 }
12eae2d3
JJ		 6256 break;
6257
19e6b90e
L		 6258 case DW_CFA_restore_extended:
6259 reg = LEB ();
665ce1f6
L		 6260 if (reg >= (unsigned int) cie->ncols
6261 || reg >= (unsigned int) fc->ncols)
6262 reg_prefix = bad_reg;
6263 if (! do_debug_frames_interp || *reg_prefix != '\0')
6264 printf (" DW_CFA_restore_extended: %s%s\n",
6265 reg_prefix, regname (reg, 0));
6266 if (*reg_prefix == '\0')
6267 {
6268 fc->col_type[reg] = cie->col_type[reg];
6269 fc->col_offset[reg] = cie->col_offset[reg];
6270 }
19e6b90e
L		 6271 break;
6272
6273 case DW_CFA_undefined:
6274 reg = LEB ();
665ce1f6
L		 6275 if (reg >= (unsigned int) fc->ncols)
6276 reg_prefix = bad_reg;
6277 if (! do_debug_frames_interp || *reg_prefix != '\0')
6278 printf (" DW_CFA_undefined: %s%s\n",
6279 reg_prefix, regname (reg, 0));
6280 if (*reg_prefix == '\0')
6281 {
6282 fc->col_type[reg] = DW_CFA_undefined;
6283 fc->col_offset[reg] = 0;
6284 }
19e6b90e
L		 6285 break;
6286
6287 case DW_CFA_same_value:
6288 reg = LEB ();
665ce1f6
L		 6289 if (reg >= (unsigned int) fc->ncols)
6290 reg_prefix = bad_reg;
6291 if (! do_debug_frames_interp || *reg_prefix != '\0')
6292 printf (" DW_CFA_same_value: %s%s\n",
6293 reg_prefix, regname (reg, 0));
6294 if (*reg_prefix == '\0')
6295 {
6296 fc->col_type[reg] = DW_CFA_same_value;
6297 fc->col_offset[reg] = 0;
6298 }
19e6b90e
L		 6299 break;
6300
6301 case DW_CFA_register:
6302 reg = LEB ();
6303 roffs = LEB ();
665ce1f6
L		 6304 if (reg >= (unsigned int) fc->ncols)
6305 reg_prefix = bad_reg;
6306 if (! do_debug_frames_interp || *reg_prefix != '\0')
2dc4cec1 6307 {
665ce1f6
L		 6308 printf (" DW_CFA_register: %s%s in ",
6309 reg_prefix, regname (reg, 0));
2dc4cec1
L		 6310 puts (regname (roffs, 0));
6311 }
665ce1f6
L		 6312 if (*reg_prefix == '\0')
6313 {
6314 fc->col_type[reg] = DW_CFA_register;
6315 fc->col_offset[reg] = roffs;
6316 }
19e6b90e
L		 6317 break;
6318
6319 case DW_CFA_remember_state:
6320 if (! do_debug_frames_interp)
6321 printf (" DW_CFA_remember_state\n");
3f5e193b 6322 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
d71ad7fc
RC		 6323 rs->cfa_offset = fc->cfa_offset;
6324 rs->cfa_reg = fc->cfa_reg;
6325 rs->ra = fc->ra;
6326 rs->cfa_exp = fc->cfa_exp;
19e6b90e 6327 rs->ncols = fc->ncols;
3f5e193b 6328 rs->col_type = (short int *) xcmalloc (rs->ncols,
d71ad7fc
RC		 6329 sizeof (* rs->col_type));
6330 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6331 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6332 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
19e6b90e
L		 6333 rs->next = remembered_state;
6334 remembered_state = rs;
6335 break;
6336
6337 case DW_CFA_restore_state:
6338 if (! do_debug_frames_interp)
6339 printf (" DW_CFA_restore_state\n");
6340 rs = remembered_state;
6341 if (rs)
6342 {
6343 remembered_state = rs->next;
d71ad7fc
RC		 6344 fc->cfa_offset = rs->cfa_offset;
6345 fc->cfa_reg = rs->cfa_reg;
6346 fc->ra = rs->ra;
6347 fc->cfa_exp = rs->cfa_exp;
06614111
NC		 6348 if (frame_need_space (fc, rs->ncols - 1) < 0)
6349 {
1306a742 6350 warn (_("Invalid column number in saved frame state\n"));
06614111
NC		 6351 fc->ncols = 0;
6352 break;
6353 }
d71ad7fc 6354 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
19e6b90e 6355 memcpy (fc->col_offset, rs->col_offset,
d71ad7fc 6356 rs->ncols * sizeof (* rs->col_offset));
19e6b90e
L		 6357 free (rs->col_type);
6358 free (rs->col_offset);
6359 free (rs);
6360 }
6361 else if (do_debug_frames_interp)
6362 printf ("Mismatched DW_CFA_restore_state\n");
6363 break;
6364
6365 case DW_CFA_def_cfa:
6366 fc->cfa_reg = LEB ();
6367 fc->cfa_offset = LEB ();
6368 fc->cfa_exp = 0;
6369 if (! do_debug_frames_interp)
2dc4cec1
L		 6370 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6371 regname (fc->cfa_reg, 0), fc->cfa_offset);
19e6b90e
L		 6372 break;
6373
6374 case DW_CFA_def_cfa_register:
6375 fc->cfa_reg = LEB ();
6376 fc->cfa_exp = 0;
6377 if (! do_debug_frames_interp)
2dc4cec1
L		 6378 printf (" DW_CFA_def_cfa_register: %s\n",
6379 regname (fc->cfa_reg, 0));
19e6b90e
L		 6380 break;
6381
6382 case DW_CFA_def_cfa_offset:
6383 fc->cfa_offset = LEB ();
6384 if (! do_debug_frames_interp)
6385 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6386 break;
6387
6388 case DW_CFA_nop:
6389 if (! do_debug_frames_interp)
6390 printf (" DW_CFA_nop\n");
6391 break;
6392
6393 case DW_CFA_def_cfa_expression:
6394 ul = LEB ();
06614111 6395 if (start >= block_end || start + ul > block_end || start + ul < start)
6937bb54 6396 {
a1165289 6397 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 6398 break;
6399 }
19e6b90e
L		 6400 if (! do_debug_frames_interp)
6401 {
6402 printf (" DW_CFA_def_cfa_expression (");
b7807392
JJ		 6403 decode_location_expression (start, eh_addr_size, 0, -1,
6404 ul, 0, section);
19e6b90e
L		 6405 printf (")\n");
6406 }
6407 fc->cfa_exp = 1;
6408 start += ul;
6409 break;
6410
6411 case DW_CFA_expression:
6412 reg = LEB ();
6413 ul = LEB ();
665ce1f6
L		 6414 if (reg >= (unsigned int) fc->ncols)
6415 reg_prefix = bad_reg;
6937bb54 6416 /* PR 17512: file: 069-133014-0.006. */
06614111 6417 /* PR 17512: file: 98c02eb4. */
362beea4
NC		 6418 tmp = start + ul;
6419 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 6420 {
a1165289 6421 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 6422 break;
6423 }
665ce1f6 6424 if (! do_debug_frames_interp || *reg_prefix != '\0')
19e6b90e 6425 {
665ce1f6
L		 6426 printf (" DW_CFA_expression: %s%s (",
6427 reg_prefix, regname (reg, 0));
b7807392 6428 decode_location_expression (start, eh_addr_size, 0, -1,
f1c4cc75 6429 ul, 0, section);
19e6b90e
L		 6430 printf (")\n");
6431 }
665ce1f6
L		 6432 if (*reg_prefix == '\0')
6433 fc->col_type[reg] = DW_CFA_expression;
362beea4 6434 start = tmp;
19e6b90e
L		 6435 break;
6436
12eae2d3
JJ		 6437 case DW_CFA_val_expression:
6438 reg = LEB ();
6439 ul = LEB ();
665ce1f6
L		 6440 if (reg >= (unsigned int) fc->ncols)
6441 reg_prefix = bad_reg;
362beea4
NC		 6442 tmp = start + ul;
6443 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 6444 {
a1165289 6445 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6937bb54
NC		 6446 break;
6447 }
665ce1f6 6448 if (! do_debug_frames_interp || *reg_prefix != '\0')
12eae2d3 6449 {
665ce1f6
L		 6450 printf (" DW_CFA_val_expression: %s%s (",
6451 reg_prefix, regname (reg, 0));
b7807392
JJ		 6452 decode_location_expression (start, eh_addr_size, 0, -1,
6453 ul, 0, section);
12eae2d3
JJ		 6454 printf (")\n");
6455 }
665ce1f6
L		 6456 if (*reg_prefix == '\0')
6457 fc->col_type[reg] = DW_CFA_val_expression;
362beea4 6458 start = tmp;
12eae2d3
JJ		 6459 break;
6460
19e6b90e
L		 6461 case DW_CFA_offset_extended_sf:
6462 reg = LEB ();
6463 l = SLEB ();
665ce1f6
L		 6464 if (frame_need_space (fc, reg) < 0)
6465 reg_prefix = bad_reg;
6466 if (! do_debug_frames_interp || *reg_prefix != '\0')
6467 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6468 reg_prefix, regname (reg, 0),
6469 l * fc->data_factor);
6470 if (*reg_prefix == '\0')
6471 {
6472 fc->col_type[reg] = DW_CFA_offset;
6473 fc->col_offset[reg] = l * fc->data_factor;
6474 }
19e6b90e
L		 6475 break;
6476
12eae2d3
JJ		 6477 case DW_CFA_val_offset_sf:
6478 reg = LEB ();
6479 l = SLEB ();
665ce1f6
L		 6480 if (frame_need_space (fc, reg) < 0)
6481 reg_prefix = bad_reg;
6482 if (! do_debug_frames_interp || *reg_prefix != '\0')
6483 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6484 reg_prefix, regname (reg, 0),
6485 l * fc->data_factor);
6486 if (*reg_prefix == '\0')
6487 {
6488 fc->col_type[reg] = DW_CFA_val_offset;
6489 fc->col_offset[reg] = l * fc->data_factor;
6490 }
12eae2d3
JJ		 6491 break;
6492
19e6b90e
L		 6493 case DW_CFA_def_cfa_sf:
6494 fc->cfa_reg = LEB ();
6495 fc->cfa_offset = SLEB ();
6496 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6497 fc->cfa_exp = 0;
6498 if (! do_debug_frames_interp)
2dc4cec1
L		 6499 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6500 regname (fc->cfa_reg, 0), fc->cfa_offset);
19e6b90e
L		 6501 break;
6502
6503 case DW_CFA_def_cfa_offset_sf:
6504 fc->cfa_offset = SLEB ();
6505 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6506 if (! do_debug_frames_interp)
6507 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
6508 break;
6509
6510 case DW_CFA_MIPS_advance_loc8:
6937bb54 6511 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
19e6b90e
L		 6512 if (do_debug_frames_interp)
6513 frame_display_row (fc, &need_col_headers, &max_regs);
6514 else
bf5117e3
NC		 6515 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6516 (unsigned long) (ofs * fc->code_factor),
6517 dwarf_vmatoa_1 (NULL,
6518 fc->pc_begin + ofs * fc->code_factor,
6519 fc->ptr_size));
19e6b90e
L		 6520 fc->pc_begin += ofs * fc->code_factor;
6521 break;
6522
6523 case DW_CFA_GNU_window_save:
6524 if (! do_debug_frames_interp)
6525 printf (" DW_CFA_GNU_window_save\n");
6526 break;
6527
6528 case DW_CFA_GNU_args_size:
6529 ul = LEB ();
6530 if (! do_debug_frames_interp)
6531 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6532 break;
6533
6534 case DW_CFA_GNU_negative_offset_extended:
6535 reg = LEB ();
6536 l = - LEB ();
665ce1f6
L		 6537 if (frame_need_space (fc, reg) < 0)
6538 reg_prefix = bad_reg;
6539 if (! do_debug_frames_interp || *reg_prefix != '\0')
6540 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6541 reg_prefix, regname (reg, 0),
6542 l * fc->data_factor);
6543 if (*reg_prefix == '\0')
6544 {
6545 fc->col_type[reg] = DW_CFA_offset;
6546 fc->col_offset[reg] = l * fc->data_factor;
6547 }
19e6b90e
L		 6548 break;
6549
6550 default:
53b8873b
NC		 6551 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6552 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6553 else
f41e4712 6554 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
19e6b90e
L		 6555 start = block_end;
6556 }
6557 }
6558
6559 if (do_debug_frames_interp)
6560 frame_display_row (fc, &need_col_headers, &max_regs);
6561
6562 start = block_end;
604282a7 6563 eh_addr_size = saved_eh_addr_size;
19e6b90e
L		 6564 }
6565
6566 printf ("\n");
6567
6568 return 1;
6569}
6570
6571#undef GET
6572#undef LEB
6573#undef SLEB
6574
5bbdf3d5
DE		 6575static int
6576display_gdb_index (struct dwarf_section *section,
6577 void *file ATTRIBUTE_UNUSED)
6578{
6579 unsigned char *start = section->start;
6580 uint32_t version;
6581 uint32_t cu_list_offset, tu_list_offset;
6582 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6583 unsigned int cu_list_elements, tu_list_elements;
6584 unsigned int address_table_size, symbol_table_slots;
6585 unsigned char *cu_list, *tu_list;
6586 unsigned char *address_table, *symbol_table, *constant_pool;
6587 unsigned int i;
6588
6589 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6590
6591 printf (_("Contents of the %s section:\n"), section->name);
6592
6593 if (section->size < 6 * sizeof (uint32_t))
6594 {
6595 warn (_("Truncated header in the %s section.\n"), section->name);
6596 return 0;
6597 }
6598
6599 version = byte_get_little_endian (start, 4);
da88a764 6600 printf (_("Version %ld\n"), (long) version);
5bbdf3d5
DE		 6601
6602 /* Prior versions are obsolete, and future versions may not be
6603 backwards compatible. */
aa170720 6604 if (version < 3 || version > 8)
5bbdf3d5 6605 {
da88a764 6606 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5bbdf3d5
DE		 6607 return 0;
6608 }
8d6eee87
TT		 6609 if (version < 4)
6610 warn (_("The address table data in version 3 may be wrong.\n"));
6611 if (version < 5)
6612 warn (_("Version 4 does not support case insensitive lookups.\n"));
6613 if (version < 6)
6614 warn (_("Version 5 does not include inlined functions.\n"));
6615 if (version < 7)
6616 warn (_("Version 6 does not include symbol attributes.\n"));
aa170720
DE		 6617 /* Version 7 indices generated by Gold have bad type unit references,
6618 PR binutils/15021. But we don't know if the index was generated by
6619 Gold or not, so to avoid worrying users with gdb-generated indices
6620 we say nothing for version 7 here. */
5bbdf3d5
DE		 6621
6622 cu_list_offset = byte_get_little_endian (start + 4, 4);
6623 tu_list_offset = byte_get_little_endian (start + 8, 4);
6624 address_table_offset = byte_get_little_endian (start + 12, 4);
6625 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6626 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6627
6628 if (cu_list_offset > section->size
6629 || tu_list_offset > section->size
6630 || address_table_offset > section->size
6631 || symbol_table_offset > section->size
6632 || constant_pool_offset > section->size)
6633 {
6634 warn (_("Corrupt header in the %s section.\n"), section->name);
6635 return 0;
6636 }
6637
53774b7e
NC		 6638 /* PR 17531: file: 418d0a8a. */
6639 if (tu_list_offset < cu_list_offset)
6640 {
6641 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6642 tu_list_offset, cu_list_offset);
6643 return 0;
6644 }
6645
5bbdf3d5 6646 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
53774b7e
NC		 6647
6648 if (address_table_offset < tu_list_offset)
6649 {
6650 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6651 address_table_offset, tu_list_offset);
6652 return 0;
6653 }
6654
5bbdf3d5 6655 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
53774b7e
NC		 6656
6657 /* PR 17531: file: 18a47d3d. */
6658 if (symbol_table_offset < address_table_offset)
6659 {
acff9664 6660 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
53774b7e
NC		 6661 symbol_table_offset, address_table_offset);
6662 return 0;
6663 }
6664
5bbdf3d5 6665 address_table_size = symbol_table_offset - address_table_offset;
53774b7e
NC		 6666
6667 if (constant_pool_offset < symbol_table_offset)
6668 {
6669 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6670 constant_pool_offset, symbol_table_offset);
6671 return 0;
6672 }
6673
5bbdf3d5
DE		 6674 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6675
6676 cu_list = start + cu_list_offset;
6677 tu_list = start + tu_list_offset;
6678 address_table = start + address_table_offset;
6679 symbol_table = start + symbol_table_offset;
6680 constant_pool = start + constant_pool_offset;
6681
acff9664
NC		 6682 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6683 {
1306a742 6684 warn (_("Address table extends beyond end of section.\n"));
acff9664
NC		 6685 return 0;
6686 }
6687
5bbdf3d5
DE		 6688 printf (_("\nCU table:\n"));
6689 for (i = 0; i < cu_list_elements; i += 2)
6690 {
6691 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6692 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6693
6694 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6695 (unsigned long) cu_offset,
6696 (unsigned long) (cu_offset + cu_length - 1));
6697 }
6698
6699 printf (_("\nTU table:\n"));
6700 for (i = 0; i < tu_list_elements; i += 3)
6701 {
6702 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6703 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6704 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6705
6706 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6707 (unsigned long) tu_offset,
6708 (unsigned long) type_offset);
6709 print_dwarf_vma (signature, 8);
6710 printf ("\n");
6711 }
6712
6713 printf (_("\nAddress table:\n"));
acff9664
NC		 6714 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6715 i += 2 * 8 + 4)
5bbdf3d5
DE		 6716 {
6717 uint64_t low = byte_get_little_endian (address_table + i, 8);
6718 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6719 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6720
6721 print_dwarf_vma (low, 8);
6722 print_dwarf_vma (high, 8);
da88a764 6723 printf (_("%lu\n"), (unsigned long) cu_index);
5bbdf3d5
DE		 6724 }
6725
6726 printf (_("\nSymbol table:\n"));
6727 for (i = 0; i < symbol_table_slots; ++i)
6728 {
6729 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6730 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6731 uint32_t num_cus, cu;
6732
6733 if (name_offset != 0
6734 || cu_vector_offset != 0)
6735 {
6736 unsigned int j;
362beea4 6737 unsigned char * adr;
5bbdf3d5 6738
362beea4 6739 adr = constant_pool + name_offset;
53774b7e 6740 /* PR 17531: file: 5b7b07ad. */
362beea4 6741 if (adr < constant_pool || adr >= section->start + section->size)
53774b7e
NC		 6742 {
6743 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6744 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6745 name_offset, i);
6746 }
6747 else
acff9664
NC		 6748 printf ("[%3u] %.*s:", i,
6749 (int) (section->size - (constant_pool_offset + name_offset)),
6750 constant_pool + name_offset);
53774b7e 6751
362beea4
NC		 6752 adr = constant_pool + cu_vector_offset;
6753 if (adr < constant_pool || adr >= section->start + section->size - 3)
53774b7e
NC		 6754 {
6755 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6756 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6757 cu_vector_offset, i);
6758 continue;
6759 }
57028622 6760
362beea4 6761 num_cus = byte_get_little_endian (adr, 4);
53774b7e 6762
362beea4 6763 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
acff9664 6764 if (num_cus * 4 < num_cus
362beea4
NC		 6765 || adr >= section->start + section->size
6766 || adr < constant_pool)
53774b7e
NC		 6767 {
6768 printf ("<invalid number of CUs: %d>\n", num_cus);
acff9664 6769 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
53774b7e
NC		 6770 num_cus, i);
6771 continue;
6772 }
6773
8d6eee87
TT		 6774 if (num_cus > 1)
6775 printf ("\n");
f3853b34 6776
5bbdf3d5
DE		 6777 for (j = 0; j < num_cus; ++j)
6778 {
7c1cef97 6779 int is_static;
8d6eee87
TT		 6780 gdb_index_symbol_kind kind;
6781
5bbdf3d5 6782 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
7c1cef97 6783 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
8d6eee87
TT		 6784 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6785 cu = GDB_INDEX_CU_VALUE (cu);
5bbdf3d5 6786 /* Convert to TU number if it's for a type unit. */
ad6b52dd 6787 if (cu >= cu_list_elements / 2)
8d6eee87
TT		 6788 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6789 (unsigned long) (cu - cu_list_elements / 2));
5bbdf3d5 6790 else
8d6eee87
TT		 6791 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6792
459d52c8
DE		 6793 printf (" [%s, %s]",
6794 is_static ? _("static") : _("global"),
6795 get_gdb_index_symbol_kind_name (kind));
8d6eee87
TT		 6796 if (num_cus > 1)
6797 printf ("\n");
5bbdf3d5 6798 }
8d6eee87
TT		 6799 if (num_cus <= 1)
6800 printf ("\n");
5bbdf3d5
DE		 6801 }
6802 }
6803
6804 return 1;
6805}
6806
657d0d47
CC		 6807/* Pre-allocate enough space for the CU/TU sets needed. */
6808
6809static void
6810prealloc_cu_tu_list (unsigned int nshndx)
6811{
6812 if (shndx_pool == NULL)
6813 {
6814 shndx_pool_size = nshndx;
6815 shndx_pool_used = 0;
6816 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6817 sizeof (unsigned int));
6818 }
6819 else
6820 {
6821 shndx_pool_size = shndx_pool_used + nshndx;
6822 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6823 sizeof (unsigned int));
6824 }
6825}
6826
6827static void
6828add_shndx_to_cu_tu_entry (unsigned int shndx)
6829{
6830 if (shndx_pool_used >= shndx_pool_size)
6831 {
6832 error (_("Internal error: out of space in the shndx pool.\n"));
6833 return;
6834 }
6835 shndx_pool [shndx_pool_used++] = shndx;
6836}
6837
6838static void
6839end_cu_tu_entry (void)
6840{
6841 if (shndx_pool_used >= shndx_pool_size)
6842 {
6843 error (_("Internal error: out of space in the shndx pool.\n"));
6844 return;
6845 }
6846 shndx_pool [shndx_pool_used++] = 0;
6847}
6848
341f9135
CC		 6849/* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6850
6851static const char *
6852get_DW_SECT_short_name (unsigned int dw_sect)
6853{
6854 static char buf[16];
6855
6856 switch (dw_sect)
6857 {
6858 case DW_SECT_INFO:
6859 return "info";
6860 case DW_SECT_TYPES:
6861 return "types";
6862 case DW_SECT_ABBREV:
6863 return "abbrev";
6864 case DW_SECT_LINE:
6865 return "line";
6866 case DW_SECT_LOC:
6867 return "loc";
6868 case DW_SECT_STR_OFFSETS:
6869 return "str_off";
6870 case DW_SECT_MACINFO:
6871 return "macinfo";
6872 case DW_SECT_MACRO:
6873 return "macro";
6874 default:
6875 break;
6876 }
6877
6878 snprintf (buf, sizeof (buf), "%d", dw_sect);
6879 return buf;
6880}
6881
6882/* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6883 These sections are extensions for Fission.
6884 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
657d0d47
CC		 6885
6886static int
6887process_cu_tu_index (struct dwarf_section *section, int do_display)
6888{
6889 unsigned char *phdr = section->start;
6890 unsigned char *limit = phdr + section->size;
6891 unsigned char *phash;
6892 unsigned char *pindex;
6893 unsigned char *ppool;
6894 unsigned int version;
341f9135 6895 unsigned int ncols = 0;
657d0d47
CC		 6896 unsigned int nused;
6897 unsigned int nslots;
6898 unsigned int i;
341f9135
CC		 6899 unsigned int j;
6900 dwarf_vma signature_high;
6901 dwarf_vma signature_low;
6902 char buf[64];
657d0d47 6903
6937bb54
NC		 6904 /* PR 17512: file: 002-168123-0.004. */
6905 if (phdr == NULL)
6906 {
6907 warn (_("Section %s is empty\n"), section->name);
6908 return 0;
6909 }
6910 /* PR 17512: file: 002-376-0.004. */
6911 if (section->size < 24)
6912 {
72c61a0d 6913 warn (_("Section %s is too small to contain a CU/TU header\n"),
6937bb54
NC		 6914 section->name);
6915 return 0;
6916 }
6917
6918 SAFE_BYTE_GET (version, phdr, 4, limit);
341f9135 6919 if (version >= 2)
6937bb54
NC		 6920 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6921 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6922 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6923
657d0d47
CC		 6924 phash = phdr + 16;
6925 pindex = phash + nslots * 8;
6926 ppool = pindex + nslots * 4;
6927
57028622 6928 /* PR 17531: file: 45d69832. */
03a91817 6929 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
57028622
NC		 6930 {
6931 warn (_("Section %s is too small for %d slots\n"),
6932 section->name, nslots);
6933 return 0;
6934 }
6935
657d0d47
CC		 6936 if (do_display)
6937 {
6938 printf (_("Contents of the %s section:\n\n"), section->name);
6939 printf (_(" Version: %d\n"), version);
341f9135
CC		 6940 if (version >= 2)
6941 printf (_(" Number of columns: %d\n"), ncols);
657d0d47
CC		 6942 printf (_(" Number of used entries: %d\n"), nused);
6943 printf (_(" Number of slots: %d\n\n"), nslots);
6944 }
6945
03a91817 6946 if (ppool > limit || ppool < phdr)
657d0d47
CC		 6947 {
6948 warn (_("Section %s too small for %d hash table entries\n"),
6949 section->name, nslots);
6950 return 0;
6951 }
6952
341f9135 6953 if (version == 1)
657d0d47 6954 {
341f9135
CC		 6955 if (!do_display)
6956 prealloc_cu_tu_list ((limit - ppool) / 4);
6957 for (i = 0; i < nslots; i++)
657d0d47 6958 {
341f9135
CC		 6959 unsigned char *shndx_list;
6960 unsigned int shndx;
6961
6937bb54 6962 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
341f9135 6963 if (signature_high != 0 || signature_low != 0)
657d0d47 6964 {
6937bb54 6965 SAFE_BYTE_GET (j, pindex, 4, limit);
341f9135 6966 shndx_list = ppool + j * 4;
f3853b34
NC		 6967 /* PR 17531: file: 705e010d. */
6968 if (shndx_list < ppool)
6969 {
6970 warn (_("Section index pool located before start of section\n"));
6971 return 0;
6972 }
6973
341f9135
CC		 6974 if (do_display)
6975 printf (_(" [%3d] Signature: 0x%s Sections: "),
6976 i, dwarf_vmatoa64 (signature_high, signature_low,
6977 buf, sizeof (buf)));
6978 for (;;)
657d0d47 6979 {
341f9135
CC		 6980 if (shndx_list >= limit)
6981 {
6982 warn (_("Section %s too small for shndx pool\n"),
6983 section->name);
6984 return 0;
6985 }
6937bb54 6986 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
341f9135
CC		 6987 if (shndx == 0)
6988 break;
6989 if (do_display)
6990 printf (" %d", shndx);
6991 else
6992 add_shndx_to_cu_tu_entry (shndx);
6993 shndx_list += 4;
657d0d47 6994 }
657d0d47 6995 if (do_display)
341f9135 6996 printf ("\n");
657d0d47 6997 else
341f9135
CC		 6998 end_cu_tu_entry ();
6999 }
7000 phash += 8;
7001 pindex += 4;
7002 }
7003 }
7004 else if (version == 2)
7005 {
7006 unsigned int val;
7007 unsigned int dw_sect;
7008 unsigned char *ph = phash;
7009 unsigned char *pi = pindex;
7010 unsigned char *poffsets = ppool + ncols * 4;
7011 unsigned char *psizes = poffsets + nused * ncols * 4;
7012 unsigned char *pend = psizes + nused * ncols * 4;
7013 bfd_boolean is_tu_index;
7014 struct cu_tu_set *this_set = NULL;
7015 unsigned int row;
7016 unsigned char *prow;
7017
7018 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7019
362beea4
NC		 7020 /* PR 17531: file: 0dd159bf.
7021 Check for wraparound with an overlarge ncols value. */
7022 if ((unsigned int) ((poffsets - ppool) / 4) != ncols)
7023 {
7024 warn (_("Overlarge number of columns: %x\n"), ncols);
7025 return 0;
7026 }
7027
341f9135
CC		 7028 if (pend > limit)
7029 {
7030 warn (_("Section %s too small for offset and size tables\n"),
7031 section->name);
7032 return 0;
7033 }
7034
7035 if (do_display)
7036 {
7037 printf (_(" Offset table\n"));
7038 printf (" slot %-16s ",
7039 is_tu_index ? _("signature") : _("dwo_id"));
7040 }
7041 else
7042 {
7043 if (is_tu_index)
7044 {
7045 tu_count = nused;
72c61a0d 7046 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135 7047 this_set = tu_sets;
657d0d47 7048 }
657d0d47 7049 else
341f9135
CC		 7050 {
7051 cu_count = nused;
72c61a0d 7052 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135
CC		 7053 this_set = cu_sets;
7054 }
7055 }
6937bb54 7056
341f9135
CC		 7057 if (do_display)
7058 {
7059 for (j = 0; j < ncols; j++)
7060 {
6937bb54 7061 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
341f9135
CC		 7062 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7063 }
7064 printf ("\n");
7065 }
6937bb54 7066
341f9135
CC		 7067 for (i = 0; i < nslots; i++)
7068 {
6937bb54
NC		 7069 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7070
7071 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 7072 if (row != 0)
7073 {
591f7597 7074 /* PR 17531: file: a05f6ab3. */
ef77750e 7075 if (row > nused)
591f7597
NC		 7076 {
7077 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7078 row, nused);
7079 return 0;
7080 }
7081
341f9135
CC		 7082 if (!do_display)
7083 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6937bb54 7084
341f9135 7085 prow = poffsets + (row - 1) * ncols * 4;
6937bb54 7086
341f9135
CC		 7087 if (do_display)
7088 printf (_(" [%3d] 0x%s"),
7089 i, dwarf_vmatoa64 (signature_high, signature_low,
7090 buf, sizeof (buf)));
7091 for (j = 0; j < ncols; j++)
7092 {
6937bb54 7093 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 7094 if (do_display)
7095 printf (" %8d", val);
7096 else
7097 {
6937bb54 7098 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 7099
7100 /* PR 17531: file: 10796eb3. */
7101 if (dw_sect >= DW_SECT_MAX)
7102 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7103 else
7104 this_set [row - 1].section_offsets [dw_sect] = val;
341f9135
CC		 7105 }
7106 }
6937bb54 7107
341f9135
CC		 7108 if (do_display)
7109 printf ("\n");
7110 }
7111 ph += 8;
7112 pi += 4;
7113 }
7114
7115 ph = phash;
7116 pi = pindex;
7117 if (do_display)
7118 {
7119 printf ("\n");
7120 printf (_(" Size table\n"));
7121 printf (" slot %-16s ",
7122 is_tu_index ? _("signature") : _("dwo_id"));
7123 }
6937bb54 7124
341f9135
CC		 7125 for (j = 0; j < ncols; j++)
7126 {
6937bb54 7127 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
341f9135
CC		 7128 if (do_display)
7129 printf (" %8s", get_DW_SECT_short_name (val));
7130 }
6937bb54 7131
341f9135
CC		 7132 if (do_display)
7133 printf ("\n");
6937bb54 7134
341f9135
CC		 7135 for (i = 0; i < nslots; i++)
7136 {
6937bb54
NC		 7137 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7138
7139 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 7140 if (row != 0)
7141 {
7142 prow = psizes + (row - 1) * ncols * 4;
6937bb54 7143
341f9135
CC		 7144 if (do_display)
7145 printf (_(" [%3d] 0x%s"),
7146 i, dwarf_vmatoa64 (signature_high, signature_low,
7147 buf, sizeof (buf)));
6937bb54 7148
341f9135
CC		 7149 for (j = 0; j < ncols; j++)
7150 {
6937bb54 7151 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 7152 if (do_display)
7153 printf (" %8d", val);
7154 else
7155 {
6937bb54 7156 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 7157 if (dw_sect >= DW_SECT_MAX)
7158 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7159 else
341f9135
CC		 7160 this_set [row - 1].section_sizes [dw_sect] = val;
7161 }
7162 }
6937bb54 7163
341f9135
CC		 7164 if (do_display)
7165 printf ("\n");
7166 }
6937bb54 7167
341f9135
CC		 7168 ph += 8;
7169 pi += 4;
657d0d47 7170 }
657d0d47 7171 }
341f9135 7172 else if (do_display)
6937bb54 7173 printf (_(" Unsupported version (%d)\n"), version);
657d0d47
CC		 7174
7175 if (do_display)
7176 printf ("\n");
7177
7178 return 1;
7179}
7180
7181/* Load the CU and TU indexes if present. This will build a list of
7182 section sets that we can use to associate a .debug_info.dwo section
7183 with its associated .debug_abbrev.dwo section in a .dwp file. */
7184
7185static void
7186load_cu_tu_indexes (void *file)
7187{
7188 /* If we have already loaded (or tried to load) the CU and TU indexes
7189 then do not bother to repeat the task. */
7190 if (cu_tu_indexes_read)
7191 return;
7192
7193 if (load_debug_section (dwp_cu_index, file))
7194 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7195
7196 if (load_debug_section (dwp_tu_index, file))
7197 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7198
7199 cu_tu_indexes_read = 1;
7200}
7201
7202/* Find the set of sections that includes section SHNDX. */
7203
7204unsigned int *
7205find_cu_tu_set (void *file, unsigned int shndx)
7206{
7207 unsigned int i;
7208
7209 load_cu_tu_indexes (file);
7210
7211 /* Find SHNDX in the shndx pool. */
7212 for (i = 0; i < shndx_pool_used; i++)
7213 if (shndx_pool [i] == shndx)
7214 break;
7215
7216 if (i >= shndx_pool_used)
7217 return NULL;
7218
7219 /* Now backup to find the first entry in the set. */
7220 while (i > 0 && shndx_pool [i - 1] != 0)
7221 i--;
7222
7223 return shndx_pool + i;
7224}
7225
7226/* Display a .debug_cu_index or .debug_tu_index section. */
7227
7228static int
7229display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7230{
7231 return process_cu_tu_index (section, 1);
7232}
7233
19e6b90e
L		 7234static int
7235display_debug_not_supported (struct dwarf_section *section,
7236 void *file ATTRIBUTE_UNUSED)
7237{
7238 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7239 section->name);
7240
7241 return 1;
7242}
7243
1306a742
NC		 7244/* Like malloc, but takes two parameters like calloc.
7245 Verifies that the first parameter is not too large.
82b1b41b 7246 Note: does *not* initialise the allocated memory to zero. */
19e6b90e
L		 7247void *
7248cmalloc (size_t nmemb, size_t size)
7249{
7250 /* Check for overflow. */
7251 if (nmemb >= ~(size_t) 0 / size)
7252 return NULL;
82b1b41b
NC		 7253
7254 return xmalloc (nmemb * size);
19e6b90e
L		 7255}
7256
1306a742
NC		 7257/* Like xmalloc, but takes two parameters like calloc.
7258 Verifies that the first parameter is not too large.
7259 Note: does *not* initialise the allocated memory to zero. */
72c61a0d 7260void *
1306a742 7261xcmalloc (size_t nmemb, size_t size)
72c61a0d
NC		 7262{
7263 /* Check for overflow. */
7264 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7265 {
7266 fprintf (stderr,
7267 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7268 (long) nmemb);
7269 xexit (1);
7270 }
72c61a0d 7271
1306a742 7272 return xmalloc (nmemb * size);
72c61a0d
NC		 7273}
7274
1306a742
NC		 7275/* Like xrealloc, but takes three parameters.
7276 Verifies that the second parameter is not too large.
7277 Note: does *not* initialise any new memory to zero. */
19e6b90e 7278void *
1306a742 7279xcrealloc (void *ptr, size_t nmemb, size_t size)
19e6b90e
L		 7280{
7281 /* Check for overflow. */
7282 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7283 {
7284 fprintf (stderr,
7285 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7286 (long) nmemb);
7287 xexit (1);
7288 }
82b1b41b 7289
1306a742 7290 return xrealloc (ptr, nmemb * size);
19e6b90e
L		 7291}
7292
1306a742 7293/* Like xcalloc, but verifies that the first parameter is not too large. */
19e6b90e 7294void *
1306a742 7295xcalloc2 (size_t nmemb, size_t size)
19e6b90e
L		 7296{
7297 /* Check for overflow. */
7298 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7299 {
7300 fprintf (stderr,
7301 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7302 (long) nmemb);
7303 xexit (1);
7304 }
82b1b41b 7305
1306a742 7306 return xcalloc (nmemb, size);
19e6b90e
L		 7307}
7308
19e6b90e
L		 7309void
7310free_debug_memory (void)
7311{
3f5e193b 7312 unsigned int i;
19e6b90e
L		 7313
7314 free_abbrevs ();
7315
7316 for (i = 0; i < max; i++)
3f5e193b 7317 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 7318
cc86f28f 7319 if (debug_information != NULL)
19e6b90e 7320 {
cc86f28f 7321 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
19e6b90e 7322 {
cc86f28f 7323 for (i = 0; i < num_debug_info_entries; i++)
19e6b90e 7324 {
cc86f28f
NC		 7325 if (!debug_information [i].max_loc_offsets)
7326 {
7327 free (debug_information [i].loc_offsets);
7328 free (debug_information [i].have_frame_base);
7329 }
7330 if (!debug_information [i].max_range_lists)
7331 free (debug_information [i].range_lists);
19e6b90e 7332 }
19e6b90e
L		 7333 }
7334 free (debug_information);
7335 debug_information = NULL;
82b1b41b 7336 alloc_num_debug_info_entries = num_debug_info_entries = 0;
19e6b90e 7337 }
19e6b90e
L		 7338}
7339
4cb93e3b
TG		 7340void
7341dwarf_select_sections_by_names (const char *names)
7342{
7343 typedef struct
7344 {
7345 const char * option;
7346 int * variable;
f9f0e732 7347 int val;
4cb93e3b
TG		 7348 }
7349 debug_dump_long_opts;
7350
7351 static const debug_dump_long_opts opts_table [] =
7352 {
7353 /* Please keep this table alpha- sorted. */
7354 { "Ranges", & do_debug_ranges, 1 },
7355 { "abbrev", & do_debug_abbrevs, 1 },
657d0d47 7356 { "addr", & do_debug_addr, 1 },
4cb93e3b 7357 { "aranges", & do_debug_aranges, 1 },
657d0d47
CC		 7358 { "cu_index", & do_debug_cu_index, 1 },
7359 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4cb93e3b
TG		 7360 { "frames", & do_debug_frames, 1 },
7361 { "frames-interp", & do_debug_frames_interp, 1 },
657d0d47
CC		 7362 /* The special .gdb_index section. */
7363 { "gdb_index", & do_gdb_index, 1 },
4cb93e3b
TG		 7364 { "info", & do_debug_info, 1 },
7365 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
4cb93e3b
TG		 7366 { "loc", & do_debug_loc, 1 },
7367 { "macro", & do_debug_macinfo, 1 },
7368 { "pubnames", & do_debug_pubnames, 1 },
357da287 7369 { "pubtypes", & do_debug_pubtypes, 1 },
4cb93e3b
TG		 7370 /* This entry is for compatability
7371 with earlier versions of readelf. */
7372 { "ranges", & do_debug_aranges, 1 },
657d0d47 7373 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4cb93e3b 7374 { "str", & do_debug_str, 1 },
6f875884
TG		 7375 /* These trace_* sections are used by Itanium VMS. */
7376 { "trace_abbrev", & do_trace_abbrevs, 1 },
7377 { "trace_aranges", & do_trace_aranges, 1 },
7378 { "trace_info", & do_trace_info, 1 },
4cb93e3b
TG		 7379 { NULL, NULL, 0 }
7380 };
7381
7382 const char *p;
467c65bc 7383
4cb93e3b
TG		 7384 p = names;
7385 while (*p)
7386 {
7387 const debug_dump_long_opts * entry;
467c65bc 7388
4cb93e3b
TG		 7389 for (entry = opts_table; entry->option; entry++)
7390 {
7391 size_t len = strlen (entry->option);
467c65bc 7392
4cb93e3b
TG		 7393 if (strncmp (p, entry->option, len) == 0
7394 && (p[len] == ',' || p[len] == '\0'))
7395 {
7396 * entry->variable |= entry->val;
467c65bc 7397
4cb93e3b
TG		 7398 /* The --debug-dump=frames-interp option also
7399 enables the --debug-dump=frames option. */
7400 if (do_debug_frames_interp)
7401 do_debug_frames = 1;
7402
7403 p += len;
7404 break;
7405 }
7406 }
467c65bc 7407
4cb93e3b
TG		 7408 if (entry->option == NULL)
7409 {
7410 warn (_("Unrecognized debug option '%s'\n"), p);
7411 p = strchr (p, ',');
7412 if (p == NULL)
7413 break;
7414 }
467c65bc 7415
4cb93e3b
TG		 7416 if (*p == ',')
7417 p++;
7418 }
7419}
7420
7421void
7422dwarf_select_sections_by_letters (const char *letters)
7423{
91d6fa6a 7424 unsigned int lindex = 0;
4cb93e3b 7425
91d6fa6a
NC		 7426 while (letters[lindex])
7427 switch (letters[lindex++])
4cb93e3b
TG		 7428 {
7429 case 'i':
7430 do_debug_info = 1;
7431 break;
467c65bc 7432
4cb93e3b
TG		 7433 case 'a':
7434 do_debug_abbrevs = 1;
7435 break;
467c65bc 7436
4cb93e3b
TG		 7437 case 'l':
7438 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7439 break;
467c65bc 7440
4cb93e3b
TG		 7441 case 'L':
7442 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7443 break;
467c65bc 7444
4cb93e3b
TG		 7445 case 'p':
7446 do_debug_pubnames = 1;
7447 break;
467c65bc 7448
f9f0e732
NC		 7449 case 't':
7450 do_debug_pubtypes = 1;
7451 break;
467c65bc 7452
4cb93e3b
TG		 7453 case 'r':
7454 do_debug_aranges = 1;
7455 break;
467c65bc 7456
4cb93e3b
TG		 7457 case 'R':
7458 do_debug_ranges = 1;
7459 break;
467c65bc 7460
4cb93e3b
TG		 7461 case 'F':
7462 do_debug_frames_interp = 1;
7463 case 'f':
7464 do_debug_frames = 1;
7465 break;
467c65bc 7466
4cb93e3b
TG		 7467 case 'm':
7468 do_debug_macinfo = 1;
7469 break;
467c65bc 7470
4cb93e3b
TG		 7471 case 's':
7472 do_debug_str = 1;
7473 break;
467c65bc 7474
4cb93e3b
TG		 7475 case 'o':
7476 do_debug_loc = 1;
7477 break;
467c65bc 7478
4cb93e3b 7479 default:
7cc78d07 7480 warn (_("Unrecognized debug option '%s'\n"), letters);
4cb93e3b
TG		 7481 break;
7482 }
7483}
7484
7485void
7486dwarf_select_sections_all (void)
7487{
7488 do_debug_info = 1;
7489 do_debug_abbrevs = 1;
7490 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7491 do_debug_pubnames = 1;
f9f0e732 7492 do_debug_pubtypes = 1;
4cb93e3b
TG		 7493 do_debug_aranges = 1;
7494 do_debug_ranges = 1;
7495 do_debug_frames = 1;
7496 do_debug_macinfo = 1;
7497 do_debug_str = 1;
7498 do_debug_loc = 1;
5bbdf3d5 7499 do_gdb_index = 1;
6f875884
TG		 7500 do_trace_info = 1;
7501 do_trace_abbrevs = 1;
7502 do_trace_aranges = 1;
657d0d47
CC		 7503 do_debug_addr = 1;
7504 do_debug_cu_index = 1;
4cb93e3b
TG		 7505}
7506
19e6b90e
L		 7507struct dwarf_section_display debug_displays[] =
7508{
06614111 7509 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL },
4723351a 7510 display_debug_abbrev, &do_debug_abbrevs, 0 },
06614111 7511 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL },
4723351a 7512 display_debug_aranges, &do_debug_aranges, 1 },
06614111 7513 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL },
4723351a 7514 display_debug_frames, &do_debug_frames, 1 },
06614111 7515 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL },
4723351a 7516 display_debug_info, &do_debug_info, 1 },
06614111 7517 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL },
4723351a 7518 display_debug_lines, &do_debug_lines, 1 },
06614111 7519 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL },
4723351a 7520 display_debug_pubnames, &do_debug_pubnames, 0 },
06614111 7521 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL },
459d52c8 7522 display_debug_gnu_pubnames, &do_debug_pubnames, 0 },
06614111 7523 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL },
4723351a 7524 display_debug_frames, &do_debug_frames, 1 },
06614111 7525 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL },
4723351a 7526 display_debug_macinfo, &do_debug_macinfo, 0 },
06614111 7527 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL },
4723351a 7528 display_debug_macro, &do_debug_macinfo, 1 },
06614111 7529 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL },
4723351a 7530 display_debug_str, &do_debug_str, 0 },
06614111 7531 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL },
4723351a 7532 display_debug_loc, &do_debug_loc, 1 },
06614111 7533 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL },
4723351a 7534 display_debug_pubnames, &do_debug_pubtypes, 0 },
06614111 7535 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL },
459d52c8 7536 display_debug_gnu_pubnames, &do_debug_pubtypes, 0 },
06614111 7537 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL },
4723351a 7538 display_debug_ranges, &do_debug_ranges, 1 },
06614111 7539 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL },
4723351a 7540 display_debug_not_supported, NULL, 0 },
06614111 7541 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL },
4723351a 7542 display_debug_not_supported, NULL, 0 },
06614111 7543 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL },
4723351a 7544 display_debug_types, &do_debug_info, 1 },
06614111 7545 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL },
4723351a 7546 display_debug_not_supported, NULL, 0 },
06614111 7547 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7548 display_gdb_index, &do_gdb_index, 0 },
06614111 7549 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL },
657d0d47 7550 display_trace_info, &do_trace_info, 1 },
06614111 7551 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7552 display_debug_abbrev, &do_trace_abbrevs, 0 },
06614111 7553 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7554 display_debug_aranges, &do_trace_aranges, 0 },
06614111 7555 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
657d0d47 7556 display_debug_info, &do_debug_info, 1 },
06614111 7557 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7558 display_debug_abbrev, &do_debug_abbrevs, 0 },
06614111 7559 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL },
657d0d47 7560 display_debug_types, &do_debug_info, 1 },
06614111 7561 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7562 display_debug_lines, &do_debug_lines, 1 },
06614111 7563 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL },
4723351a 7564 display_debug_loc, &do_debug_loc, 1 },
06614111 7565 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL },
4723351a 7566 display_debug_macro, &do_debug_macinfo, 1 },
06614111 7567 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL },
4723351a 7568 display_debug_macinfo, &do_debug_macinfo, 0 },
06614111 7569 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7570 display_debug_str, &do_debug_str, 1 },
06614111 7571 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL },
4723351a 7572 display_debug_str_offsets, NULL, 0 },
06614111 7573 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL },
4723351a 7574 display_debug_str_offsets, NULL, 0 },
06614111 7575 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7576 display_debug_addr, &do_debug_addr, 1 },
06614111 7577 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7578 display_cu_index, &do_debug_cu_index, 0 },
06614111 7579 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL },
657d0d47 7580 display_cu_index, &do_debug_cu_index, 0 },
19e6b90e 7581};
GDB Binutils - Deliverables
This page took 1.053664 seconds and 4 git commands to generate.