projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[ARC] Fix warn.exp test error.
[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 {
4913 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4914 break;
4915 }
4916
47704ddf
KT		 4917 printf (_(" Length: %ld\n"),
4918 (long) arange.ar_length);
19e6b90e 4919 printf (_(" Version: %d\n"), arange.ar_version);
47704ddf
KT		 4920 printf (_(" Offset into .debug_info: 0x%lx\n"),
4921 (unsigned long) arange.ar_info_offset);
19e6b90e
L		 4922 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
4923 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
4924
53b8873b
NC		 4925 address_size = arange.ar_pointer_size + arange.ar_segment_size;
4926
f41e4712
NC		 4927 /* PR 17512: file: 001-108546-0.001:0.1. */
4928 if (address_size == 0 || address_size > 8)
b3681d67
L		 4929 {
4930 error (_("Invalid address size in %s section!\n"),
4931 section->name);
4932 break;
4933 }
4934
53b8873b
NC		 4935 /* The DWARF spec does not require that the address size be a power
4936 of two, but we do. This will have to change if we ever encounter
4937 an uneven architecture. */
4938 if ((address_size & (address_size - 1)) != 0)
4939 {
4940 warn (_("Pointer size + Segment size is not a power of two.\n"));
4941 break;
4942 }
cecf136e 4943
209c9a13
NC		 4944 if (address_size > 4)
4945 printf (_("\n Address Length\n"));
4946 else
4947 printf (_("\n Address Length\n"));
19e6b90e 4948
91d6fa6a 4949 addr_ranges = hdrptr;
19e6b90e 4950
53b8873b
NC		 4951 /* Must pad to an alignment boundary that is twice the address size. */
4952 excess = (hdrptr - start) % (2 * address_size);
19e6b90e 4953 if (excess)
91d6fa6a 4954 addr_ranges += (2 * address_size) - excess;
19e6b90e 4955
ffc0f143
NC		 4956 hdrptr = start + arange.ar_length + initial_length_size;
4957 if (hdrptr < start || hdrptr > end)
4958 {
4959 error (_("Excessive header length: %lx\n"), (long) arange.ar_length);
4960 break;
4961 }
4962 start = hdrptr;
1617e571 4963
91d6fa6a 4964 while (addr_ranges + 2 * address_size <= start)
19e6b90e 4965 {
0c588247
NC		 4966 SAFE_BYTE_GET_AND_INC (address, addr_ranges, address_size, end);
4967 SAFE_BYTE_GET_AND_INC (length, addr_ranges, address_size, end);
19e6b90e 4968
80c35038 4969 printf (" ");
2d9472a2
NC		 4970 print_dwarf_vma (address, address_size);
4971 print_dwarf_vma (length, address_size);
4972 putchar ('\n');
19e6b90e 4973 }
19e6b90e
L		 4974 }
4975
4976 printf ("\n");
4977
4978 return 1;
4979}
4980
4723351a
CC		 4981/* Comparison function for qsort. */
4982static int
4983comp_addr_base (const void * v0, const void * v1)
4984{
4985 debug_info * info0 = (debug_info *) v0;
4986 debug_info * info1 = (debug_info *) v1;
4987 return info0->addr_base - info1->addr_base;
4988}
4989
4990/* Display the debug_addr section. */
4991static int
4992display_debug_addr (struct dwarf_section *section,
b4eb7656 4993 void *file)
4723351a
CC		 4994{
4995 debug_info **debug_addr_info;
4996 unsigned char *entry;
4997 unsigned char *end;
4998 unsigned int i;
4999 unsigned int count;
5000
5001 if (section->size == 0)
5002 {
5003 printf (_("\nThe %s section is empty.\n"), section->name);
5004 return 0;
5005 }
5006
5007 if (load_debug_info (file) == 0)
5008 {
5009 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5010 section->name);
5011 return 0;
5012 }
5013
5014 printf (_("Contents of the %s section:\n\n"), section->name);
5015
1306a742
NC		 5016 /* PR 17531: file: cf38d01b.
5017 We use xcalloc because a corrupt file may not have initialised all of the
5018 fields in the debug_info structure, which means that the sort below might
5019 try to move uninitialised data. */
5020 debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1),
b4eb7656 5021 sizeof (debug_info *));
4723351a
CC		 5022
5023 count = 0;
5024 for (i = 0; i < num_debug_info_entries; i++)
82b1b41b 5025 if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE)
1306a742
NC		 5026 {
5027 /* PR 17531: file: cf38d01b. */
5028 if (debug_information[i].addr_base >= section->size)
5029 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5030 (unsigned long) debug_information[i].addr_base, i);
5031 else
5032 debug_addr_info [count++] = debug_information + i;
5033 }
4723351a
CC		 5034
5035 /* Add a sentinel to make iteration convenient. */
5036 debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info));
5037 debug_addr_info [count]->addr_base = section->size;
4723351a 5038 qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base);
1306a742 5039
4723351a
CC		 5040 for (i = 0; i < count; i++)
5041 {
5042 unsigned int idx;
fab128ef 5043 unsigned int address_size = debug_addr_info [i]->pointer_size;
4723351a
CC		 5044
5045 printf (_(" For compilation unit at offset 0x%s:\n"),
b4eb7656 5046 dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset));
4723351a 5047
fab128ef 5048 printf (_("\tIndex\tAddress\n"));
4723351a
CC		 5049 entry = section->start + debug_addr_info [i]->addr_base;
5050 end = section->start + debug_addr_info [i + 1]->addr_base;
5051 idx = 0;
5052 while (entry < end)
b4eb7656
AM		 5053 {
5054 dwarf_vma base = byte_get (entry, address_size);
5055 printf (_("\t%d:\t"), idx);
5056 print_dwarf_vma (base, address_size);
5057 printf ("\n");
5058 entry += address_size;
5059 idx++;
5060 }
4723351a
CC		 5061 }
5062 printf ("\n");
5063
5064 free (debug_addr_info);
5065 return 1;
5066}
5067
5068/* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5069static int
5070display_debug_str_offsets (struct dwarf_section *section,
b4eb7656 5071 void *file ATTRIBUTE_UNUSED)
4723351a
CC		 5072{
5073 if (section->size == 0)
5074 {
5075 printf (_("\nThe %s section is empty.\n"), section->name);
5076 return 0;
5077 }
5078 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5079 what the offset size is for this section. */
5080 return 1;
5081}
5082
01a8f077
JK		 5083/* Each debug_information[x].range_lists[y] gets this representation for
5084 sorting purposes. */
5085
5086struct range_entry
467c65bc
NC		 5087{
5088 /* The debug_information[x].range_lists[y] value. */
5089 unsigned long ranges_offset;
01a8f077 5090
467c65bc
NC		 5091 /* Original debug_information to find parameters of the data. */
5092 debug_info *debug_info_p;
5093};
01a8f077
JK		 5094
5095/* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5096
5097static int
5098range_entry_compar (const void *ap, const void *bp)
5099{
3f5e193b
NC		 5100 const struct range_entry *a_re = (const struct range_entry *) ap;
5101 const struct range_entry *b_re = (const struct range_entry *) bp;
01a8f077
JK		 5102 const unsigned long a = a_re->ranges_offset;
5103 const unsigned long b = b_re->ranges_offset;
5104
5105 return (a > b) - (b > a);
5106}
5107
19e6b90e
L		 5108static int
5109display_debug_ranges (struct dwarf_section *section,
5110 void *file ATTRIBUTE_UNUSED)
5111{
5112 unsigned char *start = section->start;
a2ff7a4b 5113 unsigned char *last_start = start;
f6f0e17b 5114 unsigned long bytes = section->size;
19e6b90e 5115 unsigned char *section_begin = start;
f6f0e17b 5116 unsigned char *finish = start + bytes;
01a8f077
JK		 5117 unsigned int num_range_list, i;
5118 struct range_entry *range_entries, *range_entry_fill;
19e6b90e 5119
19e6b90e
L		 5120 if (bytes == 0)
5121 {
5122 printf (_("\nThe %s section is empty.\n"), section->name);
5123 return 0;
5124 }
5125
1febe64d
NC		 5126 if (load_debug_info (file) == 0)
5127 {
5128 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5129 section->name);
5130 return 0;
5131 }
19e6b90e 5132
01a8f077 5133 num_range_list = 0;
19e6b90e 5134 for (i = 0; i < num_debug_info_entries; i++)
01a8f077 5135 num_range_list += debug_information [i].num_range_lists;
19e6b90e 5136
01a8f077 5137 if (num_range_list == 0)
4723351a
CC		 5138 {
5139 /* This can happen when the file was compiled with -gsplit-debug
b4eb7656 5140 which removes references to range lists from the primary .o file. */
4723351a
CC		 5141 printf (_("No range lists in .debug_info section.\n"));
5142 return 1;
5143 }
19e6b90e 5144
3f5e193b
NC		 5145 range_entries = (struct range_entry *)
5146 xmalloc (sizeof (*range_entries) * num_range_list);
01a8f077 5147 range_entry_fill = range_entries;
19e6b90e 5148
01a8f077
JK		 5149 for (i = 0; i < num_debug_info_entries; i++)
5150 {
5151 debug_info *debug_info_p = &debug_information[i];
5152 unsigned int j;
5153
5154 for (j = 0; j < debug_info_p->num_range_lists; j++)
5155 {
5156 range_entry_fill->ranges_offset = debug_info_p->range_lists[j];
5157 range_entry_fill->debug_info_p = debug_info_p;
5158 range_entry_fill++;
19e6b90e
L		 5159 }
5160 }
5161
01a8f077
JK		 5162 qsort (range_entries, num_range_list, sizeof (*range_entries),
5163 range_entry_compar);
19e6b90e 5164
d493b283 5165 if (dwarf_check != 0 && range_entries[0].ranges_offset != 0)
19e6b90e 5166 warn (_("Range lists in %s section start at 0x%lx\n"),
01a8f077 5167 section->name, range_entries[0].ranges_offset);
19e6b90e
L		 5168
5169 printf (_("Contents of the %s section:\n\n"), section->name);
5170 printf (_(" Offset Begin End\n"));
5171
01a8f077 5172 for (i = 0; i < num_range_list; i++)
19e6b90e 5173 {
01a8f077
JK		 5174 struct range_entry *range_entry = &range_entries[i];
5175 debug_info *debug_info_p = range_entry->debug_info_p;
19e6b90e 5176 unsigned int pointer_size;
01a8f077
JK		 5177 unsigned long offset;
5178 unsigned char *next;
19e6b90e
L		 5179 unsigned long base_address;
5180
01a8f077 5181 pointer_size = debug_info_p->pointer_size;
d493b283 5182 offset = range_entry->ranges_offset;
01a8f077
JK		 5183 next = section_begin + offset;
5184 base_address = debug_info_p->base_address;
cecf136e 5185
f41e4712
NC		 5186 /* PR 17512: file: 001-101485-0.001:0.1. */
5187 if (pointer_size < 2 || pointer_size > 8)
5188 {
5189 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5190 pointer_size, offset);
5191 continue;
5192 }
b4eb7656 5193
4723351a 5194 if (dwarf_check != 0 && i > 0)
19e6b90e 5195 {
01a8f077
JK		 5196 if (start < next)
5197 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5198 (unsigned long) (start - section_begin),
5199 (unsigned long) (next - section_begin), section->name);
5200 else if (start > next)
a2ff7a4b
AM		 5201 {
5202 if (next == last_start)
5203 continue;
5204 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5205 (unsigned long) (start - section_begin),
5206 (unsigned long) (next - section_begin), section->name);
5207 }
01a8f077
JK		 5208 }
5209 start = next;
a2ff7a4b 5210 last_start = next;
19e6b90e 5211
f6f0e17b 5212 while (start < finish)
01a8f077
JK		 5213 {
5214 dwarf_vma begin;
5215 dwarf_vma end;
5216
0c588247 5217 SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish);
f6f0e17b
NC		 5218 if (start >= finish)
5219 break;
0c588247 5220 SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish);
01a8f077
JK		 5221
5222 printf (" %8.8lx ", offset);
5223
5224 if (begin == 0 && end == 0)
19e6b90e 5225 {
01a8f077
JK		 5226 printf (_("<End of list>\n"));
5227 break;
19e6b90e 5228 }
19e6b90e 5229
01a8f077 5230 /* Check base address specifiers. */
42bcef4a
AB		 5231 if (is_max_address (begin, pointer_size)
5232 && !is_max_address (end, pointer_size))
19e6b90e 5233 {
01a8f077
JK		 5234 base_address = end;
5235 print_dwarf_vma (begin, pointer_size);
5236 print_dwarf_vma (end, pointer_size);
5237 printf ("(base address)\n");
5238 continue;
5239 }
19e6b90e 5240
01a8f077
JK		 5241 print_dwarf_vma (begin + base_address, pointer_size);
5242 print_dwarf_vma (end + base_address, pointer_size);
4a149252 5243
01a8f077
JK		 5244 if (begin == end)
5245 fputs (_("(start == end)"), stdout);
5246 else if (begin > end)
5247 fputs (_("(start > end)"), stdout);
19e6b90e 5248
01a8f077 5249 putchar ('\n');
19e6b90e
L		 5250 }
5251 }
5252 putchar ('\n');
01a8f077
JK		 5253
5254 free (range_entries);
5255
19e6b90e
L		 5256 return 1;
5257}
5258
5259typedef struct Frame_Chunk
5260{
5261 struct Frame_Chunk *next;
5262 unsigned char *chunk_start;
a1165289 5263 unsigned int ncols;
19e6b90e
L		 5264 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5265 short int *col_type;
5266 int *col_offset;
5267 char *augmentation;
5268 unsigned int code_factor;
5269 int data_factor;
bf5117e3
NC		 5270 dwarf_vma pc_begin;
5271 dwarf_vma pc_range;
19e6b90e 5272 int cfa_reg;
c8071705 5273 dwarf_vma cfa_offset;
a1165289 5274 unsigned int ra;
19e6b90e
L		 5275 unsigned char fde_encoding;
5276 unsigned char cfa_exp;
604282a7
JJ		 5277 unsigned char ptr_size;
5278 unsigned char segment_size;
19e6b90e
L		 5279}
5280Frame_Chunk;
5281
665ce1f6
L		 5282static const char *const *dwarf_regnames;
5283static unsigned int dwarf_regnames_count;
5284
19e6b90e
L		 5285/* A marker for a col_type that means this column was never referenced
5286 in the frame info. */
5287#define DW_CFA_unreferenced (-1)
5288
a1165289 5289/* Return 0 if no more space is needed, 1 if more space is needed,
665ce1f6
L		 5290 -1 for invalid reg. */
5291
5292static int
5293frame_need_space (Frame_Chunk *fc, unsigned int reg)
19e6b90e 5294{
a1165289 5295 unsigned int prev = fc->ncols;
19e6b90e 5296
665ce1f6
L		 5297 if (reg < (unsigned int) fc->ncols)
5298 return 0;
5299
5300 if (dwarf_regnames_count
5301 && reg > dwarf_regnames_count)
5302 return -1;
19e6b90e
L		 5303
5304 fc->ncols = reg + 1;
a1165289
NC		 5305 /* PR 17512: file: 10450-2643-0.004.
5306 If reg == -1 then this can happen... */
5307 if (fc->ncols == 0)
5308 return -1;
5309
06614111
NC		 5310 /* PR 17512: file: 2844a11d. */
5311 if (fc->ncols > 1024)
5312 {
5313 error (_("Unfeasibly large register number: %u\n"), reg);
5314 fc->ncols = 0;
5315 /* FIXME: 1024 is an arbitrary limit. Increase it if
5316 we ever encounter a valid binary that exceeds it. */
5317 return -1;
5318 }
5319
3f5e193b 5320 fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols,
b4eb7656 5321 sizeof (short int));
3f5e193b 5322 fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int));
b4eb7656 5323 /* PR 17512: file:002-10025-0.005. */
041830e0
NC		 5324 if (fc->col_type == NULL || fc->col_offset == NULL)
5325 {
5326 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5327 fc->ncols);
5328 fc->ncols = 0;
5329 return -1;
5330 }
19e6b90e
L		 5331
5332 while (prev < fc->ncols)
5333 {
5334 fc->col_type[prev] = DW_CFA_unreferenced;
5335 fc->col_offset[prev] = 0;
5336 prev++;
5337 }
665ce1f6 5338 return 1;
19e6b90e
L		 5339}
5340
2dc4cec1
L		 5341static const char *const dwarf_regnames_i386[] =
5342{
43234a1e
L		 5343 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5344 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5345 "eip", "eflags", NULL, /* 8 - 10 */
5346 "st0", "st1", "st2", "st3", /* 11 - 14 */
5347 "st4", "st5", "st6", "st7", /* 15 - 18 */
5348 NULL, NULL, /* 19 - 20 */
5349 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5350 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5351 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5352 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5353 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5354 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5355 "tr", "ldtr", /* 48 - 49 */
5356 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5357 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5358 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5359 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5360 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5361 NULL, NULL, NULL, /* 90 - 92 */
5362 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
2dc4cec1
L		 5363};
5364
3d875af5
L		 5365static const char *const dwarf_regnames_iamcu[] =
5366{
5367 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5368 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5369 "eip", "eflags", NULL, /* 8 - 10 */
5370 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */
5371 NULL, NULL, /* 19 - 20 */
5372 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */
5373 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */
5374 NULL, NULL, NULL, /* 37 - 39 */
5375 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */
5376 "tr", "ldtr", /* 48 - 49 */
5377 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */
5378 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */
5379 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */
5380 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */
5381 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */
5382 NULL, NULL, NULL, /* 90 - 92 */
5383 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */
5384};
5385
b129eb0e
RH		 5386void
5387init_dwarf_regnames_i386 (void)
5388{
5389 dwarf_regnames = dwarf_regnames_i386;
5390 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386);
5391}
5392
3d875af5
L		 5393void
5394init_dwarf_regnames_iamcu (void)
5395{
5396 dwarf_regnames = dwarf_regnames_iamcu;
5397 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu);
5398}
5399
2dc4cec1
L		 5400static const char *const dwarf_regnames_x86_64[] =
5401{
5402 "rax", "rdx", "rcx", "rbx",
5403 "rsi", "rdi", "rbp", "rsp",
5404 "r8", "r9", "r10", "r11",
5405 "r12", "r13", "r14", "r15",
5406 "rip",
5407 "xmm0", "xmm1", "xmm2", "xmm3",
5408 "xmm4", "xmm5", "xmm6", "xmm7",
5409 "xmm8", "xmm9", "xmm10", "xmm11",
5410 "xmm12", "xmm13", "xmm14", "xmm15",
5411 "st0", "st1", "st2", "st3",
5412 "st4", "st5", "st6", "st7",
5413 "mm0", "mm1", "mm2", "mm3",
5414 "mm4", "mm5", "mm6", "mm7",
5415 "rflags",
5416 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
5417 "fs.base", "gs.base", NULL, NULL,
5418 "tr", "ldtr",
43234a1e
L		 5419 "mxcsr", "fcw", "fsw",
5420 "xmm16", "xmm17", "xmm18", "xmm19",
5421 "xmm20", "xmm21", "xmm22", "xmm23",
5422 "xmm24", "xmm25", "xmm26", "xmm27",
5423 "xmm28", "xmm29", "xmm30", "xmm31",
5424 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 83 - 90 */
5425 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 91 - 98 */
5426 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 99 - 106 */
5427 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 107 - 114 */
5428 NULL, NULL, NULL, /* 115 - 117 */
5429 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
2dc4cec1
L		 5430};
5431
b129eb0e
RH		 5432void
5433init_dwarf_regnames_x86_64 (void)
5434{
5435 dwarf_regnames = dwarf_regnames_x86_64;
5436 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_x86_64);
5437}
5438
4ee22035
RH		 5439static const char *const dwarf_regnames_aarch64[] =
5440{
b4eb7656
AM		 5441 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5442 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
4ee22035
RH		 5443 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5444 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5445 NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL,
5446 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5447 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
5448 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
b4eb7656
AM		 5449 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5450 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
4ee22035
RH		 5451 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5452 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5453};
5454
5455void
5456init_dwarf_regnames_aarch64 (void)
5457{
5458 dwarf_regnames = dwarf_regnames_aarch64;
5459 dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64);
5460}
5461
2dc4cec1
L		 5462void
5463init_dwarf_regnames (unsigned int e_machine)
5464{
5465 switch (e_machine)
5466 {
5467 case EM_386:
b129eb0e 5468 init_dwarf_regnames_i386 ();
2dc4cec1
L		 5469 break;
5470
3d875af5
L		 5471 case EM_IAMCU:
5472 init_dwarf_regnames_iamcu ();
5473 break;
5474
2dc4cec1 5475 case EM_X86_64:
7f502d6c 5476 case EM_L1OM:
7a9068fe 5477 case EM_K1OM:
b129eb0e 5478 init_dwarf_regnames_x86_64 ();
2dc4cec1
L		 5479 break;
5480
4ee22035
RH		 5481 case EM_AARCH64:
5482 init_dwarf_regnames_aarch64 ();
5483 break;
5484
2dc4cec1
L		 5485 default:
5486 break;
5487 }
5488}
5489
5490static const char *
5491regname (unsigned int regno, int row)
5492{
5493 static char reg[64];
5494 if (dwarf_regnames
5495 && regno < dwarf_regnames_count
5496 && dwarf_regnames [regno] != NULL)
5497 {
5498 if (row)
5499 return dwarf_regnames [regno];
5500 snprintf (reg, sizeof (reg), "r%d (%s)", regno,
5501 dwarf_regnames [regno]);
5502 }
5503 else
5504 snprintf (reg, sizeof (reg), "r%d", regno);
5505 return reg;
5506}
5507
19e6b90e 5508static void
a1165289 5509frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_regs)
19e6b90e 5510{
a1165289 5511 unsigned int r;
19e6b90e
L		 5512 char tmp[100];
5513
5514 if (*max_regs < fc->ncols)
5515 *max_regs = fc->ncols;
5516
5517 if (*need_col_headers)
5518 {
91d6fa6a 5519 static const char *sloc = " LOC";
2dc4cec1 5520
19e6b90e
L		 5521 *need_col_headers = 0;
5522
91d6fa6a 5523 printf ("%-*s CFA ", eh_addr_size * 2, sloc);
19e6b90e
L		 5524
5525 for (r = 0; r < *max_regs; r++)
5526 if (fc->col_type[r] != DW_CFA_unreferenced)
5527 {
5528 if (r == fc->ra)
2dc4cec1 5529 printf ("ra ");
19e6b90e 5530 else
2dc4cec1 5531 printf ("%-5s ", regname (r, 1));
19e6b90e
L		 5532 }
5533
5534 printf ("\n");
5535 }
5536
bf5117e3 5537 print_dwarf_vma (fc->pc_begin, eh_addr_size);
19e6b90e
L		 5538 if (fc->cfa_exp)
5539 strcpy (tmp, "exp");
5540 else
c8071705 5541 sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset);
19e6b90e
L		 5542 printf ("%-8s ", tmp);
5543
5544 for (r = 0; r < fc->ncols; r++)
5545 {
5546 if (fc->col_type[r] != DW_CFA_unreferenced)
5547 {
5548 switch (fc->col_type[r])
5549 {
5550 case DW_CFA_undefined:
5551 strcpy (tmp, "u");
5552 break;
5553 case DW_CFA_same_value:
5554 strcpy (tmp, "s");
5555 break;
5556 case DW_CFA_offset:
5557 sprintf (tmp, "c%+d", fc->col_offset[r]);
5558 break;
12eae2d3
JJ		 5559 case DW_CFA_val_offset:
5560 sprintf (tmp, "v%+d", fc->col_offset[r]);
5561 break;
19e6b90e 5562 case DW_CFA_register:
2dc4cec1 5563 sprintf (tmp, "%s", regname (fc->col_offset[r], 0));
19e6b90e
L		 5564 break;
5565 case DW_CFA_expression:
5566 strcpy (tmp, "exp");
5567 break;
12eae2d3
JJ		 5568 case DW_CFA_val_expression:
5569 strcpy (tmp, "vexp");
5570 break;
19e6b90e
L		 5571 default:
5572 strcpy (tmp, "n/a");
5573 break;
5574 }
2dc4cec1 5575 printf ("%-5s ", tmp);
19e6b90e
L		 5576 }
5577 }
5578 printf ("\n");
5579}
5580
49727e46 5581#define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
f6f0e17b
NC		 5582#define LEB() read_uleb128 (start, & length_return, end); start += length_return
5583#define SLEB() read_sleb128 (start, & length_return, end); start += length_return
19e6b90e 5584
49727e46
AM		 5585static unsigned char *
5586read_cie (unsigned char *start, unsigned char *end,
5587 Frame_Chunk **p_cie, int *p_version,
5588 unsigned long *p_aug_len, unsigned char **p_aug)
5589{
5590 int version;
5591 Frame_Chunk *fc;
5592 unsigned int length_return;
5593 unsigned char *augmentation_data = NULL;
5594 unsigned long augmentation_data_len = 0;
5595
041830e0 5596 * p_cie = NULL;
f41e4712
NC		 5597 /* PR 17512: file: 001-228113-0.004. */
5598 if (start >= end)
5599 return end;
5600
49727e46
AM		 5601 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
5602 memset (fc, 0, sizeof (Frame_Chunk));
5603
5604 fc->col_type = (short int *) xmalloc (sizeof (short int));
5605 fc->col_offset = (int *) xmalloc (sizeof (int));
5606
5607 version = *start++;
5608
5609 fc->augmentation = (char *) start;
f41e4712
NC		 5610 /* PR 17512: file: 001-228113-0.004.
5611 Skip past augmentation name, but avoid running off the end of the data. */
5612 while (start < end)
5613 if (* start ++ == '\0')
5614 break;
5615 if (start == end)
5616 {
5617 warn (_("No terminator for augmentation name\n"));
5618 return start;
5619 }
49727e46
AM		 5620
5621 if (strcmp (fc->augmentation, "eh") == 0)
5622 start += eh_addr_size;
5623
5624 if (version >= 4)
5625 {
5626 GET (fc->ptr_size, 1);
77ef8654
NC		 5627 if (fc->ptr_size < 1 || fc->ptr_size > 8)
5628 {
5629 warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size);
5630 return end;
5631 }
5632
49727e46 5633 GET (fc->segment_size, 1);
77ef8654
NC		 5634 /* PR 17512: file: e99d2804. */
5635 if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8)
5636 {
5637 warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size);
5638 return end;
5639 }
5640
49727e46
AM		 5641 eh_addr_size = fc->ptr_size;
5642 }
5643 else
5644 {
5645 fc->ptr_size = eh_addr_size;
5646 fc->segment_size = 0;
5647 }
5648 fc->code_factor = LEB ();
5649 fc->data_factor = SLEB ();
5650 if (version == 1)
5651 {
5652 GET (fc->ra, 1);
5653 }
5654 else
5655 {
5656 fc->ra = LEB ();
5657 }
5658
5659 if (fc->augmentation[0] == 'z')
5660 {
5661 augmentation_data_len = LEB ();
5662 augmentation_data = start;
5663 start += augmentation_data_len;
a1165289
NC		 5664 /* PR 17512: file: 11042-2589-0.004. */
5665 if (start > end)
5666 {
1306a742 5667 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len);
a1165289
NC		 5668 return end;
5669 }
49727e46
AM		 5670 }
5671
5672 if (augmentation_data_len)
5673 {
058037d3
NC		 5674 unsigned char *p;
5675 unsigned char *q;
5676 unsigned char *qend;
b4eb7656 5677
49727e46
AM		 5678 p = (unsigned char *) fc->augmentation + 1;
5679 q = augmentation_data;
058037d3
NC		 5680 qend = q + augmentation_data_len;
5681
5682 /* PR 17531: file: 015adfaa. */
5683 if (qend < q)
5684 {
5685 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len);
5686 augmentation_data_len = 0;
5687 }
49727e46 5688
a1165289 5689 while (p < end && q < augmentation_data + augmentation_data_len)
49727e46
AM		 5690 {
5691 if (*p == 'L')
5692 q++;
5693 else if (*p == 'P')
5694 q += 1 + size_of_encoded_value (*q);
5695 else if (*p == 'R')
5696 fc->fde_encoding = *q++;
5697 else if (*p == 'S')
5698 ;
5699 else
5700 break;
5701 p++;
5702 }
c361b9ac
NC		 5703 /* Note - it is OK if this loop terminates with q < qend.
5704 Padding may have been inserted to align the end of the CIE. */
49727e46
AM		 5705 }
5706
5707 *p_cie = fc;
5708 if (p_version)
5709 *p_version = version;
5710 if (p_aug_len)
5711 {
5712 *p_aug_len = augmentation_data_len;
5713 *p_aug = augmentation_data;
5714 }
5715 return start;
5716}
5717
19e6b90e
L		 5718static int
5719display_debug_frames (struct dwarf_section *section,
5720 void *file ATTRIBUTE_UNUSED)
5721{
5722 unsigned char *start = section->start;
5723 unsigned char *end = start + section->size;
5724 unsigned char *section_start = start;
49727e46 5725 Frame_Chunk *chunks = 0, *forward_refs = 0;
19e6b90e
L		 5726 Frame_Chunk *remembered_state = 0;
5727 Frame_Chunk *rs;
5728 int is_eh = strcmp (section->name, ".eh_frame") == 0;
5729 unsigned int length_return;
a1165289 5730 unsigned int max_regs = 0;
665ce1f6 5731 const char *bad_reg = _("bad register: ");
77ef8654 5732 unsigned int saved_eh_addr_size = eh_addr_size;
19e6b90e 5733
80c35038 5734 printf (_("Contents of the %s section:\n"), section->name);
19e6b90e
L		 5735
5736 while (start < end)
5737 {
5738 unsigned char *saved_start;
5739 unsigned char *block_end;
bf5117e3
NC		 5740 dwarf_vma length;
5741 dwarf_vma cie_id;
19e6b90e
L		 5742 Frame_Chunk *fc;
5743 Frame_Chunk *cie;
5744 int need_col_headers = 1;
5745 unsigned char *augmentation_data = NULL;
5746 unsigned long augmentation_data_len = 0;
bf5117e3
NC		 5747 unsigned int encoded_ptr_size = saved_eh_addr_size;
5748 unsigned int offset_size;
5749 unsigned int initial_length_size;
19e6b90e
L		 5750
5751 saved_start = start;
19e6b90e 5752
0c588247 5753 SAFE_BYTE_GET_AND_INC (length, start, 4, end);
041830e0 5754
19e6b90e
L		 5755 if (length == 0)
5756 {
5757 printf ("\n%08lx ZERO terminator\n\n",
5758 (unsigned long)(saved_start - section_start));
6937bb54
NC		 5759 /* Skip any zero terminators that directly follow.
5760 A corrupt section size could have loaded a whole
5761 slew of zero filled memory bytes. eg
5762 PR 17512: file: 070-19381-0.004. */
5763 while (start < end && * start == 0)
5764 ++ start;
b758e50f 5765 continue;
19e6b90e
L		 5766 }
5767
5768 if (length == 0xffffffff)
5769 {
0c588247 5770 SAFE_BYTE_GET_AND_INC (length, start, 8, end);
19e6b90e
L		 5771 offset_size = 8;
5772 initial_length_size = 12;
5773 }
5774 else
5775 {
5776 offset_size = 4;
5777 initial_length_size = 4;
5778 }
5779
5780 block_end = saved_start + length + initial_length_size;
041830e0 5781 if (block_end > end || block_end < start)
53b8873b 5782 {
bf5117e3
NC		 5783 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5784 dwarf_vmatoa_1 (NULL, length, offset_size),
5785 (unsigned long) (saved_start - section_start));
53b8873b
NC		 5786 block_end = end;
5787 }
0c588247
NC		 5788
5789 SAFE_BYTE_GET_AND_INC (cie_id, start, offset_size, end);
19e6b90e 5790
846a11e4
NC		 5791 if (is_eh ? (cie_id == 0) : ((offset_size == 4 && cie_id == DW_CIE_ID)
5792 || (offset_size == 8 && cie_id == DW64_CIE_ID)))
19e6b90e
L		 5793 {
5794 int version;
a1165289 5795 unsigned int mreg;
19e6b90e 5796
49727e46
AM		 5797 start = read_cie (start, end, &cie, &version,
5798 &augmentation_data_len, &augmentation_data);
041830e0
NC		 5799 /* PR 17512: file: 027-135133-0.005. */
5800 if (cie == NULL)
5801 break;
a1165289 5802
49727e46 5803 fc = cie;
19e6b90e
L		 5804 fc->next = chunks;
5805 chunks = fc;
5806 fc->chunk_start = saved_start;
a1165289 5807 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 5808 if (mreg < fc->ra)
5809 mreg = fc->ra;
06614111
NC		 5810 if (frame_need_space (fc, mreg) < 0)
5811 break;
49727e46
AM		 5812 if (fc->fde_encoding)
5813 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
19e6b90e 5814
bf5117e3
NC		 5815 printf ("\n%08lx ", (unsigned long) (saved_start - section_start));
5816 print_dwarf_vma (length, fc->ptr_size);
9c41109d 5817 print_dwarf_vma (cie_id, offset_size);
bf5117e3 5818
19e6b90e 5819 if (do_debug_frames_interp)
bf5117e3
NC		 5820 {
5821 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc->augmentation,
5822 fc->code_factor, fc->data_factor, fc->ra);
5823 }
19e6b90e
L		 5824 else
5825 {
bf5117e3 5826 printf ("CIE\n");
19e6b90e
L		 5827 printf (" Version: %d\n", version);
5828 printf (" Augmentation: \"%s\"\n", fc->augmentation);
604282a7
JJ		 5829 if (version >= 4)
5830 {
5831 printf (" Pointer Size: %u\n", fc->ptr_size);
5832 printf (" Segment Size: %u\n", fc->segment_size);
5833 }
19e6b90e
L		 5834 printf (" Code alignment factor: %u\n", fc->code_factor);
5835 printf (" Data alignment factor: %d\n", fc->data_factor);
5836 printf (" Return address column: %d\n", fc->ra);
5837
5838 if (augmentation_data_len)
5839 {
5840 unsigned long i;
a1165289 5841
19e6b90e
L		 5842 printf (" Augmentation data: ");
5843 for (i = 0; i < augmentation_data_len; ++i)
a1165289
NC		 5844 /* FIXME: If do_wide is FALSE, then we should
5845 add carriage returns at 80 columns... */
19e6b90e
L		 5846 printf (" %02x", augmentation_data[i]);
5847 putchar ('\n');
5848 }
5849 putchar ('\n');
5850 }
19e6b90e
L		 5851 }
5852 else
5853 {
5854 unsigned char *look_for;
5855 static Frame_Chunk fde_fc;
604282a7 5856 unsigned long segment_selector;
19e6b90e 5857
49727e46
AM		 5858 if (is_eh)
5859 {
5860 dwarf_vma sign = (dwarf_vma) 1 << (offset_size * 8 - 1);
5861 look_for = start - 4 - ((cie_id ^ sign) - sign);
5862 }
5863 else
5864 look_for = section_start + cie_id;
19e6b90e 5865
49727e46
AM		 5866 if (look_for <= saved_start)
5867 {
5868 for (cie = chunks; cie ; cie = cie->next)
5869 if (cie->chunk_start == look_for)
5870 break;
5871 }
5872 else
5873 {
5874 for (cie = forward_refs; cie ; cie = cie->next)
5875 if (cie->chunk_start == look_for)
5876 break;
5877 if (!cie)
5878 {
5879 unsigned int off_size;
5880 unsigned char *cie_scan;
19e6b90e 5881
49727e46
AM		 5882 cie_scan = look_for;
5883 off_size = 4;
5884 SAFE_BYTE_GET_AND_INC (length, cie_scan, 4, end);
5885 if (length == 0xffffffff)
5886 {
5887 SAFE_BYTE_GET_AND_INC (length, cie_scan, 8, end);
5888 off_size = 8;
5889 }
5890 if (length != 0)
5891 {
5892 dwarf_vma c_id;
5893
5894 SAFE_BYTE_GET_AND_INC (c_id, cie_scan, off_size, end);
5895 if (is_eh
5896 ? c_id == 0
5897 : ((off_size == 4 && c_id == DW_CIE_ID)
5898 || (off_size == 8 && c_id == DW64_CIE_ID)))
5899 {
5900 int version;
a1165289 5901 unsigned int mreg;
49727e46
AM		 5902
5903 read_cie (cie_scan, end, &cie, &version,
5904 &augmentation_data_len, &augmentation_data);
a1165289
NC		 5905 /* PR 17512: file: 3450-2098-0.004. */
5906 if (cie == NULL)
5907 {
5908 warn (_("Failed to read CIE information\n"));
5909 break;
5910 }
49727e46
AM		 5911 cie->next = forward_refs;
5912 forward_refs = cie;
5913 cie->chunk_start = look_for;
a1165289 5914 mreg = max_regs > 0 ? max_regs - 1 : 0;
49727e46
AM		 5915 if (mreg < cie->ra)
5916 mreg = cie->ra;
06614111
NC		 5917 if (frame_need_space (cie, mreg) < 0)
5918 {
5919 warn (_("Invalid max register\n"));
5920 break;
5921 }
49727e46
AM		 5922 if (cie->fde_encoding)
5923 encoded_ptr_size
5924 = size_of_encoded_value (cie->fde_encoding);
5925 }
5926 }
5927 }
5928 }
5929
5930 fc = &fde_fc;
5931 memset (fc, 0, sizeof (Frame_Chunk));
19e6b90e
L		 5932
5933 if (!cie)
5934 {
bf5117e3
NC		 5935 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5936 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
5937 (unsigned long) (saved_start - section_start));
19e6b90e 5938 fc->ncols = 0;
3f5e193b
NC		 5939 fc->col_type = (short int *) xmalloc (sizeof (short int));
5940 fc->col_offset = (int *) xmalloc (sizeof (int));
06614111
NC		 5941 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1 : 0) < 0)
5942 {
5943 warn (_("Invalid max register\n"));
5944 break;
5945 }
19e6b90e
L		 5946 cie = fc;
5947 fc->augmentation = "";
5948 fc->fde_encoding = 0;
604282a7
JJ		 5949 fc->ptr_size = eh_addr_size;
5950 fc->segment_size = 0;
19e6b90e
L		 5951 }
5952 else
5953 {
5954 fc->ncols = cie->ncols;
3f5e193b
NC		 5955 fc->col_type = (short int *) xcmalloc (fc->ncols, sizeof (short int));
5956 fc->col_offset = (int *) xcmalloc (fc->ncols, sizeof (int));
19e6b90e
L		 5957 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
5958 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
5959 fc->augmentation = cie->augmentation;
604282a7
JJ		 5960 fc->ptr_size = cie->ptr_size;
5961 eh_addr_size = cie->ptr_size;
5962 fc->segment_size = cie->segment_size;
19e6b90e
L		 5963 fc->code_factor = cie->code_factor;
5964 fc->data_factor = cie->data_factor;
5965 fc->cfa_reg = cie->cfa_reg;
5966 fc->cfa_offset = cie->cfa_offset;
5967 fc->ra = cie->ra;
06614111
NC		 5968 if (frame_need_space (fc, max_regs > 0 ? max_regs - 1: 0) < 0)
5969 {
5970 warn (_("Invalid max register\n"));
5971 break;
5972 }
19e6b90e
L		 5973 fc->fde_encoding = cie->fde_encoding;
5974 }
5975
5976 if (fc->fde_encoding)
5977 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
5978
604282a7
JJ		 5979 segment_selector = 0;
5980 if (fc->segment_size)
c8071705
NC		 5981 {
5982 if (fc->segment_size > sizeof (segment_selector))
5983 {
5984 /* PR 17512: file: 9e196b3e. */
5985 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size);
5986 fc->segment_size = 4;
5987 }
5988 SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end);
5989 }
041830e0
NC		 5990
5991 fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end);
19e6b90e 5992
0c588247
NC		 5993 /* FIXME: It appears that sometimes the final pc_range value is
5994 encoded in less than encoded_ptr_size bytes. See the x86_64
5995 run of the "objcopy on compressed debug sections" test for an
5996 example of this. */
5997 SAFE_BYTE_GET_AND_INC (fc->pc_range, start, encoded_ptr_size, end);
bf5117e3 5998
19e6b90e
L		 5999 if (cie->augmentation[0] == 'z')
6000 {
6001 augmentation_data_len = LEB ();
6002 augmentation_data = start;
6003 start += augmentation_data_len;
0a9d414a 6004 /* PR 17512: file: 722-8446-0.004. */
53774b7e 6005 if (start >= end || ((signed long) augmentation_data_len) < 0)
0a9d414a
NC		 6006 {
6007 warn (_("Corrupt augmentation data length: %lx\n"),
6008 augmentation_data_len);
6009 start = end;
6010 augmentation_data = NULL;
6011 augmentation_data_len = 0;
6012 }
19e6b90e
L		 6013 }
6014
bf5117e3
NC		 6015 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6016 (unsigned long)(saved_start - section_start),
6017 dwarf_vmatoa_1 (NULL, length, fc->ptr_size),
9c41109d 6018 dwarf_vmatoa_1 (NULL, cie_id, offset_size),
604282a7 6019 (unsigned long)(cie->chunk_start - section_start));
bf5117e3 6020
604282a7
JJ		 6021 if (fc->segment_size)
6022 printf ("%04lx:", segment_selector);
bf5117e3
NC		 6023
6024 printf ("%s..%s\n",
6025 dwarf_vmatoa_1 (NULL, fc->pc_begin, fc->ptr_size),
6026 dwarf_vmatoa_1 (NULL, fc->pc_begin + fc->pc_range, fc->ptr_size));
6027
19e6b90e
L		 6028 if (! do_debug_frames_interp && augmentation_data_len)
6029 {
6030 unsigned long i;
6031
6032 printf (" Augmentation data: ");
6033 for (i = 0; i < augmentation_data_len; ++i)
6034 printf (" %02x", augmentation_data[i]);
6035 putchar ('\n');
6036 putchar ('\n');
6037 }
6038 }
6039
6040 /* At this point, fc is the current chunk, cie (if any) is set, and
6041 we're about to interpret instructions for the chunk. */
6042 /* ??? At present we need to do this always, since this sizes the
6043 fc->col_type and fc->col_offset arrays, which we write into always.
6044 We should probably split the interpreted and non-interpreted bits
6045 into two different routines, since there's so much that doesn't
6046 really overlap between them. */
6047 if (1 || do_debug_frames_interp)
6048 {
6049 /* Start by making a pass over the chunk, allocating storage
6050 and taking note of what registers are used. */
6051 unsigned char *tmp = start;
6052
6053 while (start < block_end)
6054 {
041830e0
NC		 6055 unsigned int reg, op, opa;
6056 unsigned long temp;
5929c344 6057 unsigned char * new_start;
19e6b90e
L		 6058
6059 op = *start++;
6060 opa = op & 0x3f;
6061 if (op & 0xc0)
6062 op &= 0xc0;
6063
6064 /* Warning: if you add any more cases to this switch, be
6065 sure to add them to the corresponding switch below. */
6066 switch (op)
6067 {
6068 case DW_CFA_advance_loc:
6069 break;
6070 case DW_CFA_offset:
6071 LEB ();
665ce1f6
L		 6072 if (frame_need_space (fc, opa) >= 0)
6073 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 6074 break;
6075 case DW_CFA_restore:
665ce1f6
L		 6076 if (frame_need_space (fc, opa) >= 0)
6077 fc->col_type[opa] = DW_CFA_undefined;
19e6b90e
L		 6078 break;
6079 case DW_CFA_set_loc:
6080 start += encoded_ptr_size;
6081 break;
6082 case DW_CFA_advance_loc1:
6083 start += 1;
6084 break;
6085 case DW_CFA_advance_loc2:
6086 start += 2;
6087 break;
6088 case DW_CFA_advance_loc4:
6089 start += 4;
6090 break;
6091 case DW_CFA_offset_extended:
12eae2d3 6092 case DW_CFA_val_offset:
19e6b90e 6093 reg = LEB (); LEB ();
665ce1f6
L		 6094 if (frame_need_space (fc, reg) >= 0)
6095 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6096 break;
6097 case DW_CFA_restore_extended:
6098 reg = LEB ();
665ce1f6
L		 6099 if (frame_need_space (fc, reg) >= 0)
6100 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6101 break;
6102 case DW_CFA_undefined:
6103 reg = LEB ();
665ce1f6
L		 6104 if (frame_need_space (fc, reg) >= 0)
6105 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6106 break;
6107 case DW_CFA_same_value:
6108 reg = LEB ();
665ce1f6
L		 6109 if (frame_need_space (fc, reg) >= 0)
6110 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6111 break;
6112 case DW_CFA_register:
6113 reg = LEB (); LEB ();
665ce1f6
L		 6114 if (frame_need_space (fc, reg) >= 0)
6115 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6116 break;
6117 case DW_CFA_def_cfa:
6118 LEB (); LEB ();
6119 break;
6120 case DW_CFA_def_cfa_register:
6121 LEB ();
6122 break;
6123 case DW_CFA_def_cfa_offset:
6124 LEB ();
6125 break;
6126 case DW_CFA_def_cfa_expression:
91d6fa6a 6127 temp = LEB ();
5929c344
NC		 6128 new_start = start + temp;
6129 if (new_start < start)
041830e0
NC		 6130 {
6131 warn (_("Corrupt CFA_def expression value: %lu\n"), temp);
6132 start = block_end;
6133 }
6134 else
5929c344 6135 start = new_start;
19e6b90e
L		 6136 break;
6137 case DW_CFA_expression:
12eae2d3 6138 case DW_CFA_val_expression:
19e6b90e 6139 reg = LEB ();
91d6fa6a 6140 temp = LEB ();
5929c344
NC		 6141 new_start = start + temp;
6142 if (new_start < start)
041830e0 6143 {
b4eb7656 6144 /* PR 17512: file:306-192417-0.005. */
041830e0
NC		 6145 warn (_("Corrupt CFA expression value: %lu\n"), temp);
6146 start = block_end;
6147 }
6148 else
5929c344 6149 start = new_start;
665ce1f6
L		 6150 if (frame_need_space (fc, reg) >= 0)
6151 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6152 break;
6153 case DW_CFA_offset_extended_sf:
12eae2d3 6154 case DW_CFA_val_offset_sf:
19e6b90e 6155 reg = LEB (); SLEB ();
665ce1f6
L		 6156 if (frame_need_space (fc, reg) >= 0)
6157 fc->col_type[reg] = DW_CFA_undefined;
19e6b90e
L		 6158 break;
6159 case DW_CFA_def_cfa_sf:
6160 LEB (); SLEB ();
6161 break;
6162 case DW_CFA_def_cfa_offset_sf:
6163 SLEB ();
6164 break;
6165 case DW_CFA_MIPS_advance_loc8:
6166 start += 8;
6167 break;
6168 case DW_CFA_GNU_args_size:
6169 LEB ();
6170 break;
6171 case DW_CFA_GNU_negative_offset_extended:
6172 reg = LEB (); LEB ();
665ce1f6
L		 6173 if (frame_need_space (fc, reg) >= 0)
6174 fc->col_type[reg] = DW_CFA_undefined;
6175 break;
19e6b90e
L		 6176 default:
6177 break;
6178 }
6179 }
6180 start = tmp;
6181 }
6182
6183 /* Now we know what registers are used, make a second pass over
6184 the chunk, this time actually printing out the info. */
6185
6186 while (start < block_end)
6187 {
362beea4 6188 unsigned char * tmp;
19e6b90e
L		 6189 unsigned op, opa;
6190 unsigned long ul, reg, roffs;
c8071705 6191 dwarf_vma l;
bf5117e3 6192 dwarf_vma ofs;
19e6b90e 6193 dwarf_vma vma;
665ce1f6 6194 const char *reg_prefix = "";
19e6b90e
L		 6195
6196 op = *start++;
6197 opa = op & 0x3f;
6198 if (op & 0xc0)
6199 op &= 0xc0;
6200
6201 /* Warning: if you add any more cases to this switch, be
6202 sure to add them to the corresponding switch above. */
6203 switch (op)
6204 {
6205 case DW_CFA_advance_loc:
6206 if (do_debug_frames_interp)
6207 frame_display_row (fc, &need_col_headers, &max_regs);
6208 else
bf5117e3 6209 printf (" DW_CFA_advance_loc: %d to %s\n",
19e6b90e 6210 opa * fc->code_factor,
b4eb7656 6211 dwarf_vmatoa_1 (NULL,
bf5117e3
NC		 6212 fc->pc_begin + opa * fc->code_factor,
6213 fc->ptr_size));
19e6b90e
L		 6214 fc->pc_begin += opa * fc->code_factor;
6215 break;
6216
6217 case DW_CFA_offset:
6218 roffs = LEB ();
665ce1f6
L		 6219 if (opa >= (unsigned int) fc->ncols)
6220 reg_prefix = bad_reg;
6221 if (! do_debug_frames_interp || *reg_prefix != '\0')
6222 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6223 reg_prefix, regname (opa, 0),
6224 roffs * fc->data_factor);
6225 if (*reg_prefix == '\0')
6226 {
6227 fc->col_type[opa] = DW_CFA_offset;
6228 fc->col_offset[opa] = roffs * fc->data_factor;
6229 }
19e6b90e
L		 6230 break;
6231
6232 case DW_CFA_restore:
665ce1f6
L		 6233 if (opa >= (unsigned int) cie->ncols
6234 || opa >= (unsigned int) fc->ncols)
6235 reg_prefix = bad_reg;
6236 if (! do_debug_frames_interp || *reg_prefix != '\0')
6237 printf (" DW_CFA_restore: %s%s\n",
6238 reg_prefix, regname (opa, 0));
6239 if (*reg_prefix == '\0')
6240 {
6241 fc->col_type[opa] = cie->col_type[opa];
6242 fc->col_offset[opa] = cie->col_offset[opa];
b3f5b73b
ILT		 6243 if (do_debug_frames_interp
6244 && fc->col_type[opa] == DW_CFA_unreferenced)
6245 fc->col_type[opa] = DW_CFA_undefined;
665ce1f6 6246 }
19e6b90e
L		 6247 break;
6248
6249 case DW_CFA_set_loc:
6937bb54 6250 vma = get_encoded_value (&start, fc->fde_encoding, section, block_end);
19e6b90e
L		 6251 if (do_debug_frames_interp)
6252 frame_display_row (fc, &need_col_headers, &max_regs);
6253 else
bf5117e3
NC		 6254 printf (" DW_CFA_set_loc: %s\n",
6255 dwarf_vmatoa_1 (NULL, vma, fc->ptr_size));
19e6b90e
L		 6256 fc->pc_begin = vma;
6257 break;
6258
6259 case DW_CFA_advance_loc1:
0c588247 6260 SAFE_BYTE_GET_AND_INC (ofs, start, 1, end);
19e6b90e
L		 6261 if (do_debug_frames_interp)
6262 frame_display_row (fc, &need_col_headers, &max_regs);
6263 else
bf5117e3
NC		 6264 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6265 (unsigned long) (ofs * fc->code_factor),
6266 dwarf_vmatoa_1 (NULL,
6267 fc->pc_begin + ofs * fc->code_factor,
6268 fc->ptr_size));
19e6b90e
L		 6269 fc->pc_begin += ofs * fc->code_factor;
6270 break;
6271
6272 case DW_CFA_advance_loc2:
6937bb54 6273 SAFE_BYTE_GET_AND_INC (ofs, start, 2, block_end);
19e6b90e
L		 6274 if (do_debug_frames_interp)
6275 frame_display_row (fc, &need_col_headers, &max_regs);
6276 else
bf5117e3
NC		 6277 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6278 (unsigned long) (ofs * fc->code_factor),
6279 dwarf_vmatoa_1 (NULL,
6280 fc->pc_begin + ofs * fc->code_factor,
6281 fc->ptr_size));
19e6b90e
L		 6282 fc->pc_begin += ofs * fc->code_factor;
6283 break;
6284
6285 case DW_CFA_advance_loc4:
6937bb54 6286 SAFE_BYTE_GET_AND_INC (ofs, start, 4, block_end);
19e6b90e
L		 6287 if (do_debug_frames_interp)
6288 frame_display_row (fc, &need_col_headers, &max_regs);
6289 else
bf5117e3
NC		 6290 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6291 (unsigned long) (ofs * fc->code_factor),
6292 dwarf_vmatoa_1 (NULL,
6293 fc->pc_begin + ofs * fc->code_factor,
6294 fc->ptr_size));
19e6b90e
L		 6295 fc->pc_begin += ofs * fc->code_factor;
6296 break;
6297
6298 case DW_CFA_offset_extended:
6299 reg = LEB ();
6300 roffs = LEB ();
665ce1f6
L		 6301 if (reg >= (unsigned int) fc->ncols)
6302 reg_prefix = bad_reg;
6303 if (! do_debug_frames_interp || *reg_prefix != '\0')
6304 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6305 reg_prefix, regname (reg, 0),
6306 roffs * fc->data_factor);
6307 if (*reg_prefix == '\0')
6308 {
6309 fc->col_type[reg] = DW_CFA_offset;
6310 fc->col_offset[reg] = roffs * fc->data_factor;
6311 }
19e6b90e
L		 6312 break;
6313
12eae2d3
JJ		 6314 case DW_CFA_val_offset:
6315 reg = LEB ();
6316 roffs = LEB ();
665ce1f6
L		 6317 if (reg >= (unsigned int) fc->ncols)
6318 reg_prefix = bad_reg;
6319 if (! do_debug_frames_interp || *reg_prefix != '\0')
6320 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6321 reg_prefix, regname (reg, 0),
6322 roffs * fc->data_factor);
6323 if (*reg_prefix == '\0')
6324 {
6325 fc->col_type[reg] = DW_CFA_val_offset;
6326 fc->col_offset[reg] = roffs * fc->data_factor;
6327 }
12eae2d3
JJ		 6328 break;
6329
19e6b90e
L		 6330 case DW_CFA_restore_extended:
6331 reg = LEB ();
665ce1f6
L		 6332 if (reg >= (unsigned int) cie->ncols
6333 || reg >= (unsigned int) fc->ncols)
6334 reg_prefix = bad_reg;
6335 if (! do_debug_frames_interp || *reg_prefix != '\0')
6336 printf (" DW_CFA_restore_extended: %s%s\n",
6337 reg_prefix, regname (reg, 0));
6338 if (*reg_prefix == '\0')
6339 {
6340 fc->col_type[reg] = cie->col_type[reg];
6341 fc->col_offset[reg] = cie->col_offset[reg];
6342 }
19e6b90e
L		 6343 break;
6344
6345 case DW_CFA_undefined:
6346 reg = LEB ();
665ce1f6
L		 6347 if (reg >= (unsigned int) fc->ncols)
6348 reg_prefix = bad_reg;
6349 if (! do_debug_frames_interp || *reg_prefix != '\0')
6350 printf (" DW_CFA_undefined: %s%s\n",
6351 reg_prefix, regname (reg, 0));
6352 if (*reg_prefix == '\0')
6353 {
6354 fc->col_type[reg] = DW_CFA_undefined;
6355 fc->col_offset[reg] = 0;
6356 }
19e6b90e
L		 6357 break;
6358
6359 case DW_CFA_same_value:
6360 reg = LEB ();
665ce1f6
L		 6361 if (reg >= (unsigned int) fc->ncols)
6362 reg_prefix = bad_reg;
6363 if (! do_debug_frames_interp || *reg_prefix != '\0')
6364 printf (" DW_CFA_same_value: %s%s\n",
6365 reg_prefix, regname (reg, 0));
6366 if (*reg_prefix == '\0')
6367 {
6368 fc->col_type[reg] = DW_CFA_same_value;
6369 fc->col_offset[reg] = 0;
6370 }
19e6b90e
L		 6371 break;
6372
6373 case DW_CFA_register:
6374 reg = LEB ();
6375 roffs = LEB ();
665ce1f6
L		 6376 if (reg >= (unsigned int) fc->ncols)
6377 reg_prefix = bad_reg;
6378 if (! do_debug_frames_interp || *reg_prefix != '\0')
2dc4cec1 6379 {
665ce1f6
L		 6380 printf (" DW_CFA_register: %s%s in ",
6381 reg_prefix, regname (reg, 0));
2dc4cec1
L		 6382 puts (regname (roffs, 0));
6383 }
665ce1f6
L		 6384 if (*reg_prefix == '\0')
6385 {
6386 fc->col_type[reg] = DW_CFA_register;
6387 fc->col_offset[reg] = roffs;
6388 }
19e6b90e
L		 6389 break;
6390
6391 case DW_CFA_remember_state:
6392 if (! do_debug_frames_interp)
6393 printf (" DW_CFA_remember_state\n");
3f5e193b 6394 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
b4eb7656 6395 rs->cfa_offset = fc->cfa_offset;
d71ad7fc
RC		 6396 rs->cfa_reg = fc->cfa_reg;
6397 rs->ra = fc->ra;
6398 rs->cfa_exp = fc->cfa_exp;
19e6b90e 6399 rs->ncols = fc->ncols;
3f5e193b 6400 rs->col_type = (short int *) xcmalloc (rs->ncols,
b4eb7656 6401 sizeof (* rs->col_type));
d71ad7fc
RC		 6402 rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset));
6403 memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type));
6404 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset));
19e6b90e
L		 6405 rs->next = remembered_state;
6406 remembered_state = rs;
6407 break;
6408
6409 case DW_CFA_restore_state:
6410 if (! do_debug_frames_interp)
6411 printf (" DW_CFA_restore_state\n");
6412 rs = remembered_state;
6413 if (rs)
6414 {
6415 remembered_state = rs->next;
d71ad7fc
RC		 6416 fc->cfa_offset = rs->cfa_offset;
6417 fc->cfa_reg = rs->cfa_reg;
b4eb7656
AM		 6418 fc->ra = rs->ra;
6419 fc->cfa_exp = rs->cfa_exp;
06614111
NC		 6420 if (frame_need_space (fc, rs->ncols - 1) < 0)
6421 {
1306a742 6422 warn (_("Invalid column number in saved frame state\n"));
06614111
NC		 6423 fc->ncols = 0;
6424 break;
6425 }
d71ad7fc 6426 memcpy (fc->col_type, rs->col_type, rs->ncols * sizeof (* rs->col_type));
19e6b90e 6427 memcpy (fc->col_offset, rs->col_offset,
d71ad7fc 6428 rs->ncols * sizeof (* rs->col_offset));
19e6b90e
L		 6429 free (rs->col_type);
6430 free (rs->col_offset);
6431 free (rs);
6432 }
6433 else if (do_debug_frames_interp)
6434 printf ("Mismatched DW_CFA_restore_state\n");
6435 break;
6436
6437 case DW_CFA_def_cfa:
6438 fc->cfa_reg = LEB ();
6439 fc->cfa_offset = LEB ();
6440 fc->cfa_exp = 0;
6441 if (! do_debug_frames_interp)
2dc4cec1 6442 printf (" DW_CFA_def_cfa: %s ofs %d\n",
c8071705 6443 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
19e6b90e
L		 6444 break;
6445
6446 case DW_CFA_def_cfa_register:
6447 fc->cfa_reg = LEB ();
6448 fc->cfa_exp = 0;
6449 if (! do_debug_frames_interp)
2dc4cec1
L		 6450 printf (" DW_CFA_def_cfa_register: %s\n",
6451 regname (fc->cfa_reg, 0));
19e6b90e
L		 6452 break;
6453
6454 case DW_CFA_def_cfa_offset:
6455 fc->cfa_offset = LEB ();
6456 if (! do_debug_frames_interp)
c8071705 6457 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset);
19e6b90e
L		 6458 break;
6459
6460 case DW_CFA_nop:
6461 if (! do_debug_frames_interp)
6462 printf (" DW_CFA_nop\n");
6463 break;
6464
6465 case DW_CFA_def_cfa_expression:
6466 ul = LEB ();
7460c0ab 6467 if (start >= block_end || ul > (unsigned long) (block_end - start))
6937bb54 6468 {
a1165289 6469 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 6470 break;
6471 }
19e6b90e
L		 6472 if (! do_debug_frames_interp)
6473 {
6474 printf (" DW_CFA_def_cfa_expression (");
b7807392
JJ		 6475 decode_location_expression (start, eh_addr_size, 0, -1,
6476 ul, 0, section);
19e6b90e
L		 6477 printf (")\n");
6478 }
6479 fc->cfa_exp = 1;
6480 start += ul;
6481 break;
6482
6483 case DW_CFA_expression:
6484 reg = LEB ();
6485 ul = LEB ();
665ce1f6
L		 6486 if (reg >= (unsigned int) fc->ncols)
6487 reg_prefix = bad_reg;
6937bb54 6488 /* PR 17512: file: 069-133014-0.006. */
06614111 6489 /* PR 17512: file: 98c02eb4. */
362beea4
NC		 6490 tmp = start + ul;
6491 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 6492 {
a1165289 6493 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul);
6937bb54
NC		 6494 break;
6495 }
665ce1f6 6496 if (! do_debug_frames_interp || *reg_prefix != '\0')
19e6b90e 6497 {
665ce1f6
L		 6498 printf (" DW_CFA_expression: %s%s (",
6499 reg_prefix, regname (reg, 0));
b7807392 6500 decode_location_expression (start, eh_addr_size, 0, -1,
f1c4cc75 6501 ul, 0, section);
19e6b90e
L		 6502 printf (")\n");
6503 }
665ce1f6
L		 6504 if (*reg_prefix == '\0')
6505 fc->col_type[reg] = DW_CFA_expression;
362beea4 6506 start = tmp;
19e6b90e
L		 6507 break;
6508
12eae2d3
JJ		 6509 case DW_CFA_val_expression:
6510 reg = LEB ();
6511 ul = LEB ();
665ce1f6
L		 6512 if (reg >= (unsigned int) fc->ncols)
6513 reg_prefix = bad_reg;
362beea4
NC		 6514 tmp = start + ul;
6515 if (start >= block_end || tmp > block_end || tmp < start)
6937bb54 6516 {
a1165289 6517 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul);
6937bb54
NC		 6518 break;
6519 }
665ce1f6 6520 if (! do_debug_frames_interp || *reg_prefix != '\0')
12eae2d3 6521 {
665ce1f6
L		 6522 printf (" DW_CFA_val_expression: %s%s (",
6523 reg_prefix, regname (reg, 0));
b7807392
JJ		 6524 decode_location_expression (start, eh_addr_size, 0, -1,
6525 ul, 0, section);
12eae2d3
JJ		 6526 printf (")\n");
6527 }
665ce1f6
L		 6528 if (*reg_prefix == '\0')
6529 fc->col_type[reg] = DW_CFA_val_expression;
362beea4 6530 start = tmp;
12eae2d3
JJ		 6531 break;
6532
19e6b90e
L		 6533 case DW_CFA_offset_extended_sf:
6534 reg = LEB ();
6535 l = SLEB ();
665ce1f6
L		 6536 if (frame_need_space (fc, reg) < 0)
6537 reg_prefix = bad_reg;
6538 if (! do_debug_frames_interp || *reg_prefix != '\0')
6539 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6540 reg_prefix, regname (reg, 0),
c8071705 6541 (long)(l * fc->data_factor));
665ce1f6
L		 6542 if (*reg_prefix == '\0')
6543 {
6544 fc->col_type[reg] = DW_CFA_offset;
6545 fc->col_offset[reg] = l * fc->data_factor;
6546 }
19e6b90e
L		 6547 break;
6548
12eae2d3
JJ		 6549 case DW_CFA_val_offset_sf:
6550 reg = LEB ();
6551 l = SLEB ();
665ce1f6
L		 6552 if (frame_need_space (fc, reg) < 0)
6553 reg_prefix = bad_reg;
6554 if (! do_debug_frames_interp || *reg_prefix != '\0')
6555 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6556 reg_prefix, regname (reg, 0),
c8071705 6557 (long)(l * fc->data_factor));
665ce1f6
L		 6558 if (*reg_prefix == '\0')
6559 {
6560 fc->col_type[reg] = DW_CFA_val_offset;
6561 fc->col_offset[reg] = l * fc->data_factor;
6562 }
12eae2d3
JJ		 6563 break;
6564
19e6b90e
L		 6565 case DW_CFA_def_cfa_sf:
6566 fc->cfa_reg = LEB ();
6567 fc->cfa_offset = SLEB ();
6568 fc->cfa_offset = fc->cfa_offset * fc->data_factor;
6569 fc->cfa_exp = 0;
6570 if (! do_debug_frames_interp)
2dc4cec1 6571 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
c8071705 6572 regname (fc->cfa_reg, 0), (int) fc->cfa_offset);
19e6b90e
L		 6573 break;
6574
6575 case DW_CFA_def_cfa_offset_sf:
6576 fc->cfa_offset = SLEB ();
c8071705 6577 fc->cfa_offset *= fc->data_factor;
19e6b90e 6578 if (! do_debug_frames_interp)
c8071705 6579 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset);
19e6b90e
L		 6580 break;
6581
6582 case DW_CFA_MIPS_advance_loc8:
6937bb54 6583 SAFE_BYTE_GET_AND_INC (ofs, start, 8, block_end);
19e6b90e
L		 6584 if (do_debug_frames_interp)
6585 frame_display_row (fc, &need_col_headers, &max_regs);
6586 else
bf5117e3
NC		 6587 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6588 (unsigned long) (ofs * fc->code_factor),
6589 dwarf_vmatoa_1 (NULL,
6590 fc->pc_begin + ofs * fc->code_factor,
6591 fc->ptr_size));
19e6b90e
L		 6592 fc->pc_begin += ofs * fc->code_factor;
6593 break;
6594
6595 case DW_CFA_GNU_window_save:
6596 if (! do_debug_frames_interp)
6597 printf (" DW_CFA_GNU_window_save\n");
6598 break;
6599
6600 case DW_CFA_GNU_args_size:
6601 ul = LEB ();
6602 if (! do_debug_frames_interp)
6603 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
6604 break;
6605
6606 case DW_CFA_GNU_negative_offset_extended:
6607 reg = LEB ();
6608 l = - LEB ();
665ce1f6
L		 6609 if (frame_need_space (fc, reg) < 0)
6610 reg_prefix = bad_reg;
6611 if (! do_debug_frames_interp || *reg_prefix != '\0')
6612 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6613 reg_prefix, regname (reg, 0),
c8071705 6614 (long)(l * fc->data_factor));
665ce1f6
L		 6615 if (*reg_prefix == '\0')
6616 {
6617 fc->col_type[reg] = DW_CFA_offset;
6618 fc->col_offset[reg] = l * fc->data_factor;
6619 }
19e6b90e
L		 6620 break;
6621
6622 default:
53b8873b
NC		 6623 if (op >= DW_CFA_lo_user && op <= DW_CFA_hi_user)
6624 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op);
6625 else
f41e4712 6626 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op);
19e6b90e
L		 6627 start = block_end;
6628 }
6629 }
6630
6631 if (do_debug_frames_interp)
6632 frame_display_row (fc, &need_col_headers, &max_regs);
6633
6634 start = block_end;
604282a7 6635 eh_addr_size = saved_eh_addr_size;
19e6b90e
L		 6636 }
6637
6638 printf ("\n");
6639
6640 return 1;
6641}
6642
6643#undef GET
6644#undef LEB
6645#undef SLEB
6646
5bbdf3d5
DE		 6647static int
6648display_gdb_index (struct dwarf_section *section,
6649 void *file ATTRIBUTE_UNUSED)
6650{
6651 unsigned char *start = section->start;
6652 uint32_t version;
6653 uint32_t cu_list_offset, tu_list_offset;
6654 uint32_t address_table_offset, symbol_table_offset, constant_pool_offset;
6655 unsigned int cu_list_elements, tu_list_elements;
6656 unsigned int address_table_size, symbol_table_slots;
6657 unsigned char *cu_list, *tu_list;
6658 unsigned char *address_table, *symbol_table, *constant_pool;
6659 unsigned int i;
6660
6661 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6662
6663 printf (_("Contents of the %s section:\n"), section->name);
6664
6665 if (section->size < 6 * sizeof (uint32_t))
6666 {
6667 warn (_("Truncated header in the %s section.\n"), section->name);
6668 return 0;
6669 }
6670
6671 version = byte_get_little_endian (start, 4);
da88a764 6672 printf (_("Version %ld\n"), (long) version);
5bbdf3d5
DE		 6673
6674 /* Prior versions are obsolete, and future versions may not be
6675 backwards compatible. */
aa170720 6676 if (version < 3 || version > 8)
5bbdf3d5 6677 {
da88a764 6678 warn (_("Unsupported version %lu.\n"), (unsigned long) version);
5bbdf3d5
DE		 6679 return 0;
6680 }
8d6eee87
TT		 6681 if (version < 4)
6682 warn (_("The address table data in version 3 may be wrong.\n"));
6683 if (version < 5)
6684 warn (_("Version 4 does not support case insensitive lookups.\n"));
6685 if (version < 6)
6686 warn (_("Version 5 does not include inlined functions.\n"));
6687 if (version < 7)
6688 warn (_("Version 6 does not include symbol attributes.\n"));
aa170720
DE		 6689 /* Version 7 indices generated by Gold have bad type unit references,
6690 PR binutils/15021. But we don't know if the index was generated by
6691 Gold or not, so to avoid worrying users with gdb-generated indices
6692 we say nothing for version 7 here. */
5bbdf3d5
DE		 6693
6694 cu_list_offset = byte_get_little_endian (start + 4, 4);
6695 tu_list_offset = byte_get_little_endian (start + 8, 4);
6696 address_table_offset = byte_get_little_endian (start + 12, 4);
6697 symbol_table_offset = byte_get_little_endian (start + 16, 4);
6698 constant_pool_offset = byte_get_little_endian (start + 20, 4);
6699
6700 if (cu_list_offset > section->size
6701 || tu_list_offset > section->size
6702 || address_table_offset > section->size
6703 || symbol_table_offset > section->size
6704 || constant_pool_offset > section->size)
6705 {
6706 warn (_("Corrupt header in the %s section.\n"), section->name);
6707 return 0;
6708 }
6709
53774b7e
NC		 6710 /* PR 17531: file: 418d0a8a. */
6711 if (tu_list_offset < cu_list_offset)
6712 {
6713 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6714 tu_list_offset, cu_list_offset);
6715 return 0;
6716 }
6717
5bbdf3d5 6718 cu_list_elements = (tu_list_offset - cu_list_offset) / 8;
53774b7e
NC		 6719
6720 if (address_table_offset < tu_list_offset)
6721 {
6722 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6723 address_table_offset, tu_list_offset);
6724 return 0;
6725 }
6726
5bbdf3d5 6727 tu_list_elements = (address_table_offset - tu_list_offset) / 8;
53774b7e
NC		 6728
6729 /* PR 17531: file: 18a47d3d. */
6730 if (symbol_table_offset < address_table_offset)
6731 {
acff9664 6732 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
53774b7e
NC		 6733 symbol_table_offset, address_table_offset);
6734 return 0;
6735 }
6736
5bbdf3d5 6737 address_table_size = symbol_table_offset - address_table_offset;
53774b7e
NC		 6738
6739 if (constant_pool_offset < symbol_table_offset)
6740 {
6741 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6742 constant_pool_offset, symbol_table_offset);
6743 return 0;
6744 }
6745
5bbdf3d5
DE		 6746 symbol_table_slots = (constant_pool_offset - symbol_table_offset) / 8;
6747
6748 cu_list = start + cu_list_offset;
6749 tu_list = start + tu_list_offset;
6750 address_table = start + address_table_offset;
6751 symbol_table = start + symbol_table_offset;
6752 constant_pool = start + constant_pool_offset;
6753
acff9664
NC		 6754 if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size)
6755 {
1306a742 6756 warn (_("Address table extends beyond end of section.\n"));
acff9664
NC		 6757 return 0;
6758 }
b4eb7656 6759
5bbdf3d5
DE		 6760 printf (_("\nCU table:\n"));
6761 for (i = 0; i < cu_list_elements; i += 2)
6762 {
6763 uint64_t cu_offset = byte_get_little_endian (cu_list + i * 8, 8);
6764 uint64_t cu_length = byte_get_little_endian (cu_list + i * 8 + 8, 8);
6765
6766 printf (_("[%3u] 0x%lx - 0x%lx\n"), i / 2,
6767 (unsigned long) cu_offset,
6768 (unsigned long) (cu_offset + cu_length - 1));
6769 }
6770
6771 printf (_("\nTU table:\n"));
6772 for (i = 0; i < tu_list_elements; i += 3)
6773 {
6774 uint64_t tu_offset = byte_get_little_endian (tu_list + i * 8, 8);
6775 uint64_t type_offset = byte_get_little_endian (tu_list + i * 8 + 8, 8);
6776 uint64_t signature = byte_get_little_endian (tu_list + i * 8 + 16, 8);
6777
6778 printf (_("[%3u] 0x%lx 0x%lx "), i / 3,
6779 (unsigned long) tu_offset,
6780 (unsigned long) type_offset);
6781 print_dwarf_vma (signature, 8);
6782 printf ("\n");
6783 }
6784
6785 printf (_("\nAddress table:\n"));
acff9664
NC		 6786 for (i = 0; i < address_table_size && i <= address_table_size - (2 * 8 + 4);
6787 i += 2 * 8 + 4)
5bbdf3d5
DE		 6788 {
6789 uint64_t low = byte_get_little_endian (address_table + i, 8);
6790 uint64_t high = byte_get_little_endian (address_table + i + 8, 8);
6791 uint32_t cu_index = byte_get_little_endian (address_table + i + 16, 4);
6792
6793 print_dwarf_vma (low, 8);
6794 print_dwarf_vma (high, 8);
da88a764 6795 printf (_("%lu\n"), (unsigned long) cu_index);
5bbdf3d5
DE		 6796 }
6797
6798 printf (_("\nSymbol table:\n"));
6799 for (i = 0; i < symbol_table_slots; ++i)
6800 {
6801 uint32_t name_offset = byte_get_little_endian (symbol_table + i * 8, 4);
6802 uint32_t cu_vector_offset = byte_get_little_endian (symbol_table + i * 8 + 4, 4);
6803 uint32_t num_cus, cu;
6804
6805 if (name_offset != 0
6806 || cu_vector_offset != 0)
6807 {
6808 unsigned int j;
362beea4 6809 unsigned char * adr;
5bbdf3d5 6810
362beea4 6811 adr = constant_pool + name_offset;
53774b7e 6812 /* PR 17531: file: 5b7b07ad. */
362beea4 6813 if (adr < constant_pool || adr >= section->start + section->size)
53774b7e
NC		 6814 {
6815 printf (_("[%3u] <corrupt offset: %x>"), i, name_offset);
6816 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6817 name_offset, i);
6818 }
6819 else
acff9664
NC		 6820 printf ("[%3u] %.*s:", i,
6821 (int) (section->size - (constant_pool_offset + name_offset)),
6822 constant_pool + name_offset);
53774b7e 6823
362beea4
NC		 6824 adr = constant_pool + cu_vector_offset;
6825 if (adr < constant_pool || adr >= section->start + section->size - 3)
53774b7e
NC		 6826 {
6827 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset);
6828 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6829 cu_vector_offset, i);
6830 continue;
6831 }
57028622 6832
362beea4 6833 num_cus = byte_get_little_endian (adr, 4);
53774b7e 6834
362beea4 6835 adr = constant_pool + cu_vector_offset + 4 + num_cus * 4;
acff9664 6836 if (num_cus * 4 < num_cus
362beea4
NC		 6837 || adr >= section->start + section->size
6838 || adr < constant_pool)
53774b7e
NC		 6839 {
6840 printf ("<invalid number of CUs: %d>\n", num_cus);
acff9664 6841 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
53774b7e
NC		 6842 num_cus, i);
6843 continue;
6844 }
6845
8d6eee87
TT		 6846 if (num_cus > 1)
6847 printf ("\n");
f3853b34 6848
5bbdf3d5
DE		 6849 for (j = 0; j < num_cus; ++j)
6850 {
7c1cef97 6851 int is_static;
8d6eee87
TT		 6852 gdb_index_symbol_kind kind;
6853
5bbdf3d5 6854 cu = byte_get_little_endian (constant_pool + cu_vector_offset + 4 + j * 4, 4);
7c1cef97 6855 is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu);
8d6eee87
TT		 6856 kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu);
6857 cu = GDB_INDEX_CU_VALUE (cu);
5bbdf3d5 6858 /* Convert to TU number if it's for a type unit. */
ad6b52dd 6859 if (cu >= cu_list_elements / 2)
8d6eee87
TT		 6860 printf ("%cT%lu", num_cus > 1 ? '\t' : ' ',
6861 (unsigned long) (cu - cu_list_elements / 2));
5bbdf3d5 6862 else
8d6eee87
TT		 6863 printf ("%c%lu", num_cus > 1 ? '\t' : ' ', (unsigned long) cu);
6864
459d52c8
DE		 6865 printf (" [%s, %s]",
6866 is_static ? _("static") : _("global"),
6867 get_gdb_index_symbol_kind_name (kind));
8d6eee87
TT		 6868 if (num_cus > 1)
6869 printf ("\n");
5bbdf3d5 6870 }
8d6eee87
TT		 6871 if (num_cus <= 1)
6872 printf ("\n");
5bbdf3d5
DE		 6873 }
6874 }
6875
6876 return 1;
6877}
6878
657d0d47
CC		 6879/* Pre-allocate enough space for the CU/TU sets needed. */
6880
6881static void
6882prealloc_cu_tu_list (unsigned int nshndx)
6883{
6884 if (shndx_pool == NULL)
6885 {
6886 shndx_pool_size = nshndx;
6887 shndx_pool_used = 0;
6888 shndx_pool = (unsigned int *) xcmalloc (shndx_pool_size,
6889 sizeof (unsigned int));
6890 }
6891 else
6892 {
6893 shndx_pool_size = shndx_pool_used + nshndx;
6894 shndx_pool = (unsigned int *) xcrealloc (shndx_pool, shndx_pool_size,
6895 sizeof (unsigned int));
6896 }
6897}
6898
6899static void
6900add_shndx_to_cu_tu_entry (unsigned int shndx)
6901{
6902 if (shndx_pool_used >= shndx_pool_size)
6903 {
6904 error (_("Internal error: out of space in the shndx pool.\n"));
6905 return;
6906 }
6907 shndx_pool [shndx_pool_used++] = shndx;
6908}
6909
6910static void
6911end_cu_tu_entry (void)
6912{
6913 if (shndx_pool_used >= shndx_pool_size)
6914 {
6915 error (_("Internal error: out of space in the shndx pool.\n"));
6916 return;
6917 }
6918 shndx_pool [shndx_pool_used++] = 0;
6919}
6920
341f9135
CC		 6921/* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6922
6923static const char *
6924get_DW_SECT_short_name (unsigned int dw_sect)
6925{
6926 static char buf[16];
6927
6928 switch (dw_sect)
6929 {
6930 case DW_SECT_INFO:
6931 return "info";
6932 case DW_SECT_TYPES:
6933 return "types";
6934 case DW_SECT_ABBREV:
6935 return "abbrev";
6936 case DW_SECT_LINE:
6937 return "line";
6938 case DW_SECT_LOC:
6939 return "loc";
6940 case DW_SECT_STR_OFFSETS:
6941 return "str_off";
6942 case DW_SECT_MACINFO:
6943 return "macinfo";
6944 case DW_SECT_MACRO:
6945 return "macro";
6946 default:
b4eb7656 6947 break;
341f9135
CC		 6948 }
6949
6950 snprintf (buf, sizeof (buf), "%d", dw_sect);
6951 return buf;
6952}
6953
6954/* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6955 These sections are extensions for Fission.
6956 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
657d0d47
CC		 6957
6958static int
6959process_cu_tu_index (struct dwarf_section *section, int do_display)
6960{
6961 unsigned char *phdr = section->start;
6962 unsigned char *limit = phdr + section->size;
6963 unsigned char *phash;
6964 unsigned char *pindex;
6965 unsigned char *ppool;
6966 unsigned int version;
341f9135 6967 unsigned int ncols = 0;
657d0d47
CC		 6968 unsigned int nused;
6969 unsigned int nslots;
6970 unsigned int i;
341f9135
CC		 6971 unsigned int j;
6972 dwarf_vma signature_high;
6973 dwarf_vma signature_low;
6974 char buf[64];
657d0d47 6975
6937bb54
NC		 6976 /* PR 17512: file: 002-168123-0.004. */
6977 if (phdr == NULL)
6978 {
6979 warn (_("Section %s is empty\n"), section->name);
6980 return 0;
6981 }
6982 /* PR 17512: file: 002-376-0.004. */
6983 if (section->size < 24)
6984 {
72c61a0d 6985 warn (_("Section %s is too small to contain a CU/TU header\n"),
6937bb54
NC		 6986 section->name);
6987 return 0;
6988 }
6989
6990 SAFE_BYTE_GET (version, phdr, 4, limit);
341f9135 6991 if (version >= 2)
6937bb54
NC		 6992 SAFE_BYTE_GET (ncols, phdr + 4, 4, limit);
6993 SAFE_BYTE_GET (nused, phdr + 8, 4, limit);
6994 SAFE_BYTE_GET (nslots, phdr + 12, 4, limit);
6995
657d0d47
CC		 6996 phash = phdr + 16;
6997 pindex = phash + nslots * 8;
6998 ppool = pindex + nslots * 4;
6999
57028622 7000 /* PR 17531: file: 45d69832. */
03a91817 7001 if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0))
57028622
NC		 7002 {
7003 warn (_("Section %s is too small for %d slots\n"),
7004 section->name, nslots);
7005 return 0;
7006 }
7007
657d0d47
CC		 7008 if (do_display)
7009 {
7010 printf (_("Contents of the %s section:\n\n"), section->name);
7011 printf (_(" Version: %d\n"), version);
341f9135
CC		 7012 if (version >= 2)
7013 printf (_(" Number of columns: %d\n"), ncols);
657d0d47
CC		 7014 printf (_(" Number of used entries: %d\n"), nused);
7015 printf (_(" Number of slots: %d\n\n"), nslots);
7016 }
7017
03a91817 7018 if (ppool > limit || ppool < phdr)
657d0d47
CC		 7019 {
7020 warn (_("Section %s too small for %d hash table entries\n"),
7021 section->name, nslots);
7022 return 0;
7023 }
7024
341f9135 7025 if (version == 1)
657d0d47 7026 {
341f9135
CC		 7027 if (!do_display)
7028 prealloc_cu_tu_list ((limit - ppool) / 4);
7029 for (i = 0; i < nslots; i++)
657d0d47 7030 {
341f9135
CC		 7031 unsigned char *shndx_list;
7032 unsigned int shndx;
7033
6937bb54 7034 SAFE_BYTE_GET64 (phash, &signature_high, &signature_low, limit);
341f9135 7035 if (signature_high != 0 || signature_low != 0)
657d0d47 7036 {
6937bb54 7037 SAFE_BYTE_GET (j, pindex, 4, limit);
341f9135 7038 shndx_list = ppool + j * 4;
f3853b34
NC		 7039 /* PR 17531: file: 705e010d. */
7040 if (shndx_list < ppool)
7041 {
7042 warn (_("Section index pool located before start of section\n"));
7043 return 0;
7044 }
7045
341f9135
CC		 7046 if (do_display)
7047 printf (_(" [%3d] Signature: 0x%s Sections: "),
7048 i, dwarf_vmatoa64 (signature_high, signature_low,
7049 buf, sizeof (buf)));
7050 for (;;)
657d0d47 7051 {
341f9135
CC		 7052 if (shndx_list >= limit)
7053 {
7054 warn (_("Section %s too small for shndx pool\n"),
7055 section->name);
7056 return 0;
7057 }
6937bb54 7058 SAFE_BYTE_GET (shndx, shndx_list, 4, limit);
341f9135
CC		 7059 if (shndx == 0)
7060 break;
7061 if (do_display)
7062 printf (" %d", shndx);
7063 else
7064 add_shndx_to_cu_tu_entry (shndx);
7065 shndx_list += 4;
657d0d47 7066 }
657d0d47 7067 if (do_display)
341f9135 7068 printf ("\n");
657d0d47 7069 else
341f9135
CC		 7070 end_cu_tu_entry ();
7071 }
7072 phash += 8;
7073 pindex += 4;
7074 }
7075 }
7076 else if (version == 2)
7077 {
7078 unsigned int val;
7079 unsigned int dw_sect;
7080 unsigned char *ph = phash;
7081 unsigned char *pi = pindex;
7082 unsigned char *poffsets = ppool + ncols * 4;
7083 unsigned char *psizes = poffsets + nused * ncols * 4;
7084 unsigned char *pend = psizes + nused * ncols * 4;
7085 bfd_boolean is_tu_index;
7086 struct cu_tu_set *this_set = NULL;
7087 unsigned int row;
7088 unsigned char *prow;
7089
7090 is_tu_index = strcmp (section->name, ".debug_tu_index") == 0;
7091
362beea4 7092 /* PR 17531: file: 0dd159bf.
b4eb7656 7093 Check for wraparound with an overlarge ncols value. */
c8071705 7094 if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols)
362beea4
NC		 7095 {
7096 warn (_("Overlarge number of columns: %x\n"), ncols);
7097 return 0;
7098 }
7099
341f9135
CC		 7100 if (pend > limit)
7101 {
7102 warn (_("Section %s too small for offset and size tables\n"),
7103 section->name);
7104 return 0;
7105 }
7106
7107 if (do_display)
7108 {
7109 printf (_(" Offset table\n"));
7110 printf (" slot %-16s ",
7111 is_tu_index ? _("signature") : _("dwo_id"));
7112 }
7113 else
7114 {
7115 if (is_tu_index)
7116 {
7117 tu_count = nused;
72c61a0d 7118 tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135 7119 this_set = tu_sets;
657d0d47 7120 }
657d0d47 7121 else
341f9135
CC		 7122 {
7123 cu_count = nused;
72c61a0d 7124 cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set));
341f9135
CC		 7125 this_set = cu_sets;
7126 }
7127 }
6937bb54 7128
341f9135
CC		 7129 if (do_display)
7130 {
7131 for (j = 0; j < ncols; j++)
7132 {
6937bb54 7133 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
341f9135
CC		 7134 printf (" %8s", get_DW_SECT_short_name (dw_sect));
7135 }
7136 printf ("\n");
7137 }
6937bb54 7138
341f9135
CC		 7139 for (i = 0; i < nslots; i++)
7140 {
6937bb54
NC		 7141 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7142
7143 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 7144 if (row != 0)
7145 {
591f7597 7146 /* PR 17531: file: a05f6ab3. */
ef77750e 7147 if (row > nused)
591f7597
NC		 7148 {
7149 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7150 row, nused);
7151 return 0;
7152 }
7153
341f9135
CC		 7154 if (!do_display)
7155 memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t));
6937bb54 7156
341f9135 7157 prow = poffsets + (row - 1) * ncols * 4;
ffc0f143
NC		 7158 /* PR 17531: file: b8ce60a8. */
7159 if (prow < poffsets || prow > limit)
7160 {
7161 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7162 row, ncols);
7163 return 0;
7164 }
3aade688 7165
341f9135
CC		 7166 if (do_display)
7167 printf (_(" [%3d] 0x%s"),
7168 i, dwarf_vmatoa64 (signature_high, signature_low,
7169 buf, sizeof (buf)));
7170 for (j = 0; j < ncols; j++)
7171 {
6937bb54 7172 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 7173 if (do_display)
7174 printf (" %8d", val);
7175 else
7176 {
6937bb54 7177 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 7178
7179 /* PR 17531: file: 10796eb3. */
7180 if (dw_sect >= DW_SECT_MAX)
7181 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7182 else
7183 this_set [row - 1].section_offsets [dw_sect] = val;
341f9135
CC		 7184 }
7185 }
6937bb54 7186
341f9135
CC		 7187 if (do_display)
7188 printf ("\n");
7189 }
7190 ph += 8;
7191 pi += 4;
7192 }
7193
7194 ph = phash;
7195 pi = pindex;
7196 if (do_display)
b4eb7656 7197 {
341f9135
CC		 7198 printf ("\n");
7199 printf (_(" Size table\n"));
7200 printf (" slot %-16s ",
7201 is_tu_index ? _("signature") : _("dwo_id"));
b4eb7656 7202 }
6937bb54 7203
341f9135
CC		 7204 for (j = 0; j < ncols; j++)
7205 {
6937bb54 7206 SAFE_BYTE_GET (val, ppool + j * 4, 4, limit);
341f9135
CC		 7207 if (do_display)
7208 printf (" %8s", get_DW_SECT_short_name (val));
7209 }
6937bb54 7210
341f9135
CC		 7211 if (do_display)
7212 printf ("\n");
6937bb54 7213
341f9135
CC		 7214 for (i = 0; i < nslots; i++)
7215 {
6937bb54
NC		 7216 SAFE_BYTE_GET64 (ph, &signature_high, &signature_low, limit);
7217
7218 SAFE_BYTE_GET (row, pi, 4, limit);
341f9135
CC		 7219 if (row != 0)
7220 {
7221 prow = psizes + (row - 1) * ncols * 4;
6937bb54 7222
341f9135
CC		 7223 if (do_display)
7224 printf (_(" [%3d] 0x%s"),
7225 i, dwarf_vmatoa64 (signature_high, signature_low,
7226 buf, sizeof (buf)));
6937bb54 7227
341f9135
CC		 7228 for (j = 0; j < ncols; j++)
7229 {
6937bb54 7230 SAFE_BYTE_GET (val, prow + j * 4, 4, limit);
341f9135
CC		 7231 if (do_display)
7232 printf (" %8d", val);
7233 else
7234 {
6937bb54 7235 SAFE_BYTE_GET (dw_sect, ppool + j * 4, 4, limit);
82b1b41b
NC		 7236 if (dw_sect >= DW_SECT_MAX)
7237 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect);
7238 else
341f9135
CC		 7239 this_set [row - 1].section_sizes [dw_sect] = val;
7240 }
7241 }
6937bb54 7242
341f9135
CC		 7243 if (do_display)
7244 printf ("\n");
7245 }
6937bb54 7246
341f9135
CC		 7247 ph += 8;
7248 pi += 4;
657d0d47 7249 }
657d0d47 7250 }
341f9135 7251 else if (do_display)
6937bb54 7252 printf (_(" Unsupported version (%d)\n"), version);
657d0d47
CC		 7253
7254 if (do_display)
7255 printf ("\n");
7256
7257 return 1;
7258}
7259
7260/* Load the CU and TU indexes if present. This will build a list of
7261 section sets that we can use to associate a .debug_info.dwo section
7262 with its associated .debug_abbrev.dwo section in a .dwp file. */
7263
7264static void
7265load_cu_tu_indexes (void *file)
7266{
7267 /* If we have already loaded (or tried to load) the CU and TU indexes
7268 then do not bother to repeat the task. */
7269 if (cu_tu_indexes_read)
7270 return;
7271
7272 if (load_debug_section (dwp_cu_index, file))
7273 process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0);
7274
7275 if (load_debug_section (dwp_tu_index, file))
7276 process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0);
7277
7278 cu_tu_indexes_read = 1;
7279}
7280
7281/* Find the set of sections that includes section SHNDX. */
7282
7283unsigned int *
7284find_cu_tu_set (void *file, unsigned int shndx)
7285{
7286 unsigned int i;
7287
7288 load_cu_tu_indexes (file);
7289
7290 /* Find SHNDX in the shndx pool. */
7291 for (i = 0; i < shndx_pool_used; i++)
7292 if (shndx_pool [i] == shndx)
7293 break;
7294
7295 if (i >= shndx_pool_used)
7296 return NULL;
7297
7298 /* Now backup to find the first entry in the set. */
7299 while (i > 0 && shndx_pool [i - 1] != 0)
7300 i--;
7301
7302 return shndx_pool + i;
7303}
7304
7305/* Display a .debug_cu_index or .debug_tu_index section. */
7306
7307static int
7308display_cu_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED)
7309{
7310 return process_cu_tu_index (section, 1);
7311}
7312
19e6b90e
L		 7313static int
7314display_debug_not_supported (struct dwarf_section *section,
7315 void *file ATTRIBUTE_UNUSED)
7316{
7317 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7318 section->name);
7319
7320 return 1;
7321}
7322
1306a742
NC		 7323/* Like malloc, but takes two parameters like calloc.
7324 Verifies that the first parameter is not too large.
82b1b41b 7325 Note: does *not* initialise the allocated memory to zero. */
19e6b90e
L		 7326void *
7327cmalloc (size_t nmemb, size_t size)
7328{
7329 /* Check for overflow. */
7330 if (nmemb >= ~(size_t) 0 / size)
7331 return NULL;
82b1b41b
NC		 7332
7333 return xmalloc (nmemb * size);
19e6b90e
L		 7334}
7335
1306a742
NC		 7336/* Like xmalloc, but takes two parameters like calloc.
7337 Verifies that the first parameter is not too large.
7338 Note: does *not* initialise the allocated memory to zero. */
72c61a0d 7339void *
1306a742 7340xcmalloc (size_t nmemb, size_t size)
72c61a0d
NC		 7341{
7342 /* Check for overflow. */
7343 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7344 {
7345 fprintf (stderr,
7346 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7347 (long) nmemb);
7348 xexit (1);
7349 }
72c61a0d 7350
1306a742 7351 return xmalloc (nmemb * size);
72c61a0d
NC		 7352}
7353
1306a742
NC		 7354/* Like xrealloc, but takes three parameters.
7355 Verifies that the second parameter is not too large.
7356 Note: does *not* initialise any new memory to zero. */
19e6b90e 7357void *
1306a742 7358xcrealloc (void *ptr, size_t nmemb, size_t size)
19e6b90e
L		 7359{
7360 /* Check for overflow. */
7361 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7362 {
7363 fprintf (stderr,
7364 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7365 (long) nmemb);
7366 xexit (1);
7367 }
82b1b41b 7368
1306a742 7369 return xrealloc (ptr, nmemb * size);
19e6b90e
L		 7370}
7371
1306a742 7372/* Like xcalloc, but verifies that the first parameter is not too large. */
19e6b90e 7373void *
1306a742 7374xcalloc2 (size_t nmemb, size_t size)
19e6b90e
L		 7375{
7376 /* Check for overflow. */
7377 if (nmemb >= ~(size_t) 0 / size)
8490fb40
NC		 7378 {
7379 fprintf (stderr,
7380 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7381 (long) nmemb);
7382 xexit (1);
7383 }
82b1b41b 7384
1306a742 7385 return xcalloc (nmemb, size);
19e6b90e
L		 7386}
7387
19e6b90e
L		 7388void
7389free_debug_memory (void)
7390{
3f5e193b 7391 unsigned int i;
19e6b90e
L		 7392
7393 free_abbrevs ();
7394
7395 for (i = 0; i < max; i++)
3f5e193b 7396 free_debug_section ((enum dwarf_section_display_enum) i);
19e6b90e 7397
cc86f28f 7398 if (debug_information != NULL)
19e6b90e 7399 {
cc86f28f 7400 if (num_debug_info_entries != DEBUG_INFO_UNAVAILABLE)
19e6b90e 7401 {
cc86f28f 7402 for (i = 0; i < num_debug_info_entries; i++)
19e6b90e 7403 {
cc86f28f
NC		 7404 if (!debug_information [i].max_loc_offsets)
7405 {
7406 free (debug_information [i].loc_offsets);
7407 free (debug_information [i].have_frame_base);
7408 }
7409 if (!debug_information [i].max_range_lists)
7410 free (debug_information [i].range_lists);
19e6b90e 7411 }
19e6b90e
L		 7412 }
7413 free (debug_information);
7414 debug_information = NULL;
82b1b41b 7415 alloc_num_debug_info_entries = num_debug_info_entries = 0;
19e6b90e 7416 }
19e6b90e
L		 7417}
7418
4cb93e3b
TG		 7419void
7420dwarf_select_sections_by_names (const char *names)
7421{
7422 typedef struct
7423 {
7424 const char * option;
7425 int * variable;
f9f0e732 7426 int val;
4cb93e3b
TG		 7427 }
7428 debug_dump_long_opts;
7429
7430 static const debug_dump_long_opts opts_table [] =
7431 {
7432 /* Please keep this table alpha- sorted. */
7433 { "Ranges", & do_debug_ranges, 1 },
7434 { "abbrev", & do_debug_abbrevs, 1 },
657d0d47 7435 { "addr", & do_debug_addr, 1 },
4cb93e3b 7436 { "aranges", & do_debug_aranges, 1 },
657d0d47
CC		 7437 { "cu_index", & do_debug_cu_index, 1 },
7438 { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED },
4cb93e3b
TG		 7439 { "frames", & do_debug_frames, 1 },
7440 { "frames-interp", & do_debug_frames_interp, 1 },
657d0d47
CC		 7441 /* The special .gdb_index section. */
7442 { "gdb_index", & do_gdb_index, 1 },
4cb93e3b
TG		 7443 { "info", & do_debug_info, 1 },
7444 { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */
4cb93e3b
TG		 7445 { "loc", & do_debug_loc, 1 },
7446 { "macro", & do_debug_macinfo, 1 },
7447 { "pubnames", & do_debug_pubnames, 1 },
357da287 7448 { "pubtypes", & do_debug_pubtypes, 1 },
4cb93e3b
TG		 7449 /* This entry is for compatability
7450 with earlier versions of readelf. */
7451 { "ranges", & do_debug_aranges, 1 },
657d0d47 7452 { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW },
4cb93e3b 7453 { "str", & do_debug_str, 1 },
6f875884
TG		 7454 /* These trace_* sections are used by Itanium VMS. */
7455 { "trace_abbrev", & do_trace_abbrevs, 1 },
7456 { "trace_aranges", & do_trace_aranges, 1 },
7457 { "trace_info", & do_trace_info, 1 },
4cb93e3b
TG		 7458 { NULL, NULL, 0 }
7459 };
7460
7461 const char *p;
467c65bc 7462
4cb93e3b
TG		 7463 p = names;
7464 while (*p)
7465 {
7466 const debug_dump_long_opts * entry;
467c65bc 7467
4cb93e3b
TG		 7468 for (entry = opts_table; entry->option; entry++)
7469 {
7470 size_t len = strlen (entry->option);
467c65bc 7471
4cb93e3b
TG		 7472 if (strncmp (p, entry->option, len) == 0
7473 && (p[len] == ',' || p[len] == '\0'))
7474 {
7475 * entry->variable |= entry->val;
467c65bc 7476
4cb93e3b
TG		 7477 /* The --debug-dump=frames-interp option also
7478 enables the --debug-dump=frames option. */
7479 if (do_debug_frames_interp)
7480 do_debug_frames = 1;
7481
7482 p += len;
7483 break;
7484 }
7485 }
467c65bc 7486
4cb93e3b
TG		 7487 if (entry->option == NULL)
7488 {
7489 warn (_("Unrecognized debug option '%s'\n"), p);
7490 p = strchr (p, ',');
7491 if (p == NULL)
7492 break;
7493 }
467c65bc 7494
4cb93e3b
TG		 7495 if (*p == ',')
7496 p++;
7497 }
7498}
7499
7500void
7501dwarf_select_sections_by_letters (const char *letters)
7502{
91d6fa6a 7503 unsigned int lindex = 0;
4cb93e3b 7504
91d6fa6a
NC		 7505 while (letters[lindex])
7506 switch (letters[lindex++])
4cb93e3b
TG		 7507 {
7508 case 'i':
7509 do_debug_info = 1;
7510 break;
467c65bc 7511
4cb93e3b
TG		 7512 case 'a':
7513 do_debug_abbrevs = 1;
7514 break;
467c65bc 7515
4cb93e3b
TG		 7516 case 'l':
7517 do_debug_lines |= FLAG_DEBUG_LINES_RAW;
7518 break;
467c65bc 7519
4cb93e3b
TG		 7520 case 'L':
7521 do_debug_lines |= FLAG_DEBUG_LINES_DECODED;
7522 break;
467c65bc 7523
4cb93e3b
TG		 7524 case 'p':
7525 do_debug_pubnames = 1;
7526 break;
467c65bc 7527
f9f0e732
NC		 7528 case 't':
7529 do_debug_pubtypes = 1;
7530 break;
467c65bc 7531
4cb93e3b
TG		 7532 case 'r':
7533 do_debug_aranges = 1;
7534 break;
467c65bc 7535
4cb93e3b
TG		 7536 case 'R':
7537 do_debug_ranges = 1;
7538 break;
467c65bc 7539
4cb93e3b
TG		 7540 case 'F':
7541 do_debug_frames_interp = 1;
7542 case 'f':
7543 do_debug_frames = 1;
7544 break;
467c65bc 7545
4cb93e3b
TG		 7546 case 'm':
7547 do_debug_macinfo = 1;
7548 break;
467c65bc 7549
4cb93e3b
TG		 7550 case 's':
7551 do_debug_str = 1;
7552 break;
467c65bc 7553
4cb93e3b
TG		 7554 case 'o':
7555 do_debug_loc = 1;
7556 break;
467c65bc 7557
4cb93e3b 7558 default:
7cc78d07 7559 warn (_("Unrecognized debug option '%s'\n"), letters);
4cb93e3b
TG		 7560 break;
7561 }
7562}
7563
7564void
7565dwarf_select_sections_all (void)
7566{
7567 do_debug_info = 1;
7568 do_debug_abbrevs = 1;
7569 do_debug_lines = FLAG_DEBUG_LINES_RAW;
7570 do_debug_pubnames = 1;
f9f0e732 7571 do_debug_pubtypes = 1;
4cb93e3b
TG		 7572 do_debug_aranges = 1;
7573 do_debug_ranges = 1;
7574 do_debug_frames = 1;
7575 do_debug_macinfo = 1;
7576 do_debug_str = 1;
7577 do_debug_loc = 1;
5bbdf3d5 7578 do_gdb_index = 1;
6f875884
TG		 7579 do_trace_info = 1;
7580 do_trace_abbrevs = 1;
7581 do_trace_aranges = 1;
657d0d47
CC		 7582 do_debug_addr = 1;
7583 do_debug_cu_index = 1;
4cb93e3b
TG		 7584}
7585
19e6b90e
L		 7586struct dwarf_section_display debug_displays[] =
7587{
d1c4b12b
NC		 7588 { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7589 display_debug_abbrev, &do_debug_abbrevs, FALSE },
7590 { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7591 display_debug_aranges, &do_debug_aranges, TRUE },
7592 { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7593 display_debug_frames, &do_debug_frames, TRUE },
7594 { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7595 display_debug_info, &do_debug_info, TRUE },
7596 { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7597 display_debug_lines, &do_debug_lines, TRUE },
7598 { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7599 display_debug_pubnames, &do_debug_pubnames, FALSE },
7600 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7601 display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
7602 { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7603 display_debug_frames, &do_debug_frames, TRUE },
7604 { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7605 display_debug_macinfo, &do_debug_macinfo, FALSE },
7606 { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7607 display_debug_macro, &do_debug_macinfo, TRUE },
7608 { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7609 display_debug_str, &do_debug_str, FALSE },
7610 { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7611 display_debug_loc, &do_debug_loc, TRUE },
7612 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7613 display_debug_pubnames, &do_debug_pubtypes, FALSE },
7614 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7615 display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
7616 { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7617 display_debug_ranges, &do_debug_ranges, TRUE },
7618 { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7619 display_debug_not_supported, NULL, FALSE },
7620 { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7621 display_debug_not_supported, NULL, FALSE },
7622 { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL },
7623 display_debug_types, &do_debug_info, TRUE },
7624 { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7625 display_debug_not_supported, NULL, FALSE },
7626 { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7627 display_gdb_index, &do_gdb_index, FALSE },
7628 { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL },
7629 display_trace_info, &do_trace_info, TRUE },
7630 { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7631 display_debug_abbrev, &do_trace_abbrevs, FALSE },
7632 { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7633 display_debug_aranges, &do_trace_aranges, FALSE },
7634 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7635 display_debug_info, &do_debug_info, TRUE },
7636 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7637 display_debug_abbrev, &do_debug_abbrevs, FALSE },
7638 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL },
7639 display_debug_types, &do_debug_info, TRUE },
7640 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7641 display_debug_lines, &do_debug_lines, TRUE },
7642 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7643 display_debug_loc, &do_debug_loc, TRUE },
7644 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7645 display_debug_macro, &do_debug_macinfo, TRUE },
7646 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7647 display_debug_macinfo, &do_debug_macinfo, FALSE },
7648 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7649 display_debug_str, &do_debug_str, TRUE },
7650 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7651 display_debug_str_offsets, NULL, FALSE },
7652 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7653 display_debug_str_offsets, NULL, FALSE },
7654 { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7655 display_debug_addr, &do_debug_addr, TRUE },
7656 { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7657 display_cu_index, &do_debug_cu_index, FALSE },
7658 { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL },
7659 display_cu_index, &do_debug_cu_index, FALSE },
19e6b90e 7660};
GDB Binutils - Deliverables
This page took 0.987491 seconds and 4 git commands to generate.