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