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