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