?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2003-09-29 H.J. Lu <hongjiu.lu@intel.com>
[binutils.git] / binutils / readelf.c
blob520b736395baabcc1ba54fd056e3249c1a3c8293
1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 02111-1307, USA. */
23 \f
24
25 #include <assert.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <stdio.h>
29 #include <time.h>
30
31 #if __GNUC__ >= 2
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we believe that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
36 #define BFD64
37 #endif
38
39 #include "bfd.h"
40
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
45
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
49
50 #define RELOC_MACROS_GEN_FUNC
51
52 #include "elf/alpha.h"
53 #include "elf/arc.h"
54 #include "elf/arm.h"
55 #include "elf/avr.h"
56 #include "elf/cris.h"
57 #include "elf/d10v.h"
58 #include "elf/d30v.h"
59 #include "elf/dlx.h"
60 #include "elf/fr30.h"
61 #include "elf/frv.h"
62 #include "elf/h8.h"
63 #include "elf/hppa.h"
64 #include "elf/i386.h"
65 #include "elf/i370.h"
66 #include "elf/i860.h"
67 #include "elf/i960.h"
68 #include "elf/ia64.h"
69 #include "elf/ip2k.h"
70 #include "elf/m32r.h"
71 #include "elf/m68k.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
74 #include "elf/mips.h"
75 #include "elf/mmix.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
79 #include "elf/or32.h"
80 #include "elf/pj.h"
81 #include "elf/ppc.h"
82 #include "elf/ppc64.h"
83 #include "elf/s390.h"
84 #include "elf/sh.h"
85 #include "elf/sparc.h"
86 #include "elf/v850.h"
87 #include "elf/vax.h"
88 #include "elf/x86-64.h"
89 #include "elf/xstormy16.h"
90 #include "elf/iq2000.h"
91 #include "elf/xtensa.h"
92
93 #include "aout/ar.h"
94
95 #include "bucomm.h"
96 #include "getopt.h"
97 #include "libiberty.h"
98
99 char *program_name = "readelf";
100 long archive_file_offset;
101 unsigned long archive_file_size;
102 unsigned long dynamic_addr;
103 bfd_size_type dynamic_size;
104 char *dynamic_strings;
105 char *string_table;
106 unsigned long string_table_length;
107 unsigned long num_dynamic_syms;
108 Elf_Internal_Sym *dynamic_symbols;
109 Elf_Internal_Syminfo *dynamic_syminfo;
110 unsigned long dynamic_syminfo_offset;
111 unsigned int dynamic_syminfo_nent;
112 char program_interpreter[64];
113 bfd_vma dynamic_info[DT_JMPREL + 1];
114 bfd_vma version_info[16];
115 Elf_Internal_Ehdr elf_header;
116 Elf_Internal_Shdr *section_headers;
117 Elf_Internal_Phdr *program_headers;
118 Elf_Internal_Dyn *dynamic_segment;
119 Elf_Internal_Shdr *symtab_shndx_hdr;
120 int show_name;
121 int do_dynamic;
122 int do_syms;
123 int do_reloc;
124 int do_sections;
125 int do_segments;
126 int do_unwind;
127 int do_using_dynamic;
128 int do_header;
129 int do_dump;
130 int do_version;
131 int do_wide;
132 int do_histogram;
133 int do_debugging;
134 int do_debug_info;
135 int do_debug_abbrevs;
136 int do_debug_lines;
137 int do_debug_pubnames;
138 int do_debug_aranges;
139 int do_debug_frames;
140 int do_debug_frames_interp;
141 int do_debug_macinfo;
142 int do_debug_str;
143 int do_debug_loc;
144 int do_arch;
145 int do_notes;
146 int is_32bit_elf;
147
148 /* A dynamic array of flags indicating which sections require dumping. */
149 char *dump_sects = NULL;
150 unsigned int num_dump_sects = 0;
151
152 #define HEX_DUMP (1 << 0)
153 #define DISASS_DUMP (1 << 1)
154 #define DEBUG_DUMP (1 << 2)
155
156 /* How to rpint a vma value. */
157 typedef enum print_mode
158 {
159 HEX,
160 DEC,
161 DEC_5,
162 UNSIGNED,
163 PREFIX_HEX,
164 FULL_HEX,
165 LONG_HEX
166 }
167 print_mode;
168
169 static bfd_vma (*byte_get) (unsigned char *, int);
170 static void (*byte_put) (unsigned char *, bfd_vma, int);
171
172 typedef int Elf32_Word;
173
174 #define UNKNOWN -1
175
176 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
177 ((X)->sh_name >= string_table_length \
178 ? "<corrupt>" : string_table + (X)->sh_name))
179
180 /* Given st_shndx I, map to section_headers index. */
181 #define SECTION_HEADER_INDEX(I) \
182 ((I) < SHN_LORESERVE \
183 ? (I) \
184 : ((I) <= SHN_HIRESERVE \
185 ? 0 \
186 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
187
188 /* Reverse of the above. */
189 #define SECTION_HEADER_NUM(N) \
190 ((N) < SHN_LORESERVE \
191 ? (N) \
192 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
193
194 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
195
196 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
197
198 #define BYTE_GET(field) byte_get (field, sizeof (field))
199
200 /* If we can support a 64 bit data type then BFD64 should be defined
201 and sizeof (bfd_vma) == 8. In this case when translating from an
202 external 8 byte field to an internal field, we can assume that the
203 internal field is also 8 bytes wide and so we can extract all the data.
204 If, however, BFD64 is not defined, then we must assume that the
205 internal data structure only has 4 byte wide fields that are the
206 equivalent of the 8 byte wide external counterparts, and so we must
207 truncate the data. */
208 #ifdef BFD64
209 #define BYTE_GET8(field) byte_get (field, -8)
210 #else
211 #define BYTE_GET8(field) byte_get (field, 8)
212 #endif
213
214 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
215
216 #define GET_ELF_SYMBOLS(file, section) \
217 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
218 : get_64bit_elf_symbols (file, section))
219
220
221 static void
222 error (const char *message, ...)
223 {
224 va_list args;
225
226 va_start (args, message);
227 fprintf (stderr, _("%s: Error: "), program_name);
228 vfprintf (stderr, message, args);
229 va_end (args);
230 }
231
232 static void
233 warn (const char *message, ...)
234 {
235 va_list args;
236
237 va_start (args, message);
238 fprintf (stderr, _("%s: Warning: "), program_name);
239 vfprintf (stderr, message, args);
240 va_end (args);
241 }
242
243 static void *
244 get_data (void *var, FILE *file, long offset, size_t size, const char *reason)
245 {
246 void *mvar;
247
248 if (size == 0)
249 return NULL;
250
251 if (fseek (file, archive_file_offset + offset, SEEK_SET))
252 {
253 error (_("Unable to seek to 0x%x for %s\n"),
254 archive_file_offset + offset, reason);
255 return NULL;
256 }
257
258 mvar = var;
259 if (mvar == NULL)
260 {
261 mvar = malloc (size);
262
263 if (mvar == NULL)
264 {
265 error (_("Out of memory allocating 0x%x bytes for %s\n"),
266 size, reason);
267 return NULL;
268 }
269 }
270
271 if (fread (mvar, size, 1, file) != 1)
272 {
273 error (_("Unable to read in 0x%x bytes of %s\n"), size, reason);
274 if (mvar != var)
275 free (mvar);
276 return NULL;
277 }
278
279 return mvar;
280 }
281
282 static bfd_vma
283 byte_get_little_endian (unsigned char *field, int size)
284 {
285 switch (size)
286 {
287 case 1:
288 return *field;
289
290 case 2:
291 return ((unsigned int) (field[0]))
292 | (((unsigned int) (field[1])) << 8);
293
294 #ifndef BFD64
295 case 8:
296 /* We want to extract data from an 8 byte wide field and
297 place it into a 4 byte wide field. Since this is a little
298 endian source we can just use the 4 byte extraction code. */
299 /* Fall through. */
300 #endif
301 case 4:
302 return ((unsigned long) (field[0]))
303 | (((unsigned long) (field[1])) << 8)
304 | (((unsigned long) (field[2])) << 16)
305 | (((unsigned long) (field[3])) << 24);
306
307 #ifdef BFD64
308 case 8:
309 case -8:
310 /* This is a special case, generated by the BYTE_GET8 macro.
311 It means that we are loading an 8 byte value from a field
312 in an external structure into an 8 byte value in a field
313 in an internal strcuture. */
314 return ((bfd_vma) (field[0]))
315 | (((bfd_vma) (field[1])) << 8)
316 | (((bfd_vma) (field[2])) << 16)
317 | (((bfd_vma) (field[3])) << 24)
318 | (((bfd_vma) (field[4])) << 32)
319 | (((bfd_vma) (field[5])) << 40)
320 | (((bfd_vma) (field[6])) << 48)
321 | (((bfd_vma) (field[7])) << 56);
322 #endif
323 default:
324 error (_("Unhandled data length: %d\n"), size);
325 abort ();
326 }
327 }
328
329 static bfd_vma
330 byte_get_signed (unsigned char *field, int size)
331 {
332 bfd_vma x = byte_get (field, size);
333
334 switch (size)
335 {
336 case 1:
337 return (x ^ 0x80) - 0x80;
338 case 2:
339 return (x ^ 0x8000) - 0x8000;
340 case 4:
341 return (x ^ 0x80000000) - 0x80000000;
342 case 8:
343 case -8:
344 return x;
345 default:
346 abort ();
347 }
348 }
349
350 static void
351 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
352 {
353 switch (size)
354 {
355 case 8:
356 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
357 field[6] = ((value >> 24) >> 24) & 0xff;
358 field[5] = ((value >> 24) >> 16) & 0xff;
359 field[4] = ((value >> 24) >> 8) & 0xff;
360 /* Fall through. */
361 case 4:
362 field[3] = (value >> 24) & 0xff;
363 field[2] = (value >> 16) & 0xff;
364 /* Fall through. */
365 case 2:
366 field[1] = (value >> 8) & 0xff;
367 /* Fall through. */
368 case 1:
369 field[0] = value & 0xff;
370 break;
371
372 default:
373 error (_("Unhandled data length: %d\n"), size);
374 abort ();
375 }
376 }
377
378 /* Print a VMA value. */
379 static void
380 print_vma (bfd_vma vma, print_mode mode)
381 {
382 #ifdef BFD64
383 if (is_32bit_elf)
384 #endif
385 {
386 switch (mode)
387 {
388 case FULL_HEX:
389 printf ("0x");
390 /* Drop through. */
391 case LONG_HEX:
392 printf ("%8.8lx", (unsigned long) vma);
393 break;
394
395 case DEC_5:
396 if (vma <= 99999)
397 {
398 printf ("%5ld", (long) vma);
399 break;
400 }
401 /* Drop through. */
402 case PREFIX_HEX:
403 printf ("0x");
404 /* Drop through. */
405 case HEX:
406 printf ("%lx", (unsigned long) vma);
407 break;
408
409 case DEC:
410 printf ("%ld", (unsigned long) vma);
411 break;
412
413 case UNSIGNED:
414 printf ("%lu", (unsigned long) vma);
415 break;
416 }
417 }
418 #ifdef BFD64
419 else
420 {
421 switch (mode)
422 {
423 case FULL_HEX:
424 printf ("0x");
425 /* Drop through. */
426
427 case LONG_HEX:
428 printf_vma (vma);
429 break;
430
431 case PREFIX_HEX:
432 printf ("0x");
433 /* Drop through. */
434
435 case HEX:
436 #if BFD_HOST_64BIT_LONG
437 printf ("%lx", vma);
438 #else
439 if (_bfd_int64_high (vma))
440 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
441 else
442 printf ("%lx", _bfd_int64_low (vma));
443 #endif
444 break;
445
446 case DEC:
447 #if BFD_HOST_64BIT_LONG
448 printf ("%ld", vma);
449 #else
450 if (_bfd_int64_high (vma))
451 /* ugg */
452 printf ("++%ld", _bfd_int64_low (vma));
453 else
454 printf ("%ld", _bfd_int64_low (vma));
455 #endif
456 break;
457
458 case DEC_5:
459 #if BFD_HOST_64BIT_LONG
460 if (vma <= 99999)
461 printf ("%5ld", vma);
462 else
463 printf ("%#lx", vma);
464 #else
465 if (_bfd_int64_high (vma))
466 /* ugg */
467 printf ("++%ld", _bfd_int64_low (vma));
468 else if (vma <= 99999)
469 printf ("%5ld", _bfd_int64_low (vma));
470 else
471 printf ("%#lx", _bfd_int64_low (vma));
472 #endif
473 break;
474
475 case UNSIGNED:
476 #if BFD_HOST_64BIT_LONG
477 printf ("%lu", vma);
478 #else
479 if (_bfd_int64_high (vma))
480 /* ugg */
481 printf ("++%lu", _bfd_int64_low (vma));
482 else
483 printf ("%lu", _bfd_int64_low (vma));
484 #endif
485 break;
486 }
487 }
488 #endif
489 }
490
491 /* Display a symbol on stdout. If do_wide is not true then
492 format the symbol to be at most WIDTH characters,
493 truncating as necessary. If WIDTH is negative then
494 format the string to be exactly - WIDTH characters,
495 truncating or padding as necessary. */
496
497 static void
498 print_symbol (int width, const char *symbol)
499 {
500 if (do_wide)
501 printf ("%s", symbol);
502 else if (width < 0)
503 printf ("%-*.*s", width, width, symbol);
504 else
505 printf ("%-.*s", width, symbol);
506 }
507
508 static bfd_vma
509 byte_get_big_endian (unsigned char *field, int size)
510 {
511 switch (size)
512 {
513 case 1:
514 return *field;
515
516 case 2:
517 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
518
519 case 4:
520 return ((unsigned long) (field[3]))
521 | (((unsigned long) (field[2])) << 8)
522 | (((unsigned long) (field[1])) << 16)
523 | (((unsigned long) (field[0])) << 24);
524
525 #ifndef BFD64
526 case 8:
527 /* Although we are extracing data from an 8 byte wide field, we
528 are returning only 4 bytes of data. */
529 return ((unsigned long) (field[7]))
530 | (((unsigned long) (field[6])) << 8)
531 | (((unsigned long) (field[5])) << 16)
532 | (((unsigned long) (field[4])) << 24);
533 #else
534 case 8:
535 case -8:
536 /* This is a special case, generated by the BYTE_GET8 macro.
537 It means that we are loading an 8 byte value from a field
538 in an external structure into an 8 byte value in a field
539 in an internal strcuture. */
540 return ((bfd_vma) (field[7]))
541 | (((bfd_vma) (field[6])) << 8)
542 | (((bfd_vma) (field[5])) << 16)
543 | (((bfd_vma) (field[4])) << 24)
544 | (((bfd_vma) (field[3])) << 32)
545 | (((bfd_vma) (field[2])) << 40)
546 | (((bfd_vma) (field[1])) << 48)
547 | (((bfd_vma) (field[0])) << 56);
548 #endif
549
550 default:
551 error (_("Unhandled data length: %d\n"), size);
552 abort ();
553 }
554 }
555
556 static void
557 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
558 {
559 switch (size)
560 {
561 case 8:
562 field[7] = value & 0xff;
563 field[6] = (value >> 8) & 0xff;
564 field[5] = (value >> 16) & 0xff;
565 field[4] = (value >> 24) & 0xff;
566 value >>= 16;
567 value >>= 16;
568 /* Fall through. */
569 case 4:
570 field[3] = value & 0xff;
571 field[2] = (value >> 8) & 0xff;
572 value >>= 16;
573 /* Fall through. */
574 case 2:
575 field[1] = value & 0xff;
576 value >>= 8;
577 /* Fall through. */
578 case 1:
579 field[0] = value & 0xff;
580 break;
581
582 default:
583 error (_("Unhandled data length: %d\n"), size);
584 abort ();
585 }
586 }
587
588 /* Guess the relocation size commonly used by the specific machines. */
589
590 static int
591 guess_is_rela (unsigned long e_machine)
592 {
593 switch (e_machine)
594 {
595 /* Targets that use REL relocations. */
596 case EM_ARM:
597 case EM_386:
598 case EM_486:
599 case EM_960:
600 case EM_DLX:
601 case EM_OPENRISC:
602 case EM_OR32:
603 case EM_M32R:
604 case EM_CYGNUS_M32R:
605 case EM_D10V:
606 case EM_CYGNUS_D10V:
607 case EM_MIPS:
608 case EM_MIPS_RS3_LE:
609 return FALSE;
610
611 /* Targets that use RELA relocations. */
612 case EM_68K:
613 case EM_H8_300:
614 case EM_H8_300H:
615 case EM_H8S:
616 case EM_SPARC32PLUS:
617 case EM_SPARCV9:
618 case EM_SPARC:
619 case EM_PPC:
620 case EM_PPC64:
621 case EM_V850:
622 case EM_CYGNUS_V850:
623 case EM_D30V:
624 case EM_CYGNUS_D30V:
625 case EM_MN10200:
626 case EM_CYGNUS_MN10200:
627 case EM_MN10300:
628 case EM_CYGNUS_MN10300:
629 case EM_FR30:
630 case EM_CYGNUS_FR30:
631 case EM_CYGNUS_FRV:
632 case EM_SH:
633 case EM_ALPHA:
634 case EM_MCORE:
635 case EM_IA_64:
636 case EM_AVR:
637 case EM_AVR_OLD:
638 case EM_CRIS:
639 case EM_860:
640 case EM_X86_64:
641 case EM_S390:
642 case EM_S390_OLD:
643 case EM_MMIX:
644 case EM_MSP430:
645 case EM_MSP430_OLD:
646 case EM_XSTORMY16:
647 case EM_VAX:
648 case EM_IP2K:
649 case EM_IP2K_OLD:
650 case EM_IQ2000:
651 case EM_XTENSA:
652 case EM_XTENSA_OLD:
653 return TRUE;
654
655 case EM_MMA:
656 case EM_PCP:
657 case EM_NCPU:
658 case EM_NDR1:
659 case EM_STARCORE:
660 case EM_ME16:
661 case EM_ST100:
662 case EM_TINYJ:
663 case EM_FX66:
664 case EM_ST9PLUS:
665 case EM_ST7:
666 case EM_68HC16:
667 case EM_68HC11:
668 case EM_68HC08:
669 case EM_68HC05:
670 case EM_SVX:
671 case EM_ST19:
672 default:
673 warn (_("Don't know about relocations on this machine architecture\n"));
674 return FALSE;
675 }
676 }
677
678 static int
679 slurp_rela_relocs (FILE *file,
680 unsigned long rel_offset,
681 unsigned long rel_size,
682 Elf_Internal_Rela **relasp,
683 unsigned long *nrelasp)
684 {
685 Elf_Internal_Rela *relas;
686 unsigned long nrelas;
687 unsigned int i;
688
689 if (is_32bit_elf)
690 {
691 Elf32_External_Rela *erelas;
692
693 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
694 if (!erelas)
695 return 0;
696
697 nrelas = rel_size / sizeof (Elf32_External_Rela);
698
699 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
700
701 if (relas == NULL)
702 {
703 error(_("out of memory parsing relocs"));
704 return 0;
705 }
706
707 for (i = 0; i < nrelas; i++)
708 {
709 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
710 relas[i].r_info = BYTE_GET (erelas[i].r_info);
711 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
712 }
713
714 free (erelas);
715 }
716 else
717 {
718 Elf64_External_Rela *erelas;
719
720 erelas = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
721 if (!erelas)
722 return 0;
723
724 nrelas = rel_size / sizeof (Elf64_External_Rela);
725
726 relas = malloc (nrelas * sizeof (Elf_Internal_Rela));
727
728 if (relas == NULL)
729 {
730 error(_("out of memory parsing relocs"));
731 return 0;
732 }
733
734 for (i = 0; i < nrelas; i++)
735 {
736 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
737 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
738 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
739 }
740
741 free (erelas);
742 }
743 *relasp = relas;
744 *nrelasp = nrelas;
745 return 1;
746 }
747
748 static int
749 slurp_rel_relocs (FILE *file,
750 unsigned long rel_offset,
751 unsigned long rel_size,
752 Elf_Internal_Rela **relsp,
753 unsigned long *nrelsp)
754 {
755 Elf_Internal_Rela *rels;
756 unsigned long nrels;
757 unsigned int i;
758
759 if (is_32bit_elf)
760 {
761 Elf32_External_Rel *erels;
762
763 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
764 if (!erels)
765 return 0;
766
767 nrels = rel_size / sizeof (Elf32_External_Rel);
768
769 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
770
771 if (rels == NULL)
772 {
773 error(_("out of memory parsing relocs"));
774 return 0;
775 }
776
777 for (i = 0; i < nrels; i++)
778 {
779 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
780 rels[i].r_info = BYTE_GET (erels[i].r_info);
781 rels[i].r_addend = 0;
782 }
783
784 free (erels);
785 }
786 else
787 {
788 Elf64_External_Rel *erels;
789
790 erels = get_data (NULL, file, rel_offset, rel_size, _("relocs"));
791 if (!erels)
792 return 0;
793
794 nrels = rel_size / sizeof (Elf64_External_Rel);
795
796 rels = malloc (nrels * sizeof (Elf_Internal_Rela));
797
798 if (rels == NULL)
799 {
800 error(_("out of memory parsing relocs"));
801 return 0;
802 }
803
804 for (i = 0; i < nrels; i++)
805 {
806 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
807 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
808 rels[i].r_addend = 0;
809 }
810
811 free (erels);
812 }
813 *relsp = rels;
814 *nrelsp = nrels;
815 return 1;
816 }
817
818 /* Display the contents of the relocation data found at the specified
819 offset. */
820
821 static int
822 dump_relocations (FILE *file,
823 unsigned long rel_offset,
824 unsigned long rel_size,
825 Elf_Internal_Sym *symtab,
826 unsigned long nsyms,
827 char *strtab,
828 int is_rela)
829 {
830 unsigned int i;
831 Elf_Internal_Rela *rels;
832
833
834 if (is_rela == UNKNOWN)
835 is_rela = guess_is_rela (elf_header.e_machine);
836
837 if (is_rela)
838 {
839 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
840 return 0;
841 }
842 else
843 {
844 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
845 return 0;
846 }
847
848 if (is_32bit_elf)
849 {
850 if (is_rela)
851 {
852 if (do_wide)
853 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
854 else
855 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
856 }
857 else
858 {
859 if (do_wide)
860 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
861 else
862 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
863 }
864 }
865 else
866 {
867 if (is_rela)
868 {
869 if (do_wide)
870 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
871 else
872 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
873 }
874 else
875 {
876 if (do_wide)
877 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
878 else
879 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
880 }
881 }
882
883 for (i = 0; i < rel_size; i++)
884 {
885 const char *rtype;
886 const char *rtype2 = NULL;
887 const char *rtype3 = NULL;
888 bfd_vma offset;
889 bfd_vma info;
890 bfd_vma symtab_index;
891 bfd_vma type;
892 bfd_vma type2 = 0;
893 bfd_vma type3 = 0;
894
895 offset = rels[i].r_offset;
896 info = rels[i].r_info;
897
898 if (is_32bit_elf)
899 {
900 type = ELF32_R_TYPE (info);
901 symtab_index = ELF32_R_SYM (info);
902 }
903 else
904 {
905 /* The #ifdef BFD64 below is to prevent a compile time warning.
906 We know that if we do not have a 64 bit data type that we
907 will never execute this code anyway. */
908 #ifdef BFD64
909 if (elf_header.e_machine == EM_MIPS)
910 {
911 /* In little-endian objects, r_info isn't really a 64-bit
912 little-endian value: it has a 32-bit little-endian
913 symbol index followed by four individual byte fields.
914 Reorder INFO accordingly. */
915 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
916 info = (((info & 0xffffffff) << 32)
917 | ((info >> 56) & 0xff)
918 | ((info >> 40) & 0xff00)
919 | ((info >> 24) & 0xff0000)
920 | ((info >> 8) & 0xff000000));
921 type = ELF64_MIPS_R_TYPE (info);
922 type2 = ELF64_MIPS_R_TYPE2 (info);
923 type3 = ELF64_MIPS_R_TYPE3 (info);
924 }
925 else if (elf_header.e_machine == EM_SPARCV9)
926 type = ELF64_R_TYPE_ID (info);
927 else
928 type = ELF64_R_TYPE (info);
929
930 symtab_index = ELF64_R_SYM (info);
931 #endif
932 }
933
934 if (is_32bit_elf)
935 {
936 #ifdef _bfd_int64_low
937 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
938 #else
939 printf ("%8.8lx %8.8lx ", offset, info);
940 #endif
941 }
942 else
943 {
944 #ifdef _bfd_int64_low
945 printf (do_wide
946 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
947 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
948 _bfd_int64_high (offset),
949 _bfd_int64_low (offset),
950 _bfd_int64_high (info),
951 _bfd_int64_low (info));
952 #else
953 printf (do_wide
954 ? "%16.16lx %16.16lx "
955 : "%12.12lx %12.12lx ",
956 offset, info);
957 #endif
958 }
959
960 switch (elf_header.e_machine)
961 {
962 default:
963 rtype = NULL;
964 break;
965
966 case EM_M32R:
967 case EM_CYGNUS_M32R:
968 rtype = elf_m32r_reloc_type (type);
969 break;
970
971 case EM_386:
972 case EM_486:
973 rtype = elf_i386_reloc_type (type);
974 break;
975
976 case EM_68HC11:
977 case EM_68HC12:
978 rtype = elf_m68hc11_reloc_type (type);
979 break;
980
981 case EM_68K:
982 rtype = elf_m68k_reloc_type (type);
983 break;
984
985 case EM_960:
986 rtype = elf_i960_reloc_type (type);
987 break;
988
989 case EM_AVR:
990 case EM_AVR_OLD:
991 rtype = elf_avr_reloc_type (type);
992 break;
993
994 case EM_OLD_SPARCV9:
995 case EM_SPARC32PLUS:
996 case EM_SPARCV9:
997 case EM_SPARC:
998 rtype = elf_sparc_reloc_type (type);
999 break;
1000
1001 case EM_V850:
1002 case EM_CYGNUS_V850:
1003 rtype = v850_reloc_type (type);
1004 break;
1005
1006 case EM_D10V:
1007 case EM_CYGNUS_D10V:
1008 rtype = elf_d10v_reloc_type (type);
1009 break;
1010
1011 case EM_D30V:
1012 case EM_CYGNUS_D30V:
1013 rtype = elf_d30v_reloc_type (type);
1014 break;
1015
1016 case EM_DLX:
1017 rtype = elf_dlx_reloc_type (type);
1018 break;
1019
1020 case EM_SH:
1021 rtype = elf_sh_reloc_type (type);
1022 break;
1023
1024 case EM_MN10300:
1025 case EM_CYGNUS_MN10300:
1026 rtype = elf_mn10300_reloc_type (type);
1027 break;
1028
1029 case EM_MN10200:
1030 case EM_CYGNUS_MN10200:
1031 rtype = elf_mn10200_reloc_type (type);
1032 break;
1033
1034 case EM_FR30:
1035 case EM_CYGNUS_FR30:
1036 rtype = elf_fr30_reloc_type (type);
1037 break;
1038
1039 case EM_CYGNUS_FRV:
1040 rtype = elf_frv_reloc_type (type);
1041 break;
1042
1043 case EM_MCORE:
1044 rtype = elf_mcore_reloc_type (type);
1045 break;
1046
1047 case EM_MMIX:
1048 rtype = elf_mmix_reloc_type (type);
1049 break;
1050
1051 case EM_MSP430:
1052 case EM_MSP430_OLD:
1053 rtype = elf_msp430_reloc_type (type);
1054 break;
1055
1056 case EM_PPC:
1057 rtype = elf_ppc_reloc_type (type);
1058 break;
1059
1060 case EM_PPC64:
1061 rtype = elf_ppc64_reloc_type (type);
1062 break;
1063
1064 case EM_MIPS:
1065 case EM_MIPS_RS3_LE:
1066 rtype = elf_mips_reloc_type (type);
1067 if (!is_32bit_elf)
1068 {
1069 rtype2 = elf_mips_reloc_type (type2);
1070 rtype3 = elf_mips_reloc_type (type3);
1071 }
1072 break;
1073
1074 case EM_ALPHA:
1075 rtype = elf_alpha_reloc_type (type);
1076 break;
1077
1078 case EM_ARM:
1079 rtype = elf_arm_reloc_type (type);
1080 break;
1081
1082 case EM_ARC:
1083 rtype = elf_arc_reloc_type (type);
1084 break;
1085
1086 case EM_PARISC:
1087 rtype = elf_hppa_reloc_type (type);
1088 break;
1089
1090 case EM_H8_300:
1091 case EM_H8_300H:
1092 case EM_H8S:
1093 rtype = elf_h8_reloc_type (type);
1094 break;
1095
1096 case EM_OPENRISC:
1097 case EM_OR32:
1098 rtype = elf_or32_reloc_type (type);
1099 break;
1100
1101 case EM_PJ:
1102 case EM_PJ_OLD:
1103 rtype = elf_pj_reloc_type (type);
1104 break;
1105 case EM_IA_64:
1106 rtype = elf_ia64_reloc_type (type);
1107 break;
1108
1109 case EM_CRIS:
1110 rtype = elf_cris_reloc_type (type);
1111 break;
1112
1113 case EM_860:
1114 rtype = elf_i860_reloc_type (type);
1115 break;
1116
1117 case EM_X86_64:
1118 rtype = elf_x86_64_reloc_type (type);
1119 break;
1120
1121 case EM_S370:
1122 rtype = i370_reloc_type (type);
1123 break;
1124
1125 case EM_S390_OLD:
1126 case EM_S390:
1127 rtype = elf_s390_reloc_type (type);
1128 break;
1129
1130 case EM_XSTORMY16:
1131 rtype = elf_xstormy16_reloc_type (type);
1132 break;
1133
1134 case EM_VAX:
1135 rtype = elf_vax_reloc_type (type);
1136 break;
1137
1138 case EM_IP2K:
1139 case EM_IP2K_OLD:
1140 rtype = elf_ip2k_reloc_type (type);
1141 break;
1142
1143 case EM_IQ2000:
1144 rtype = elf_iq2000_reloc_type (type);
1145 break;
1146
1147 case EM_XTENSA_OLD:
1148 case EM_XTENSA:
1149 rtype = elf_xtensa_reloc_type (type);
1150 break;
1151 }
1152
1153 if (rtype == NULL)
1154 #ifdef _bfd_int64_low
1155 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1156 #else
1157 printf (_("unrecognized: %-7lx"), type);
1158 #endif
1159 else
1160 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1161
1162 if (symtab_index)
1163 {
1164 if (symtab == NULL || symtab_index >= nsyms)
1165 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1166 else
1167 {
1168 Elf_Internal_Sym *psym;
1169
1170 psym = symtab + symtab_index;
1171
1172 printf (" ");
1173 print_vma (psym->st_value, LONG_HEX);
1174 printf (is_32bit_elf ? " " : " ");
1175
1176 if (psym->st_name == 0)
1177 {
1178 const char *sec_name = "<null>";
1179 char name_buf[40];
1180
1181 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1182 {
1183 bfd_vma sec_index = (bfd_vma) -1;
1184
1185 if (psym->st_shndx < SHN_LORESERVE)
1186 sec_index = psym->st_shndx;
1187 else if (psym->st_shndx > SHN_LORESERVE)
1188 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1189 - SHN_LORESERVE);
1190
1191 if (sec_index != (bfd_vma) -1)
1192 sec_name = SECTION_NAME (section_headers + sec_index);
1193 else if (psym->st_shndx == SHN_ABS)
1194 sec_name = "ABS";
1195 else if (psym->st_shndx == SHN_COMMON)
1196 sec_name = "COMMON";
1197 else if (elf_header.e_machine == EM_IA_64
1198 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1199 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1200 sec_name = "ANSI_COM";
1201 else
1202 {
1203 sprintf (name_buf, "<section 0x%x>",
1204 (unsigned int) psym->st_shndx);
1205 sec_name = name_buf;
1206 }
1207 }
1208 print_symbol (22, sec_name);
1209 }
1210 else if (strtab == NULL)
1211 printf (_("<string table index %3ld>"), psym->st_name);
1212 else
1213 print_symbol (22, strtab + psym->st_name);
1214
1215 if (is_rela)
1216 printf (" + %lx", (unsigned long) rels[i].r_addend);
1217 }
1218 }
1219 else if (is_rela)
1220 {
1221 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1222 print_vma (rels[i].r_addend, LONG_HEX);
1223 }
1224
1225 if (elf_header.e_machine == EM_SPARCV9
1226 && !strcmp (rtype, "R_SPARC_OLO10"))
1227 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1228
1229 putchar ('\n');
1230
1231 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1232 {
1233 printf (" Type2: ");
1234
1235 if (rtype2 == NULL)
1236 #ifdef _bfd_int64_low
1237 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1238 #else
1239 printf (_("unrecognized: %-7lx"), type2);
1240 #endif
1241 else
1242 printf ("%-17.17s", rtype2);
1243
1244 printf("\n Type3: ");
1245
1246 if (rtype3 == NULL)
1247 #ifdef _bfd_int64_low
1248 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1249 #else
1250 printf (_("unrecognized: %-7lx"), type3);
1251 #endif
1252 else
1253 printf ("%-17.17s", rtype3);
1254
1255 putchar ('\n');
1256 }
1257 }
1258
1259 free (rels);
1260
1261 return 1;
1262 }
1263
1264 static const char *
1265 get_mips_dynamic_type (unsigned long type)
1266 {
1267 switch (type)
1268 {
1269 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1270 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1271 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1272 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1273 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1274 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1275 case DT_MIPS_MSYM: return "MIPS_MSYM";
1276 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1277 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1278 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1279 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1280 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1281 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1282 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1283 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1284 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1285 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1286 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1287 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1288 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1289 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1290 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1291 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1292 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1293 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1294 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1295 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1296 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1297 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1298 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1299 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1300 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1301 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1302 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1303 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1304 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1305 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1306 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1307 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1308 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1309 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1310 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1311 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1312 default:
1313 return NULL;
1314 }
1315 }
1316
1317 static const char *
1318 get_sparc64_dynamic_type (unsigned long type)
1319 {
1320 switch (type)
1321 {
1322 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1323 default:
1324 return NULL;
1325 }
1326 }
1327
1328 static const char *
1329 get_ppc64_dynamic_type (unsigned long type)
1330 {
1331 switch (type)
1332 {
1333 case DT_PPC64_GLINK: return "PPC64_GLINK";
1334 case DT_PPC64_OPD: return "PPC64_OPD";
1335 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1336 default:
1337 return NULL;
1338 }
1339 }
1340
1341 static const char *
1342 get_parisc_dynamic_type (unsigned long type)
1343 {
1344 switch (type)
1345 {
1346 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1347 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1348 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1349 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1350 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1351 case DT_HP_PREINIT: return "HP_PREINIT";
1352 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1353 case DT_HP_NEEDED: return "HP_NEEDED";
1354 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1355 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1356 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1357 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1358 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1359 default:
1360 return NULL;
1361 }
1362 }
1363
1364 static const char *
1365 get_ia64_dynamic_type (unsigned long type)
1366 {
1367 switch (type)
1368 {
1369 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1370 default:
1371 return NULL;
1372 }
1373 }
1374
1375 static const char *
1376 get_dynamic_type (unsigned long type)
1377 {
1378 static char buff[32];
1379
1380 switch (type)
1381 {
1382 case DT_NULL: return "NULL";
1383 case DT_NEEDED: return "NEEDED";
1384 case DT_PLTRELSZ: return "PLTRELSZ";
1385 case DT_PLTGOT: return "PLTGOT";
1386 case DT_HASH: return "HASH";
1387 case DT_STRTAB: return "STRTAB";
1388 case DT_SYMTAB: return "SYMTAB";
1389 case DT_RELA: return "RELA";
1390 case DT_RELASZ: return "RELASZ";
1391 case DT_RELAENT: return "RELAENT";
1392 case DT_STRSZ: return "STRSZ";
1393 case DT_SYMENT: return "SYMENT";
1394 case DT_INIT: return "INIT";
1395 case DT_FINI: return "FINI";
1396 case DT_SONAME: return "SONAME";
1397 case DT_RPATH: return "RPATH";
1398 case DT_SYMBOLIC: return "SYMBOLIC";
1399 case DT_REL: return "REL";
1400 case DT_RELSZ: return "RELSZ";
1401 case DT_RELENT: return "RELENT";
1402 case DT_PLTREL: return "PLTREL";
1403 case DT_DEBUG: return "DEBUG";
1404 case DT_TEXTREL: return "TEXTREL";
1405 case DT_JMPREL: return "JMPREL";
1406 case DT_BIND_NOW: return "BIND_NOW";
1407 case DT_INIT_ARRAY: return "INIT_ARRAY";
1408 case DT_FINI_ARRAY: return "FINI_ARRAY";
1409 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1410 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1411 case DT_RUNPATH: return "RUNPATH";
1412 case DT_FLAGS: return "FLAGS";
1413
1414 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1415 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1416
1417 case DT_CHECKSUM: return "CHECKSUM";
1418 case DT_PLTPADSZ: return "PLTPADSZ";
1419 case DT_MOVEENT: return "MOVEENT";
1420 case DT_MOVESZ: return "MOVESZ";
1421 case DT_FEATURE: return "FEATURE";
1422 case DT_POSFLAG_1: return "POSFLAG_1";
1423 case DT_SYMINSZ: return "SYMINSZ";
1424 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1425
1426 case DT_ADDRRNGLO: return "ADDRRNGLO";
1427 case DT_CONFIG: return "CONFIG";
1428 case DT_DEPAUDIT: return "DEPAUDIT";
1429 case DT_AUDIT: return "AUDIT";
1430 case DT_PLTPAD: return "PLTPAD";
1431 case DT_MOVETAB: return "MOVETAB";
1432 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1433
1434 case DT_VERSYM: return "VERSYM";
1435
1436 case DT_RELACOUNT: return "RELACOUNT";
1437 case DT_RELCOUNT: return "RELCOUNT";
1438 case DT_FLAGS_1: return "FLAGS_1";
1439 case DT_VERDEF: return "VERDEF";
1440 case DT_VERDEFNUM: return "VERDEFNUM";
1441 case DT_VERNEED: return "VERNEED";
1442 case DT_VERNEEDNUM: return "VERNEEDNUM";
1443
1444 case DT_AUXILIARY: return "AUXILIARY";
1445 case DT_USED: return "USED";
1446 case DT_FILTER: return "FILTER";
1447
1448 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1449 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1450 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1451 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1452 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1453
1454 default:
1455 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1456 {
1457 const char *result;
1458
1459 switch (elf_header.e_machine)
1460 {
1461 case EM_MIPS:
1462 case EM_MIPS_RS3_LE:
1463 result = get_mips_dynamic_type (type);
1464 break;
1465 case EM_SPARCV9:
1466 result = get_sparc64_dynamic_type (type);
1467 break;
1468 case EM_PPC64:
1469 result = get_ppc64_dynamic_type (type);
1470 break;
1471 case EM_IA_64:
1472 result = get_ia64_dynamic_type (type);
1473 break;
1474 default:
1475 result = NULL;
1476 break;
1477 }
1478
1479 if (result != NULL)
1480 return result;
1481
1482 sprintf (buff, _("Processor Specific: %lx"), type);
1483 }
1484 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1485 {
1486 const char *result;
1487
1488 switch (elf_header.e_machine)
1489 {
1490 case EM_PARISC:
1491 result = get_parisc_dynamic_type (type);
1492 break;
1493 default:
1494 result = NULL;
1495 break;
1496 }
1497
1498 if (result != NULL)
1499 return result;
1500
1501 sprintf (buff, _("Operating System specific: %lx"), type);
1502 }
1503 else
1504 sprintf (buff, _("<unknown>: %lx"), type);
1505
1506 return buff;
1507 }
1508 }
1509
1510 static char *
1511 get_file_type (unsigned e_type)
1512 {
1513 static char buff[32];
1514
1515 switch (e_type)
1516 {
1517 case ET_NONE: return _("NONE (None)");
1518 case ET_REL: return _("REL (Relocatable file)");
1519 case ET_EXEC: return _("EXEC (Executable file)");
1520 case ET_DYN: return _("DYN (Shared object file)");
1521 case ET_CORE: return _("CORE (Core file)");
1522
1523 default:
1524 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1525 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1526 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1527 sprintf (buff, _("OS Specific: (%x)"), e_type);
1528 else
1529 sprintf (buff, _("<unknown>: %x"), e_type);
1530 return buff;
1531 }
1532 }
1533
1534 static char *
1535 get_machine_name (unsigned e_machine)
1536 {
1537 static char buff[64]; /* XXX */
1538
1539 switch (e_machine)
1540 {
1541 case EM_NONE: return _("None");
1542 case EM_M32: return "WE32100";
1543 case EM_SPARC: return "Sparc";
1544 case EM_386: return "Intel 80386";
1545 case EM_68K: return "MC68000";
1546 case EM_88K: return "MC88000";
1547 case EM_486: return "Intel 80486";
1548 case EM_860: return "Intel 80860";
1549 case EM_MIPS: return "MIPS R3000";
1550 case EM_S370: return "IBM System/370";
1551 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1552 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1553 case EM_PARISC: return "HPPA";
1554 case EM_PPC_OLD: return "Power PC (old)";
1555 case EM_SPARC32PLUS: return "Sparc v8+" ;
1556 case EM_960: return "Intel 90860";
1557 case EM_PPC: return "PowerPC";
1558 case EM_PPC64: return "PowerPC64";
1559 case EM_V800: return "NEC V800";
1560 case EM_FR20: return "Fujitsu FR20";
1561 case EM_RH32: return "TRW RH32";
1562 case EM_MCORE: return "MCORE";
1563 case EM_ARM: return "ARM";
1564 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1565 case EM_SH: return "Renesas / SuperH SH";
1566 case EM_SPARCV9: return "Sparc v9";
1567 case EM_TRICORE: return "Siemens Tricore";
1568 case EM_ARC: return "ARC";
1569 case EM_H8_300: return "Renesas H8/300";
1570 case EM_H8_300H: return "Renesas H8/300H";
1571 case EM_H8S: return "Renesas H8S";
1572 case EM_H8_500: return "Renesas H8/500";
1573 case EM_IA_64: return "Intel IA-64";
1574 case EM_MIPS_X: return "Stanford MIPS-X";
1575 case EM_COLDFIRE: return "Motorola Coldfire";
1576 case EM_68HC12: return "Motorola M68HC12";
1577 case EM_ALPHA: return "Alpha";
1578 case EM_CYGNUS_D10V:
1579 case EM_D10V: return "d10v";
1580 case EM_CYGNUS_D30V:
1581 case EM_D30V: return "d30v";
1582 case EM_CYGNUS_M32R:
1583 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1584 case EM_CYGNUS_V850:
1585 case EM_V850: return "NEC v850";
1586 case EM_CYGNUS_MN10300:
1587 case EM_MN10300: return "mn10300";
1588 case EM_CYGNUS_MN10200:
1589 case EM_MN10200: return "mn10200";
1590 case EM_CYGNUS_FR30:
1591 case EM_FR30: return "Fujitsu FR30";
1592 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1593 case EM_PJ_OLD:
1594 case EM_PJ: return "picoJava";
1595 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1596 case EM_PCP: return "Siemens PCP";
1597 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1598 case EM_NDR1: return "Denso NDR1 microprocesspr";
1599 case EM_STARCORE: return "Motorola Star*Core processor";
1600 case EM_ME16: return "Toyota ME16 processor";
1601 case EM_ST100: return "STMicroelectronics ST100 processor";
1602 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1603 case EM_FX66: return "Siemens FX66 microcontroller";
1604 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1605 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1606 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1607 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1608 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1609 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1610 case EM_SVX: return "Silicon Graphics SVx";
1611 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1612 case EM_VAX: return "Digital VAX";
1613 case EM_AVR_OLD:
1614 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1615 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1616 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1617 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1618 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1619 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1620 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1621 case EM_PRISM: return "Vitesse Prism";
1622 case EM_X86_64: return "Advanced Micro Devices X86-64";
1623 case EM_S390_OLD:
1624 case EM_S390: return "IBM S/390";
1625 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1626 case EM_OPENRISC:
1627 case EM_OR32: return "OpenRISC";
1628 case EM_DLX: return "OpenDLX";
1629 case EM_IP2K_OLD:
1630 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1631 case EM_IQ2000: return "Vitesse IQ2000";
1632 case EM_XTENSA_OLD:
1633 case EM_XTENSA: return "Tensilica Xtensa Processor";
1634 default:
1635 sprintf (buff, _("<unknown>: %x"), e_machine);
1636 return buff;
1637 }
1638 }
1639
1640 static void
1641 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1642 {
1643 unsigned eabi;
1644 int unknown = 0;
1645
1646 eabi = EF_ARM_EABI_VERSION (e_flags);
1647 e_flags &= ~ EF_ARM_EABIMASK;
1648
1649 /* Handle "generic" ARM flags. */
1650 if (e_flags & EF_ARM_RELEXEC)
1651 {
1652 strcat (buf, ", relocatable executable");
1653 e_flags &= ~ EF_ARM_RELEXEC;
1654 }
1655
1656 if (e_flags & EF_ARM_HASENTRY)
1657 {
1658 strcat (buf, ", has entry point");
1659 e_flags &= ~ EF_ARM_HASENTRY;
1660 }
1661
1662 /* Now handle EABI specific flags. */
1663 switch (eabi)
1664 {
1665 default:
1666 strcat (buf, ", <unrecognized EABI>");
1667 if (e_flags)
1668 unknown = 1;
1669 break;
1670
1671 case EF_ARM_EABI_VER1:
1672 strcat (buf, ", Version1 EABI");
1673 while (e_flags)
1674 {
1675 unsigned flag;
1676
1677 /* Process flags one bit at a time. */
1678 flag = e_flags & - e_flags;
1679 e_flags &= ~ flag;
1680
1681 switch (flag)
1682 {
1683 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1684 strcat (buf, ", sorted symbol tables");
1685 break;
1686
1687 default:
1688 unknown = 1;
1689 break;
1690 }
1691 }
1692 break;
1693
1694 case EF_ARM_EABI_VER2:
1695 strcat (buf, ", Version2 EABI");
1696 while (e_flags)
1697 {
1698 unsigned flag;
1699
1700 /* Process flags one bit at a time. */
1701 flag = e_flags & - e_flags;
1702 e_flags &= ~ flag;
1703
1704 switch (flag)
1705 {
1706 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1707 strcat (buf, ", sorted symbol tables");
1708 break;
1709
1710 case EF_ARM_DYNSYMSUSESEGIDX:
1711 strcat (buf, ", dynamic symbols use segment index");
1712 break;
1713
1714 case EF_ARM_MAPSYMSFIRST:
1715 strcat (buf, ", mapping symbols precede others");
1716 break;
1717
1718 default:
1719 unknown = 1;
1720 break;
1721 }
1722 }
1723 break;
1724
1725 case EF_ARM_EABI_UNKNOWN:
1726 strcat (buf, ", GNU EABI");
1727 while (e_flags)
1728 {
1729 unsigned flag;
1730
1731 /* Process flags one bit at a time. */
1732 flag = e_flags & - e_flags;
1733 e_flags &= ~ flag;
1734
1735 switch (flag)
1736 {
1737 case EF_ARM_INTERWORK:
1738 strcat (buf, ", interworking enabled");
1739 break;
1740
1741 case EF_ARM_APCS_26:
1742 strcat (buf, ", uses APCS/26");
1743 break;
1744
1745 case EF_ARM_APCS_FLOAT:
1746 strcat (buf, ", uses APCS/float");
1747 break;
1748
1749 case EF_ARM_PIC:
1750 strcat (buf, ", position independent");
1751 break;
1752
1753 case EF_ARM_ALIGN8:
1754 strcat (buf, ", 8 bit structure alignment");
1755 break;
1756
1757 case EF_ARM_NEW_ABI:
1758 strcat (buf, ", uses new ABI");
1759 break;
1760
1761 case EF_ARM_OLD_ABI:
1762 strcat (buf, ", uses old ABI");
1763 break;
1764
1765 case EF_ARM_SOFT_FLOAT:
1766 strcat (buf, ", software FP");
1767 break;
1768
1769 case EF_ARM_MAVERICK_FLOAT:
1770 strcat (buf, ", Maverick FP");
1771 break;
1772
1773 default:
1774 unknown = 1;
1775 break;
1776 }
1777 }
1778 }
1779
1780 if (unknown)
1781 strcat (buf,", <unknown>");
1782 }
1783
1784 static char *
1785 get_machine_flags (unsigned e_flags, unsigned e_machine)
1786 {
1787 static char buf[1024];
1788
1789 buf[0] = '\0';
1790
1791 if (e_flags)
1792 {
1793 switch (e_machine)
1794 {
1795 default:
1796 break;
1797
1798 case EM_ARM:
1799 decode_ARM_machine_flags (e_flags, buf);
1800 break;
1801
1802 case EM_68K:
1803 if (e_flags & EF_CPU32)
1804 strcat (buf, ", cpu32");
1805 if (e_flags & EF_M68000)
1806 strcat (buf, ", m68000");
1807 break;
1808
1809 case EM_PPC:
1810 if (e_flags & EF_PPC_EMB)
1811 strcat (buf, ", emb");
1812
1813 if (e_flags & EF_PPC_RELOCATABLE)
1814 strcat (buf, ", relocatable");
1815
1816 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1817 strcat (buf, ", relocatable-lib");
1818 break;
1819
1820 case EM_V850:
1821 case EM_CYGNUS_V850:
1822 switch (e_flags & EF_V850_ARCH)
1823 {
1824 case E_V850E1_ARCH:
1825 strcat (buf, ", v850e1");
1826 break;
1827 case E_V850E_ARCH:
1828 strcat (buf, ", v850e");
1829 break;
1830 case E_V850_ARCH:
1831 strcat (buf, ", v850");
1832 break;
1833 default:
1834 strcat (buf, ", unknown v850 architecture variant");
1835 break;
1836 }
1837 break;
1838
1839 case EM_M32R:
1840 case EM_CYGNUS_M32R:
1841 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1842 strcat (buf, ", m32r");
1843
1844 break;
1845
1846 case EM_MIPS:
1847 case EM_MIPS_RS3_LE:
1848 if (e_flags & EF_MIPS_NOREORDER)
1849 strcat (buf, ", noreorder");
1850
1851 if (e_flags & EF_MIPS_PIC)
1852 strcat (buf, ", pic");
1853
1854 if (e_flags & EF_MIPS_CPIC)
1855 strcat (buf, ", cpic");
1856
1857 if (e_flags & EF_MIPS_UCODE)
1858 strcat (buf, ", ugen_reserved");
1859
1860 if (e_flags & EF_MIPS_ABI2)
1861 strcat (buf, ", abi2");
1862
1863 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1864 strcat (buf, ", odk first");
1865
1866 if (e_flags & EF_MIPS_32BITMODE)
1867 strcat (buf, ", 32bitmode");
1868
1869 switch ((e_flags & EF_MIPS_MACH))
1870 {
1871 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1872 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1873 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1874 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1875 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
1876 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1877 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
1878 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
1879 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1880 case 0:
1881 /* We simply ignore the field in this case to avoid confusion:
1882 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1883 extension. */
1884 break;
1885 default: strcat (buf, ", unknown CPU"); break;
1886 }
1887
1888 switch ((e_flags & EF_MIPS_ABI))
1889 {
1890 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1891 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1892 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1893 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1894 case 0:
1895 /* We simply ignore the field in this case to avoid confusion:
1896 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1897 This means it is likely to be an o32 file, but not for
1898 sure. */
1899 break;
1900 default: strcat (buf, ", unknown ABI"); break;
1901 }
1902
1903 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1904 strcat (buf, ", mdmx");
1905
1906 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1907 strcat (buf, ", mips16");
1908
1909 switch ((e_flags & EF_MIPS_ARCH))
1910 {
1911 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1912 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1913 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1914 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1915 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1916 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1917 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
1918 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1919 default: strcat (buf, ", unknown ISA"); break;
1920 }
1921
1922 break;
1923
1924 case EM_SPARCV9:
1925 if (e_flags & EF_SPARC_32PLUS)
1926 strcat (buf, ", v8+");
1927
1928 if (e_flags & EF_SPARC_SUN_US1)
1929 strcat (buf, ", ultrasparcI");
1930
1931 if (e_flags & EF_SPARC_SUN_US3)
1932 strcat (buf, ", ultrasparcIII");
1933
1934 if (e_flags & EF_SPARC_HAL_R1)
1935 strcat (buf, ", halr1");
1936
1937 if (e_flags & EF_SPARC_LEDATA)
1938 strcat (buf, ", ledata");
1939
1940 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1941 strcat (buf, ", tso");
1942
1943 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1944 strcat (buf, ", pso");
1945
1946 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1947 strcat (buf, ", rmo");
1948 break;
1949
1950 case EM_PARISC:
1951 switch (e_flags & EF_PARISC_ARCH)
1952 {
1953 case EFA_PARISC_1_0:
1954 strcpy (buf, ", PA-RISC 1.0");
1955 break;
1956 case EFA_PARISC_1_1:
1957 strcpy (buf, ", PA-RISC 1.1");
1958 break;
1959 case EFA_PARISC_2_0:
1960 strcpy (buf, ", PA-RISC 2.0");
1961 break;
1962 default:
1963 break;
1964 }
1965 if (e_flags & EF_PARISC_TRAPNIL)
1966 strcat (buf, ", trapnil");
1967 if (e_flags & EF_PARISC_EXT)
1968 strcat (buf, ", ext");
1969 if (e_flags & EF_PARISC_LSB)
1970 strcat (buf, ", lsb");
1971 if (e_flags & EF_PARISC_WIDE)
1972 strcat (buf, ", wide");
1973 if (e_flags & EF_PARISC_NO_KABP)
1974 strcat (buf, ", no kabp");
1975 if (e_flags & EF_PARISC_LAZYSWAP)
1976 strcat (buf, ", lazyswap");
1977 break;
1978
1979 case EM_PJ:
1980 case EM_PJ_OLD:
1981 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1982 strcat (buf, ", new calling convention");
1983
1984 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1985 strcat (buf, ", gnu calling convention");
1986 break;
1987
1988 case EM_IA_64:
1989 if ((e_flags & EF_IA_64_ABI64))
1990 strcat (buf, ", 64-bit");
1991 else
1992 strcat (buf, ", 32-bit");
1993 if ((e_flags & EF_IA_64_REDUCEDFP))
1994 strcat (buf, ", reduced fp model");
1995 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1996 strcat (buf, ", no function descriptors, constant gp");
1997 else if ((e_flags & EF_IA_64_CONS_GP))
1998 strcat (buf, ", constant gp");
1999 if ((e_flags & EF_IA_64_ABSOLUTE))
2000 strcat (buf, ", absolute");
2001 break;
2002
2003 case EM_VAX:
2004 if ((e_flags & EF_VAX_NONPIC))
2005 strcat (buf, ", non-PIC");
2006 if ((e_flags & EF_VAX_DFLOAT))
2007 strcat (buf, ", D-Float");
2008 if ((e_flags & EF_VAX_GFLOAT))
2009 strcat (buf, ", G-Float");
2010 break;
2011 }
2012 }
2013
2014 return buf;
2015 }
2016
2017 static const char *
2018 get_osabi_name (unsigned int osabi)
2019 {
2020 static char buff[32];
2021
2022 switch (osabi)
2023 {
2024 case ELFOSABI_NONE: return "UNIX - System V";
2025 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2026 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2027 case ELFOSABI_LINUX: return "UNIX - Linux";
2028 case ELFOSABI_HURD: return "GNU/Hurd";
2029 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2030 case ELFOSABI_AIX: return "UNIX - AIX";
2031 case ELFOSABI_IRIX: return "UNIX - IRIX";
2032 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2033 case ELFOSABI_TRU64: return "UNIX - TRU64";
2034 case ELFOSABI_MODESTO: return "Novell - Modesto";
2035 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2036 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2037 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2038 case ELFOSABI_AROS: return "Amiga Research OS";
2039 case ELFOSABI_STANDALONE: return _("Standalone App");
2040 case ELFOSABI_ARM: return "ARM";
2041 default:
2042 sprintf (buff, _("<unknown: %x>"), osabi);
2043 return buff;
2044 }
2045 }
2046
2047 static const char *
2048 get_mips_segment_type (unsigned long type)
2049 {
2050 switch (type)
2051 {
2052 case PT_MIPS_REGINFO:
2053 return "REGINFO";
2054 case PT_MIPS_RTPROC:
2055 return "RTPROC";
2056 case PT_MIPS_OPTIONS:
2057 return "OPTIONS";
2058 default:
2059 break;
2060 }
2061
2062 return NULL;
2063 }
2064
2065 static const char *
2066 get_parisc_segment_type (unsigned long type)
2067 {
2068 switch (type)
2069 {
2070 case PT_HP_TLS: return "HP_TLS";
2071 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2072 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2073 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2074 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2075 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2076 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2077 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2078 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2079 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2080 case PT_HP_PARALLEL: return "HP_PARALLEL";
2081 case PT_HP_FASTBIND: return "HP_FASTBIND";
2082 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2083 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2084 default:
2085 break;
2086 }
2087
2088 return NULL;
2089 }
2090
2091 static const char *
2092 get_ia64_segment_type (unsigned long type)
2093 {
2094 switch (type)
2095 {
2096 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2097 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2098 case PT_HP_TLS: return "HP_TLS";
2099 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2100 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2101 case PT_IA_64_HP_STACK: return "HP_STACK";
2102 default:
2103 break;
2104 }
2105
2106 return NULL;
2107 }
2108
2109 static const char *
2110 get_segment_type (unsigned long p_type)
2111 {
2112 static char buff[32];
2113
2114 switch (p_type)
2115 {
2116 case PT_NULL: return "NULL";
2117 case PT_LOAD: return "LOAD";
2118 case PT_DYNAMIC: return "DYNAMIC";
2119 case PT_INTERP: return "INTERP";
2120 case PT_NOTE: return "NOTE";
2121 case PT_SHLIB: return "SHLIB";
2122 case PT_PHDR: return "PHDR";
2123 case PT_TLS: return "TLS";
2124
2125 case PT_GNU_EH_FRAME:
2126 return "GNU_EH_FRAME";
2127 case PT_GNU_STACK: return "STACK";
2128
2129 default:
2130 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2131 {
2132 const char *result;
2133
2134 switch (elf_header.e_machine)
2135 {
2136 case EM_MIPS:
2137 case EM_MIPS_RS3_LE:
2138 result = get_mips_segment_type (p_type);
2139 break;
2140 case EM_PARISC:
2141 result = get_parisc_segment_type (p_type);
2142 break;
2143 case EM_IA_64:
2144 result = get_ia64_segment_type (p_type);
2145 break;
2146 default:
2147 result = NULL;
2148 break;
2149 }
2150
2151 if (result != NULL)
2152 return result;
2153
2154 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2155 }
2156 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2157 {
2158 const char *result;
2159
2160 switch (elf_header.e_machine)
2161 {
2162 case EM_PARISC:
2163 result = get_parisc_segment_type (p_type);
2164 break;
2165 case EM_IA_64:
2166 result = get_ia64_segment_type (p_type);
2167 break;
2168 default:
2169 result = NULL;
2170 break;
2171 }
2172
2173 if (result != NULL)
2174 return result;
2175
2176 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2177 }
2178 else
2179 sprintf (buff, _("<unknown>: %lx"), p_type);
2180
2181 return buff;
2182 }
2183 }
2184
2185 static const char *
2186 get_mips_section_type_name (unsigned int sh_type)
2187 {
2188 switch (sh_type)
2189 {
2190 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2191 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2192 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2193 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2194 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2195 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2196 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2197 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2198 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2199 case SHT_MIPS_RELD: return "MIPS_RELD";
2200 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2201 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2202 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2203 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2204 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2205 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2206 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2207 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2208 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2209 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2210 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2211 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2212 case SHT_MIPS_LINE: return "MIPS_LINE";
2213 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2214 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2215 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2216 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2217 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2218 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2219 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2220 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2221 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2222 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2223 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2224 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2225 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2226 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2227 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2228 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2229 default:
2230 break;
2231 }
2232 return NULL;
2233 }
2234
2235 static const char *
2236 get_parisc_section_type_name (unsigned int sh_type)
2237 {
2238 switch (sh_type)
2239 {
2240 case SHT_PARISC_EXT: return "PARISC_EXT";
2241 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2242 case SHT_PARISC_DOC: return "PARISC_DOC";
2243 default:
2244 break;
2245 }
2246 return NULL;
2247 }
2248
2249 static const char *
2250 get_ia64_section_type_name (unsigned int sh_type)
2251 {
2252 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2253 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2254 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2255
2256 switch (sh_type)
2257 {
2258 case SHT_IA_64_EXT: return "IA_64_EXT";
2259 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2260 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2261 default:
2262 break;
2263 }
2264 return NULL;
2265 }
2266
2267 static const char *
2268 get_section_type_name (unsigned int sh_type)
2269 {
2270 static char buff[32];
2271
2272 switch (sh_type)
2273 {
2274 case SHT_NULL: return "NULL";
2275 case SHT_PROGBITS: return "PROGBITS";
2276 case SHT_SYMTAB: return "SYMTAB";
2277 case SHT_STRTAB: return "STRTAB";
2278 case SHT_RELA: return "RELA";
2279 case SHT_HASH: return "HASH";
2280 case SHT_DYNAMIC: return "DYNAMIC";
2281 case SHT_NOTE: return "NOTE";
2282 case SHT_NOBITS: return "NOBITS";
2283 case SHT_REL: return "REL";
2284 case SHT_SHLIB: return "SHLIB";
2285 case SHT_DYNSYM: return "DYNSYM";
2286 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2287 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2288 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2289 case SHT_GROUP: return "GROUP";
2290 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2291 case SHT_GNU_verdef: return "VERDEF";
2292 case SHT_GNU_verneed: return "VERNEED";
2293 case SHT_GNU_versym: return "VERSYM";
2294 case 0x6ffffff0: return "VERSYM";
2295 case 0x6ffffffc: return "VERDEF";
2296 case 0x7ffffffd: return "AUXILIARY";
2297 case 0x7fffffff: return "FILTER";
2298 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2299
2300 default:
2301 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2302 {
2303 const char *result;
2304
2305 switch (elf_header.e_machine)
2306 {
2307 case EM_MIPS:
2308 case EM_MIPS_RS3_LE:
2309 result = get_mips_section_type_name (sh_type);
2310 break;
2311 case EM_PARISC:
2312 result = get_parisc_section_type_name (sh_type);
2313 break;
2314 case EM_IA_64:
2315 result = get_ia64_section_type_name (sh_type);
2316 break;
2317 default:
2318 result = NULL;
2319 break;
2320 }
2321
2322 if (result != NULL)
2323 return result;
2324
2325 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2326 }
2327 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2328 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2329 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2330 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2331 else
2332 sprintf (buff, _("<unknown>: %x"), sh_type);
2333
2334 return buff;
2335 }
2336 }
2337
2338 #define OPTION_DEBUG_DUMP 512
2339
2340 struct option options[] =
2341 {
2342 {"all", no_argument, 0, 'a'},
2343 {"file-header", no_argument, 0, 'h'},
2344 {"program-headers", no_argument, 0, 'l'},
2345 {"headers", no_argument, 0, 'e'},
2346 {"histogram", no_argument, 0, 'I'},
2347 {"segments", no_argument, 0, 'l'},
2348 {"sections", no_argument, 0, 'S'},
2349 {"section-headers", no_argument, 0, 'S'},
2350 {"symbols", no_argument, 0, 's'},
2351 {"syms", no_argument, 0, 's'},
2352 {"relocs", no_argument, 0, 'r'},
2353 {"notes", no_argument, 0, 'n'},
2354 {"dynamic", no_argument, 0, 'd'},
2355 {"arch-specific", no_argument, 0, 'A'},
2356 {"version-info", no_argument, 0, 'V'},
2357 {"use-dynamic", no_argument, 0, 'D'},
2358 {"hex-dump", required_argument, 0, 'x'},
2359 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2360 {"unwind", no_argument, 0, 'u'},
2361 #ifdef SUPPORT_DISASSEMBLY
2362 {"instruction-dump", required_argument, 0, 'i'},
2363 #endif
2364
2365 {"version", no_argument, 0, 'v'},
2366 {"wide", no_argument, 0, 'W'},
2367 {"help", no_argument, 0, 'H'},
2368 {0, no_argument, 0, 0}
2369 };
2370
2371 static void
2372 usage (void)
2373 {
2374 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2375 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2376 fprintf (stdout, _(" Options are:\n\
2377 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2378 -h --file-header Display the ELF file header\n\
2379 -l --program-headers Display the program headers\n\
2380 --segments An alias for --program-headers\n\
2381 -S --section-headers Display the sections' header\n\
2382 --sections An alias for --section-headers\n\
2383 -e --headers Equivalent to: -h -l -S\n\
2384 -s --syms Display the symbol table\n\
2385 --symbols An alias for --syms\n\
2386 -n --notes Display the core notes (if present)\n\
2387 -r --relocs Display the relocations (if present)\n\
2388 -u --unwind Display the unwind info (if present)\n\
2389 -d --dynamic Display the dynamic segment (if present)\n\
2390 -V --version-info Display the version sections (if present)\n\
2391 -A --arch-specific Display architecture specific information (if any).\n\
2392 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2393 -x --hex-dump=<number> Dump the contents of section <number>\n\
2394 -w[liaprmfFso] or\n\
2395 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2396 Display the contents of DWARF2 debug sections\n"));
2397 #ifdef SUPPORT_DISASSEMBLY
2398 fprintf (stdout, _("\
2399 -i --instruction-dump=<number>\n\
2400 Disassemble the contents of section <number>\n"));
2401 #endif
2402 fprintf (stdout, _("\
2403 -I --histogram Display histogram of bucket list lengths\n\
2404 -W --wide Allow output width to exceed 80 characters\n\
2405 -H --help Display this information\n\
2406 -v --version Display the version number of readelf\n"));
2407 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2408
2409 exit (0);
2410 }
2411
2412 static void
2413 request_dump (unsigned int section, int type)
2414 {
2415 if (section >= num_dump_sects)
2416 {
2417 char *new_dump_sects;
2418
2419 new_dump_sects = calloc (section + 1, 1);
2420
2421 if (new_dump_sects == NULL)
2422 error (_("Out of memory allocating dump request table."));
2423 else
2424 {
2425 /* Copy current flag settings. */
2426 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2427
2428 free (dump_sects);
2429
2430 dump_sects = new_dump_sects;
2431 num_dump_sects = section + 1;
2432 }
2433 }
2434
2435 if (dump_sects)
2436 dump_sects[section] |= type;
2437
2438 return;
2439 }
2440
2441 static void
2442 parse_args (int argc, char **argv)
2443 {
2444 int c;
2445
2446 if (argc < 2)
2447 usage ();
2448
2449 while ((c = getopt_long
2450 (argc, argv, "ersuahnldSDAIw::x:i:vVWH", options, NULL)) != EOF)
2451 {
2452 char *cp;
2453 int section;
2454
2455 switch (c)
2456 {
2457 case 0:
2458 /* Long options. */
2459 break;
2460 case 'H':
2461 usage ();
2462 break;
2463
2464 case 'a':
2465 do_syms++;
2466 do_reloc++;
2467 do_unwind++;
2468 do_dynamic++;
2469 do_header++;
2470 do_sections++;
2471 do_segments++;
2472 do_version++;
2473 do_histogram++;
2474 do_arch++;
2475 do_notes++;
2476 break;
2477 case 'e':
2478 do_header++;
2479 do_sections++;
2480 do_segments++;
2481 break;
2482 case 'A':
2483 do_arch++;
2484 break;
2485 case 'D':
2486 do_using_dynamic++;
2487 break;
2488 case 'r':
2489 do_reloc++;
2490 break;
2491 case 'u':
2492 do_unwind++;
2493 break;
2494 case 'h':
2495 do_header++;
2496 break;
2497 case 'l':
2498 do_segments++;
2499 break;
2500 case 's':
2501 do_syms++;
2502 break;
2503 case 'S':
2504 do_sections++;
2505 break;
2506 case 'd':
2507 do_dynamic++;
2508 break;
2509 case 'I':
2510 do_histogram++;
2511 break;
2512 case 'n':
2513 do_notes++;
2514 break;
2515 case 'x':
2516 do_dump++;
2517 section = strtoul (optarg, & cp, 0);
2518 if (! *cp && section >= 0)
2519 {
2520 request_dump (section, HEX_DUMP);
2521 break;
2522 }
2523 goto oops;
2524 case 'w':
2525 do_dump++;
2526 if (optarg == 0)
2527 do_debugging = 1;
2528 else
2529 {
2530 unsigned int index = 0;
2531
2532 do_debugging = 0;
2533
2534 while (optarg[index])
2535 switch (optarg[index++])
2536 {
2537 case 'i':
2538 case 'I':
2539 do_debug_info = 1;
2540 break;
2541
2542 case 'a':
2543 case 'A':
2544 do_debug_abbrevs = 1;
2545 break;
2546
2547 case 'l':
2548 case 'L':
2549 do_debug_lines = 1;
2550 break;
2551
2552 case 'p':
2553 case 'P':
2554 do_debug_pubnames = 1;
2555 break;
2556
2557 case 'r':
2558 case 'R':
2559 do_debug_aranges = 1;
2560 break;
2561
2562 case 'F':
2563 do_debug_frames_interp = 1;
2564 case 'f':
2565 do_debug_frames = 1;
2566 break;
2567
2568 case 'm':
2569 case 'M':
2570 do_debug_macinfo = 1;
2571 break;
2572
2573 case 's':
2574 case 'S':
2575 do_debug_str = 1;
2576 break;
2577
2578 case 'o':
2579 case 'O':
2580 do_debug_loc = 1;
2581 break;
2582
2583 default:
2584 warn (_("Unrecognized debug option '%s'\n"), optarg);
2585 break;
2586 }
2587 }
2588 break;
2589 case OPTION_DEBUG_DUMP:
2590 do_dump++;
2591 if (optarg == 0)
2592 do_debugging = 1;
2593 else
2594 {
2595 static const char *debug_dump_opt[]
2596 = { "line", "info", "abbrev", "pubnames", "ranges",
2597 "macro", "frames", "frames-interp", "str", "loc", NULL };
2598 unsigned int index;
2599 const char *p;
2600
2601 do_debugging = 0;
2602
2603 p = optarg;
2604 while (*p)
2605 {
2606 for (index = 0; debug_dump_opt[index]; index++)
2607 {
2608 size_t len = strlen (debug_dump_opt[index]);
2609
2610 if (strncmp (p, debug_dump_opt[index], len) == 0
2611 && (p[len] == ',' || p[len] == '\0'))
2612 {
2613 switch (p[0])
2614 {
2615 case 'i':
2616 do_debug_info = 1;
2617 break;
2618
2619 case 'a':
2620 do_debug_abbrevs = 1;
2621 break;
2622
2623 case 'l':
2624 if (p[1] == 'i')
2625 do_debug_lines = 1;
2626 else
2627 do_debug_loc = 1;
2628 break;
2629
2630 case 'p':
2631 do_debug_pubnames = 1;
2632 break;
2633
2634 case 'r':
2635 do_debug_aranges = 1;
2636 break;
2637
2638 case 'f':
2639 if (len > 6)
2640 do_debug_frames_interp = 1;
2641 do_debug_frames = 1;
2642 break;
2643
2644 case 'm':
2645 do_debug_macinfo = 1;
2646 break;
2647
2648 case 's':
2649 do_debug_str = 1;
2650 break;
2651 }
2652
2653 p += len;
2654 break;
2655 }
2656 }
2657
2658 if (debug_dump_opt[index] == NULL)
2659 {
2660 warn (_("Unrecognized debug option '%s'\n"), p);
2661 p = strchr (p, ',');
2662 if (p == NULL)
2663 break;
2664 }
2665
2666 if (*p == ',')
2667 p++;
2668 }
2669 }
2670 break;
2671 #ifdef SUPPORT_DISASSEMBLY
2672 case 'i':
2673 do_dump++;
2674 section = strtoul (optarg, & cp, 0);
2675 if (! *cp && section >= 0)
2676 {
2677 request_dump (section, DISASS_DUMP);
2678 break;
2679 }
2680 goto oops;
2681 #endif
2682 case 'v':
2683 print_version (program_name);
2684 break;
2685 case 'V':
2686 do_version++;
2687 break;
2688 case 'W':
2689 do_wide++;
2690 break;
2691 default:
2692 oops:
2693 /* xgettext:c-format */
2694 error (_("Invalid option '-%c'\n"), c);
2695 /* Drop through. */
2696 case '?':
2697 usage ();
2698 }
2699 }
2700
2701 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2702 && !do_segments && !do_header && !do_dump && !do_version
2703 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2704 usage ();
2705 else if (argc < 3)
2706 {
2707 warn (_("Nothing to do.\n"));
2708 usage();
2709 }
2710 }
2711
2712 static const char *
2713 get_elf_class (unsigned int elf_class)
2714 {
2715 static char buff[32];
2716
2717 switch (elf_class)
2718 {
2719 case ELFCLASSNONE: return _("none");
2720 case ELFCLASS32: return "ELF32";
2721 case ELFCLASS64: return "ELF64";
2722 default:
2723 sprintf (buff, _("<unknown: %x>"), elf_class);
2724 return buff;
2725 }
2726 }
2727
2728 static const char *
2729 get_data_encoding (unsigned int encoding)
2730 {
2731 static char buff[32];
2732
2733 switch (encoding)
2734 {
2735 case ELFDATANONE: return _("none");
2736 case ELFDATA2LSB: return _("2's complement, little endian");
2737 case ELFDATA2MSB: return _("2's complement, big endian");
2738 default:
2739 sprintf (buff, _("<unknown: %x>"), encoding);
2740 return buff;
2741 }
2742 }
2743
2744 /* Decode the data held in 'elf_header'. */
2745
2746 static int
2747 process_file_header (void)
2748 {
2749 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
2750 || elf_header.e_ident[EI_MAG1] != ELFMAG1
2751 || elf_header.e_ident[EI_MAG2] != ELFMAG2
2752 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
2753 {
2754 error
2755 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2756 return 0;
2757 }
2758
2759 if (do_header)
2760 {
2761 int i;
2762
2763 printf (_("ELF Header:\n"));
2764 printf (_(" Magic: "));
2765 for (i = 0; i < EI_NIDENT; i++)
2766 printf ("%2.2x ", elf_header.e_ident[i]);
2767 printf ("\n");
2768 printf (_(" Class: %s\n"),
2769 get_elf_class (elf_header.e_ident[EI_CLASS]));
2770 printf (_(" Data: %s\n"),
2771 get_data_encoding (elf_header.e_ident[EI_DATA]));
2772 printf (_(" Version: %d %s\n"),
2773 elf_header.e_ident[EI_VERSION],
2774 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
2775 ? "(current)"
2776 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2777 ? "<unknown: %lx>"
2778 : "")));
2779 printf (_(" OS/ABI: %s\n"),
2780 get_osabi_name (elf_header.e_ident[EI_OSABI]));
2781 printf (_(" ABI Version: %d\n"),
2782 elf_header.e_ident[EI_ABIVERSION]);
2783 printf (_(" Type: %s\n"),
2784 get_file_type (elf_header.e_type));
2785 printf (_(" Machine: %s\n"),
2786 get_machine_name (elf_header.e_machine));
2787 printf (_(" Version: 0x%lx\n"),
2788 (unsigned long) elf_header.e_version);
2789
2790 printf (_(" Entry point address: "));
2791 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2792 printf (_("\n Start of program headers: "));
2793 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2794 printf (_(" (bytes into file)\n Start of section headers: "));
2795 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2796 printf (_(" (bytes into file)\n"));
2797
2798 printf (_(" Flags: 0x%lx%s\n"),
2799 (unsigned long) elf_header.e_flags,
2800 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2801 printf (_(" Size of this header: %ld (bytes)\n"),
2802 (long) elf_header.e_ehsize);
2803 printf (_(" Size of program headers: %ld (bytes)\n"),
2804 (long) elf_header.e_phentsize);
2805 printf (_(" Number of program headers: %ld\n"),
2806 (long) elf_header.e_phnum);
2807 printf (_(" Size of section headers: %ld (bytes)\n"),
2808 (long) elf_header.e_shentsize);
2809 printf (_(" Number of section headers: %ld"),
2810 (long) elf_header.e_shnum);
2811 if (section_headers != NULL && elf_header.e_shnum == 0)
2812 printf (" (%ld)", (long) section_headers[0].sh_size);
2813 putc ('\n', stdout);
2814 printf (_(" Section header string table index: %ld"),
2815 (long) elf_header.e_shstrndx);
2816 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2817 printf (" (%ld)", (long) section_headers[0].sh_link);
2818 putc ('\n', stdout);
2819 }
2820
2821 if (section_headers != NULL)
2822 {
2823 if (elf_header.e_shnum == 0)
2824 elf_header.e_shnum = section_headers[0].sh_size;
2825 if (elf_header.e_shstrndx == SHN_XINDEX)
2826 elf_header.e_shstrndx = section_headers[0].sh_link;
2827 free (section_headers);
2828 section_headers = NULL;
2829 }
2830
2831 return 1;
2832 }
2833
2834
2835 static int
2836 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
2837 {
2838 Elf32_External_Phdr *phdrs;
2839 Elf32_External_Phdr *external;
2840 Elf_Internal_Phdr *internal;
2841 unsigned int i;
2842
2843 phdrs = get_data (NULL, file, elf_header.e_phoff,
2844 elf_header.e_phentsize * elf_header.e_phnum,
2845 _("program headers"));
2846 if (!phdrs)
2847 return 0;
2848
2849 for (i = 0, internal = program_headers, external = phdrs;
2850 i < elf_header.e_phnum;
2851 i++, internal++, external++)
2852 {
2853 internal->p_type = BYTE_GET (external->p_type);
2854 internal->p_offset = BYTE_GET (external->p_offset);
2855 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2856 internal->p_paddr = BYTE_GET (external->p_paddr);
2857 internal->p_filesz = BYTE_GET (external->p_filesz);
2858 internal->p_memsz = BYTE_GET (external->p_memsz);
2859 internal->p_flags = BYTE_GET (external->p_flags);
2860 internal->p_align = BYTE_GET (external->p_align);
2861 }
2862
2863 free (phdrs);
2864
2865 return 1;
2866 }
2867
2868 static int
2869 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
2870 {
2871 Elf64_External_Phdr *phdrs;
2872 Elf64_External_Phdr *external;
2873 Elf_Internal_Phdr *internal;
2874 unsigned int i;
2875
2876 phdrs = get_data (NULL, file, elf_header.e_phoff,
2877 elf_header.e_phentsize * elf_header.e_phnum,
2878 _("program headers"));
2879 if (!phdrs)
2880 return 0;
2881
2882 for (i = 0, internal = program_headers, external = phdrs;
2883 i < elf_header.e_phnum;
2884 i++, internal++, external++)
2885 {
2886 internal->p_type = BYTE_GET (external->p_type);
2887 internal->p_flags = BYTE_GET (external->p_flags);
2888 internal->p_offset = BYTE_GET8 (external->p_offset);
2889 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2890 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2891 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2892 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2893 internal->p_align = BYTE_GET8 (external->p_align);
2894 }
2895
2896 free (phdrs);
2897
2898 return 1;
2899 }
2900
2901 /* Returns 1 if the program headers were read into `program_headers'. */
2902
2903 static int
2904 get_program_headers (FILE *file)
2905 {
2906 Elf_Internal_Phdr *phdrs;
2907
2908 /* Check cache of prior read. */
2909 if (program_headers != NULL)
2910 return 1;
2911
2912 phdrs = malloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2913
2914 if (phdrs == NULL)
2915 {
2916 error (_("Out of memory\n"));
2917 return 0;
2918 }
2919
2920 if (is_32bit_elf
2921 ? get_32bit_program_headers (file, phdrs)
2922 : get_64bit_program_headers (file, phdrs))
2923 {
2924 program_headers = phdrs;
2925 return 1;
2926 }
2927
2928 free (phdrs);
2929 return 0;
2930 }
2931
2932 /* Returns 1 if the program headers were loaded. */
2933
2934 static int
2935 process_program_headers (FILE *file)
2936 {
2937 Elf_Internal_Phdr *segment;
2938 unsigned int i;
2939
2940 if (elf_header.e_phnum == 0)
2941 {
2942 if (do_segments)
2943 printf (_("\nThere are no program headers in this file.\n"));
2944 return 0;
2945 }
2946
2947 if (do_segments && !do_header)
2948 {
2949 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2950 printf (_("Entry point "));
2951 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2952 printf (_("\nThere are %d program headers, starting at offset "),
2953 elf_header.e_phnum);
2954 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2955 printf ("\n");
2956 }
2957
2958 if (! get_program_headers (file))
2959 return 0;
2960
2961 if (do_segments)
2962 {
2963 if (elf_header.e_phnum > 1)
2964 printf (_("\nProgram Headers:\n"));
2965 else
2966 printf (_("\nProgram Headers:\n"));
2967
2968 if (is_32bit_elf)
2969 printf
2970 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2971 else if (do_wide)
2972 printf
2973 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2974 else
2975 {
2976 printf
2977 (_(" Type Offset VirtAddr PhysAddr\n"));
2978 printf
2979 (_(" FileSiz MemSiz Flags Align\n"));
2980 }
2981 }
2982
2983 dynamic_addr = 0;
2984 dynamic_size = 0;
2985
2986 for (i = 0, segment = program_headers;
2987 i < elf_header.e_phnum;
2988 i++, segment++)
2989 {
2990 if (do_segments)
2991 {
2992 printf (" %-14.14s ", get_segment_type (segment->p_type));
2993
2994 if (is_32bit_elf)
2995 {
2996 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2997 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2998 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2999 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3000 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3001 printf ("%c%c%c ",
3002 (segment->p_flags & PF_R ? 'R' : ' '),
3003 (segment->p_flags & PF_W ? 'W' : ' '),
3004 (segment->p_flags & PF_X ? 'E' : ' '));
3005 printf ("%#lx", (unsigned long) segment->p_align);
3006 }
3007 else if (do_wide)
3008 {
3009 if ((unsigned long) segment->p_offset == segment->p_offset)
3010 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3011 else
3012 {
3013 print_vma (segment->p_offset, FULL_HEX);
3014 putchar (' ');
3015 }
3016
3017 print_vma (segment->p_vaddr, FULL_HEX);
3018 putchar (' ');
3019 print_vma (segment->p_paddr, FULL_HEX);
3020 putchar (' ');
3021
3022 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3023 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3024 else
3025 {
3026 print_vma (segment->p_filesz, FULL_HEX);
3027 putchar (' ');
3028 }
3029
3030 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3031 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3032 else
3033 {
3034 print_vma (segment->p_offset, FULL_HEX);
3035 }
3036
3037 printf (" %c%c%c ",
3038 (segment->p_flags & PF_R ? 'R' : ' '),
3039 (segment->p_flags & PF_W ? 'W' : ' '),
3040 (segment->p_flags & PF_X ? 'E' : ' '));
3041
3042 if ((unsigned long) segment->p_align == segment->p_align)
3043 printf ("%#lx", (unsigned long) segment->p_align);
3044 else
3045 {
3046 print_vma (segment->p_align, PREFIX_HEX);
3047 }
3048 }
3049 else
3050 {
3051 print_vma (segment->p_offset, FULL_HEX);
3052 putchar (' ');
3053 print_vma (segment->p_vaddr, FULL_HEX);
3054 putchar (' ');
3055 print_vma (segment->p_paddr, FULL_HEX);
3056 printf ("\n ");
3057 print_vma (segment->p_filesz, FULL_HEX);
3058 putchar (' ');
3059 print_vma (segment->p_memsz, FULL_HEX);
3060 printf (" %c%c%c ",
3061 (segment->p_flags & PF_R ? 'R' : ' '),
3062 (segment->p_flags & PF_W ? 'W' : ' '),
3063 (segment->p_flags & PF_X ? 'E' : ' '));
3064 print_vma (segment->p_align, HEX);
3065 }
3066 }
3067
3068 switch (segment->p_type)
3069 {
3070 case PT_DYNAMIC:
3071 if (dynamic_addr)
3072 error (_("more than one dynamic segment\n"));
3073
3074 dynamic_addr = segment->p_offset;
3075 dynamic_size = segment->p_filesz;
3076 break;
3077
3078 case PT_INTERP:
3079 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3080 SEEK_SET))
3081 error (_("Unable to find program interpreter name\n"));
3082 else
3083 {
3084 program_interpreter[0] = 0;
3085 fscanf (file, "%63s", program_interpreter);
3086
3087 if (do_segments)
3088 printf (_("\n [Requesting program interpreter: %s]"),
3089 program_interpreter);
3090 }
3091 break;
3092 }
3093
3094 if (do_segments)
3095 putc ('\n', stdout);
3096 }
3097
3098 if (do_segments && section_headers != NULL)
3099 {
3100 printf (_("\n Section to Segment mapping:\n"));
3101 printf (_(" Segment Sections...\n"));
3102
3103 assert (string_table != NULL);
3104
3105 for (i = 0; i < elf_header.e_phnum; i++)
3106 {
3107 unsigned int j;
3108 Elf_Internal_Shdr *section;
3109
3110 segment = program_headers + i;
3111 section = section_headers;
3112
3113 printf (" %2.2d ", i);
3114
3115 for (j = 1; j < elf_header.e_shnum; j++, section++)
3116 {
3117 if (section->sh_size > 0
3118 /* Compare allocated sections by VMA, unallocated
3119 sections by file offset. */
3120 && (section->sh_flags & SHF_ALLOC
3121 ? (section->sh_addr >= segment->p_vaddr
3122 && section->sh_addr + section->sh_size
3123 <= segment->p_vaddr + segment->p_memsz)
3124 : ((bfd_vma) section->sh_offset >= segment->p_offset
3125 && (section->sh_offset + section->sh_size
3126 <= segment->p_offset + segment->p_filesz))))
3127 printf ("%s ", SECTION_NAME (section));
3128 }
3129
3130 putc ('\n',stdout);
3131 }
3132 }
3133
3134 return 1;
3135 }
3136
3137
3138 /* Find the file offset corresponding to VMA by using the program headers. */
3139
3140 static long
3141 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3142 {
3143 Elf_Internal_Phdr *seg;
3144
3145 if (! get_program_headers (file))
3146 {
3147 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3148 return (long) vma;
3149 }
3150
3151 for (seg = program_headers;
3152 seg < program_headers + elf_header.e_phnum;
3153 ++seg)
3154 {
3155 if (seg->p_type != PT_LOAD)
3156 continue;
3157
3158 if (vma >= (seg->p_vaddr & -seg->p_align)
3159 && vma + size <= seg->p_vaddr + seg->p_filesz)
3160 return vma - seg->p_vaddr + seg->p_offset;
3161 }
3162
3163 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3164 (long) vma);
3165 return (long) vma;
3166 }
3167
3168
3169 static int
3170 get_32bit_section_headers (FILE *file, unsigned int num)
3171 {
3172 Elf32_External_Shdr *shdrs;
3173 Elf_Internal_Shdr *internal;
3174 unsigned int i;
3175
3176 shdrs = get_data (NULL, file, elf_header.e_shoff,
3177 elf_header.e_shentsize * num, _("section headers"));
3178 if (!shdrs)
3179 return 0;
3180
3181 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3182
3183 if (section_headers == NULL)
3184 {
3185 error (_("Out of memory\n"));
3186 return 0;
3187 }
3188
3189 for (i = 0, internal = section_headers;
3190 i < num;
3191 i++, internal++)
3192 {
3193 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3194 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3195 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3196 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3197 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3198 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3199 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3200 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3201 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3202 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3203 }
3204
3205 free (shdrs);
3206
3207 return 1;
3208 }
3209
3210 static int
3211 get_64bit_section_headers (FILE *file, unsigned int num)
3212 {
3213 Elf64_External_Shdr *shdrs;
3214 Elf_Internal_Shdr *internal;
3215 unsigned int i;
3216
3217 shdrs = get_data (NULL, file, elf_header.e_shoff,
3218 elf_header.e_shentsize * num, _("section headers"));
3219 if (!shdrs)
3220 return 0;
3221
3222 section_headers = malloc (num * sizeof (Elf_Internal_Shdr));
3223
3224 if (section_headers == NULL)
3225 {
3226 error (_("Out of memory\n"));
3227 return 0;
3228 }
3229
3230 for (i = 0, internal = section_headers;
3231 i < num;
3232 i++, internal++)
3233 {
3234 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3235 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3236 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3237 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3238 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3239 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3240 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3241 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3242 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3243 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3244 }
3245
3246 free (shdrs);
3247
3248 return 1;
3249 }
3250
3251 static Elf_Internal_Sym *
3252 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3253 {
3254 unsigned long number;
3255 Elf32_External_Sym *esyms;
3256 Elf_External_Sym_Shndx *shndx;
3257 Elf_Internal_Sym *isyms;
3258 Elf_Internal_Sym *psym;
3259 unsigned int j;
3260
3261 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3262 _("symbols"));
3263 if (!esyms)
3264 return NULL;
3265
3266 shndx = NULL;
3267 if (symtab_shndx_hdr != NULL
3268 && (symtab_shndx_hdr->sh_link
3269 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3270 {
3271 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3272 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3273 if (!shndx)
3274 {
3275 free (esyms);
3276 return NULL;
3277 }
3278 }
3279
3280 number = section->sh_size / section->sh_entsize;
3281 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3282
3283 if (isyms == NULL)
3284 {
3285 error (_("Out of memory\n"));
3286 if (shndx)
3287 free (shndx);
3288 free (esyms);
3289 return NULL;
3290 }
3291
3292 for (j = 0, psym = isyms;
3293 j < number;
3294 j++, psym++)
3295 {
3296 psym->st_name = BYTE_GET (esyms[j].st_name);
3297 psym->st_value = BYTE_GET (esyms[j].st_value);
3298 psym->st_size = BYTE_GET (esyms[j].st_size);
3299 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3300 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3301 psym->st_shndx
3302 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3303 psym->st_info = BYTE_GET (esyms[j].st_info);
3304 psym->st_other = BYTE_GET (esyms[j].st_other);
3305 }
3306
3307 if (shndx)
3308 free (shndx);
3309 free (esyms);
3310
3311 return isyms;
3312 }
3313
3314 static Elf_Internal_Sym *
3315 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3316 {
3317 unsigned long number;
3318 Elf64_External_Sym *esyms;
3319 Elf_External_Sym_Shndx *shndx;
3320 Elf_Internal_Sym *isyms;
3321 Elf_Internal_Sym *psym;
3322 unsigned int j;
3323
3324 esyms = get_data (NULL, file, section->sh_offset, section->sh_size,
3325 _("symbols"));
3326 if (!esyms)
3327 return NULL;
3328
3329 shndx = NULL;
3330 if (symtab_shndx_hdr != NULL
3331 && (symtab_shndx_hdr->sh_link
3332 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3333 {
3334 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3335 symtab_shndx_hdr->sh_size, _("symtab shndx"));
3336 if (!shndx)
3337 {
3338 free (esyms);
3339 return NULL;
3340 }
3341 }
3342
3343 number = section->sh_size / section->sh_entsize;
3344 isyms = malloc (number * sizeof (Elf_Internal_Sym));
3345
3346 if (isyms == NULL)
3347 {
3348 error (_("Out of memory\n"));
3349 if (shndx)
3350 free (shndx);
3351 free (esyms);
3352 return NULL;
3353 }
3354
3355 for (j = 0, psym = isyms;
3356 j < number;
3357 j++, psym++)
3358 {
3359 psym->st_name = BYTE_GET (esyms[j].st_name);
3360 psym->st_info = BYTE_GET (esyms[j].st_info);
3361 psym->st_other = BYTE_GET (esyms[j].st_other);
3362 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3363 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3364 psym->st_shndx
3365 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3366 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3367 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3368 }
3369
3370 if (shndx)
3371 free (shndx);
3372 free (esyms);
3373
3374 return isyms;
3375 }
3376
3377 static const char *
3378 get_elf_section_flags (bfd_vma sh_flags)
3379 {
3380 static char buff[32];
3381
3382 *buff = 0;
3383
3384 while (sh_flags)
3385 {
3386 bfd_vma flag;
3387
3388 flag = sh_flags & - sh_flags;
3389 sh_flags &= ~ flag;
3390
3391 switch (flag)
3392 {
3393 case SHF_WRITE: strcat (buff, "W"); break;
3394 case SHF_ALLOC: strcat (buff, "A"); break;
3395 case SHF_EXECINSTR: strcat (buff, "X"); break;
3396 case SHF_MERGE: strcat (buff, "M"); break;
3397 case SHF_STRINGS: strcat (buff, "S"); break;
3398 case SHF_INFO_LINK: strcat (buff, "I"); break;
3399 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3400 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3401 case SHF_GROUP: strcat (buff, "G"); break;
3402 case SHF_TLS: strcat (buff, "T"); break;
3403
3404 default:
3405 if (flag & SHF_MASKOS)
3406 {
3407 strcat (buff, "o");
3408 sh_flags &= ~ SHF_MASKOS;
3409 }
3410 else if (flag & SHF_MASKPROC)
3411 {
3412 strcat (buff, "p");
3413 sh_flags &= ~ SHF_MASKPROC;
3414 }
3415 else
3416 strcat (buff, "x");
3417 break;
3418 }
3419 }
3420
3421 return buff;
3422 }
3423
3424 static int
3425 process_section_headers (FILE *file)
3426 {
3427 Elf_Internal_Shdr *section;
3428 unsigned int i;
3429
3430 section_headers = NULL;
3431
3432 if (elf_header.e_shnum == 0)
3433 {
3434 if (do_sections)
3435 printf (_("\nThere are no sections in this file.\n"));
3436
3437 return 1;
3438 }
3439
3440 if (do_sections && !do_header)
3441 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3442 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3443
3444 if (is_32bit_elf)
3445 {
3446 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3447 return 0;
3448 }
3449 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3450 return 0;
3451
3452 /* Read in the string table, so that we have names to display. */
3453 section = SECTION_HEADER (elf_header.e_shstrndx);
3454
3455 if (section->sh_size != 0)
3456 {
3457 string_table = get_data (NULL, file, section->sh_offset,
3458 section->sh_size, _("string table"));
3459
3460 if (string_table == NULL)
3461 return 0;
3462
3463 string_table_length = section->sh_size;
3464 }
3465
3466 /* Scan the sections for the dynamic symbol table
3467 and dynamic string table and debug sections. */
3468 dynamic_symbols = NULL;
3469 dynamic_strings = NULL;
3470 dynamic_syminfo = NULL;
3471 symtab_shndx_hdr = NULL;
3472
3473 for (i = 0, section = section_headers;
3474 i < elf_header.e_shnum;
3475 i++, section++)
3476 {
3477 char *name = SECTION_NAME (section);
3478
3479 if (section->sh_type == SHT_DYNSYM)
3480 {
3481 if (dynamic_symbols != NULL)
3482 {
3483 error (_("File contains multiple dynamic symbol tables\n"));
3484 continue;
3485 }
3486
3487 num_dynamic_syms = section->sh_size / section->sh_entsize;
3488 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3489 }
3490 else if (section->sh_type == SHT_STRTAB
3491 && strcmp (name, ".dynstr") == 0)
3492 {
3493 if (dynamic_strings != NULL)
3494 {
3495 error (_("File contains multiple dynamic string tables\n"));
3496 continue;
3497 }
3498
3499 dynamic_strings = get_data (NULL, file, section->sh_offset,
3500 section->sh_size, _("dynamic strings"));
3501 }
3502 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3503 {
3504 if (symtab_shndx_hdr != NULL)
3505 {
3506 error (_("File contains multiple symtab shndx tables\n"));
3507 continue;
3508 }
3509 symtab_shndx_hdr = section;
3510 }
3511 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3512 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3513 || do_debug_frames || do_debug_macinfo || do_debug_str
3514 || do_debug_loc)
3515 && strncmp (name, ".debug_", 7) == 0)
3516 {
3517 name += 7;
3518
3519 if (do_debugging
3520 || (do_debug_info && (strcmp (name, "info") == 0))
3521 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3522 || (do_debug_lines && (strcmp (name, "line") == 0))
3523 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3524 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3525 || (do_debug_frames && (strcmp (name, "frame") == 0))
3526 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3527 || (do_debug_str && (strcmp (name, "str") == 0))
3528 || (do_debug_loc && (strcmp (name, "loc") == 0))
3529 )
3530 request_dump (i, DEBUG_DUMP);
3531 }
3532 /* linkonce section to be combined with .debug_info at link time. */
3533 else if ((do_debugging || do_debug_info)
3534 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3535 request_dump (i, DEBUG_DUMP);
3536 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3537 request_dump (i, DEBUG_DUMP);
3538 }
3539
3540 if (! do_sections)
3541 return 1;
3542
3543 if (elf_header.e_shnum > 1)
3544 printf (_("\nSection Headers:\n"));
3545 else
3546 printf (_("\nSection Header:\n"));
3547
3548 if (is_32bit_elf)
3549 printf
3550 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3551 else if (do_wide)
3552 printf
3553 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3554 else
3555 {
3556 printf (_(" [Nr] Name Type Address Offset\n"));
3557 printf (_(" Size EntSize Flags Link Info Align\n"));
3558 }
3559
3560 for (i = 0, section = section_headers;
3561 i < elf_header.e_shnum;
3562 i++, section++)
3563 {
3564 printf (" [%2u] %-17.17s %-15.15s ",
3565 SECTION_HEADER_NUM (i),
3566 SECTION_NAME (section),
3567 get_section_type_name (section->sh_type));
3568
3569 if (is_32bit_elf)
3570 {
3571 print_vma (section->sh_addr, LONG_HEX);
3572
3573 printf ( " %6.6lx %6.6lx %2.2lx",
3574 (unsigned long) section->sh_offset,
3575 (unsigned long) section->sh_size,
3576 (unsigned long) section->sh_entsize);
3577
3578 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3579
3580 printf ("%2ld %3lx %2ld\n",
3581 (unsigned long) section->sh_link,
3582 (unsigned long) section->sh_info,
3583 (unsigned long) section->sh_addralign);
3584 }
3585 else if (do_wide)
3586 {
3587 print_vma (section->sh_addr, LONG_HEX);
3588
3589 if ((long) section->sh_offset == section->sh_offset)
3590 printf (" %6.6lx", (unsigned long) section->sh_offset);
3591 else
3592 {
3593 putchar (' ');
3594 print_vma (section->sh_offset, LONG_HEX);
3595 }
3596
3597 if ((unsigned long) section->sh_size == section->sh_size)
3598 printf (" %6.6lx", (unsigned long) section->sh_size);
3599 else
3600 {
3601 putchar (' ');
3602 print_vma (section->sh_size, LONG_HEX);
3603 }
3604
3605 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3606 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3607 else
3608 {
3609 putchar (' ');
3610 print_vma (section->sh_entsize, LONG_HEX);
3611 }
3612
3613 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3614
3615 printf ("%2ld %3lx ",
3616 (unsigned long) section->sh_link,
3617 (unsigned long) section->sh_info);
3618
3619 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3620 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3621 else
3622 {
3623 print_vma (section->sh_addralign, DEC);
3624 putchar ('\n');
3625 }
3626 }
3627 else
3628 {
3629 putchar (' ');
3630 print_vma (section->sh_addr, LONG_HEX);
3631 if ((long) section->sh_offset == section->sh_offset)
3632 printf (" %8.8lx", (unsigned long) section->sh_offset);
3633 else
3634 {
3635 printf (" ");
3636 print_vma (section->sh_offset, LONG_HEX);
3637 }
3638 printf ("\n ");
3639 print_vma (section->sh_size, LONG_HEX);
3640 printf (" ");
3641 print_vma (section->sh_entsize, LONG_HEX);
3642
3643 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3644
3645 printf (" %2ld %3lx %ld\n",
3646 (unsigned long) section->sh_link,
3647 (unsigned long) section->sh_info,
3648 (unsigned long) section->sh_addralign);
3649 }
3650 }
3651
3652 printf (_("Key to Flags:\n\
3653 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3654 I (info), L (link order), G (group), x (unknown)\n\
3655 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3656
3657 return 1;
3658 }
3659
3660 struct
3661 {
3662 const char *name;
3663 int reloc;
3664 int size;
3665 int rela;
3666 } dynamic_relocations [] =
3667 {
3668 { "REL", DT_REL, DT_RELSZ, FALSE },
3669 { "RELA", DT_RELA, DT_RELASZ, TRUE },
3670 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
3671 };
3672
3673 /* Process the reloc section. */
3674 static int
3675 process_relocs (FILE *file)
3676 {
3677 unsigned long rel_size;
3678 unsigned long rel_offset;
3679
3680
3681 if (!do_reloc)
3682 return 1;
3683
3684 if (do_using_dynamic)
3685 {
3686 int is_rela;
3687 const char *name;
3688 int has_dynamic_reloc;
3689 unsigned int i;
3690
3691 has_dynamic_reloc = 0;
3692
3693 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
3694 {
3695 is_rela = dynamic_relocations [i].rela;
3696 name = dynamic_relocations [i].name;
3697 rel_size = dynamic_info [dynamic_relocations [i].size];
3698 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
3699
3700 has_dynamic_reloc |= rel_size;
3701
3702 if (is_rela == UNKNOWN)
3703 {
3704 if (dynamic_relocations [i].reloc == DT_JMPREL)
3705 switch (dynamic_info[DT_PLTREL])
3706 {
3707 case DT_REL:
3708 is_rela = FALSE;
3709 break;
3710 case DT_RELA:
3711 is_rela = TRUE;
3712 break;
3713 }
3714 }
3715
3716 if (rel_size)
3717 {
3718 printf
3719 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
3720 name, rel_offset, rel_size);
3721
3722 dump_relocations (file,
3723 offset_from_vma (file, rel_offset, rel_size),
3724 rel_size,
3725 dynamic_symbols, num_dynamic_syms,
3726 dynamic_strings, is_rela);
3727 }
3728 }
3729
3730 if (! has_dynamic_reloc)
3731 printf (_("\nThere are no dynamic relocations in this file.\n"));
3732 }
3733 else
3734 {
3735 Elf_Internal_Shdr *section;
3736 unsigned long i;
3737 int found = 0;
3738
3739 for (i = 0, section = section_headers;
3740 i < elf_header.e_shnum;
3741 i++, section++)
3742 {
3743 if ( section->sh_type != SHT_RELA
3744 && section->sh_type != SHT_REL)
3745 continue;
3746
3747 rel_offset = section->sh_offset;
3748 rel_size = section->sh_size;
3749
3750 if (rel_size)
3751 {
3752 Elf_Internal_Shdr *strsec;
3753 Elf_Internal_Sym *symtab;
3754 char *strtab;
3755 int is_rela;
3756 unsigned long nsyms;
3757
3758 printf (_("\nRelocation section "));
3759
3760 if (string_table == NULL)
3761 printf ("%d", section->sh_name);
3762 else
3763 printf (_("'%s'"), SECTION_NAME (section));
3764
3765 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3766 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3767
3768 symtab = NULL;
3769 strtab = NULL;
3770 nsyms = 0;
3771 if (section->sh_link)
3772 {
3773 Elf_Internal_Shdr *symsec;
3774
3775 symsec = SECTION_HEADER (section->sh_link);
3776 nsyms = symsec->sh_size / symsec->sh_entsize;
3777 symtab = GET_ELF_SYMBOLS (file, symsec);
3778
3779 if (symtab == NULL)
3780 continue;
3781
3782 strsec = SECTION_HEADER (symsec->sh_link);
3783
3784 strtab = get_data (NULL, file, strsec->sh_offset,
3785 strsec->sh_size, _("string table"));
3786 }
3787 is_rela = section->sh_type == SHT_RELA;
3788
3789 dump_relocations (file, rel_offset, rel_size,
3790 symtab, nsyms, strtab, is_rela);
3791
3792 if (strtab)
3793 free (strtab);
3794 if (symtab)
3795 free (symtab);
3796
3797 found = 1;
3798 }
3799 }
3800
3801 if (! found)
3802 printf (_("\nThere are no relocations in this file.\n"));
3803 }
3804
3805 return 1;
3806 }
3807
3808 #include "unwind-ia64.h"
3809
3810 /* An absolute address consists of a section and an offset. If the
3811 section is NULL, the offset itself is the address, otherwise, the
3812 address equals to LOAD_ADDRESS(section) + offset. */
3813
3814 struct absaddr
3815 {
3816 unsigned short section;
3817 bfd_vma offset;
3818 };
3819
3820 struct unw_aux_info
3821 {
3822 struct unw_table_entry
3823 {
3824 struct absaddr start;
3825 struct absaddr end;
3826 struct absaddr info;
3827 }
3828 *table; /* Unwind table. */
3829 unsigned long table_len; /* Length of unwind table. */
3830 unsigned char *info; /* Unwind info. */
3831 unsigned long info_size; /* Size of unwind info. */
3832 bfd_vma info_addr; /* starting address of unwind info. */
3833 bfd_vma seg_base; /* Starting address of segment. */
3834 Elf_Internal_Sym *symtab; /* The symbol table. */
3835 unsigned long nsyms; /* Number of symbols. */
3836 char *strtab; /* The string table. */
3837 unsigned long strtab_size; /* Size of string table. */
3838 };
3839
3840 static void
3841 find_symbol_for_address (struct unw_aux_info *aux,
3842 struct absaddr addr,
3843 const char **symname,
3844 bfd_vma *offset)
3845 {
3846 bfd_vma dist = 0x100000;
3847 Elf_Internal_Sym *sym, *best = NULL;
3848 unsigned long i;
3849
3850 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3851 {
3852 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3853 && sym->st_name != 0
3854 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3855 && addr.offset >= sym->st_value
3856 && addr.offset - sym->st_value < dist)
3857 {
3858 best = sym;
3859 dist = addr.offset - sym->st_value;
3860 if (!dist)
3861 break;
3862 }
3863 }
3864 if (best)
3865 {
3866 *symname = (best->st_name >= aux->strtab_size
3867 ? "<corrupt>" : aux->strtab + best->st_name);
3868 *offset = dist;
3869 return;
3870 }
3871 *symname = NULL;
3872 *offset = addr.offset;
3873 }
3874
3875 static void
3876 dump_ia64_unwind (struct unw_aux_info *aux)
3877 {
3878 bfd_vma addr_size;
3879 struct unw_table_entry *tp;
3880 int in_body;
3881
3882 addr_size = is_32bit_elf ? 4 : 8;
3883
3884 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3885 {
3886 bfd_vma stamp;
3887 bfd_vma offset;
3888 const unsigned char *dp;
3889 const unsigned char *head;
3890 const char *procname;
3891
3892 find_symbol_for_address (aux, tp->start, &procname, &offset);
3893
3894 fputs ("\n<", stdout);
3895
3896 if (procname)
3897 {
3898 fputs (procname, stdout);
3899
3900 if (offset)
3901 printf ("+%lx", (unsigned long) offset);
3902 }
3903
3904 fputs (">: [", stdout);
3905 print_vma (tp->start.offset, PREFIX_HEX);
3906 fputc ('-', stdout);
3907 print_vma (tp->end.offset, PREFIX_HEX);
3908 printf ("], info at +0x%lx\n",
3909 (unsigned long) (tp->info.offset - aux->seg_base));
3910
3911 head = aux->info + (tp->info.offset - aux->info_addr);
3912 stamp = BYTE_GET8 ((unsigned char *) head);
3913
3914 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3915 (unsigned) UNW_VER (stamp),
3916 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3917 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3918 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3919 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3920
3921 if (UNW_VER (stamp) != 1)
3922 {
3923 printf ("\tUnknown version.\n");
3924 continue;
3925 }
3926
3927 in_body = 0;
3928 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3929 dp = unw_decode (dp, in_body, & in_body);
3930 }
3931 }
3932
3933 static int
3934 slurp_ia64_unwind_table (FILE *file,
3935 struct unw_aux_info *aux,
3936 Elf_Internal_Shdr *sec)
3937 {
3938 unsigned long size, addr_size, nrelas, i;
3939 Elf_Internal_Phdr *seg;
3940 struct unw_table_entry *tep;
3941 Elf_Internal_Shdr *relsec;
3942 Elf_Internal_Rela *rela, *rp;
3943 unsigned char *table, *tp;
3944 Elf_Internal_Sym *sym;
3945 const char *relname;
3946
3947 addr_size = is_32bit_elf ? 4 : 8;
3948
3949 /* First, find the starting address of the segment that includes
3950 this section: */
3951
3952 if (elf_header.e_phnum)
3953 {
3954 if (! get_program_headers (file))
3955 return 0;
3956
3957 for (seg = program_headers;
3958 seg < program_headers + elf_header.e_phnum;
3959 ++seg)
3960 {
3961 if (seg->p_type != PT_LOAD)
3962 continue;
3963
3964 if (sec->sh_addr >= seg->p_vaddr
3965 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3966 {
3967 aux->seg_base = seg->p_vaddr;
3968 break;
3969 }
3970 }
3971 }
3972
3973 /* Second, build the unwind table from the contents of the unwind section: */
3974 size = sec->sh_size;
3975 table = get_data (NULL, file, sec->sh_offset, size, _("unwind table"));
3976 if (!table)
3977 return 0;
3978
3979 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3980 for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
3981 {
3982 tep->start.section = SHN_UNDEF;
3983 tep->end.section = SHN_UNDEF;
3984 tep->info.section = SHN_UNDEF;
3985 if (is_32bit_elf)
3986 {
3987 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3988 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3989 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3990 }
3991 else
3992 {
3993 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3994 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3995 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3996 }
3997 tep->start.offset += aux->seg_base;
3998 tep->end.offset += aux->seg_base;
3999 tep->info.offset += aux->seg_base;
4000 }
4001 free (table);
4002
4003 /* Third, apply any relocations to the unwind table: */
4004
4005 for (relsec = section_headers;
4006 relsec < section_headers + elf_header.e_shnum;
4007 ++relsec)
4008 {
4009 if (relsec->sh_type != SHT_RELA
4010 || SECTION_HEADER (relsec->sh_info) != sec)
4011 continue;
4012
4013 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4014 & rela, & nrelas))
4015 return 0;
4016
4017 for (rp = rela; rp < rela + nrelas; ++rp)
4018 {
4019 if (is_32bit_elf)
4020 {
4021 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4022 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4023
4024 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
4025 {
4026 warn (_("Skipping unexpected symbol type %u\n"),
4027 ELF32_ST_TYPE (sym->st_info));
4028 continue;
4029 }
4030 }
4031 else
4032 {
4033 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4034 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4035
4036 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
4037 {
4038 warn (_("Skipping unexpected symbol type %u\n"),
4039 ELF64_ST_TYPE (sym->st_info));
4040 continue;
4041 }
4042 }
4043
4044 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4045 {
4046 warn (_("Skipping unexpected relocation type %s\n"), relname);
4047 continue;
4048 }
4049
4050 i = rp->r_offset / (3 * addr_size);
4051
4052 switch (rp->r_offset/addr_size % 3)
4053 {
4054 case 0:
4055 aux->table[i].start.section = sym->st_shndx;
4056 aux->table[i].start.offset += rp->r_addend;
4057 break;
4058 case 1:
4059 aux->table[i].end.section = sym->st_shndx;
4060 aux->table[i].end.offset += rp->r_addend;
4061 break;
4062 case 2:
4063 aux->table[i].info.section = sym->st_shndx;
4064 aux->table[i].info.offset += rp->r_addend;
4065 break;
4066 default:
4067 break;
4068 }
4069 }
4070
4071 free (rela);
4072 }
4073
4074 aux->table_len = size / (3 * addr_size);
4075 return 1;
4076 }
4077
4078 static int
4079 process_unwind (FILE *file)
4080 {
4081 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4082 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4083 struct unw_aux_info aux;
4084
4085 if (!do_unwind)
4086 return 1;
4087
4088 if (elf_header.e_machine != EM_IA_64)
4089 {
4090 printf (_("\nThere are no unwind sections in this file.\n"));
4091 return 1;
4092 }
4093
4094 memset (& aux, 0, sizeof (aux));
4095
4096 addr_size = is_32bit_elf ? 4 : 8;
4097
4098 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4099 {
4100 if (sec->sh_type == SHT_SYMTAB)
4101 {
4102 aux.nsyms = sec->sh_size / sec->sh_entsize;
4103 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4104
4105 strsec = SECTION_HEADER (sec->sh_link);
4106 aux.strtab_size = strsec->sh_size;
4107 aux.strtab = get_data (NULL, file, strsec->sh_offset,
4108 aux.strtab_size, _("string table"));
4109 }
4110 else if (sec->sh_type == SHT_IA_64_UNWIND)
4111 unwcount++;
4112 }
4113
4114 if (!unwcount)
4115 printf (_("\nThere are no unwind sections in this file.\n"));
4116
4117 while (unwcount-- > 0)
4118 {
4119 char *suffix;
4120 size_t len, len2;
4121
4122 for (i = unwstart, sec = section_headers + unwstart;
4123 i < elf_header.e_shnum; ++i, ++sec)
4124 if (sec->sh_type == SHT_IA_64_UNWIND)
4125 {
4126 unwsec = sec;
4127 break;
4128 }
4129
4130 unwstart = i + 1;
4131 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4132
4133 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4134 len) == 0)
4135 {
4136 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4137 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4138 suffix = SECTION_NAME (unwsec) + len;
4139 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4140 ++i, ++sec)
4141 if (strncmp (SECTION_NAME (sec),
4142 ELF_STRING_ia64_unwind_info_once, len2) == 0
4143 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4144 break;
4145 }
4146 else
4147 {
4148 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4149 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4150 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4151 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4152 suffix = "";
4153 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4154 len) == 0)
4155 suffix = SECTION_NAME (unwsec) + len;
4156 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4157 ++i, ++sec)
4158 if (strncmp (SECTION_NAME (sec),
4159 ELF_STRING_ia64_unwind_info, len2) == 0
4160 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4161 break;
4162 }
4163
4164 if (i == elf_header.e_shnum)
4165 {
4166 printf (_("\nCould not find unwind info section for "));
4167
4168 if (string_table == NULL)
4169 printf ("%d", unwsec->sh_name);
4170 else
4171 printf (_("'%s'"), SECTION_NAME (unwsec));
4172 }
4173 else
4174 {
4175 aux.info_size = sec->sh_size;
4176 aux.info_addr = sec->sh_addr;
4177 aux.info = get_data (NULL, file, sec->sh_offset, aux.info_size,
4178 _("unwind info"));
4179
4180 printf (_("\nUnwind section "));
4181
4182 if (string_table == NULL)
4183 printf ("%d", unwsec->sh_name);
4184 else
4185 printf (_("'%s'"), SECTION_NAME (unwsec));
4186
4187 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4188 (unsigned long) unwsec->sh_offset,
4189 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4190
4191 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4192
4193 if (aux.table_len > 0)
4194 dump_ia64_unwind (& aux);
4195
4196 if (aux.table)
4197 free ((char *) aux.table);
4198 if (aux.info)
4199 free ((char *) aux.info);
4200 aux.table = NULL;
4201 aux.info = NULL;
4202 }
4203 }
4204
4205 if (aux.symtab)
4206 free (aux.symtab);
4207 if (aux.strtab)
4208 free ((char *) aux.strtab);
4209
4210 return 1;
4211 }
4212
4213 static void
4214 dynamic_segment_mips_val (Elf_Internal_Dyn *entry)
4215 {
4216 switch (entry->d_tag)
4217 {
4218 case DT_MIPS_FLAGS:
4219 if (entry->d_un.d_val == 0)
4220 printf ("NONE\n");
4221 else
4222 {
4223 static const char * opts[] =
4224 {
4225 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4226 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4227 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4228 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4229 "RLD_ORDER_SAFE"
4230 };
4231 unsigned int cnt;
4232 int first = 1;
4233 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
4234 if (entry->d_un.d_val & (1 << cnt))
4235 {
4236 printf ("%s%s", first ? "" : " ", opts[cnt]);
4237 first = 0;
4238 }
4239 puts ("");
4240 }
4241 break;
4242
4243 case DT_MIPS_IVERSION:
4244 if (dynamic_strings != NULL)
4245 printf ("Interface Version: %s\n",
4246 dynamic_strings + entry->d_un.d_val);
4247 else
4248 printf ("%ld\n", (long) entry->d_un.d_ptr);
4249 break;
4250
4251 case DT_MIPS_TIME_STAMP:
4252 {
4253 char timebuf[20];
4254 struct tm *tmp;
4255
4256 time_t time = entry->d_un.d_val;
4257 tmp = gmtime (&time);
4258 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4259 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4260 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4261 printf ("Time Stamp: %s\n", timebuf);
4262 }
4263 break;
4264
4265 case DT_MIPS_RLD_VERSION:
4266 case DT_MIPS_LOCAL_GOTNO:
4267 case DT_MIPS_CONFLICTNO:
4268 case DT_MIPS_LIBLISTNO:
4269 case DT_MIPS_SYMTABNO:
4270 case DT_MIPS_UNREFEXTNO:
4271 case DT_MIPS_HIPAGENO:
4272 case DT_MIPS_DELTA_CLASS_NO:
4273 case DT_MIPS_DELTA_INSTANCE_NO:
4274 case DT_MIPS_DELTA_RELOC_NO:
4275 case DT_MIPS_DELTA_SYM_NO:
4276 case DT_MIPS_DELTA_CLASSSYM_NO:
4277 case DT_MIPS_COMPACT_SIZE:
4278 printf ("%ld\n", (long) entry->d_un.d_ptr);
4279 break;
4280
4281 default:
4282 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4283 }
4284 }
4285
4286
4287 static void
4288 dynamic_segment_parisc_val (Elf_Internal_Dyn *entry)
4289 {
4290 switch (entry->d_tag)
4291 {
4292 case DT_HP_DLD_FLAGS:
4293 {
4294 static struct
4295 {
4296 long int bit;
4297 const char *str;
4298 }
4299 flags[] =
4300 {
4301 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4302 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4303 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4304 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4305 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4306 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4307 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4308 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4309 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4310 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4311 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4312 };
4313 int first = 1;
4314 size_t cnt;
4315 bfd_vma val = entry->d_un.d_val;
4316
4317 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4318 if (val & flags[cnt].bit)
4319 {
4320 if (! first)
4321 putchar (' ');
4322 fputs (flags[cnt].str, stdout);
4323 first = 0;
4324 val ^= flags[cnt].bit;
4325 }
4326
4327 if (val != 0 || first)
4328 {
4329 if (! first)
4330 putchar (' ');
4331 print_vma (val, HEX);
4332 }
4333 }
4334 break;
4335
4336 default:
4337 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4338 break;
4339 }
4340 putchar ('\n');
4341 }
4342
4343 static void
4344 dynamic_segment_ia64_val (Elf_Internal_Dyn *entry)
4345 {
4346 switch (entry->d_tag)
4347 {
4348 case DT_IA_64_PLT_RESERVE:
4349 /* First 3 slots reserved. */
4350 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4351 printf (" -- ");
4352 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
4353 break;
4354
4355 default:
4356 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4357 break;
4358 }
4359 putchar ('\n');
4360 }
4361
4362 static int
4363 get_32bit_dynamic_segment (FILE *file)
4364 {
4365 Elf32_External_Dyn *edyn;
4366 Elf_Internal_Dyn *entry;
4367 bfd_size_type i;
4368
4369 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4370 _("dynamic segment"));
4371 if (!edyn)
4372 return 0;
4373
4374 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4375 how large this .dynamic is now. We can do this even before the byte
4376 swapping since the DT_NULL tag is recognizable. */
4377 dynamic_size = 0;
4378 while (*(Elf32_Word *) edyn[dynamic_size++].d_tag != DT_NULL)
4379 ;
4380
4381 dynamic_segment = malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4382
4383 if (dynamic_segment == NULL)
4384 {
4385 error (_("Out of memory\n"));
4386 free (edyn);
4387 return 0;
4388 }
4389
4390 for (i = 0, entry = dynamic_segment;
4391 i < dynamic_size;
4392 i++, entry++)
4393 {
4394 entry->d_tag = BYTE_GET (edyn[i].d_tag);
4395 entry->d_un.d_val = BYTE_GET (edyn[i].d_un.d_val);
4396 }
4397
4398 free (edyn);
4399
4400 return 1;
4401 }
4402
4403 static int
4404 get_64bit_dynamic_segment (FILE *file)
4405 {
4406 Elf64_External_Dyn *edyn;
4407 Elf_Internal_Dyn *entry;
4408 bfd_size_type i;
4409
4410 edyn = get_data (NULL, file, dynamic_addr, dynamic_size,
4411 _("dynamic segment"));
4412 if (!edyn)
4413 return 0;
4414
4415 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4416 how large this .dynamic is now. We can do this even before the byte
4417 swapping since the DT_NULL tag is recognizable. */
4418 dynamic_size = 0;
4419 while (*(bfd_vma *) edyn[dynamic_size++].d_tag != DT_NULL)
4420 ;
4421
4422 dynamic_segment = malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4423
4424 if (dynamic_segment == NULL)
4425 {
4426 error (_("Out of memory\n"));
4427 free (edyn);
4428 return 0;
4429 }
4430
4431 for (i = 0, entry = dynamic_segment;
4432 i < dynamic_size;
4433 i++, entry++)
4434 {
4435 entry->d_tag = BYTE_GET8 (edyn[i].d_tag);
4436 entry->d_un.d_val = BYTE_GET8 (edyn[i].d_un.d_val);
4437 }
4438
4439 free (edyn);
4440
4441 return 1;
4442 }
4443
4444 static const char *
4445 get_dynamic_flags (bfd_vma flags)
4446 {
4447 static char buff[128];
4448 char *p = buff;
4449
4450 *p = '\0';
4451 while (flags)
4452 {
4453 bfd_vma flag;
4454
4455 flag = flags & - flags;
4456 flags &= ~ flag;
4457
4458 if (p != buff)
4459 *p++ = ' ';
4460
4461 switch (flag)
4462 {
4463 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4464 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4465 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4466 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4467 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4468 default: strcpy (p, "unknown"); break;
4469 }
4470
4471 p = strchr (p, '\0');
4472 }
4473 return buff;
4474 }
4475
4476 /* Parse and display the contents of the dynamic segment. */
4477 static int
4478 process_dynamic_segment (FILE *file)
4479 {
4480 Elf_Internal_Dyn *entry;
4481 bfd_size_type i;
4482
4483 if (dynamic_size == 0)
4484 {
4485 if (do_dynamic)
4486 printf (_("\nThere is no dynamic segment in this file.\n"));
4487
4488 return 1;
4489 }
4490
4491 if (is_32bit_elf)
4492 {
4493 if (! get_32bit_dynamic_segment (file))
4494 return 0;
4495 }
4496 else if (! get_64bit_dynamic_segment (file))
4497 return 0;
4498
4499 /* Find the appropriate symbol table. */
4500 if (dynamic_symbols == NULL)
4501 {
4502 for (i = 0, entry = dynamic_segment;
4503 i < dynamic_size;
4504 ++i, ++entry)
4505 {
4506 Elf_Internal_Shdr section;
4507
4508 if (entry->d_tag != DT_SYMTAB)
4509 continue;
4510
4511 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4512
4513 /* Since we do not know how big the symbol table is,
4514 we default to reading in the entire file (!) and
4515 processing that. This is overkill, I know, but it
4516 should work. */
4517 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
4518
4519 if (archive_file_offset != 0)
4520 section.sh_size = archive_file_size - section.sh_offset;
4521 else
4522 {
4523 if (fseek (file, 0, SEEK_END))
4524 error (_("Unable to seek to end of file!"));
4525
4526 section.sh_size = ftell (file) - section.sh_offset;
4527 }
4528
4529 if (is_32bit_elf)
4530 section.sh_entsize = sizeof (Elf32_External_Sym);
4531 else
4532 section.sh_entsize = sizeof (Elf64_External_Sym);
4533
4534 num_dynamic_syms = section.sh_size / section.sh_entsize;
4535 if (num_dynamic_syms < 1)
4536 {
4537 error (_("Unable to determine the number of symbols to load\n"));
4538 continue;
4539 }
4540
4541 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
4542 }
4543 }
4544
4545 /* Similarly find a string table. */
4546 if (dynamic_strings == NULL)
4547 {
4548 for (i = 0, entry = dynamic_segment;
4549 i < dynamic_size;
4550 ++i, ++entry)
4551 {
4552 unsigned long offset;
4553 long str_tab_len;
4554
4555 if (entry->d_tag != DT_STRTAB)
4556 continue;
4557
4558 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4559
4560 /* Since we do not know how big the string table is,
4561 we default to reading in the entire file (!) and
4562 processing that. This is overkill, I know, but it
4563 should work. */
4564
4565 offset = offset_from_vma (file, entry->d_un.d_val, 0);
4566
4567 if (archive_file_offset != 0)
4568 str_tab_len = archive_file_size - offset;
4569 else
4570 {
4571 if (fseek (file, 0, SEEK_END))
4572 error (_("Unable to seek to end of file\n"));
4573 str_tab_len = ftell (file) - offset;
4574 }
4575
4576 if (str_tab_len < 1)
4577 {
4578 error
4579 (_("Unable to determine the length of the dynamic string table\n"));
4580 continue;
4581 }
4582
4583 dynamic_strings = get_data (NULL, file, offset, str_tab_len,
4584 _("dynamic string table"));
4585 break;
4586 }
4587 }
4588
4589 /* And find the syminfo section if available. */
4590 if (dynamic_syminfo == NULL)
4591 {
4592 unsigned long syminsz = 0;
4593
4594 for (i = 0, entry = dynamic_segment;
4595 i < dynamic_size;
4596 ++i, ++entry)
4597 {
4598 if (entry->d_tag == DT_SYMINENT)
4599 {
4600 /* Note: these braces are necessary to avoid a syntax
4601 error from the SunOS4 C compiler. */
4602 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4603 }
4604 else if (entry->d_tag == DT_SYMINSZ)
4605 syminsz = entry->d_un.d_val;
4606 else if (entry->d_tag == DT_SYMINFO)
4607 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
4608 syminsz);
4609 }
4610
4611 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4612 {
4613 Elf_External_Syminfo *extsyminfo;
4614 Elf_Internal_Syminfo *syminfo;
4615
4616 /* There is a syminfo section. Read the data. */
4617 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, syminsz,
4618 _("symbol information"));
4619 if (!extsyminfo)
4620 return 0;
4621
4622 dynamic_syminfo = malloc (syminsz);
4623 if (dynamic_syminfo == NULL)
4624 {
4625 error (_("Out of memory\n"));
4626 return 0;
4627 }
4628
4629 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4630 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4631 ++i, ++syminfo)
4632 {
4633 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4634 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4635 }
4636
4637 free (extsyminfo);
4638 }
4639 }
4640
4641 if (do_dynamic && dynamic_addr)
4642 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4643 dynamic_addr, (long) dynamic_size);
4644 if (do_dynamic)
4645 printf (_(" Tag Type Name/Value\n"));
4646
4647 for (i = 0, entry = dynamic_segment;
4648 i < dynamic_size;
4649 i++, entry++)
4650 {
4651 if (do_dynamic)
4652 {
4653 const char *dtype;
4654
4655 putchar (' ');
4656 print_vma (entry->d_tag, FULL_HEX);
4657 dtype = get_dynamic_type (entry->d_tag);
4658 printf (" (%s)%*s", dtype,
4659 ((is_32bit_elf ? 27 : 19)
4660 - (int) strlen (dtype)),
4661 " ");
4662 }
4663
4664 switch (entry->d_tag)
4665 {
4666 case DT_FLAGS:
4667 if (do_dynamic)
4668 puts (get_dynamic_flags (entry->d_un.d_val));
4669 break;
4670
4671 case DT_AUXILIARY:
4672 case DT_FILTER:
4673 case DT_CONFIG:
4674 case DT_DEPAUDIT:
4675 case DT_AUDIT:
4676 if (do_dynamic)
4677 {
4678 switch (entry->d_tag)
4679 {
4680 case DT_AUXILIARY:
4681 printf (_("Auxiliary library"));
4682 break;
4683
4684 case DT_FILTER:
4685 printf (_("Filter library"));
4686 break;
4687
4688 case DT_CONFIG:
4689 printf (_("Configuration file"));
4690 break;
4691
4692 case DT_DEPAUDIT:
4693 printf (_("Dependency audit library"));
4694 break;
4695
4696 case DT_AUDIT:
4697 printf (_("Audit library"));
4698 break;
4699 }
4700
4701 if (dynamic_strings)
4702 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4703 else
4704 {
4705 printf (": ");
4706 print_vma (entry->d_un.d_val, PREFIX_HEX);
4707 putchar ('\n');
4708 }
4709 }
4710 break;
4711
4712 case DT_FEATURE:
4713 if (do_dynamic)
4714 {
4715 printf (_("Flags:"));
4716
4717 if (entry->d_un.d_val == 0)
4718 printf (_(" None\n"));
4719 else
4720 {
4721 unsigned long int val = entry->d_un.d_val;
4722
4723 if (val & DTF_1_PARINIT)
4724 {
4725 printf (" PARINIT");
4726 val ^= DTF_1_PARINIT;
4727 }
4728 if (val & DTF_1_CONFEXP)
4729 {
4730 printf (" CONFEXP");
4731 val ^= DTF_1_CONFEXP;
4732 }
4733 if (val != 0)
4734 printf (" %lx", val);
4735 puts ("");
4736 }
4737 }
4738 break;
4739
4740 case DT_POSFLAG_1:
4741 if (do_dynamic)
4742 {
4743 printf (_("Flags:"));
4744
4745 if (entry->d_un.d_val == 0)
4746 printf (_(" None\n"));
4747 else
4748 {
4749 unsigned long int val = entry->d_un.d_val;
4750
4751 if (val & DF_P1_LAZYLOAD)
4752 {
4753 printf (" LAZYLOAD");
4754 val ^= DF_P1_LAZYLOAD;
4755 }
4756 if (val & DF_P1_GROUPPERM)
4757 {
4758 printf (" GROUPPERM");
4759 val ^= DF_P1_GROUPPERM;
4760 }
4761 if (val != 0)
4762 printf (" %lx", val);
4763 puts ("");
4764 }
4765 }
4766 break;
4767
4768 case DT_FLAGS_1:
4769 if (do_dynamic)
4770 {
4771 printf (_("Flags:"));
4772 if (entry->d_un.d_val == 0)
4773 printf (_(" None\n"));
4774 else
4775 {
4776 unsigned long int val = entry->d_un.d_val;
4777
4778 if (val & DF_1_NOW)
4779 {
4780 printf (" NOW");
4781 val ^= DF_1_NOW;
4782 }
4783 if (val & DF_1_GLOBAL)
4784 {
4785 printf (" GLOBAL");
4786 val ^= DF_1_GLOBAL;
4787 }
4788 if (val & DF_1_GROUP)
4789 {
4790 printf (" GROUP");
4791 val ^= DF_1_GROUP;
4792 }
4793 if (val & DF_1_NODELETE)
4794 {
4795 printf (" NODELETE");
4796 val ^= DF_1_NODELETE;
4797 }
4798 if (val & DF_1_LOADFLTR)
4799 {
4800 printf (" LOADFLTR");
4801 val ^= DF_1_LOADFLTR;
4802 }
4803 if (val & DF_1_INITFIRST)
4804 {
4805 printf (" INITFIRST");
4806 val ^= DF_1_INITFIRST;
4807 }
4808 if (val & DF_1_NOOPEN)
4809 {
4810 printf (" NOOPEN");
4811 val ^= DF_1_NOOPEN;
4812 }
4813 if (val & DF_1_ORIGIN)
4814 {
4815 printf (" ORIGIN");
4816 val ^= DF_1_ORIGIN;
4817 }
4818 if (val & DF_1_DIRECT)
4819 {
4820 printf (" DIRECT");
4821 val ^= DF_1_DIRECT;
4822 }
4823 if (val & DF_1_TRANS)
4824 {
4825 printf (" TRANS");
4826 val ^= DF_1_TRANS;
4827 }
4828 if (val & DF_1_INTERPOSE)
4829 {
4830 printf (" INTERPOSE");
4831 val ^= DF_1_INTERPOSE;
4832 }
4833 if (val & DF_1_NODEFLIB)
4834 {
4835 printf (" NODEFLIB");
4836 val ^= DF_1_NODEFLIB;
4837 }
4838 if (val & DF_1_NODUMP)
4839 {
4840 printf (" NODUMP");
4841 val ^= DF_1_NODUMP;
4842 }
4843 if (val & DF_1_CONLFAT)
4844 {
4845 printf (" CONLFAT");
4846 val ^= DF_1_CONLFAT;
4847 }
4848 if (val != 0)
4849 printf (" %lx", val);
4850 puts ("");
4851 }
4852 }
4853 break;
4854
4855 case DT_PLTREL:
4856 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4857 if (do_dynamic)
4858 puts (get_dynamic_type (entry->d_un.d_val));
4859 break;
4860
4861 case DT_NULL :
4862 case DT_NEEDED :
4863 case DT_PLTGOT :
4864 case DT_HASH :
4865 case DT_STRTAB :
4866 case DT_SYMTAB :
4867 case DT_RELA :
4868 case DT_INIT :
4869 case DT_FINI :
4870 case DT_SONAME :
4871 case DT_RPATH :
4872 case DT_SYMBOLIC:
4873 case DT_REL :
4874 case DT_DEBUG :
4875 case DT_TEXTREL :
4876 case DT_JMPREL :
4877 case DT_RUNPATH :
4878 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4879
4880 if (do_dynamic)
4881 {
4882 char *name;
4883
4884 if (dynamic_strings == NULL)
4885 name = NULL;
4886 else
4887 name = dynamic_strings + entry->d_un.d_val;
4888
4889 if (name)
4890 {
4891 switch (entry->d_tag)
4892 {
4893 case DT_NEEDED:
4894 printf (_("Shared library: [%s]"), name);
4895
4896 if (strcmp (name, program_interpreter) == 0)
4897 printf (_(" program interpreter"));
4898 break;
4899
4900 case DT_SONAME:
4901 printf (_("Library soname: [%s]"), name);
4902 break;
4903
4904 case DT_RPATH:
4905 printf (_("Library rpath: [%s]"), name);
4906 break;
4907
4908 case DT_RUNPATH:
4909 printf (_("Library runpath: [%s]"), name);
4910 break;
4911
4912 default:
4913 print_vma (entry->d_un.d_val, PREFIX_HEX);
4914 break;
4915 }
4916 }
4917 else
4918 print_vma (entry->d_un.d_val, PREFIX_HEX);
4919
4920 putchar ('\n');
4921 }
4922 break;
4923
4924 case DT_PLTRELSZ:
4925 case DT_RELASZ :
4926 case DT_STRSZ :
4927 case DT_RELSZ :
4928 case DT_RELAENT :
4929 case DT_SYMENT :
4930 case DT_RELENT :
4931 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4932 case DT_PLTPADSZ:
4933 case DT_MOVEENT :
4934 case DT_MOVESZ :
4935 case DT_INIT_ARRAYSZ:
4936 case DT_FINI_ARRAYSZ:
4937 case DT_GNU_CONFLICTSZ:
4938 case DT_GNU_LIBLISTSZ:
4939 if (do_dynamic)
4940 {
4941 print_vma (entry->d_un.d_val, UNSIGNED);
4942 printf (" (bytes)\n");
4943 }
4944 break;
4945
4946 case DT_VERDEFNUM:
4947 case DT_VERNEEDNUM:
4948 case DT_RELACOUNT:
4949 case DT_RELCOUNT:
4950 if (do_dynamic)
4951 {
4952 print_vma (entry->d_un.d_val, UNSIGNED);
4953 putchar ('\n');
4954 }
4955 break;
4956
4957 case DT_SYMINSZ:
4958 case DT_SYMINENT:
4959 case DT_SYMINFO:
4960 case DT_USED:
4961 case DT_INIT_ARRAY:
4962 case DT_FINI_ARRAY:
4963 if (do_dynamic)
4964 {
4965 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4966 {
4967 char *name;
4968
4969 name = dynamic_strings + entry->d_un.d_val;
4970
4971 if (*name)
4972 {
4973 printf (_("Not needed object: [%s]\n"), name);
4974 break;
4975 }
4976 }
4977
4978 print_vma (entry->d_un.d_val, PREFIX_HEX);
4979 putchar ('\n');
4980 }
4981 break;
4982
4983 case DT_BIND_NOW:
4984 /* The value of this entry is ignored. */
4985 if (do_dynamic)
4986 putchar ('\n');
4987 break;
4988
4989 case DT_GNU_PRELINKED:
4990 if (do_dynamic)
4991 {
4992 struct tm *tmp;
4993 time_t time = entry->d_un.d_val;
4994
4995 tmp = gmtime (&time);
4996 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4997 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4998 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4999
5000 }
5001 break;
5002
5003 default:
5004 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
5005 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
5006 entry->d_un.d_val;
5007
5008 if (do_dynamic)
5009 {
5010 switch (elf_header.e_machine)
5011 {
5012 case EM_MIPS:
5013 case EM_MIPS_RS3_LE:
5014 dynamic_segment_mips_val (entry);
5015 break;
5016 case EM_PARISC:
5017 dynamic_segment_parisc_val (entry);
5018 break;
5019 case EM_IA_64:
5020 dynamic_segment_ia64_val (entry);
5021 break;
5022 default:
5023 print_vma (entry->d_un.d_val, PREFIX_HEX);
5024 putchar ('\n');
5025 }
5026 }
5027 break;
5028 }
5029 }
5030
5031 return 1;
5032 }
5033
5034 static char *
5035 get_ver_flags (unsigned int flags)
5036 {
5037 static char buff[32];
5038
5039 buff[0] = 0;
5040
5041 if (flags == 0)
5042 return _("none");
5043
5044 if (flags & VER_FLG_BASE)
5045 strcat (buff, "BASE ");
5046
5047 if (flags & VER_FLG_WEAK)
5048 {
5049 if (flags & VER_FLG_BASE)
5050 strcat (buff, "| ");
5051
5052 strcat (buff, "WEAK ");
5053 }
5054
5055 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
5056 strcat (buff, "| <unknown>");
5057
5058 return buff;
5059 }
5060
5061 /* Display the contents of the version sections. */
5062 static int
5063 process_version_sections (FILE *file)
5064 {
5065 Elf_Internal_Shdr *section;
5066 unsigned i;
5067 int found = 0;
5068
5069 if (! do_version)
5070 return 1;
5071
5072 for (i = 0, section = section_headers;
5073 i < elf_header.e_shnum;
5074 i++, section++)
5075 {
5076 switch (section->sh_type)
5077 {
5078 case SHT_GNU_verdef:
5079 {
5080 Elf_External_Verdef *edefs;
5081 unsigned int idx;
5082 unsigned int cnt;
5083
5084 found = 1;
5085
5086 printf
5087 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5088 SECTION_NAME (section), section->sh_info);
5089
5090 printf (_(" Addr: 0x"));
5091 printf_vma (section->sh_addr);
5092 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5093 (unsigned long) section->sh_offset, section->sh_link,
5094 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5095
5096 edefs = get_data (NULL, file, section->sh_offset, section->sh_size,
5097 _("version definition section"));
5098 if (!edefs)
5099 break;
5100
5101 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5102 {
5103 char *vstart;
5104 Elf_External_Verdef *edef;
5105 Elf_Internal_Verdef ent;
5106 Elf_External_Verdaux *eaux;
5107 Elf_Internal_Verdaux aux;
5108 int j;
5109 int isum;
5110
5111 vstart = ((char *) edefs) + idx;
5112
5113 edef = (Elf_External_Verdef *) vstart;
5114
5115 ent.vd_version = BYTE_GET (edef->vd_version);
5116 ent.vd_flags = BYTE_GET (edef->vd_flags);
5117 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5118 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5119 ent.vd_hash = BYTE_GET (edef->vd_hash);
5120 ent.vd_aux = BYTE_GET (edef->vd_aux);
5121 ent.vd_next = BYTE_GET (edef->vd_next);
5122
5123 printf (_(" %#06x: Rev: %d Flags: %s"),
5124 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5125
5126 printf (_(" Index: %d Cnt: %d "),
5127 ent.vd_ndx, ent.vd_cnt);
5128
5129 vstart += ent.vd_aux;
5130
5131 eaux = (Elf_External_Verdaux *) vstart;
5132
5133 aux.vda_name = BYTE_GET (eaux->vda_name);
5134 aux.vda_next = BYTE_GET (eaux->vda_next);
5135
5136 if (dynamic_strings)
5137 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5138 else
5139 printf (_("Name index: %ld\n"), aux.vda_name);
5140
5141 isum = idx + ent.vd_aux;
5142
5143 for (j = 1; j < ent.vd_cnt; j++)
5144 {
5145 isum += aux.vda_next;
5146 vstart += aux.vda_next;
5147
5148 eaux = (Elf_External_Verdaux *) vstart;
5149
5150 aux.vda_name = BYTE_GET (eaux->vda_name);
5151 aux.vda_next = BYTE_GET (eaux->vda_next);
5152
5153 if (dynamic_strings)
5154 printf (_(" %#06x: Parent %d: %s\n"),
5155 isum, j, dynamic_strings + aux.vda_name);
5156 else
5157 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5158 isum, j, aux.vda_name);
5159 }
5160
5161 idx += ent.vd_next;
5162 }
5163
5164 free (edefs);
5165 }
5166 break;
5167
5168 case SHT_GNU_verneed:
5169 {
5170 Elf_External_Verneed *eneed;
5171 unsigned int idx;
5172 unsigned int cnt;
5173
5174 found = 1;
5175
5176 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5177 SECTION_NAME (section), section->sh_info);
5178
5179 printf (_(" Addr: 0x"));
5180 printf_vma (section->sh_addr);
5181 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5182 (unsigned long) section->sh_offset, section->sh_link,
5183 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5184
5185 eneed = get_data (NULL, file, section->sh_offset, section->sh_size,
5186 _("version need section"));
5187 if (!eneed)
5188 break;
5189
5190 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5191 {
5192 Elf_External_Verneed *entry;
5193 Elf_Internal_Verneed ent;
5194 int j;
5195 int isum;
5196 char *vstart;
5197
5198 vstart = ((char *) eneed) + idx;
5199
5200 entry = (Elf_External_Verneed *) vstart;
5201
5202 ent.vn_version = BYTE_GET (entry->vn_version);
5203 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5204 ent.vn_file = BYTE_GET (entry->vn_file);
5205 ent.vn_aux = BYTE_GET (entry->vn_aux);
5206 ent.vn_next = BYTE_GET (entry->vn_next);
5207
5208 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5209
5210 if (dynamic_strings)
5211 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5212 else
5213 printf (_(" File: %lx"), ent.vn_file);
5214
5215 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5216
5217 vstart += ent.vn_aux;
5218
5219 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5220 {
5221 Elf_External_Vernaux *eaux;
5222 Elf_Internal_Vernaux aux;
5223
5224 eaux = (Elf_External_Vernaux *) vstart;
5225
5226 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5227 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5228 aux.vna_other = BYTE_GET (eaux->vna_other);
5229 aux.vna_name = BYTE_GET (eaux->vna_name);
5230 aux.vna_next = BYTE_GET (eaux->vna_next);
5231
5232 if (dynamic_strings)
5233 printf (_(" %#06x: Name: %s"),
5234 isum, dynamic_strings + aux.vna_name);
5235 else
5236 printf (_(" %#06x: Name index: %lx"),
5237 isum, aux.vna_name);
5238
5239 printf (_(" Flags: %s Version: %d\n"),
5240 get_ver_flags (aux.vna_flags), aux.vna_other);
5241
5242 isum += aux.vna_next;
5243 vstart += aux.vna_next;
5244 }
5245
5246 idx += ent.vn_next;
5247 }
5248
5249 free (eneed);
5250 }
5251 break;
5252
5253 case SHT_GNU_versym:
5254 {
5255 Elf_Internal_Shdr *link_section;
5256 int total;
5257 int cnt;
5258 unsigned char *edata;
5259 unsigned short *data;
5260 char *strtab;
5261 Elf_Internal_Sym *symbols;
5262 Elf_Internal_Shdr *string_sec;
5263 long off;
5264
5265 link_section = SECTION_HEADER (section->sh_link);
5266 total = section->sh_size / section->sh_entsize;
5267
5268 found = 1;
5269
5270 symbols = GET_ELF_SYMBOLS (file, link_section);
5271
5272 string_sec = SECTION_HEADER (link_section->sh_link);
5273
5274 strtab = get_data (NULL, file, string_sec->sh_offset,
5275 string_sec->sh_size, _("version string table"));
5276 if (!strtab)
5277 break;
5278
5279 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5280 SECTION_NAME (section), total);
5281
5282 printf (_(" Addr: "));
5283 printf_vma (section->sh_addr);
5284 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5285 (unsigned long) section->sh_offset, section->sh_link,
5286 SECTION_NAME (link_section));
5287
5288 off = offset_from_vma (file,
5289 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
5290 total * sizeof (short));
5291 edata = get_data (NULL, file, off, total * sizeof (short),
5292 _("version symbol data"));
5293 if (!edata)
5294 {
5295 free (strtab);
5296 break;
5297 }
5298
5299 data = malloc (total * sizeof (short));
5300
5301 for (cnt = total; cnt --;)
5302 data[cnt] = byte_get (edata + cnt * sizeof (short),
5303 sizeof (short));
5304
5305 free (edata);
5306
5307 for (cnt = 0; cnt < total; cnt += 4)
5308 {
5309 int j, nn;
5310 int check_def, check_need;
5311 char *name;
5312
5313 printf (" %03x:", cnt);
5314
5315 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5316 switch (data[cnt + j])
5317 {
5318 case 0:
5319 fputs (_(" 0 (*local*) "), stdout);
5320 break;
5321
5322 case 1:
5323 fputs (_(" 1 (*global*) "), stdout);
5324 break;
5325
5326 default:
5327 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
5328 data[cnt + j] & 0x8000 ? 'h' : ' ');
5329
5330 check_def = 1;
5331 check_need = 1;
5332 if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
5333 != SHT_NOBITS)
5334 {
5335 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
5336 check_def = 0;
5337 else
5338 check_need = 0;
5339 }
5340
5341 if (check_need
5342 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
5343 {
5344 Elf_Internal_Verneed ivn;
5345 unsigned long offset;
5346
5347 offset = offset_from_vma
5348 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
5349 sizeof (Elf_External_Verneed));
5350
5351 do
5352 {
5353 Elf_Internal_Vernaux ivna;
5354 Elf_External_Verneed evn;
5355 Elf_External_Vernaux evna;
5356 unsigned long a_off;
5357
5358 get_data (&evn, file, offset, sizeof (evn),
5359 _("version need"));
5360
5361 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5362 ivn.vn_next = BYTE_GET (evn.vn_next);
5363
5364 a_off = offset + ivn.vn_aux;
5365
5366 do
5367 {
5368 get_data (&evna, file, a_off, sizeof (evna),
5369 _("version need aux (2)"));
5370
5371 ivna.vna_next = BYTE_GET (evna.vna_next);
5372 ivna.vna_other = BYTE_GET (evna.vna_other);
5373
5374 a_off += ivna.vna_next;
5375 }
5376 while (ivna.vna_other != data[cnt + j]
5377 && ivna.vna_next != 0);
5378
5379 if (ivna.vna_other == data[cnt + j])
5380 {
5381 ivna.vna_name = BYTE_GET (evna.vna_name);
5382
5383 name = strtab + ivna.vna_name;
5384 nn += printf ("(%s%-*s",
5385 name,
5386 12 - (int) strlen (name),
5387 ")");
5388 check_def = 0;
5389 break;
5390 }
5391
5392 offset += ivn.vn_next;
5393 }
5394 while (ivn.vn_next);
5395 }
5396
5397 if (check_def && data[cnt + j] != 0x8001
5398 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5399 {
5400 Elf_Internal_Verdef ivd;
5401 Elf_External_Verdef evd;
5402 unsigned long offset;
5403
5404 offset = offset_from_vma
5405 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
5406 sizeof evd);
5407
5408 do
5409 {
5410 get_data (&evd, file, offset, sizeof (evd),
5411 _("version def"));
5412
5413 ivd.vd_next = BYTE_GET (evd.vd_next);
5414 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5415
5416 offset += ivd.vd_next;
5417 }
5418 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
5419 && ivd.vd_next != 0);
5420
5421 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
5422 {
5423 Elf_External_Verdaux evda;
5424 Elf_Internal_Verdaux ivda;
5425
5426 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5427
5428 get_data (&evda, file,
5429 offset - ivd.vd_next + ivd.vd_aux,
5430 sizeof (evda), _("version def aux"));
5431
5432 ivda.vda_name = BYTE_GET (evda.vda_name);
5433
5434 name = strtab + ivda.vda_name;
5435 nn += printf ("(%s%-*s",
5436 name,
5437 12 - (int) strlen (name),
5438 ")");
5439 }
5440 }
5441
5442 if (nn < 18)
5443 printf ("%*c", 18 - nn, ' ');
5444 }
5445
5446 putchar ('\n');
5447 }
5448
5449 free (data);
5450 free (strtab);
5451 free (symbols);
5452 }
5453 break;
5454
5455 default:
5456 break;
5457 }
5458 }
5459
5460 if (! found)
5461 printf (_("\nNo version information found in this file.\n"));
5462
5463 return 1;
5464 }
5465
5466 static const char *
5467 get_symbol_binding (unsigned int binding)
5468 {
5469 static char buff[32];
5470
5471 switch (binding)
5472 {
5473 case STB_LOCAL: return "LOCAL";
5474 case STB_GLOBAL: return "GLOBAL";
5475 case STB_WEAK: return "WEAK";
5476 default:
5477 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5478 sprintf (buff, _("<processor specific>: %d"), binding);
5479 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5480 sprintf (buff, _("<OS specific>: %d"), binding);
5481 else
5482 sprintf (buff, _("<unknown>: %d"), binding);
5483 return buff;
5484 }
5485 }
5486
5487 static const char *
5488 get_symbol_type (unsigned int type)
5489 {
5490 static char buff[32];
5491
5492 switch (type)
5493 {
5494 case STT_NOTYPE: return "NOTYPE";
5495 case STT_OBJECT: return "OBJECT";
5496 case STT_FUNC: return "FUNC";
5497 case STT_SECTION: return "SECTION";
5498 case STT_FILE: return "FILE";
5499 case STT_COMMON: return "COMMON";
5500 case STT_TLS: return "TLS";
5501 default:
5502 if (type >= STT_LOPROC && type <= STT_HIPROC)
5503 {
5504 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5505 return "THUMB_FUNC";
5506
5507 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5508 return "REGISTER";
5509
5510 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5511 return "PARISC_MILLI";
5512
5513 sprintf (buff, _("<processor specific>: %d"), type);
5514 }
5515 else if (type >= STT_LOOS && type <= STT_HIOS)
5516 {
5517 if (elf_header.e_machine == EM_PARISC)
5518 {
5519 if (type == STT_HP_OPAQUE)
5520 return "HP_OPAQUE";
5521 if (type == STT_HP_STUB)
5522 return "HP_STUB";
5523 }
5524
5525 sprintf (buff, _("<OS specific>: %d"), type);
5526 }
5527 else
5528 sprintf (buff, _("<unknown>: %d"), type);
5529 return buff;
5530 }
5531 }
5532
5533 static const char *
5534 get_symbol_visibility (unsigned int visibility)
5535 {
5536 switch (visibility)
5537 {
5538 case STV_DEFAULT: return "DEFAULT";
5539 case STV_INTERNAL: return "INTERNAL";
5540 case STV_HIDDEN: return "HIDDEN";
5541 case STV_PROTECTED: return "PROTECTED";
5542 default: abort ();
5543 }
5544 }
5545
5546 static const char *
5547 get_symbol_index_type (unsigned int type)
5548 {
5549 static char buff[32];
5550
5551 switch (type)
5552 {
5553 case SHN_UNDEF: return "UND";
5554 case SHN_ABS: return "ABS";
5555 case SHN_COMMON: return "COM";
5556 default:
5557 if (type == SHN_IA_64_ANSI_COMMON
5558 && elf_header.e_machine == EM_IA_64
5559 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
5560 return "ANSI_COM";
5561 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5562 sprintf (buff, "PRC[0x%04x]", type);
5563 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5564 sprintf (buff, "OS [0x%04x]", type);
5565 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5566 sprintf (buff, "RSV[0x%04x]", type);
5567 else
5568 sprintf (buff, "%3d", type);
5569 break;
5570 }
5571
5572 return buff;
5573 }
5574
5575 static int *
5576 get_dynamic_data (FILE *file, unsigned int number)
5577 {
5578 unsigned char *e_data;
5579 int *i_data;
5580
5581 e_data = malloc (number * 4);
5582
5583 if (e_data == NULL)
5584 {
5585 error (_("Out of memory\n"));
5586 return NULL;
5587 }
5588
5589 if (fread (e_data, 4, number, file) != number)
5590 {
5591 error (_("Unable to read in dynamic data\n"));
5592 return NULL;
5593 }
5594
5595 i_data = malloc (number * sizeof (*i_data));
5596
5597 if (i_data == NULL)
5598 {
5599 error (_("Out of memory\n"));
5600 free (e_data);
5601 return NULL;
5602 }
5603
5604 while (number--)
5605 i_data[number] = byte_get (e_data + number * 4, 4);
5606
5607 free (e_data);
5608
5609 return i_data;
5610 }
5611
5612 /* Dump the symbol table. */
5613 static int
5614 process_symbol_table (FILE *file)
5615 {
5616 Elf_Internal_Shdr *section;
5617 unsigned char nb[4];
5618 unsigned char nc[4];
5619 int nbuckets = 0;
5620 int nchains = 0;
5621 int *buckets = NULL;
5622 int *chains = NULL;
5623
5624 if (! do_syms && !do_histogram)
5625 return 1;
5626
5627 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5628 || do_histogram))
5629 {
5630 if (fseek (file,
5631 (archive_file_offset
5632 + offset_from_vma (file, dynamic_info[DT_HASH],
5633 sizeof nb + sizeof nc)),
5634 SEEK_SET))
5635 {
5636 error (_("Unable to seek to start of dynamic information"));
5637 return 0;
5638 }
5639
5640 if (fread (nb, sizeof (nb), 1, file) != 1)
5641 {
5642 error (_("Failed to read in number of buckets\n"));
5643 return 0;
5644 }
5645
5646 if (fread (nc, sizeof (nc), 1, file) != 1)
5647 {
5648 error (_("Failed to read in number of chains\n"));
5649 return 0;
5650 }
5651
5652 nbuckets = byte_get (nb, 4);
5653 nchains = byte_get (nc, 4);
5654
5655 buckets = get_dynamic_data (file, nbuckets);
5656 chains = get_dynamic_data (file, nchains);
5657
5658 if (buckets == NULL || chains == NULL)
5659 return 0;
5660 }
5661
5662 if (do_syms
5663 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5664 {
5665 int hn;
5666 int si;
5667
5668 printf (_("\nSymbol table for image:\n"));
5669 if (is_32bit_elf)
5670 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5671 else
5672 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5673
5674 for (hn = 0; hn < nbuckets; hn++)
5675 {
5676 if (! buckets[hn])
5677 continue;
5678
5679 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
5680 {
5681 Elf_Internal_Sym *psym;
5682
5683 psym = dynamic_symbols + si;
5684
5685 printf (" %3d %3d: ", si, hn);
5686 print_vma (psym->st_value, LONG_HEX);
5687 putchar (' ' );
5688 print_vma (psym->st_size, DEC_5);
5689
5690 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5691 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5692 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5693 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5694 print_symbol (25, dynamic_strings + psym->st_name);
5695 putchar ('\n');
5696 }
5697 }
5698 }
5699 else if (do_syms && !do_using_dynamic)
5700 {
5701 unsigned int i;
5702
5703 for (i = 0, section = section_headers;
5704 i < elf_header.e_shnum;
5705 i++, section++)
5706 {
5707 unsigned int si;
5708 char *strtab;
5709 Elf_Internal_Sym *symtab;
5710 Elf_Internal_Sym *psym;
5711
5712
5713 if ( section->sh_type != SHT_SYMTAB
5714 && section->sh_type != SHT_DYNSYM)
5715 continue;
5716
5717 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5718 SECTION_NAME (section),
5719 (unsigned long) (section->sh_size / section->sh_entsize));
5720 if (is_32bit_elf)
5721 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5722 else
5723 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5724
5725 symtab = GET_ELF_SYMBOLS (file, section);
5726 if (symtab == NULL)
5727 continue;
5728
5729 if (section->sh_link == elf_header.e_shstrndx)
5730 strtab = string_table;
5731 else
5732 {
5733 Elf_Internal_Shdr *string_sec;
5734
5735 string_sec = SECTION_HEADER (section->sh_link);
5736
5737 strtab = get_data (NULL, file, string_sec->sh_offset,
5738 string_sec->sh_size, _("string table"));
5739 }
5740
5741 for (si = 0, psym = symtab;
5742 si < section->sh_size / section->sh_entsize;
5743 si++, psym++)
5744 {
5745 printf ("%6d: ", si);
5746 print_vma (psym->st_value, LONG_HEX);
5747 putchar (' ');
5748 print_vma (psym->st_size, DEC_5);
5749 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5750 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5751 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5752 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5753 print_symbol (25, strtab + psym->st_name);
5754
5755 if (section->sh_type == SHT_DYNSYM &&
5756 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5757 {
5758 unsigned char data[2];
5759 unsigned short vers_data;
5760 unsigned long offset;
5761 int is_nobits;
5762 int check_def;
5763
5764 offset = offset_from_vma
5765 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
5766 sizeof data + si * sizeof (vers_data));
5767
5768 get_data (&data, file, offset + si * sizeof (vers_data),
5769 sizeof (data), _("version data"));
5770
5771 vers_data = byte_get (data, 2);
5772
5773 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5774 == SHT_NOBITS);
5775
5776 check_def = (psym->st_shndx != SHN_UNDEF);
5777
5778 if ((vers_data & 0x8000) || vers_data > 1)
5779 {
5780 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5781 && (is_nobits || ! check_def))
5782 {
5783 Elf_External_Verneed evn;
5784 Elf_Internal_Verneed ivn;
5785 Elf_Internal_Vernaux ivna;
5786
5787 /* We must test both. */
5788 offset = offset_from_vma
5789 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
5790 sizeof evn);
5791
5792 do
5793 {
5794 unsigned long vna_off;
5795
5796 get_data (&evn, file, offset, sizeof (evn),
5797 _("version need"));
5798
5799 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5800 ivn.vn_next = BYTE_GET (evn.vn_next);
5801
5802 vna_off = offset + ivn.vn_aux;
5803
5804 do
5805 {
5806 Elf_External_Vernaux evna;
5807
5808 get_data (&evna, file, vna_off,
5809 sizeof (evna),
5810 _("version need aux (3)"));
5811
5812 ivna.vna_other = BYTE_GET (evna.vna_other);
5813 ivna.vna_next = BYTE_GET (evna.vna_next);
5814 ivna.vna_name = BYTE_GET (evna.vna_name);
5815
5816 vna_off += ivna.vna_next;
5817 }
5818 while (ivna.vna_other != vers_data
5819 && ivna.vna_next != 0);
5820
5821 if (ivna.vna_other == vers_data)
5822 break;
5823
5824 offset += ivn.vn_next;
5825 }
5826 while (ivn.vn_next != 0);
5827
5828 if (ivna.vna_other == vers_data)
5829 {
5830 printf ("@%s (%d)",
5831 strtab + ivna.vna_name, ivna.vna_other);
5832 check_def = 0;
5833 }
5834 else if (! is_nobits)
5835 error (_("bad dynamic symbol"));
5836 else
5837 check_def = 1;
5838 }
5839
5840 if (check_def)
5841 {
5842 if (vers_data != 0x8001
5843 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5844 {
5845 Elf_Internal_Verdef ivd;
5846 Elf_Internal_Verdaux ivda;
5847 Elf_External_Verdaux evda;
5848 unsigned long offset;
5849
5850 offset = offset_from_vma
5851 (file,
5852 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
5853 sizeof (Elf_External_Verdef));
5854
5855 do
5856 {
5857 Elf_External_Verdef evd;
5858
5859 get_data (&evd, file, offset, sizeof (evd),
5860 _("version def"));
5861
5862 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5863 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5864 ivd.vd_next = BYTE_GET (evd.vd_next);
5865
5866 offset += ivd.vd_next;
5867 }
5868 while (ivd.vd_ndx != (vers_data & 0x7fff)
5869 && ivd.vd_next != 0);
5870
5871 offset -= ivd.vd_next;
5872 offset += ivd.vd_aux;
5873
5874 get_data (&evda, file, offset, sizeof (evda),
5875 _("version def aux"));
5876
5877 ivda.vda_name = BYTE_GET (evda.vda_name);
5878
5879 if (psym->st_name != ivda.vda_name)
5880 printf ((vers_data & 0x8000)
5881 ? "@%s" : "@@%s",
5882 strtab + ivda.vda_name);
5883 }
5884 }
5885 }
5886 }
5887
5888 putchar ('\n');
5889 }
5890
5891 free (symtab);
5892 if (strtab != string_table)
5893 free (strtab);
5894 }
5895 }
5896 else if (do_syms)
5897 printf
5898 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5899
5900 if (do_histogram && buckets != NULL)
5901 {
5902 int *lengths;
5903 int *counts;
5904 int hn;
5905 int si;
5906 int maxlength = 0;
5907 int nzero_counts = 0;
5908 int nsyms = 0;
5909
5910 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5911 nbuckets);
5912 printf (_(" Length Number %% of total Coverage\n"));
5913
5914 lengths = calloc (nbuckets, sizeof (int));
5915 if (lengths == NULL)
5916 {
5917 error (_("Out of memory"));
5918 return 0;
5919 }
5920 for (hn = 0; hn < nbuckets; ++hn)
5921 {
5922 if (! buckets[hn])
5923 continue;
5924
5925 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5926 {
5927 ++nsyms;
5928 if (maxlength < ++lengths[hn])
5929 ++maxlength;
5930 }
5931 }
5932
5933 counts = calloc (maxlength + 1, sizeof (int));
5934 if (counts == NULL)
5935 {
5936 error (_("Out of memory"));
5937 return 0;
5938 }
5939
5940 for (hn = 0; hn < nbuckets; ++hn)
5941 ++counts[lengths[hn]];
5942
5943 if (nbuckets > 0)
5944 {
5945 printf (" 0 %-10d (%5.1f%%)\n",
5946 counts[0], (counts[0] * 100.0) / nbuckets);
5947 for (si = 1; si <= maxlength; ++si)
5948 {
5949 nzero_counts += counts[si] * si;
5950 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5951 si, counts[si], (counts[si] * 100.0) / nbuckets,
5952 (nzero_counts * 100.0) / nsyms);
5953 }
5954 }
5955
5956 free (counts);
5957 free (lengths);
5958 }
5959
5960 if (buckets != NULL)
5961 {
5962 free (buckets);
5963 free (chains);
5964 }
5965
5966 return 1;
5967 }
5968
5969 static int
5970 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
5971 {
5972 unsigned int i;
5973
5974 if (dynamic_syminfo == NULL
5975 || !do_dynamic)
5976 /* No syminfo, this is ok. */
5977 return 1;
5978
5979 /* There better should be a dynamic symbol section. */
5980 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5981 return 0;
5982
5983 if (dynamic_addr)
5984 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5985 dynamic_syminfo_offset, dynamic_syminfo_nent);
5986
5987 printf (_(" Num: Name BoundTo Flags\n"));
5988 for (i = 0; i < dynamic_syminfo_nent; ++i)
5989 {
5990 unsigned short int flags = dynamic_syminfo[i].si_flags;
5991
5992 printf ("%4d: ", i);
5993 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
5994 putchar (' ');
5995
5996 switch (dynamic_syminfo[i].si_boundto)
5997 {
5998 case SYMINFO_BT_SELF:
5999 fputs ("SELF ", stdout);
6000 break;
6001 case SYMINFO_BT_PARENT:
6002 fputs ("PARENT ", stdout);
6003 break;
6004 default:
6005 if (dynamic_syminfo[i].si_boundto > 0
6006 && dynamic_syminfo[i].si_boundto < dynamic_size)
6007 {
6008 print_symbol (10,
6009 dynamic_strings
6010 + (dynamic_segment
6011 [dynamic_syminfo[i].si_boundto].d_un.d_val));
6012 putchar (' ' );
6013 }
6014 else
6015 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
6016 break;
6017 }
6018
6019 if (flags & SYMINFO_FLG_DIRECT)
6020 printf (" DIRECT");
6021 if (flags & SYMINFO_FLG_PASSTHRU)
6022 printf (" PASSTHRU");
6023 if (flags & SYMINFO_FLG_COPY)
6024 printf (" COPY");
6025 if (flags & SYMINFO_FLG_LAZYLOAD)
6026 printf (" LAZYLOAD");
6027
6028 puts ("");
6029 }
6030
6031 return 1;
6032 }
6033
6034 #ifdef SUPPORT_DISASSEMBLY
6035 static void
6036 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
6037 {
6038 printf (_("\nAssembly dump of section %s\n"),
6039 SECTION_NAME (section));
6040
6041 /* XXX -- to be done --- XXX */
6042
6043 return 1;
6044 }
6045 #endif
6046
6047 static int
6048 dump_section (Elf_Internal_Shdr *section, FILE *file)
6049 {
6050 bfd_size_type bytes;
6051 bfd_vma addr;
6052 unsigned char *data;
6053 unsigned char *start;
6054
6055 bytes = section->sh_size;
6056
6057 if (bytes == 0)
6058 {
6059 printf (_("\nSection '%s' has no data to dump.\n"),
6060 SECTION_NAME (section));
6061 return 0;
6062 }
6063 else
6064 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6065
6066 addr = section->sh_addr;
6067
6068 start = get_data (NULL, file, section->sh_offset, bytes, _("section data"));
6069 if (!start)
6070 return 0;
6071
6072 data = start;
6073
6074 while (bytes)
6075 {
6076 int j;
6077 int k;
6078 int lbytes;
6079
6080 lbytes = (bytes > 16 ? 16 : bytes);
6081
6082 printf (" 0x%8.8lx ", (unsigned long) addr);
6083
6084 switch (elf_header.e_ident[EI_DATA])
6085 {
6086 default:
6087 case ELFDATA2LSB:
6088 for (j = 15; j >= 0; j --)
6089 {
6090 if (j < lbytes)
6091 printf ("%2.2x", data[j]);
6092 else
6093 printf (" ");
6094
6095 if (!(j & 0x3))
6096 printf (" ");
6097 }
6098 break;
6099
6100 case ELFDATA2MSB:
6101 for (j = 0; j < 16; j++)
6102 {
6103 if (j < lbytes)
6104 printf ("%2.2x", data[j]);
6105 else
6106 printf (" ");
6107
6108 if ((j & 3) == 3)
6109 printf (" ");
6110 }
6111 break;
6112 }
6113
6114 for (j = 0; j < lbytes; j++)
6115 {
6116 k = data[j];
6117 if (k >= ' ' && k < 0x80)
6118 printf ("%c", k);
6119 else
6120 printf (".");
6121 }
6122
6123 putchar ('\n');
6124
6125 data += lbytes;
6126 addr += lbytes;
6127 bytes -= lbytes;
6128 }
6129
6130 free (start);
6131
6132 return 1;
6133 }
6134
6135
6136 static unsigned long int
6137 read_leb128 (unsigned char *data, int *length_return, int sign)
6138 {
6139 unsigned long int result = 0;
6140 unsigned int num_read = 0;
6141 int shift = 0;
6142 unsigned char byte;
6143
6144 do
6145 {
6146 byte = *data++;
6147 num_read++;
6148
6149 result |= (byte & 0x7f) << shift;
6150
6151 shift += 7;
6152
6153 }
6154 while (byte & 0x80);
6155
6156 if (length_return != NULL)
6157 *length_return = num_read;
6158
6159 if (sign && (shift < 32) && (byte & 0x40))
6160 result |= -1 << shift;
6161
6162 return result;
6163 }
6164
6165 typedef struct State_Machine_Registers
6166 {
6167 unsigned long address;
6168 unsigned int file;
6169 unsigned int line;
6170 unsigned int column;
6171 int is_stmt;
6172 int basic_block;
6173 int end_sequence;
6174 /* This variable hold the number of the last entry seen
6175 in the File Table. */
6176 unsigned int last_file_entry;
6177 } SMR;
6178
6179 static SMR state_machine_regs;
6180
6181 static void
6182 reset_state_machine (int is_stmt)
6183 {
6184 state_machine_regs.address = 0;
6185 state_machine_regs.file = 1;
6186 state_machine_regs.line = 1;
6187 state_machine_regs.column = 0;
6188 state_machine_regs.is_stmt = is_stmt;
6189 state_machine_regs.basic_block = 0;
6190 state_machine_regs.end_sequence = 0;
6191 state_machine_regs.last_file_entry = 0;
6192 }
6193
6194 /* Handled an extend line op. Returns true if this is the end
6195 of sequence. */
6196 static int
6197 process_extended_line_op (unsigned char *data, int is_stmt, int pointer_size)
6198 {
6199 unsigned char op_code;
6200 int bytes_read;
6201 unsigned int len;
6202 unsigned char *name;
6203 unsigned long adr;
6204
6205 len = read_leb128 (data, & bytes_read, 0);
6206 data += bytes_read;
6207
6208 if (len == 0)
6209 {
6210 warn (_("badly formed extended line op encountered!\n"));
6211 return bytes_read;
6212 }
6213
6214 len += bytes_read;
6215 op_code = *data++;
6216
6217 printf (_(" Extended opcode %d: "), op_code);
6218
6219 switch (op_code)
6220 {
6221 case DW_LNE_end_sequence:
6222 printf (_("End of Sequence\n\n"));
6223 reset_state_machine (is_stmt);
6224 break;
6225
6226 case DW_LNE_set_address:
6227 adr = byte_get (data, pointer_size);
6228 printf (_("set Address to 0x%lx\n"), adr);
6229 state_machine_regs.address = adr;
6230 break;
6231
6232 case DW_LNE_define_file:
6233 printf (_(" define new File Table entry\n"));
6234 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6235
6236 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6237 name = data;
6238 data += strlen ((char *) data) + 1;
6239 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6240 data += bytes_read;
6241 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6242 data += bytes_read;
6243 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6244 printf (_("%s\n\n"), name);
6245 break;
6246
6247 default:
6248 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6249 break;
6250 }
6251
6252 return len;
6253 }
6254
6255 /* Size of pointers in the .debug_line section. This information is not
6256 really present in that section. It's obtained before dumping the debug
6257 sections by doing some pre-scan of the .debug_info section. */
6258 static int debug_line_pointer_size = 4;
6259
6260 static int
6261 display_debug_lines (Elf_Internal_Shdr *section,
6262 unsigned char * start,
6263 FILE *file ATTRIBUTE_UNUSED)
6264 {
6265 unsigned char *hdrptr;
6266 DWARF2_Internal_LineInfo info;
6267 unsigned char *standard_opcodes;
6268 unsigned char *data = start;
6269 unsigned char *end = start + section->sh_size;
6270 unsigned char *end_of_sequence;
6271 int i;
6272 int offset_size;
6273 int initial_length_size;
6274
6275 printf (_("\nDump of debug contents of section %s:\n\n"),
6276 SECTION_NAME (section));
6277
6278 while (data < end)
6279 {
6280 hdrptr = data;
6281
6282 /* Check the length of the block. */
6283 info.li_length = byte_get (hdrptr, 4);
6284 hdrptr += 4;
6285
6286 if (info.li_length == 0xffffffff)
6287 {
6288 /* This section is 64-bit DWARF 3. */
6289 info.li_length = byte_get (hdrptr, 8);
6290 hdrptr += 8;
6291 offset_size = 8;
6292 initial_length_size = 12;
6293 }
6294 else
6295 {
6296 offset_size = 4;
6297 initial_length_size = 4;
6298 }
6299
6300 if (info.li_length + initial_length_size > section->sh_size)
6301 {
6302 warn
6303 (_("The line info appears to be corrupt - the section is too small\n"));
6304 return 0;
6305 }
6306
6307 /* Check its version number. */
6308 info.li_version = byte_get (hdrptr, 2);
6309 hdrptr += 2;
6310 if (info.li_version != 2 && info.li_version != 3)
6311 {
6312 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6313 return 0;
6314 }
6315
6316 info.li_prologue_length = byte_get (hdrptr, offset_size);
6317 hdrptr += offset_size;
6318 info.li_min_insn_length = byte_get (hdrptr, 1);
6319 hdrptr++;
6320 info.li_default_is_stmt = byte_get (hdrptr, 1);
6321 hdrptr++;
6322 info.li_line_base = byte_get (hdrptr, 1);
6323 hdrptr++;
6324 info.li_line_range = byte_get (hdrptr, 1);
6325 hdrptr++;
6326 info.li_opcode_base = byte_get (hdrptr, 1);
6327 hdrptr++;
6328
6329 /* Sign extend the line base field. */
6330 info.li_line_base <<= 24;
6331 info.li_line_base >>= 24;
6332
6333 printf (_(" Length: %ld\n"), info.li_length);
6334 printf (_(" DWARF Version: %d\n"), info.li_version);
6335 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6336 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6337 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6338 printf (_(" Line Base: %d\n"), info.li_line_base);
6339 printf (_(" Line Range: %d\n"), info.li_line_range);
6340 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6341
6342 end_of_sequence = data + info.li_length + initial_length_size;
6343
6344 reset_state_machine (info.li_default_is_stmt);
6345
6346 /* Display the contents of the Opcodes table. */
6347 standard_opcodes = hdrptr;
6348
6349 printf (_("\n Opcodes:\n"));
6350
6351 for (i = 1; i < info.li_opcode_base; i++)
6352 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6353
6354 /* Display the contents of the Directory table. */
6355 data = standard_opcodes + info.li_opcode_base - 1;
6356
6357 if (*data == 0)
6358 printf (_("\n The Directory Table is empty.\n"));
6359 else
6360 {
6361 printf (_("\n The Directory Table:\n"));
6362
6363 while (*data != 0)
6364 {
6365 printf (_(" %s\n"), data);
6366
6367 data += strlen ((char *) data) + 1;
6368 }
6369 }
6370
6371 /* Skip the NUL at the end of the table. */
6372 data++;
6373
6374 /* Display the contents of the File Name table. */
6375 if (*data == 0)
6376 printf (_("\n The File Name Table is empty.\n"));
6377 else
6378 {
6379 printf (_("\n The File Name Table:\n"));
6380 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6381
6382 while (*data != 0)
6383 {
6384 unsigned char *name;
6385 int bytes_read;
6386
6387 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6388 name = data;
6389
6390 data += strlen ((char *) data) + 1;
6391
6392 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6393 data += bytes_read;
6394 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6395 data += bytes_read;
6396 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6397 data += bytes_read;
6398 printf (_("%s\n"), name);
6399 }
6400 }
6401
6402 /* Skip the NUL at the end of the table. */
6403 data++;
6404
6405 /* Now display the statements. */
6406 printf (_("\n Line Number Statements:\n"));
6407
6408
6409 while (data < end_of_sequence)
6410 {
6411 unsigned char op_code;
6412 int adv;
6413 int bytes_read;
6414
6415 op_code = *data++;
6416
6417 if (op_code >= info.li_opcode_base)
6418 {
6419 op_code -= info.li_opcode_base;
6420 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6421 state_machine_regs.address += adv;
6422 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6423 op_code, adv, state_machine_regs.address);
6424 adv = (op_code % info.li_line_range) + info.li_line_base;
6425 state_machine_regs.line += adv;
6426 printf (_(" and Line by %d to %d\n"),
6427 adv, state_machine_regs.line);
6428 }
6429 else switch (op_code)
6430 {
6431 case DW_LNS_extended_op:
6432 data += process_extended_line_op (data, info.li_default_is_stmt,
6433 debug_line_pointer_size);
6434 break;
6435
6436 case DW_LNS_copy:
6437 printf (_(" Copy\n"));
6438 break;
6439
6440 case DW_LNS_advance_pc:
6441 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6442 data += bytes_read;
6443 state_machine_regs.address += adv;
6444 printf (_(" Advance PC by %d to %lx\n"), adv,
6445 state_machine_regs.address);
6446 break;
6447
6448 case DW_LNS_advance_line:
6449 adv = read_leb128 (data, & bytes_read, 1);
6450 data += bytes_read;
6451 state_machine_regs.line += adv;
6452 printf (_(" Advance Line by %d to %d\n"), adv,
6453 state_machine_regs.line);
6454 break;
6455
6456 case DW_LNS_set_file:
6457 adv = read_leb128 (data, & bytes_read, 0);
6458 data += bytes_read;
6459 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6460 adv);
6461 state_machine_regs.file = adv;
6462 break;
6463
6464 case DW_LNS_set_column:
6465 adv = read_leb128 (data, & bytes_read, 0);
6466 data += bytes_read;
6467 printf (_(" Set column to %d\n"), adv);
6468 state_machine_regs.column = adv;
6469 break;
6470
6471 case DW_LNS_negate_stmt:
6472 adv = state_machine_regs.is_stmt;
6473 adv = ! adv;
6474 printf (_(" Set is_stmt to %d\n"), adv);
6475 state_machine_regs.is_stmt = adv;
6476 break;
6477
6478 case DW_LNS_set_basic_block:
6479 printf (_(" Set basic block\n"));
6480 state_machine_regs.basic_block = 1;
6481 break;
6482
6483 case DW_LNS_const_add_pc:
6484 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6485 * info.li_min_insn_length);
6486 state_machine_regs.address += adv;
6487 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6488 state_machine_regs.address);
6489 break;
6490
6491 case DW_LNS_fixed_advance_pc:
6492 adv = byte_get (data, 2);
6493 data += 2;
6494 state_machine_regs.address += adv;
6495 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6496 adv, state_machine_regs.address);
6497 break;
6498
6499 case DW_LNS_set_prologue_end:
6500 printf (_(" Set prologue_end to true\n"));
6501 break;
6502
6503 case DW_LNS_set_epilogue_begin:
6504 printf (_(" Set epilogue_begin to true\n"));
6505 break;
6506
6507 case DW_LNS_set_isa:
6508 adv = read_leb128 (data, & bytes_read, 0);
6509 data += bytes_read;
6510 printf (_(" Set ISA to %d\n"), adv);
6511 break;
6512
6513 default:
6514 printf (_(" Unknown opcode %d with operands: "), op_code);
6515 {
6516 int i;
6517 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6518 {
6519 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6520 i == 1 ? "" : ", ");
6521 data += bytes_read;
6522 }
6523 putchar ('\n');
6524 }
6525 break;
6526 }
6527 }
6528 putchar ('\n');
6529 }
6530
6531 return 1;
6532 }
6533
6534 static int
6535 display_debug_pubnames (Elf_Internal_Shdr *section,
6536 unsigned char *start,
6537 FILE *file ATTRIBUTE_UNUSED)
6538 {
6539 DWARF2_Internal_PubNames pubnames;
6540 unsigned char *end;
6541
6542 end = start + section->sh_size;
6543
6544 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6545
6546 while (start < end)
6547 {
6548 unsigned char *data;
6549 unsigned long offset;
6550 int offset_size, initial_length_size;
6551
6552 data = start;
6553
6554 pubnames.pn_length = byte_get (data, 4);
6555 data += 4;
6556 if (pubnames.pn_length == 0xffffffff)
6557 {
6558 pubnames.pn_length = byte_get (data, 8);
6559 data += 8;
6560 offset_size = 8;
6561 initial_length_size = 12;
6562 }
6563 else
6564 {
6565 offset_size = 4;
6566 initial_length_size = 4;
6567 }
6568
6569 pubnames.pn_version = byte_get (data, 2);
6570 data += 2;
6571 pubnames.pn_offset = byte_get (data, offset_size);
6572 data += offset_size;
6573 pubnames.pn_size = byte_get (data, offset_size);
6574 data += offset_size;
6575
6576 start += pubnames.pn_length + initial_length_size;
6577
6578 if (pubnames.pn_version != 2 && pubnames.pn_version != 3)
6579 {
6580 static int warned = 0;
6581
6582 if (! warned)
6583 {
6584 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6585 warned = 1;
6586 }
6587
6588 continue;
6589 }
6590
6591 printf (_(" Length: %ld\n"),
6592 pubnames.pn_length);
6593 printf (_(" Version: %d\n"),
6594 pubnames.pn_version);
6595 printf (_(" Offset into .debug_info section: %ld\n"),
6596 pubnames.pn_offset);
6597 printf (_(" Size of area in .debug_info section: %ld\n"),
6598 pubnames.pn_size);
6599
6600 printf (_("\n Offset\tName\n"));
6601
6602 do
6603 {
6604 offset = byte_get (data, offset_size);
6605
6606 if (offset != 0)
6607 {
6608 data += offset_size;
6609 printf (" %ld\t\t%s\n", offset, data);
6610 data += strlen ((char *) data) + 1;
6611 }
6612 }
6613 while (offset != 0);
6614 }
6615
6616 printf ("\n");
6617 return 1;
6618 }
6619
6620 static char *
6621 get_TAG_name (unsigned long tag)
6622 {
6623 switch (tag)
6624 {
6625 case DW_TAG_padding: return "DW_TAG_padding";
6626 case DW_TAG_array_type: return "DW_TAG_array_type";
6627 case DW_TAG_class_type: return "DW_TAG_class_type";
6628 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6629 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6630 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6631 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6632 case DW_TAG_label: return "DW_TAG_label";
6633 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6634 case DW_TAG_member: return "DW_TAG_member";
6635 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6636 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6637 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6638 case DW_TAG_string_type: return "DW_TAG_string_type";
6639 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6640 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6641 case DW_TAG_typedef: return "DW_TAG_typedef";
6642 case DW_TAG_union_type: return "DW_TAG_union_type";
6643 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6644 case DW_TAG_variant: return "DW_TAG_variant";
6645 case DW_TAG_common_block: return "DW_TAG_common_block";
6646 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6647 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6648 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6649 case DW_TAG_module: return "DW_TAG_module";
6650 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6651 case DW_TAG_set_type: return "DW_TAG_set_type";
6652 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6653 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6654 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6655 case DW_TAG_base_type: return "DW_TAG_base_type";
6656 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6657 case DW_TAG_const_type: return "DW_TAG_const_type";
6658 case DW_TAG_constant: return "DW_TAG_constant";
6659 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6660 case DW_TAG_file_type: return "DW_TAG_file_type";
6661 case DW_TAG_friend: return "DW_TAG_friend";
6662 case DW_TAG_namelist: return "DW_TAG_namelist";
6663 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6664 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6665 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6666 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6667 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6668 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6669 case DW_TAG_try_block: return "DW_TAG_try_block";
6670 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6671 case DW_TAG_variable: return "DW_TAG_variable";
6672 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6673 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6674 case DW_TAG_format_label: return "DW_TAG_format_label";
6675 case DW_TAG_function_template: return "DW_TAG_function_template";
6676 case DW_TAG_class_template: return "DW_TAG_class_template";
6677 /* DWARF 2.1 values. */
6678 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6679 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6680 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6681 case DW_TAG_namespace: return "DW_TAG_namespace";
6682 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6683 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6684 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6685 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6686 /* UPC values. */
6687 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
6688 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
6689 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
6690 default:
6691 {
6692 static char buffer[100];
6693
6694 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6695 return buffer;
6696 }
6697 }
6698 }
6699
6700 static char *
6701 get_AT_name (unsigned long attribute)
6702 {
6703 switch (attribute)
6704 {
6705 case DW_AT_sibling: return "DW_AT_sibling";
6706 case DW_AT_location: return "DW_AT_location";
6707 case DW_AT_name: return "DW_AT_name";
6708 case DW_AT_ordering: return "DW_AT_ordering";
6709 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6710 case DW_AT_byte_size: return "DW_AT_byte_size";
6711 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6712 case DW_AT_bit_size: return "DW_AT_bit_size";
6713 case DW_AT_element_list: return "DW_AT_element_list";
6714 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6715 case DW_AT_low_pc: return "DW_AT_low_pc";
6716 case DW_AT_high_pc: return "DW_AT_high_pc";
6717 case DW_AT_language: return "DW_AT_language";
6718 case DW_AT_member: return "DW_AT_member";
6719 case DW_AT_discr: return "DW_AT_discr";
6720 case DW_AT_discr_value: return "DW_AT_discr_value";
6721 case DW_AT_visibility: return "DW_AT_visibility";
6722 case DW_AT_import: return "DW_AT_import";
6723 case DW_AT_string_length: return "DW_AT_string_length";
6724 case DW_AT_common_reference: return "DW_AT_common_reference";
6725 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6726 case DW_AT_const_value: return "DW_AT_const_value";
6727 case DW_AT_containing_type: return "DW_AT_containing_type";
6728 case DW_AT_default_value: return "DW_AT_default_value";
6729 case DW_AT_inline: return "DW_AT_inline";
6730 case DW_AT_is_optional: return "DW_AT_is_optional";
6731 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6732 case DW_AT_producer: return "DW_AT_producer";
6733 case DW_AT_prototyped: return "DW_AT_prototyped";
6734 case DW_AT_return_addr: return "DW_AT_return_addr";
6735 case DW_AT_start_scope: return "DW_AT_start_scope";
6736 case DW_AT_stride_size: return "DW_AT_stride_size";
6737 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6738 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6739 case DW_AT_accessibility: return "DW_AT_accessibility";
6740 case DW_AT_address_class: return "DW_AT_address_class";
6741 case DW_AT_artificial: return "DW_AT_artificial";
6742 case DW_AT_base_types: return "DW_AT_base_types";
6743 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6744 case DW_AT_count: return "DW_AT_count";
6745 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6746 case DW_AT_decl_column: return "DW_AT_decl_column";
6747 case DW_AT_decl_file: return "DW_AT_decl_file";
6748 case DW_AT_decl_line: return "DW_AT_decl_line";
6749 case DW_AT_declaration: return "DW_AT_declaration";
6750 case DW_AT_discr_list: return "DW_AT_discr_list";
6751 case DW_AT_encoding: return "DW_AT_encoding";
6752 case DW_AT_external: return "DW_AT_external";
6753 case DW_AT_frame_base: return "DW_AT_frame_base";
6754 case DW_AT_friend: return "DW_AT_friend";
6755 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6756 case DW_AT_macro_info: return "DW_AT_macro_info";
6757 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6758 case DW_AT_priority: return "DW_AT_priority";
6759 case DW_AT_segment: return "DW_AT_segment";
6760 case DW_AT_specification: return "DW_AT_specification";
6761 case DW_AT_static_link: return "DW_AT_static_link";
6762 case DW_AT_type: return "DW_AT_type";
6763 case DW_AT_use_location: return "DW_AT_use_location";
6764 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6765 case DW_AT_virtuality: return "DW_AT_virtuality";
6766 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6767 /* DWARF 2.1 values. */
6768 case DW_AT_allocated: return "DW_AT_allocated";
6769 case DW_AT_associated: return "DW_AT_associated";
6770 case DW_AT_data_location: return "DW_AT_data_location";
6771 case DW_AT_stride: return "DW_AT_stride";
6772 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6773 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6774 case DW_AT_extension: return "DW_AT_extension";
6775 case DW_AT_ranges: return "DW_AT_ranges";
6776 case DW_AT_trampoline: return "DW_AT_trampoline";
6777 case DW_AT_call_column: return "DW_AT_call_column";
6778 case DW_AT_call_file: return "DW_AT_call_file";
6779 case DW_AT_call_line: return "DW_AT_call_line";
6780 /* SGI/MIPS extensions. */
6781 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6782 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6783 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6784 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6785 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6786 case DW_AT_MIPS_software_pipeline_depth:
6787 return "DW_AT_MIPS_software_pipeline_depth";
6788 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6789 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6790 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6791 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6792 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6793 /* GNU extensions. */
6794 case DW_AT_sf_names: return "DW_AT_sf_names";
6795 case DW_AT_src_info: return "DW_AT_src_info";
6796 case DW_AT_mac_info: return "DW_AT_mac_info";
6797 case DW_AT_src_coords: return "DW_AT_src_coords";
6798 case DW_AT_body_begin: return "DW_AT_body_begin";
6799 case DW_AT_body_end: return "DW_AT_body_end";
6800 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6801 /* UPC extension. */
6802 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
6803 default:
6804 {
6805 static char buffer[100];
6806
6807 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6808 return buffer;
6809 }
6810 }
6811 }
6812
6813 static char *
6814 get_FORM_name (unsigned long form)
6815 {
6816 switch (form)
6817 {
6818 case DW_FORM_addr: return "DW_FORM_addr";
6819 case DW_FORM_block2: return "DW_FORM_block2";
6820 case DW_FORM_block4: return "DW_FORM_block4";
6821 case DW_FORM_data2: return "DW_FORM_data2";
6822 case DW_FORM_data4: return "DW_FORM_data4";
6823 case DW_FORM_data8: return "DW_FORM_data8";
6824 case DW_FORM_string: return "DW_FORM_string";
6825 case DW_FORM_block: return "DW_FORM_block";
6826 case DW_FORM_block1: return "DW_FORM_block1";
6827 case DW_FORM_data1: return "DW_FORM_data1";
6828 case DW_FORM_flag: return "DW_FORM_flag";
6829 case DW_FORM_sdata: return "DW_FORM_sdata";
6830 case DW_FORM_strp: return "DW_FORM_strp";
6831 case DW_FORM_udata: return "DW_FORM_udata";
6832 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6833 case DW_FORM_ref1: return "DW_FORM_ref1";
6834 case DW_FORM_ref2: return "DW_FORM_ref2";
6835 case DW_FORM_ref4: return "DW_FORM_ref4";
6836 case DW_FORM_ref8: return "DW_FORM_ref8";
6837 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6838 case DW_FORM_indirect: return "DW_FORM_indirect";
6839 default:
6840 {
6841 static char buffer[100];
6842
6843 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6844 return buffer;
6845 }
6846 }
6847 }
6848
6849 /* FIXME: There are better and more effiecint ways to handle
6850 these structures. For now though, I just want something that
6851 is simple to implement. */
6852 typedef struct abbrev_attr
6853 {
6854 unsigned long attribute;
6855 unsigned long form;
6856 struct abbrev_attr *next;
6857 }
6858 abbrev_attr;
6859
6860 typedef struct abbrev_entry
6861 {
6862 unsigned long entry;
6863 unsigned long tag;
6864 int children;
6865 struct abbrev_attr *first_attr;
6866 struct abbrev_attr *last_attr;
6867 struct abbrev_entry *next;
6868 }
6869 abbrev_entry;
6870
6871 static abbrev_entry *first_abbrev = NULL;
6872 static abbrev_entry *last_abbrev = NULL;
6873
6874 static void
6875 free_abbrevs (void)
6876 {
6877 abbrev_entry *abbrev;
6878
6879 for (abbrev = first_abbrev; abbrev;)
6880 {
6881 abbrev_entry *next = abbrev->next;
6882 abbrev_attr *attr;
6883
6884 for (attr = abbrev->first_attr; attr;)
6885 {
6886 abbrev_attr *next = attr->next;
6887
6888 free (attr);
6889 attr = next;
6890 }
6891
6892 free (abbrev);
6893 abbrev = next;
6894 }
6895
6896 last_abbrev = first_abbrev = NULL;
6897 }
6898
6899 static void
6900 add_abbrev (unsigned long number, unsigned long tag, int children)
6901 {
6902 abbrev_entry *entry;
6903
6904 entry = malloc (sizeof (*entry));
6905
6906 if (entry == NULL)
6907 /* ugg */
6908 return;
6909
6910 entry->entry = number;
6911 entry->tag = tag;
6912 entry->children = children;
6913 entry->first_attr = NULL;
6914 entry->last_attr = NULL;
6915 entry->next = NULL;
6916
6917 if (first_abbrev == NULL)
6918 first_abbrev = entry;
6919 else
6920 last_abbrev->next = entry;
6921
6922 last_abbrev = entry;
6923 }
6924
6925 static void
6926 add_abbrev_attr (unsigned long attribute, unsigned long form)
6927 {
6928 abbrev_attr *attr;
6929
6930 attr = malloc (sizeof (*attr));
6931
6932 if (attr == NULL)
6933 /* ugg */
6934 return;
6935
6936 attr->attribute = attribute;
6937 attr->form = form;
6938 attr->next = NULL;
6939
6940 if (last_abbrev->first_attr == NULL)
6941 last_abbrev->first_attr = attr;
6942 else
6943 last_abbrev->last_attr->next = attr;
6944
6945 last_abbrev->last_attr = attr;
6946 }
6947
6948 /* Processes the (partial) contents of a .debug_abbrev section.
6949 Returns NULL if the end of the section was encountered.
6950 Returns the address after the last byte read if the end of
6951 an abbreviation set was found. */
6952
6953 static unsigned char *
6954 process_abbrev_section (unsigned char *start, unsigned char *end)
6955 {
6956 if (first_abbrev != NULL)
6957 return NULL;
6958
6959 while (start < end)
6960 {
6961 int bytes_read;
6962 unsigned long entry;
6963 unsigned long tag;
6964 unsigned long attribute;
6965 int children;
6966
6967 entry = read_leb128 (start, & bytes_read, 0);
6968 start += bytes_read;
6969
6970 /* A single zero is supposed to end the section according
6971 to the standard. If there's more, then signal that to
6972 the caller. */
6973 if (entry == 0)
6974 return start == end ? NULL : start;
6975
6976 tag = read_leb128 (start, & bytes_read, 0);
6977 start += bytes_read;
6978
6979 children = *start++;
6980
6981 add_abbrev (entry, tag, children);
6982
6983 do
6984 {
6985 unsigned long form;
6986
6987 attribute = read_leb128 (start, & bytes_read, 0);
6988 start += bytes_read;
6989
6990 form = read_leb128 (start, & bytes_read, 0);
6991 start += bytes_read;
6992
6993 if (attribute != 0)
6994 add_abbrev_attr (attribute, form);
6995 }
6996 while (attribute != 0);
6997 }
6998
6999 return NULL;
7000 }
7001
7002
7003 static int
7004 display_debug_macinfo (Elf_Internal_Shdr *section,
7005 unsigned char *start,
7006 FILE *file ATTRIBUTE_UNUSED)
7007 {
7008 unsigned char *end = start + section->sh_size;
7009 unsigned char *curr = start;
7010 unsigned int bytes_read;
7011 enum dwarf_macinfo_record_type op;
7012
7013 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7014
7015 while (curr < end)
7016 {
7017 unsigned int lineno;
7018 const char *string;
7019
7020 op = *curr;
7021 curr++;
7022
7023 switch (op)
7024 {
7025 case DW_MACINFO_start_file:
7026 {
7027 unsigned int filenum;
7028
7029 lineno = read_leb128 (curr, & bytes_read, 0);
7030 curr += bytes_read;
7031 filenum = read_leb128 (curr, & bytes_read, 0);
7032 curr += bytes_read;
7033
7034 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
7035 }
7036 break;
7037
7038 case DW_MACINFO_end_file:
7039 printf (_(" DW_MACINFO_end_file\n"));
7040 break;
7041
7042 case DW_MACINFO_define:
7043 lineno = read_leb128 (curr, & bytes_read, 0);
7044 curr += bytes_read;
7045 string = curr;
7046 curr += strlen (string) + 1;
7047 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
7048 break;
7049
7050 case DW_MACINFO_undef:
7051 lineno = read_leb128 (curr, & bytes_read, 0);
7052 curr += bytes_read;
7053 string = curr;
7054 curr += strlen (string) + 1;
7055 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
7056 break;
7057
7058 case DW_MACINFO_vendor_ext:
7059 {
7060 unsigned int constant;
7061
7062 constant = read_leb128 (curr, & bytes_read, 0);
7063 curr += bytes_read;
7064 string = curr;
7065 curr += strlen (string) + 1;
7066 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
7067 }
7068 break;
7069 }
7070 }
7071
7072 return 1;
7073 }
7074
7075
7076 static int
7077 display_debug_abbrev (Elf_Internal_Shdr *section,
7078 unsigned char *start,
7079 FILE *file ATTRIBUTE_UNUSED)
7080 {
7081 abbrev_entry *entry;
7082 unsigned char *end = start + section->sh_size;
7083
7084 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7085
7086 do
7087 {
7088 start = process_abbrev_section (start, end);
7089
7090 if (first_abbrev == NULL)
7091 continue;
7092
7093 printf (_(" Number TAG\n"));
7094
7095 for (entry = first_abbrev; entry; entry = entry->next)
7096 {
7097 abbrev_attr *attr;
7098
7099 printf (_(" %ld %s [%s]\n"),
7100 entry->entry,
7101 get_TAG_name (entry->tag),
7102 entry->children ? _("has children") : _("no children"));
7103
7104 for (attr = entry->first_attr; attr; attr = attr->next)
7105 {
7106 printf (_(" %-18s %s\n"),
7107 get_AT_name (attr->attribute),
7108 get_FORM_name (attr->form));
7109 }
7110 }
7111
7112 free_abbrevs ();
7113 }
7114 while (start);
7115
7116 printf ("\n");
7117
7118 return 1;
7119 }
7120
7121
7122 static unsigned char *
7123 display_block (unsigned char *data, unsigned long length)
7124 {
7125 printf (_(" %lu byte block: "), length);
7126
7127 while (length --)
7128 printf ("%lx ", (unsigned long) byte_get (data++, 1));
7129
7130 return data;
7131 }
7132
7133 static void
7134 decode_location_expression (unsigned char * data,
7135 unsigned int pointer_size,
7136 unsigned long length)
7137 {
7138 unsigned op;
7139 int bytes_read;
7140 unsigned long uvalue;
7141 unsigned char *end = data + length;
7142
7143 while (data < end)
7144 {
7145 op = *data++;
7146
7147 switch (op)
7148 {
7149 case DW_OP_addr:
7150 printf ("DW_OP_addr: %lx",
7151 (unsigned long) byte_get (data, pointer_size));
7152 data += pointer_size;
7153 break;
7154 case DW_OP_deref:
7155 printf ("DW_OP_deref");
7156 break;
7157 case DW_OP_const1u:
7158 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7159 break;
7160 case DW_OP_const1s:
7161 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7162 break;
7163 case DW_OP_const2u:
7164 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7165 data += 2;
7166 break;
7167 case DW_OP_const2s:
7168 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7169 data += 2;
7170 break;
7171 case DW_OP_const4u:
7172 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7173 data += 4;
7174 break;
7175 case DW_OP_const4s:
7176 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7177 data += 4;
7178 break;
7179 case DW_OP_const8u:
7180 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7181 (unsigned long) byte_get (data + 4, 4));
7182 data += 8;
7183 break;
7184 case DW_OP_const8s:
7185 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7186 (long) byte_get (data + 4, 4));
7187 data += 8;
7188 break;
7189 case DW_OP_constu:
7190 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7191 data += bytes_read;
7192 break;
7193 case DW_OP_consts:
7194 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7195 data += bytes_read;
7196 break;
7197 case DW_OP_dup:
7198 printf ("DW_OP_dup");
7199 break;
7200 case DW_OP_drop:
7201 printf ("DW_OP_drop");
7202 break;
7203 case DW_OP_over:
7204 printf ("DW_OP_over");
7205 break;
7206 case DW_OP_pick:
7207 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7208 break;
7209 case DW_OP_swap:
7210 printf ("DW_OP_swap");
7211 break;
7212 case DW_OP_rot:
7213 printf ("DW_OP_rot");
7214 break;
7215 case DW_OP_xderef:
7216 printf ("DW_OP_xderef");
7217 break;
7218 case DW_OP_abs:
7219 printf ("DW_OP_abs");
7220 break;
7221 case DW_OP_and:
7222 printf ("DW_OP_and");
7223 break;
7224 case DW_OP_div:
7225 printf ("DW_OP_div");
7226 break;
7227 case DW_OP_minus:
7228 printf ("DW_OP_minus");
7229 break;
7230 case DW_OP_mod:
7231 printf ("DW_OP_mod");
7232 break;
7233 case DW_OP_mul:
7234 printf ("DW_OP_mul");
7235 break;
7236 case DW_OP_neg:
7237 printf ("DW_OP_neg");
7238 break;
7239 case DW_OP_not:
7240 printf ("DW_OP_not");
7241 break;
7242 case DW_OP_or:
7243 printf ("DW_OP_or");
7244 break;
7245 case DW_OP_plus:
7246 printf ("DW_OP_plus");
7247 break;
7248 case DW_OP_plus_uconst:
7249 printf ("DW_OP_plus_uconst: %lu",
7250 read_leb128 (data, &bytes_read, 0));
7251 data += bytes_read;
7252 break;
7253 case DW_OP_shl:
7254 printf ("DW_OP_shl");
7255 break;
7256 case DW_OP_shr:
7257 printf ("DW_OP_shr");
7258 break;
7259 case DW_OP_shra:
7260 printf ("DW_OP_shra");
7261 break;
7262 case DW_OP_xor:
7263 printf ("DW_OP_xor");
7264 break;
7265 case DW_OP_bra:
7266 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7267 data += 2;
7268 break;
7269 case DW_OP_eq:
7270 printf ("DW_OP_eq");
7271 break;
7272 case DW_OP_ge:
7273 printf ("DW_OP_ge");
7274 break;
7275 case DW_OP_gt:
7276 printf ("DW_OP_gt");
7277 break;
7278 case DW_OP_le:
7279 printf ("DW_OP_le");
7280 break;
7281 case DW_OP_lt:
7282 printf ("DW_OP_lt");
7283 break;
7284 case DW_OP_ne:
7285 printf ("DW_OP_ne");
7286 break;
7287 case DW_OP_skip:
7288 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7289 data += 2;
7290 break;
7291
7292 case DW_OP_lit0:
7293 case DW_OP_lit1:
7294 case DW_OP_lit2:
7295 case DW_OP_lit3:
7296 case DW_OP_lit4:
7297 case DW_OP_lit5:
7298 case DW_OP_lit6:
7299 case DW_OP_lit7:
7300 case DW_OP_lit8:
7301 case DW_OP_lit9:
7302 case DW_OP_lit10:
7303 case DW_OP_lit11:
7304 case DW_OP_lit12:
7305 case DW_OP_lit13:
7306 case DW_OP_lit14:
7307 case DW_OP_lit15:
7308 case DW_OP_lit16:
7309 case DW_OP_lit17:
7310 case DW_OP_lit18:
7311 case DW_OP_lit19:
7312 case DW_OP_lit20:
7313 case DW_OP_lit21:
7314 case DW_OP_lit22:
7315 case DW_OP_lit23:
7316 case DW_OP_lit24:
7317 case DW_OP_lit25:
7318 case DW_OP_lit26:
7319 case DW_OP_lit27:
7320 case DW_OP_lit28:
7321 case DW_OP_lit29:
7322 case DW_OP_lit30:
7323 case DW_OP_lit31:
7324 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7325 break;
7326
7327 case DW_OP_reg0:
7328 case DW_OP_reg1:
7329 case DW_OP_reg2:
7330 case DW_OP_reg3:
7331 case DW_OP_reg4:
7332 case DW_OP_reg5:
7333 case DW_OP_reg6:
7334 case DW_OP_reg7:
7335 case DW_OP_reg8:
7336 case DW_OP_reg9:
7337 case DW_OP_reg10:
7338 case DW_OP_reg11:
7339 case DW_OP_reg12:
7340 case DW_OP_reg13:
7341 case DW_OP_reg14:
7342 case DW_OP_reg15:
7343 case DW_OP_reg16:
7344 case DW_OP_reg17:
7345 case DW_OP_reg18:
7346 case DW_OP_reg19:
7347 case DW_OP_reg20:
7348 case DW_OP_reg21:
7349 case DW_OP_reg22:
7350 case DW_OP_reg23:
7351 case DW_OP_reg24:
7352 case DW_OP_reg25:
7353 case DW_OP_reg26:
7354 case DW_OP_reg27:
7355 case DW_OP_reg28:
7356 case DW_OP_reg29:
7357 case DW_OP_reg30:
7358 case DW_OP_reg31:
7359 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7360 break;
7361
7362 case DW_OP_breg0:
7363 case DW_OP_breg1:
7364 case DW_OP_breg2:
7365 case DW_OP_breg3:
7366 case DW_OP_breg4:
7367 case DW_OP_breg5:
7368 case DW_OP_breg6:
7369 case DW_OP_breg7:
7370 case DW_OP_breg8:
7371 case DW_OP_breg9:
7372 case DW_OP_breg10:
7373 case DW_OP_breg11:
7374 case DW_OP_breg12:
7375 case DW_OP_breg13:
7376 case DW_OP_breg14:
7377 case DW_OP_breg15:
7378 case DW_OP_breg16:
7379 case DW_OP_breg17:
7380 case DW_OP_breg18:
7381 case DW_OP_breg19:
7382 case DW_OP_breg20:
7383 case DW_OP_breg21:
7384 case DW_OP_breg22:
7385 case DW_OP_breg23:
7386 case DW_OP_breg24:
7387 case DW_OP_breg25:
7388 case DW_OP_breg26:
7389 case DW_OP_breg27:
7390 case DW_OP_breg28:
7391 case DW_OP_breg29:
7392 case DW_OP_breg30:
7393 case DW_OP_breg31:
7394 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7395 read_leb128 (data, &bytes_read, 1));
7396 data += bytes_read;
7397 break;
7398
7399 case DW_OP_regx:
7400 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7401 data += bytes_read;
7402 break;
7403 case DW_OP_fbreg:
7404 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7405 data += bytes_read;
7406 break;
7407 case DW_OP_bregx:
7408 uvalue = read_leb128 (data, &bytes_read, 0);
7409 data += bytes_read;
7410 printf ("DW_OP_bregx: %lu %ld", uvalue,
7411 read_leb128 (data, &bytes_read, 1));
7412 data += bytes_read;
7413 break;
7414 case DW_OP_piece:
7415 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7416 data += bytes_read;
7417 break;
7418 case DW_OP_deref_size:
7419 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7420 break;
7421 case DW_OP_xderef_size:
7422 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7423 break;
7424 case DW_OP_nop:
7425 printf ("DW_OP_nop");
7426 break;
7427
7428 /* DWARF 3 extensions. */
7429 case DW_OP_push_object_address:
7430 printf ("DW_OP_push_object_address");
7431 break;
7432 case DW_OP_call2:
7433 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7434 data += 2;
7435 break;
7436 case DW_OP_call4:
7437 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7438 data += 4;
7439 break;
7440 case DW_OP_call_ref:
7441 printf ("DW_OP_call_ref");
7442 break;
7443
7444 /* GNU extensions. */
7445 case DW_OP_GNU_push_tls_address:
7446 printf ("DW_OP_GNU_push_tls_address");
7447 break;
7448
7449 default:
7450 if (op >= DW_OP_lo_user
7451 && op <= DW_OP_hi_user)
7452 printf (_("(User defined location op)"));
7453 else
7454 printf (_("(Unknown location op)"));
7455 /* No way to tell where the next op is, so just bail. */
7456 return;
7457 }
7458
7459 /* Separate the ops. */
7460 if (data < end)
7461 printf ("; ");
7462 }
7463 }
7464
7465 static const char *debug_loc_contents;
7466 static bfd_vma debug_loc_size;
7467
7468 static void
7469 load_debug_loc (FILE *file)
7470 {
7471 Elf_Internal_Shdr *sec;
7472 unsigned int i;
7473
7474 /* If it is already loaded, do nothing. */
7475 if (debug_loc_contents != NULL)
7476 return;
7477
7478 /* Locate the .debug_loc section. */
7479 for (i = 0, sec = section_headers;
7480 i < elf_header.e_shnum;
7481 i++, sec++)
7482 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7483 break;
7484
7485 if (i == elf_header.e_shnum || sec->sh_size == 0)
7486 return;
7487
7488 debug_loc_size = sec->sh_size;
7489
7490 debug_loc_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7491 _("debug_loc section data"));
7492 }
7493
7494 static void
7495 free_debug_loc (void)
7496 {
7497 if (debug_loc_contents == NULL)
7498 return;
7499
7500 free ((char *) debug_loc_contents);
7501 debug_loc_contents = NULL;
7502 debug_loc_size = 0;
7503 }
7504
7505
7506 static int
7507 display_debug_loc (Elf_Internal_Shdr *section,
7508 unsigned char *start,
7509 FILE *file ATTRIBUTE_UNUSED)
7510 {
7511 unsigned char *section_end;
7512 unsigned long bytes;
7513 unsigned char *section_begin = start;
7514 bfd_vma addr;
7515
7516 addr = section->sh_addr;
7517 bytes = section->sh_size;
7518 section_end = start + bytes;
7519
7520 if (bytes == 0)
7521 {
7522 printf (_("\nThe .debug_loc section is empty.\n"));
7523 return 0;
7524 }
7525
7526 printf (_("Contents of the .debug_loc section:\n\n"));
7527 printf (_("\n Offset Begin End Expression\n"));
7528
7529 while (start < section_end)
7530 {
7531 unsigned long begin;
7532 unsigned long end;
7533 unsigned short length;
7534 unsigned long offset;
7535
7536 offset = start - section_begin;
7537
7538 while (1)
7539 {
7540 /* Normally, the lists in the debug_loc section are related to a
7541 given compilation unit, and thus, we would use the pointer size
7542 of that compilation unit. However, since we are displaying it
7543 seperately here, we either have to store pointer sizes of all
7544 compilation units, or assume they don't change. We assume,
7545 like the debug_line display, that it doesn't change. */
7546 begin = byte_get (start, debug_line_pointer_size);
7547 start += debug_line_pointer_size;
7548 end = byte_get (start, debug_line_pointer_size);
7549 start += debug_line_pointer_size;
7550
7551 if (begin == 0 && end == 0)
7552 break;
7553
7554 /* For now, skip any base address specifiers. */
7555 if (begin == 0xffffffff)
7556 continue;
7557
7558 begin += addr;
7559 end += addr;
7560
7561 length = byte_get (start, 2);
7562 start += 2;
7563
7564 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7565 decode_location_expression (start, debug_line_pointer_size, length);
7566 printf (")\n");
7567
7568 start += length;
7569 }
7570 printf ("\n");
7571 }
7572 return 1;
7573 }
7574
7575 static const char *debug_str_contents;
7576 static bfd_vma debug_str_size;
7577
7578 static void
7579 load_debug_str (FILE *file)
7580 {
7581 Elf_Internal_Shdr *sec;
7582 unsigned int i;
7583
7584 /* If it is already loaded, do nothing. */
7585 if (debug_str_contents != NULL)
7586 return;
7587
7588 /* Locate the .debug_str section. */
7589 for (i = 0, sec = section_headers;
7590 i < elf_header.e_shnum;
7591 i++, sec++)
7592 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7593 break;
7594
7595 if (i == elf_header.e_shnum || sec->sh_size == 0)
7596 return;
7597
7598 debug_str_size = sec->sh_size;
7599
7600 debug_str_contents = get_data (NULL, file, sec->sh_offset, sec->sh_size,
7601 _("debug_str section data"));
7602 }
7603
7604 static void
7605 free_debug_str (void)
7606 {
7607 if (debug_str_contents == NULL)
7608 return;
7609
7610 free ((char *) debug_str_contents);
7611 debug_str_contents = NULL;
7612 debug_str_size = 0;
7613 }
7614
7615 static const char *
7616 fetch_indirect_string (unsigned long offset)
7617 {
7618 if (debug_str_contents == NULL)
7619 return _("<no .debug_str section>");
7620
7621 if (offset > debug_str_size)
7622 return _("<offset is too big>");
7623
7624 return debug_str_contents + offset;
7625 }
7626
7627 static int
7628 display_debug_str (Elf_Internal_Shdr *section,
7629 unsigned char *start,
7630 FILE *file ATTRIBUTE_UNUSED)
7631 {
7632 unsigned long bytes;
7633 bfd_vma addr;
7634
7635 addr = section->sh_addr;
7636 bytes = section->sh_size;
7637
7638 if (bytes == 0)
7639 {
7640 printf (_("\nThe .debug_str section is empty.\n"));
7641 return 0;
7642 }
7643
7644 printf (_("Contents of the .debug_str section:\n\n"));
7645
7646 while (bytes)
7647 {
7648 int j;
7649 int k;
7650 int lbytes;
7651
7652 lbytes = (bytes > 16 ? 16 : bytes);
7653
7654 printf (" 0x%8.8lx ", (unsigned long) addr);
7655
7656 for (j = 0; j < 16; j++)
7657 {
7658 if (j < lbytes)
7659 printf ("%2.2x", start[j]);
7660 else
7661 printf (" ");
7662
7663 if ((j & 3) == 3)
7664 printf (" ");
7665 }
7666
7667 for (j = 0; j < lbytes; j++)
7668 {
7669 k = start[j];
7670 if (k >= ' ' && k < 0x80)
7671 printf ("%c", k);
7672 else
7673 printf (".");
7674 }
7675
7676 putchar ('\n');
7677
7678 start += lbytes;
7679 addr += lbytes;
7680 bytes -= lbytes;
7681 }
7682
7683 return 1;
7684 }
7685
7686 static unsigned char *
7687 read_and_display_attr_value (unsigned long attribute,
7688 unsigned long form,
7689 unsigned char *data,
7690 unsigned long cu_offset,
7691 unsigned long pointer_size,
7692 unsigned long offset_size,
7693 int dwarf_version)
7694 {
7695 unsigned long uvalue = 0;
7696 unsigned char *block_start = NULL;
7697 int bytes_read;
7698
7699 switch (form)
7700 {
7701 default:
7702 break;
7703
7704 case DW_FORM_ref_addr:
7705 if (dwarf_version == 2)
7706 {
7707 uvalue = byte_get (data, pointer_size);
7708 data += pointer_size;
7709 }
7710 else if (dwarf_version == 3)
7711 {
7712 uvalue = byte_get (data, offset_size);
7713 data += offset_size;
7714 }
7715 else
7716 {
7717 error (_("Internal error: DWARF version is not 2 or 3.\n"));
7718 }
7719 break;
7720
7721 case DW_FORM_addr:
7722 uvalue = byte_get (data, pointer_size);
7723 data += pointer_size;
7724 break;
7725
7726 case DW_FORM_strp:
7727 uvalue = byte_get (data, offset_size);
7728 data += offset_size;
7729 break;
7730
7731 case DW_FORM_ref1:
7732 case DW_FORM_flag:
7733 case DW_FORM_data1:
7734 uvalue = byte_get (data++, 1);
7735 break;
7736
7737 case DW_FORM_ref2:
7738 case DW_FORM_data2:
7739 uvalue = byte_get (data, 2);
7740 data += 2;
7741 break;
7742
7743 case DW_FORM_ref4:
7744 case DW_FORM_data4:
7745 uvalue = byte_get (data, 4);
7746 data += 4;
7747 break;
7748
7749 case DW_FORM_sdata:
7750 uvalue = read_leb128 (data, & bytes_read, 1);
7751 data += bytes_read;
7752 break;
7753
7754 case DW_FORM_ref_udata:
7755 case DW_FORM_udata:
7756 uvalue = read_leb128 (data, & bytes_read, 0);
7757 data += bytes_read;
7758 break;
7759
7760 case DW_FORM_indirect:
7761 form = read_leb128 (data, & bytes_read, 0);
7762 data += bytes_read;
7763 printf (" %s", get_FORM_name (form));
7764 return read_and_display_attr_value (attribute, form, data, cu_offset,
7765 pointer_size, offset_size,
7766 dwarf_version);
7767 }
7768
7769 switch (form)
7770 {
7771 case DW_FORM_ref_addr:
7772 printf (" <#%lx>", uvalue);
7773 break;
7774
7775 case DW_FORM_ref1:
7776 case DW_FORM_ref2:
7777 case DW_FORM_ref4:
7778 case DW_FORM_ref_udata:
7779 printf (" <%lx>", uvalue + cu_offset);
7780 break;
7781
7782 case DW_FORM_addr:
7783 printf (" %#lx", uvalue);
7784
7785 case DW_FORM_flag:
7786 case DW_FORM_data1:
7787 case DW_FORM_data2:
7788 case DW_FORM_data4:
7789 case DW_FORM_sdata:
7790 case DW_FORM_udata:
7791 printf (" %ld", uvalue);
7792 break;
7793
7794 case DW_FORM_ref8:
7795 case DW_FORM_data8:
7796 uvalue = byte_get (data, 4);
7797 printf (" %lx", uvalue);
7798 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7799 data += 8;
7800 break;
7801
7802 case DW_FORM_string:
7803 printf (" %s", data);
7804 data += strlen ((char *) data) + 1;
7805 break;
7806
7807 case DW_FORM_block:
7808 uvalue = read_leb128 (data, & bytes_read, 0);
7809 block_start = data + bytes_read;
7810 data = display_block (block_start, uvalue);
7811 break;
7812
7813 case DW_FORM_block1:
7814 uvalue = byte_get (data, 1);
7815 block_start = data + 1;
7816 data = display_block (block_start, uvalue);
7817 break;
7818
7819 case DW_FORM_block2:
7820 uvalue = byte_get (data, 2);
7821 block_start = data + 2;
7822 data = display_block (block_start, uvalue);
7823 break;
7824
7825 case DW_FORM_block4:
7826 uvalue = byte_get (data, 4);
7827 block_start = data + 4;
7828 data = display_block (block_start, uvalue);
7829 break;
7830
7831 case DW_FORM_strp:
7832 printf (_(" (indirect string, offset: 0x%lx): %s"),
7833 uvalue, fetch_indirect_string (uvalue));
7834 break;
7835
7836 case DW_FORM_indirect:
7837 /* Handled above. */
7838 break;
7839
7840 default:
7841 warn (_("Unrecognized form: %d\n"), form);
7842 break;
7843 }
7844
7845 /* For some attributes we can display futher information. */
7846
7847 printf ("\t");
7848
7849 switch (attribute)
7850 {
7851 case DW_AT_inline:
7852 switch (uvalue)
7853 {
7854 case DW_INL_not_inlined:
7855 printf (_("(not inlined)"));
7856 break;
7857 case DW_INL_inlined:
7858 printf (_("(inlined)"));
7859 break;
7860 case DW_INL_declared_not_inlined:
7861 printf (_("(declared as inline but ignored)"));
7862 break;
7863 case DW_INL_declared_inlined:
7864 printf (_("(declared as inline and inlined)"));
7865 break;
7866 default:
7867 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
7868 break;
7869 }
7870 break;
7871
7872 case DW_AT_language:
7873 switch (uvalue)
7874 {
7875 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7876 case DW_LANG_C89: printf ("(ANSI C)"); break;
7877 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7878 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7879 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7880 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7881 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7882 case DW_LANG_Ada83: printf ("(Ada)"); break;
7883 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7884 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7885 /* DWARF 2.1 values. */
7886 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7887 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7888 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7889 /* MIPS extension. */
7890 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7891 /* UPC extension. */
7892 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
7893 default:
7894 printf ("(Unknown: %lx)", uvalue);
7895 break;
7896 }
7897 break;
7898
7899 case DW_AT_encoding:
7900 switch (uvalue)
7901 {
7902 case DW_ATE_void: printf ("(void)"); break;
7903 case DW_ATE_address: printf ("(machine address)"); break;
7904 case DW_ATE_boolean: printf ("(boolean)"); break;
7905 case DW_ATE_complex_float: printf ("(complex float)"); break;
7906 case DW_ATE_float: printf ("(float)"); break;
7907 case DW_ATE_signed: printf ("(signed)"); break;
7908 case DW_ATE_signed_char: printf ("(signed char)"); break;
7909 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7910 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7911 /* DWARF 2.1 value. */
7912 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7913 default:
7914 if (uvalue >= DW_ATE_lo_user
7915 && uvalue <= DW_ATE_hi_user)
7916 printf ("(user defined type)");
7917 else
7918 printf ("(unknown type)");
7919 break;
7920 }
7921 break;
7922
7923 case DW_AT_accessibility:
7924 switch (uvalue)
7925 {
7926 case DW_ACCESS_public: printf ("(public)"); break;
7927 case DW_ACCESS_protected: printf ("(protected)"); break;
7928 case DW_ACCESS_private: printf ("(private)"); break;
7929 default:
7930 printf ("(unknown accessibility)");
7931 break;
7932 }
7933 break;
7934
7935 case DW_AT_visibility:
7936 switch (uvalue)
7937 {
7938 case DW_VIS_local: printf ("(local)"); break;
7939 case DW_VIS_exported: printf ("(exported)"); break;
7940 case DW_VIS_qualified: printf ("(qualified)"); break;
7941 default: printf ("(unknown visibility)"); break;
7942 }
7943 break;
7944
7945 case DW_AT_virtuality:
7946 switch (uvalue)
7947 {
7948 case DW_VIRTUALITY_none: printf ("(none)"); break;
7949 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7950 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7951 default: printf ("(unknown virtuality)"); break;
7952 }
7953 break;
7954
7955 case DW_AT_identifier_case:
7956 switch (uvalue)
7957 {
7958 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7959 case DW_ID_up_case: printf ("(up_case)"); break;
7960 case DW_ID_down_case: printf ("(down_case)"); break;
7961 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7962 default: printf ("(unknown case)"); break;
7963 }
7964 break;
7965
7966 case DW_AT_calling_convention:
7967 switch (uvalue)
7968 {
7969 case DW_CC_normal: printf ("(normal)"); break;
7970 case DW_CC_program: printf ("(program)"); break;
7971 case DW_CC_nocall: printf ("(nocall)"); break;
7972 default:
7973 if (uvalue >= DW_CC_lo_user
7974 && uvalue <= DW_CC_hi_user)
7975 printf ("(user defined)");
7976 else
7977 printf ("(unknown convention)");
7978 }
7979 break;
7980
7981 case DW_AT_ordering:
7982 switch (uvalue)
7983 {
7984 case -1: printf ("(undefined)"); break;
7985 case 0: printf ("(row major)"); break;
7986 case 1: printf ("(column major)"); break;
7987 }
7988 break;
7989
7990 case DW_AT_frame_base:
7991 case DW_AT_location:
7992 case DW_AT_data_member_location:
7993 case DW_AT_vtable_elem_location:
7994 case DW_AT_allocated:
7995 case DW_AT_associated:
7996 case DW_AT_data_location:
7997 case DW_AT_stride:
7998 case DW_AT_upper_bound:
7999 case DW_AT_lower_bound:
8000 if (block_start)
8001 {
8002 printf ("(");
8003 decode_location_expression (block_start, pointer_size, uvalue);
8004 printf (")");
8005 }
8006 else if (form == DW_FORM_data4 || form == DW_FORM_data8)
8007 {
8008 printf ("(");
8009 printf ("location list");
8010 printf (")");
8011 }
8012 break;
8013
8014 default:
8015 break;
8016 }
8017
8018 return data;
8019 }
8020
8021 static unsigned char *
8022 read_and_display_attr (unsigned long attribute,
8023 unsigned long form,
8024 unsigned char *data,
8025 unsigned long cu_offset,
8026 unsigned long pointer_size,
8027 unsigned long offset_size,
8028 int dwarf_version)
8029 {
8030 printf (" %-18s:", get_AT_name (attribute));
8031 data = read_and_display_attr_value (attribute, form, data, cu_offset,
8032 pointer_size, offset_size, dwarf_version);
8033 printf ("\n");
8034 return data;
8035 }
8036
8037 static int
8038 display_debug_info (Elf_Internal_Shdr *section,
8039 unsigned char *start,
8040 FILE *file)
8041 {
8042 unsigned char *end = start + section->sh_size;
8043 unsigned char *section_begin = start;
8044
8045 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8046
8047 load_debug_str (file);
8048 load_debug_loc (file);
8049
8050 while (start < end)
8051 {
8052 DWARF2_Internal_CompUnit compunit;
8053 Elf_Internal_Shdr *relsec;
8054 unsigned char *hdrptr;
8055 unsigned char *cu_abbrev_offset_ptr;
8056 unsigned char *tags;
8057 unsigned int i;
8058 int level;
8059 unsigned long cu_offset;
8060 int offset_size;
8061 int initial_length_size;
8062
8063 hdrptr = start;
8064
8065 compunit.cu_length = byte_get (hdrptr, 4);
8066 hdrptr += 4;
8067
8068 if (compunit.cu_length == 0xffffffff)
8069 {
8070 compunit.cu_length = byte_get (hdrptr, 8);
8071 hdrptr += 8;
8072 offset_size = 8;
8073 initial_length_size = 12;
8074 }
8075 else
8076 {
8077 offset_size = 4;
8078 initial_length_size = 4;
8079 }
8080
8081 compunit.cu_version = byte_get (hdrptr, 2);
8082 hdrptr += 2;
8083
8084 /* Apply addends of RELA relocations. */
8085 for (relsec = section_headers;
8086 relsec < section_headers + elf_header.e_shnum;
8087 ++relsec)
8088 {
8089 unsigned long nrelas;
8090 Elf_Internal_Rela *rela, *rp;
8091 Elf_Internal_Shdr *symsec;
8092 Elf_Internal_Sym *symtab;
8093 Elf_Internal_Sym *sym;
8094
8095 if (relsec->sh_type != SHT_RELA
8096 || SECTION_HEADER (relsec->sh_info) != section
8097 || relsec->sh_size == 0)
8098 continue;
8099
8100 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8101 & rela, & nrelas))
8102 return 0;
8103
8104 symsec = SECTION_HEADER (relsec->sh_link);
8105 symtab = GET_ELF_SYMBOLS (file, symsec);
8106
8107 for (rp = rela; rp < rela + nrelas; ++rp)
8108 {
8109 unsigned char *loc;
8110
8111 if (rp->r_offset >= (bfd_vma) (hdrptr - section_begin)
8112 && section->sh_size > (bfd_vma) offset_size
8113 && rp->r_offset <= section->sh_size - offset_size)
8114 loc = section_begin + rp->r_offset;
8115 else
8116 continue;
8117
8118 if (is_32bit_elf)
8119 {
8120 sym = symtab + ELF32_R_SYM (rp->r_info);
8121
8122 if (ELF32_R_SYM (rp->r_info) != 0
8123 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
8124 {
8125 warn (_("Skipping unexpected symbol type %u\n"),
8126 ELF32_ST_TYPE (sym->st_info));
8127 continue;
8128 }
8129 }
8130 else
8131 {
8132 sym = symtab + ELF64_R_SYM (rp->r_info);
8133
8134 if (ELF64_R_SYM (rp->r_info) != 0
8135 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8136 {
8137 warn (_("Skipping unexpected symbol type %u\n"),
8138 ELF64_ST_TYPE (sym->st_info));
8139 continue;
8140 }
8141 }
8142
8143 byte_put (loc, rp->r_addend, offset_size);
8144 }
8145
8146 free (rela);
8147 break;
8148 }
8149
8150 cu_abbrev_offset_ptr = hdrptr;
8151 compunit.cu_abbrev_offset = byte_get (hdrptr, offset_size);
8152 hdrptr += offset_size;
8153
8154 compunit.cu_pointer_size = byte_get (hdrptr, 1);
8155 hdrptr += 1;
8156
8157 tags = hdrptr;
8158 cu_offset = start - section_begin;
8159 start += compunit.cu_length + initial_length_size;
8160
8161 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8162 printf (_(" Length: %ld\n"), compunit.cu_length);
8163 printf (_(" Version: %d\n"), compunit.cu_version);
8164 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8165 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8166
8167 if (compunit.cu_version != 2 && compunit.cu_version != 3)
8168 {
8169 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8170 continue;
8171 }
8172
8173 free_abbrevs ();
8174
8175 /* Read in the abbrevs used by this compilation unit. */
8176 {
8177 Elf_Internal_Shdr *sec;
8178 unsigned char *begin;
8179
8180 /* Locate the .debug_abbrev section and process it. */
8181 for (i = 0, sec = section_headers;
8182 i < elf_header.e_shnum;
8183 i++, sec++)
8184 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
8185 break;
8186
8187 if (i == elf_header.e_shnum || sec->sh_size == 0)
8188 {
8189 warn (_("Unable to locate .debug_abbrev section!\n"));
8190 return 0;
8191 }
8192
8193 begin = get_data (NULL, file, sec->sh_offset, sec->sh_size,
8194 _("debug_abbrev section data"));
8195 if (!begin)
8196 return 0;
8197
8198 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8199 begin + sec->sh_size);
8200
8201 free (begin);
8202 }
8203
8204 level = 0;
8205 while (tags < start)
8206 {
8207 int bytes_read;
8208 unsigned long abbrev_number;
8209 abbrev_entry *entry;
8210 abbrev_attr *attr;
8211
8212 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8213 tags += bytes_read;
8214
8215 /* A null DIE marks the end of a list of children. */
8216 if (abbrev_number == 0)
8217 {
8218 --level;
8219 continue;
8220 }
8221
8222 /* Scan through the abbreviation list until we reach the
8223 correct entry. */
8224 for (entry = first_abbrev;
8225 entry && entry->entry != abbrev_number;
8226 entry = entry->next)
8227 continue;
8228
8229 if (entry == NULL)
8230 {
8231 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8232 abbrev_number);
8233 return 0;
8234 }
8235
8236 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8237 level,
8238 (unsigned long) (tags - section_begin - bytes_read),
8239 abbrev_number,
8240 get_TAG_name (entry->tag));
8241
8242 for (attr = entry->first_attr; attr; attr = attr->next)
8243 tags = read_and_display_attr (attr->attribute,
8244 attr->form,
8245 tags, cu_offset,
8246 compunit.cu_pointer_size,
8247 offset_size,
8248 compunit.cu_version);
8249
8250 if (entry->children)
8251 ++level;
8252 }
8253 }
8254
8255 free_debug_str ();
8256 free_debug_loc ();
8257
8258 printf ("\n");
8259
8260 return 1;
8261 }
8262
8263 static int
8264 display_debug_aranges (Elf_Internal_Shdr *section,
8265 unsigned char *start,
8266 FILE *file ATTRIBUTE_UNUSED)
8267 {
8268 unsigned char *end = start + section->sh_size;
8269
8270 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8271
8272 while (start < end)
8273 {
8274 unsigned char *hdrptr;
8275 DWARF2_Internal_ARange arange;
8276 unsigned char *ranges;
8277 unsigned long length;
8278 unsigned long address;
8279 int excess;
8280 int offset_size;
8281 int initial_length_size;
8282
8283 hdrptr = start;
8284
8285 arange.ar_length = byte_get (hdrptr, 4);
8286 hdrptr += 4;
8287
8288 if (arange.ar_length == 0xffffffff)
8289 {
8290 arange.ar_length = byte_get (hdrptr, 8);
8291 hdrptr += 8;
8292 offset_size = 8;
8293 initial_length_size = 12;
8294 }
8295 else
8296 {
8297 offset_size = 4;
8298 initial_length_size = 4;
8299 }
8300
8301 arange.ar_version = byte_get (hdrptr, 2);
8302 hdrptr += 2;
8303
8304 arange.ar_info_offset = byte_get (hdrptr, offset_size);
8305 hdrptr += offset_size;
8306
8307 arange.ar_pointer_size = byte_get (hdrptr, 1);
8308 hdrptr += 1;
8309
8310 arange.ar_segment_size = byte_get (hdrptr, 1);
8311 hdrptr += 1;
8312
8313 if (arange.ar_version != 2 && arange.ar_version != 3)
8314 {
8315 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8316 break;
8317 }
8318
8319 printf (_(" Length: %ld\n"), arange.ar_length);
8320 printf (_(" Version: %d\n"), arange.ar_version);
8321 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8322 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8323 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8324
8325 printf (_("\n Address Length\n"));
8326
8327 ranges = hdrptr;
8328
8329 /* Must pad to an alignment boundary that is twice the pointer size. */
8330 excess = (hdrptr - start) % (2 * arange.ar_pointer_size);
8331 if (excess)
8332 ranges += (2 * arange.ar_pointer_size) - excess;
8333
8334 for (;;)
8335 {
8336 address = byte_get (ranges, arange.ar_pointer_size);
8337
8338 ranges += arange.ar_pointer_size;
8339
8340 length = byte_get (ranges, arange.ar_pointer_size);
8341
8342 ranges += arange.ar_pointer_size;
8343
8344 /* A pair of zeros marks the end of the list. */
8345 if (address == 0 && length == 0)
8346 break;
8347
8348 printf (" %8.8lx %lu\n", address, length);
8349 }
8350
8351 start += arange.ar_length + initial_length_size;
8352 }
8353
8354 printf ("\n");
8355
8356 return 1;
8357 }
8358
8359 typedef struct Frame_Chunk
8360 {
8361 struct Frame_Chunk *next;
8362 unsigned char *chunk_start;
8363 int ncols;
8364 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8365 short int *col_type;
8366 int *col_offset;
8367 char *augmentation;
8368 unsigned int code_factor;
8369 int data_factor;
8370 unsigned long pc_begin;
8371 unsigned long pc_range;
8372 int cfa_reg;
8373 int cfa_offset;
8374 int ra;
8375 unsigned char fde_encoding;
8376 unsigned char cfa_exp;
8377 }
8378 Frame_Chunk;
8379
8380 /* A marker for a col_type that means this column was never referenced
8381 in the frame info. */
8382 #define DW_CFA_unreferenced (-1)
8383
8384 static void
8385 frame_need_space (Frame_Chunk *fc, int reg)
8386 {
8387 int prev = fc->ncols;
8388
8389 if (reg < fc->ncols)
8390 return;
8391
8392 fc->ncols = reg + 1;
8393 fc->col_type = xrealloc (fc->col_type, fc->ncols * sizeof (short int));
8394 fc->col_offset = xrealloc (fc->col_offset, fc->ncols * sizeof (int));
8395
8396 while (prev < fc->ncols)
8397 {
8398 fc->col_type[prev] = DW_CFA_unreferenced;
8399 fc->col_offset[prev] = 0;
8400 prev++;
8401 }
8402 }
8403
8404 static void
8405 frame_display_row (Frame_Chunk *fc, int *need_col_headers, int *max_regs)
8406 {
8407 int r;
8408 char tmp[100];
8409
8410 if (*max_regs < fc->ncols)
8411 *max_regs = fc->ncols;
8412
8413 if (*need_col_headers)
8414 {
8415 *need_col_headers = 0;
8416
8417 printf (" LOC CFA ");
8418
8419 for (r = 0; r < *max_regs; r++)
8420 if (fc->col_type[r] != DW_CFA_unreferenced)
8421 {
8422 if (r == fc->ra)
8423 printf ("ra ");
8424 else
8425 printf ("r%-4d", r);
8426 }
8427
8428 printf ("\n");
8429 }
8430
8431 printf ("%08lx ", fc->pc_begin);
8432 if (fc->cfa_exp)
8433 strcpy (tmp, "exp");
8434 else
8435 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8436 printf ("%-8s ", tmp);
8437
8438 for (r = 0; r < fc->ncols; r++)
8439 {
8440 if (fc->col_type[r] != DW_CFA_unreferenced)
8441 {
8442 switch (fc->col_type[r])
8443 {
8444 case DW_CFA_undefined:
8445 strcpy (tmp, "u");
8446 break;
8447 case DW_CFA_same_value:
8448 strcpy (tmp, "s");
8449 break;
8450 case DW_CFA_offset:
8451 sprintf (tmp, "c%+d", fc->col_offset[r]);
8452 break;
8453 case DW_CFA_register:
8454 sprintf (tmp, "r%d", fc->col_offset[r]);
8455 break;
8456 case DW_CFA_expression:
8457 strcpy (tmp, "exp");
8458 break;
8459 default:
8460 strcpy (tmp, "n/a");
8461 break;
8462 }
8463 printf ("%-5s", tmp);
8464 }
8465 }
8466 printf ("\n");
8467 }
8468
8469 static int
8470 size_of_encoded_value (int encoding)
8471 {
8472 switch (encoding & 0x7)
8473 {
8474 default: /* ??? */
8475 case 0: return is_32bit_elf ? 4 : 8;
8476 case 2: return 2;
8477 case 3: return 4;
8478 case 4: return 8;
8479 }
8480 }
8481
8482 static bfd_vma
8483 get_encoded_value (unsigned char *data, int encoding)
8484 {
8485 int size = size_of_encoded_value (encoding);
8486 if (encoding & DW_EH_PE_signed)
8487 return byte_get_signed (data, size);
8488 else
8489 return byte_get (data, size);
8490 }
8491
8492 #define GET(N) byte_get (start, N); start += N
8493 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8494 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8495
8496 static int
8497 display_debug_frames (Elf_Internal_Shdr *section,
8498 unsigned char *start,
8499 FILE *file ATTRIBUTE_UNUSED)
8500 {
8501 unsigned char *end = start + section->sh_size;
8502 unsigned char *section_start = start;
8503 Frame_Chunk *chunks = 0;
8504 Frame_Chunk *remembered_state = 0;
8505 Frame_Chunk *rs;
8506 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8507 int length_return;
8508 int max_regs = 0;
8509 int addr_size = is_32bit_elf ? 4 : 8;
8510
8511 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8512
8513 while (start < end)
8514 {
8515 unsigned char *saved_start;
8516 unsigned char *block_end;
8517 unsigned long length;
8518 unsigned long cie_id;
8519 Frame_Chunk *fc;
8520 Frame_Chunk *cie;
8521 int need_col_headers = 1;
8522 unsigned char *augmentation_data = NULL;
8523 unsigned long augmentation_data_len = 0;
8524 int encoded_ptr_size = addr_size;
8525 int offset_size;
8526 int initial_length_size;
8527
8528 saved_start = start;
8529 length = byte_get (start, 4); start += 4;
8530
8531 if (length == 0)
8532 {
8533 printf ("\n%08lx ZERO terminator\n\n",
8534 (unsigned long)(saved_start - section_start));
8535 return 1;
8536 }
8537
8538 if (length == 0xffffffff)
8539 {
8540 length = byte_get (start, 8);
8541 start += 8;
8542 offset_size = 8;
8543 initial_length_size = 12;
8544 }
8545 else
8546 {
8547 offset_size = 4;
8548 initial_length_size = 4;
8549 }
8550
8551 block_end = saved_start + length + initial_length_size;
8552 cie_id = byte_get (start, offset_size); start += offset_size;
8553
8554 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8555 {
8556 int version;
8557
8558 fc = xmalloc (sizeof (Frame_Chunk));
8559 memset (fc, 0, sizeof (Frame_Chunk));
8560
8561 fc->next = chunks;
8562 chunks = fc;
8563 fc->chunk_start = saved_start;
8564 fc->ncols = 0;
8565 fc->col_type = xmalloc (sizeof (short int));
8566 fc->col_offset = xmalloc (sizeof (int));
8567 frame_need_space (fc, max_regs-1);
8568
8569 version = *start++;
8570
8571 fc->augmentation = start;
8572 start = strchr (start, '\0') + 1;
8573
8574 if (fc->augmentation[0] == 'z')
8575 {
8576 fc->code_factor = LEB ();
8577 fc->data_factor = SLEB ();
8578 fc->ra = byte_get (start, 1); start += 1;
8579 augmentation_data_len = LEB ();
8580 augmentation_data = start;
8581 start += augmentation_data_len;
8582 }
8583 else if (strcmp (fc->augmentation, "eh") == 0)
8584 {
8585 start += addr_size;
8586 fc->code_factor = LEB ();
8587 fc->data_factor = SLEB ();
8588 fc->ra = byte_get (start, 1); start += 1;
8589 }
8590 else
8591 {
8592 fc->code_factor = LEB ();
8593 fc->data_factor = SLEB ();
8594 fc->ra = byte_get (start, 1); start += 1;
8595 }
8596 cie = fc;
8597
8598 if (do_debug_frames_interp)
8599 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8600 (unsigned long)(saved_start - section_start), length, cie_id,
8601 fc->augmentation, fc->code_factor, fc->data_factor,
8602 fc->ra);
8603 else
8604 {
8605 printf ("\n%08lx %08lx %08lx CIE\n",
8606 (unsigned long)(saved_start - section_start), length, cie_id);
8607 printf (" Version: %d\n", version);
8608 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8609 printf (" Code alignment factor: %u\n", fc->code_factor);
8610 printf (" Data alignment factor: %d\n", fc->data_factor);
8611 printf (" Return address column: %d\n", fc->ra);
8612
8613 if (augmentation_data_len)
8614 {
8615 unsigned long i;
8616 printf (" Augmentation data: ");
8617 for (i = 0; i < augmentation_data_len; ++i)
8618 printf (" %02x", augmentation_data[i]);
8619 putchar ('\n');
8620 }
8621 putchar ('\n');
8622 }
8623
8624 if (augmentation_data_len)
8625 {
8626 unsigned char *p, *q;
8627 p = fc->augmentation + 1;
8628 q = augmentation_data;
8629
8630 while (1)
8631 {
8632 if (*p == 'L')
8633 q++;
8634 else if (*p == 'P')
8635 q += 1 + size_of_encoded_value (*q);
8636 else if (*p == 'R')
8637 fc->fde_encoding = *q++;
8638 else
8639 break;
8640 p++;
8641 }
8642
8643 if (fc->fde_encoding)
8644 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8645 }
8646
8647 frame_need_space (fc, fc->ra);
8648 }
8649 else
8650 {
8651 unsigned char *look_for;
8652 static Frame_Chunk fde_fc;
8653
8654 fc = & fde_fc;
8655 memset (fc, 0, sizeof (Frame_Chunk));
8656
8657 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8658
8659 for (cie = chunks; cie ; cie = cie->next)
8660 if (cie->chunk_start == look_for)
8661 break;
8662
8663 if (!cie)
8664 {
8665 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8666 cie_id, saved_start);
8667 start = block_end;
8668 fc->ncols = 0;
8669 fc->col_type = xmalloc (sizeof (short int));
8670 fc->col_offset = xmalloc (sizeof (int));
8671 frame_need_space (fc, max_regs - 1);
8672 cie = fc;
8673 fc->augmentation = "";
8674 fc->fde_encoding = 0;
8675 }
8676 else
8677 {
8678 fc->ncols = cie->ncols;
8679 fc->col_type = xmalloc (fc->ncols * sizeof (short int));
8680 fc->col_offset = xmalloc (fc->ncols * sizeof (int));
8681 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8682 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8683 fc->augmentation = cie->augmentation;
8684 fc->code_factor = cie->code_factor;
8685 fc->data_factor = cie->data_factor;
8686 fc->cfa_reg = cie->cfa_reg;
8687 fc->cfa_offset = cie->cfa_offset;
8688 fc->ra = cie->ra;
8689 frame_need_space (fc, max_regs-1);
8690 fc->fde_encoding = cie->fde_encoding;
8691 }
8692
8693 if (fc->fde_encoding)
8694 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8695
8696 fc->pc_begin = get_encoded_value (start, fc->fde_encoding);
8697 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8698 fc->pc_begin += section->sh_addr + (start - section_start);
8699 start += encoded_ptr_size;
8700 fc->pc_range = byte_get (start, encoded_ptr_size);
8701 start += encoded_ptr_size;
8702
8703 if (cie->augmentation[0] == 'z')
8704 {
8705 augmentation_data_len = LEB ();
8706 augmentation_data = start;
8707 start += augmentation_data_len;
8708 }
8709
8710 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8711 (unsigned long)(saved_start - section_start), length, cie_id,
8712 (unsigned long)(cie->chunk_start - section_start),
8713 fc->pc_begin, fc->pc_begin + fc->pc_range);
8714 if (! do_debug_frames_interp && augmentation_data_len)
8715 {
8716 unsigned long i;
8717 printf (" Augmentation data: ");
8718 for (i = 0; i < augmentation_data_len; ++i)
8719 printf (" %02x", augmentation_data[i]);
8720 putchar ('\n');
8721 putchar ('\n');
8722 }
8723 }
8724
8725 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8726 about to interpret instructions for the chunk. */
8727 /* ??? At present we need to do this always, since this sizes the
8728 fc->col_type and fc->col_offset arrays, which we write into always.
8729 We should probably split the interpreted and non-interpreted bits
8730 into two different routines, since there's so much that doesn't
8731 really overlap between them. */
8732 if (1 || do_debug_frames_interp)
8733 {
8734 /* Start by making a pass over the chunk, allocating storage
8735 and taking note of what registers are used. */
8736 unsigned char *tmp = start;
8737
8738 while (start < block_end)
8739 {
8740 unsigned op, opa;
8741 unsigned long reg, tmp;
8742
8743 op = *start++;
8744 opa = op & 0x3f;
8745 if (op & 0xc0)
8746 op &= 0xc0;
8747
8748 /* Warning: if you add any more cases to this switch, be
8749 sure to add them to the corresponding switch below. */
8750 switch (op)
8751 {
8752 case DW_CFA_advance_loc:
8753 break;
8754 case DW_CFA_offset:
8755 LEB ();
8756 frame_need_space (fc, opa);
8757 fc->col_type[opa] = DW_CFA_undefined;
8758 break;
8759 case DW_CFA_restore:
8760 frame_need_space (fc, opa);
8761 fc->col_type[opa] = DW_CFA_undefined;
8762 break;
8763 case DW_CFA_set_loc:
8764 start += encoded_ptr_size;
8765 break;
8766 case DW_CFA_advance_loc1:
8767 start += 1;
8768 break;
8769 case DW_CFA_advance_loc2:
8770 start += 2;
8771 break;
8772 case DW_CFA_advance_loc4:
8773 start += 4;
8774 break;
8775 case DW_CFA_offset_extended:
8776 reg = LEB (); LEB ();
8777 frame_need_space (fc, reg);
8778 fc->col_type[reg] = DW_CFA_undefined;
8779 break;
8780 case DW_CFA_restore_extended:
8781 reg = LEB ();
8782 frame_need_space (fc, reg);
8783 fc->col_type[reg] = DW_CFA_undefined;
8784 break;
8785 case DW_CFA_undefined:
8786 reg = LEB ();
8787 frame_need_space (fc, reg);
8788 fc->col_type[reg] = DW_CFA_undefined;
8789 break;
8790 case DW_CFA_same_value:
8791 reg = LEB ();
8792 frame_need_space (fc, reg);
8793 fc->col_type[reg] = DW_CFA_undefined;
8794 break;
8795 case DW_CFA_register:
8796 reg = LEB (); LEB ();
8797 frame_need_space (fc, reg);
8798 fc->col_type[reg] = DW_CFA_undefined;
8799 break;
8800 case DW_CFA_def_cfa:
8801 LEB (); LEB ();
8802 break;
8803 case DW_CFA_def_cfa_register:
8804 LEB ();
8805 break;
8806 case DW_CFA_def_cfa_offset:
8807 LEB ();
8808 break;
8809 case DW_CFA_def_cfa_expression:
8810 tmp = LEB ();
8811 start += tmp;
8812 break;
8813 case DW_CFA_expression:
8814 reg = LEB ();
8815 tmp = LEB ();
8816 start += tmp;
8817 frame_need_space (fc, reg);
8818 fc->col_type[reg] = DW_CFA_undefined;
8819 break;
8820 case DW_CFA_offset_extended_sf:
8821 reg = LEB (); SLEB ();
8822 frame_need_space (fc, reg);
8823 fc->col_type[reg] = DW_CFA_undefined;
8824 break;
8825 case DW_CFA_def_cfa_sf:
8826 LEB (); SLEB ();
8827 break;
8828 case DW_CFA_def_cfa_offset_sf:
8829 SLEB ();
8830 break;
8831 case DW_CFA_MIPS_advance_loc8:
8832 start += 8;
8833 break;
8834 case DW_CFA_GNU_args_size:
8835 LEB ();
8836 break;
8837 case DW_CFA_GNU_negative_offset_extended:
8838 reg = LEB (); LEB ();
8839 frame_need_space (fc, reg);
8840 fc->col_type[reg] = DW_CFA_undefined;
8841
8842 default:
8843 break;
8844 }
8845 }
8846 start = tmp;
8847 }
8848
8849 /* Now we know what registers are used, make a second pass over
8850 the chunk, this time actually printing out the info. */
8851
8852 while (start < block_end)
8853 {
8854 unsigned op, opa;
8855 unsigned long ul, reg, roffs;
8856 long l, ofs;
8857 bfd_vma vma;
8858
8859 op = *start++;
8860 opa = op & 0x3f;
8861 if (op & 0xc0)
8862 op &= 0xc0;
8863
8864 /* Warning: if you add any more cases to this switch, be
8865 sure to add them to the corresponding switch above. */
8866 switch (op)
8867 {
8868 case DW_CFA_advance_loc:
8869 if (do_debug_frames_interp)
8870 frame_display_row (fc, &need_col_headers, &max_regs);
8871 else
8872 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8873 opa * fc->code_factor,
8874 fc->pc_begin + opa * fc->code_factor);
8875 fc->pc_begin += opa * fc->code_factor;
8876 break;
8877
8878 case DW_CFA_offset:
8879 roffs = LEB ();
8880 if (! do_debug_frames_interp)
8881 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8882 opa, roffs * fc->data_factor);
8883 fc->col_type[opa] = DW_CFA_offset;
8884 fc->col_offset[opa] = roffs * fc->data_factor;
8885 break;
8886
8887 case DW_CFA_restore:
8888 if (! do_debug_frames_interp)
8889 printf (" DW_CFA_restore: r%d\n", opa);
8890 fc->col_type[opa] = cie->col_type[opa];
8891 fc->col_offset[opa] = cie->col_offset[opa];
8892 break;
8893
8894 case DW_CFA_set_loc:
8895 vma = get_encoded_value (start, fc->fde_encoding);
8896 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8897 vma += section->sh_addr + (start - section_start);
8898 start += encoded_ptr_size;
8899 if (do_debug_frames_interp)
8900 frame_display_row (fc, &need_col_headers, &max_regs);
8901 else
8902 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8903 fc->pc_begin = vma;
8904 break;
8905
8906 case DW_CFA_advance_loc1:
8907 ofs = byte_get (start, 1); start += 1;
8908 if (do_debug_frames_interp)
8909 frame_display_row (fc, &need_col_headers, &max_regs);
8910 else
8911 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8912 ofs * fc->code_factor,
8913 fc->pc_begin + ofs * fc->code_factor);
8914 fc->pc_begin += ofs * fc->code_factor;
8915 break;
8916
8917 case DW_CFA_advance_loc2:
8918 ofs = byte_get (start, 2); start += 2;
8919 if (do_debug_frames_interp)
8920 frame_display_row (fc, &need_col_headers, &max_regs);
8921 else
8922 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8923 ofs * fc->code_factor,
8924 fc->pc_begin + ofs * fc->code_factor);
8925 fc->pc_begin += ofs * fc->code_factor;
8926 break;
8927
8928 case DW_CFA_advance_loc4:
8929 ofs = byte_get (start, 4); start += 4;
8930 if (do_debug_frames_interp)
8931 frame_display_row (fc, &need_col_headers, &max_regs);
8932 else
8933 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8934 ofs * fc->code_factor,
8935 fc->pc_begin + ofs * fc->code_factor);
8936 fc->pc_begin += ofs * fc->code_factor;
8937 break;
8938
8939 case DW_CFA_offset_extended:
8940 reg = LEB ();
8941 roffs = LEB ();
8942 if (! do_debug_frames_interp)
8943 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8944 reg, roffs * fc->data_factor);
8945 fc->col_type[reg] = DW_CFA_offset;
8946 fc->col_offset[reg] = roffs * fc->data_factor;
8947 break;
8948
8949 case DW_CFA_restore_extended:
8950 reg = LEB ();
8951 if (! do_debug_frames_interp)
8952 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8953 fc->col_type[reg] = cie->col_type[reg];
8954 fc->col_offset[reg] = cie->col_offset[reg];
8955 break;
8956
8957 case DW_CFA_undefined:
8958 reg = LEB ();
8959 if (! do_debug_frames_interp)
8960 printf (" DW_CFA_undefined: r%ld\n", reg);
8961 fc->col_type[reg] = DW_CFA_undefined;
8962 fc->col_offset[reg] = 0;
8963 break;
8964
8965 case DW_CFA_same_value:
8966 reg = LEB ();
8967 if (! do_debug_frames_interp)
8968 printf (" DW_CFA_same_value: r%ld\n", reg);
8969 fc->col_type[reg] = DW_CFA_same_value;
8970 fc->col_offset[reg] = 0;
8971 break;
8972
8973 case DW_CFA_register:
8974 reg = LEB ();
8975 roffs = LEB ();
8976 if (! do_debug_frames_interp)
8977 printf (" DW_CFA_register: r%ld in r%ld\n", reg, roffs);
8978 fc->col_type[reg] = DW_CFA_register;
8979 fc->col_offset[reg] = roffs;
8980 break;
8981
8982 case DW_CFA_remember_state:
8983 if (! do_debug_frames_interp)
8984 printf (" DW_CFA_remember_state\n");
8985 rs = xmalloc (sizeof (Frame_Chunk));
8986 rs->ncols = fc->ncols;
8987 rs->col_type = xmalloc (rs->ncols * sizeof (short int));
8988 rs->col_offset = xmalloc (rs->ncols * sizeof (int));
8989 memcpy (rs->col_type, fc->col_type, rs->ncols);
8990 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8991 rs->next = remembered_state;
8992 remembered_state = rs;
8993 break;
8994
8995 case DW_CFA_restore_state:
8996 if (! do_debug_frames_interp)
8997 printf (" DW_CFA_restore_state\n");
8998 rs = remembered_state;
8999 remembered_state = rs->next;
9000 frame_need_space (fc, rs->ncols-1);
9001 memcpy (fc->col_type, rs->col_type, rs->ncols);
9002 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
9003 free (rs->col_type);
9004 free (rs->col_offset);
9005 free (rs);
9006 break;
9007
9008 case DW_CFA_def_cfa:
9009 fc->cfa_reg = LEB ();
9010 fc->cfa_offset = LEB ();
9011 fc->cfa_exp = 0;
9012 if (! do_debug_frames_interp)
9013 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9014 fc->cfa_reg, fc->cfa_offset);
9015 break;
9016
9017 case DW_CFA_def_cfa_register:
9018 fc->cfa_reg = LEB ();
9019 fc->cfa_exp = 0;
9020 if (! do_debug_frames_interp)
9021 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
9022 break;
9023
9024 case DW_CFA_def_cfa_offset:
9025 fc->cfa_offset = LEB ();
9026 if (! do_debug_frames_interp)
9027 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
9028 break;
9029
9030 case DW_CFA_nop:
9031 if (! do_debug_frames_interp)
9032 printf (" DW_CFA_nop\n");
9033 break;
9034
9035 case DW_CFA_def_cfa_expression:
9036 ul = LEB ();
9037 if (! do_debug_frames_interp)
9038 {
9039 printf (" DW_CFA_def_cfa_expression (");
9040 decode_location_expression (start, addr_size, ul);
9041 printf (")\n");
9042 }
9043 fc->cfa_exp = 1;
9044 start += ul;
9045 break;
9046
9047 case DW_CFA_expression:
9048 reg = LEB ();
9049 ul = LEB ();
9050 if (! do_debug_frames_interp)
9051 {
9052 printf (" DW_CFA_expression: r%ld (", reg);
9053 decode_location_expression (start, addr_size, ul);
9054 printf (")\n");
9055 }
9056 fc->col_type[reg] = DW_CFA_expression;
9057 start += ul;
9058 break;
9059
9060 case DW_CFA_offset_extended_sf:
9061 reg = LEB ();
9062 l = SLEB ();
9063 frame_need_space (fc, reg);
9064 if (! do_debug_frames_interp)
9065 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9066 reg, l * fc->data_factor);
9067 fc->col_type[reg] = DW_CFA_offset;
9068 fc->col_offset[reg] = l * fc->data_factor;
9069 break;
9070
9071 case DW_CFA_def_cfa_sf:
9072 fc->cfa_reg = LEB ();
9073 fc->cfa_offset = SLEB ();
9074 fc->cfa_exp = 0;
9075 if (! do_debug_frames_interp)
9076 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9077 fc->cfa_reg, fc->cfa_offset);
9078 break;
9079
9080 case DW_CFA_def_cfa_offset_sf:
9081 fc->cfa_offset = SLEB ();
9082 if (! do_debug_frames_interp)
9083 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
9084 break;
9085
9086 case DW_CFA_MIPS_advance_loc8:
9087 ofs = byte_get (start, 8); start += 8;
9088 if (do_debug_frames_interp)
9089 frame_display_row (fc, &need_col_headers, &max_regs);
9090 else
9091 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9092 ofs * fc->code_factor,
9093 fc->pc_begin + ofs * fc->code_factor);
9094 fc->pc_begin += ofs * fc->code_factor;
9095 break;
9096
9097 case DW_CFA_GNU_window_save:
9098 if (! do_debug_frames_interp)
9099 printf (" DW_CFA_GNU_window_save\n");
9100 break;
9101
9102 case DW_CFA_GNU_args_size:
9103 ul = LEB ();
9104 if (! do_debug_frames_interp)
9105 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
9106 break;
9107
9108 case DW_CFA_GNU_negative_offset_extended:
9109 reg = LEB ();
9110 l = - LEB ();
9111 frame_need_space (fc, reg);
9112 if (! do_debug_frames_interp)
9113 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9114 reg, l * fc->data_factor);
9115 fc->col_type[reg] = DW_CFA_offset;
9116 fc->col_offset[reg] = l * fc->data_factor;
9117 break;
9118
9119 default:
9120 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
9121 start = block_end;
9122 }
9123 }
9124
9125 if (do_debug_frames_interp)
9126 frame_display_row (fc, &need_col_headers, &max_regs);
9127
9128 start = block_end;
9129 }
9130
9131 printf ("\n");
9132
9133 return 1;
9134 }
9135
9136 #undef GET
9137 #undef LEB
9138 #undef SLEB
9139
9140 static int
9141 display_debug_not_supported (Elf_Internal_Shdr *section,
9142 unsigned char *start ATTRIBUTE_UNUSED,
9143 FILE *file ATTRIBUTE_UNUSED)
9144 {
9145 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9146 SECTION_NAME (section));
9147
9148 return 1;
9149 }
9150
9151 /* Pre-scan the .debug_info section to record the size of address.
9152 When dumping the .debug_line, we use that size information, assuming
9153 that all compilation units have the same address size. */
9154 static int
9155 prescan_debug_info (Elf_Internal_Shdr *section ATTRIBUTE_UNUSED,
9156 unsigned char *start,
9157 FILE *file ATTRIBUTE_UNUSED)
9158 {
9159 unsigned long length;
9160
9161 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
9162 be the length. For a 64-bit DWARF section, it'll be the escape
9163 code 0xffffffff followed by an 8 byte length. For the purposes
9164 of this prescan, we don't care about the actual length, but the
9165 presence of the escape bytes does affect the location of the byte
9166 which describes the address size. */
9167 length = byte_get (start, 4);
9168
9169 if (length == 0xffffffff)
9170 {
9171 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
9172 from the start of the section. This is computed as follows:
9173
9174 unit_length: 12 bytes
9175 version: 2 bytes
9176 debug_abbrev_offset: 8 bytes
9177 -----------------------------
9178 Total: 22 bytes */
9179
9180 debug_line_pointer_size = byte_get (start + 22, 1);
9181 }
9182 else
9183 {
9184 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
9185 the start of the section:
9186 unit_length: 4 bytes
9187 version: 2 bytes
9188 debug_abbrev_offset: 4 bytes
9189 -----------------------------
9190 Total: 10 bytes */
9191
9192 debug_line_pointer_size = byte_get (start + 10, 1);
9193 }
9194 return 0;
9195 }
9196
9197 /* A structure containing the name of a debug section and a pointer
9198 to a function that can decode it. The third field is a prescan
9199 function to be run over the section before displaying any of the
9200 sections. */
9201 struct
9202 {
9203 const char *const name;
9204 int (*display) (Elf_Internal_Shdr *, unsigned char *, FILE *);
9205 int (*prescan) (Elf_Internal_Shdr *, unsigned char *, FILE *);
9206 }
9207 debug_displays[] =
9208 {
9209 { ".debug_abbrev", display_debug_abbrev, NULL },
9210 { ".debug_aranges", display_debug_aranges, NULL },
9211 { ".debug_frame", display_debug_frames, NULL },
9212 { ".debug_info", display_debug_info, prescan_debug_info },
9213 { ".debug_line", display_debug_lines, NULL },
9214 { ".debug_pubnames", display_debug_pubnames, NULL },
9215 { ".eh_frame", display_debug_frames, NULL },
9216 { ".debug_macinfo", display_debug_macinfo, NULL },
9217 { ".debug_str", display_debug_str, NULL },
9218 { ".debug_loc", display_debug_loc, NULL },
9219 { ".debug_pubtypes", display_debug_not_supported, NULL },
9220 { ".debug_ranges", display_debug_not_supported, NULL },
9221 { ".debug_static_func", display_debug_not_supported, NULL },
9222 { ".debug_static_vars", display_debug_not_supported, NULL },
9223 { ".debug_types", display_debug_not_supported, NULL },
9224 { ".debug_weaknames", display_debug_not_supported, NULL }
9225 };
9226
9227 static int
9228 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
9229 {
9230 char *name = SECTION_NAME (section);
9231 bfd_size_type length;
9232 unsigned char *start;
9233 int i;
9234
9235 length = section->sh_size;
9236 if (length == 0)
9237 {
9238 printf (_("\nSection '%s' has no debugging data.\n"), name);
9239 return 0;
9240 }
9241
9242 start = get_data (NULL, file, section->sh_offset, length,
9243 _("debug section data"));
9244 if (!start)
9245 return 0;
9246
9247 /* See if we know how to display the contents of this section. */
9248 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9249 name = ".debug_info";
9250
9251 for (i = NUM_ELEM (debug_displays); i--;)
9252 if (strcmp (debug_displays[i].name, name) == 0)
9253 {
9254 debug_displays[i].display (section, start, file);
9255 break;
9256 }
9257
9258 if (i == -1)
9259 printf (_("Unrecognized debug section: %s\n"), name);
9260
9261 free (start);
9262
9263 /* If we loaded in the abbrev section at some point,
9264 we must release it here. */
9265 free_abbrevs ();
9266
9267 return 1;
9268 }
9269
9270 static int
9271 process_section_contents (FILE *file)
9272 {
9273 Elf_Internal_Shdr *section;
9274 unsigned int i;
9275
9276 if (! do_dump)
9277 return 1;
9278
9279 /* Pre-scan the debug sections to find some debug information not
9280 present in some of them. For the .debug_line, we must find out the
9281 size of address (specified in .debug_info and .debug_aranges). */
9282 for (i = 0, section = section_headers;
9283 i < elf_header.e_shnum && i < num_dump_sects;
9284 i++, section++)
9285 {
9286 char *name = SECTION_NAME (section);
9287 int j;
9288
9289 if (section->sh_size == 0)
9290 continue;
9291
9292 /* See if there is some pre-scan operation for this section. */
9293 for (j = NUM_ELEM (debug_displays); j--;)
9294 if (strcmp (debug_displays[j].name, name) == 0)
9295 {
9296 if (debug_displays[j].prescan != NULL)
9297 {
9298 bfd_size_type length;
9299 unsigned char *start;
9300
9301 length = section->sh_size;
9302 start = get_data (NULL, file, section->sh_offset, length,
9303 _("debug section data"));
9304 if (!start)
9305 return 0;
9306
9307 debug_displays[j].prescan (section, start, file);
9308 free (start);
9309 }
9310
9311 break;
9312 }
9313 }
9314
9315 for (i = 0, section = section_headers;
9316 i < elf_header.e_shnum && i < num_dump_sects;
9317 i++, section++)
9318 {
9319 #ifdef SUPPORT_DISASSEMBLY
9320 if (dump_sects[i] & DISASS_DUMP)
9321 disassemble_section (section, file);
9322 #endif
9323 if (dump_sects[i] & HEX_DUMP)
9324 dump_section (section, file);
9325
9326 if (dump_sects[i] & DEBUG_DUMP)
9327 display_debug_section (section, file);
9328 }
9329
9330 if (i < num_dump_sects)
9331 warn (_("Some sections were not dumped because they do not exist!\n"));
9332
9333 return 1;
9334 }
9335
9336 static void
9337 process_mips_fpe_exception (int mask)
9338 {
9339 if (mask)
9340 {
9341 int first = 1;
9342 if (mask & OEX_FPU_INEX)
9343 fputs ("INEX", stdout), first = 0;
9344 if (mask & OEX_FPU_UFLO)
9345 printf ("%sUFLO", first ? "" : "|"), first = 0;
9346 if (mask & OEX_FPU_OFLO)
9347 printf ("%sOFLO", first ? "" : "|"), first = 0;
9348 if (mask & OEX_FPU_DIV0)
9349 printf ("%sDIV0", first ? "" : "|"), first = 0;
9350 if (mask & OEX_FPU_INVAL)
9351 printf ("%sINVAL", first ? "" : "|");
9352 }
9353 else
9354 fputs ("0", stdout);
9355 }
9356
9357 static int
9358 process_mips_specific (FILE *file)
9359 {
9360 Elf_Internal_Dyn *entry;
9361 size_t liblist_offset = 0;
9362 size_t liblistno = 0;
9363 size_t conflictsno = 0;
9364 size_t options_offset = 0;
9365 size_t conflicts_offset = 0;
9366
9367 /* We have a lot of special sections. Thanks SGI! */
9368 if (dynamic_segment == NULL)
9369 /* No information available. */
9370 return 0;
9371
9372 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9373 switch (entry->d_tag)
9374 {
9375 case DT_MIPS_LIBLIST:
9376 liblist_offset
9377 = offset_from_vma (file, entry->d_un.d_val,
9378 liblistno * sizeof (Elf32_External_Lib));
9379 break;
9380 case DT_MIPS_LIBLISTNO:
9381 liblistno = entry->d_un.d_val;
9382 break;
9383 case DT_MIPS_OPTIONS:
9384 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9385 break;
9386 case DT_MIPS_CONFLICT:
9387 conflicts_offset
9388 = offset_from_vma (file, entry->d_un.d_val,
9389 conflictsno * sizeof (Elf32_External_Conflict));
9390 break;
9391 case DT_MIPS_CONFLICTNO:
9392 conflictsno = entry->d_un.d_val;
9393 break;
9394 default:
9395 break;
9396 }
9397
9398 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9399 {
9400 Elf32_External_Lib *elib;
9401 size_t cnt;
9402
9403 elib = get_data (NULL, file, liblist_offset,
9404 liblistno * sizeof (Elf32_External_Lib),
9405 _("liblist"));
9406 if (elib)
9407 {
9408 printf ("\nSection '.liblist' contains %lu entries:\n",
9409 (unsigned long) liblistno);
9410 fputs (" Library Time Stamp Checksum Version Flags\n",
9411 stdout);
9412
9413 for (cnt = 0; cnt < liblistno; ++cnt)
9414 {
9415 Elf32_Lib liblist;
9416 time_t time;
9417 char timebuf[20];
9418 struct tm *tmp;
9419
9420 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9421 time = BYTE_GET (elib[cnt].l_time_stamp);
9422 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9423 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9424 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9425
9426 tmp = gmtime (&time);
9427 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9428 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9429 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9430
9431 printf ("%3lu: ", (unsigned long) cnt);
9432 print_symbol (20, dynamic_strings + liblist.l_name);
9433 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9434 liblist.l_version);
9435
9436 if (liblist.l_flags == 0)
9437 puts (" NONE");
9438 else
9439 {
9440 static const struct
9441 {
9442 const char *name;
9443 int bit;
9444 }
9445 l_flags_vals[] =
9446 {
9447 { " EXACT_MATCH", LL_EXACT_MATCH },
9448 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9449 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9450 { " EXPORTS", LL_EXPORTS },
9451 { " DELAY_LOAD", LL_DELAY_LOAD },
9452 { " DELTA", LL_DELTA }
9453 };
9454 int flags = liblist.l_flags;
9455 size_t fcnt;
9456
9457 for (fcnt = 0;
9458 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9459 ++fcnt)
9460 if ((flags & l_flags_vals[fcnt].bit) != 0)
9461 {
9462 fputs (l_flags_vals[fcnt].name, stdout);
9463 flags ^= l_flags_vals[fcnt].bit;
9464 }
9465 if (flags != 0)
9466 printf (" %#x", (unsigned int) flags);
9467
9468 puts ("");
9469 }
9470 }
9471
9472 free (elib);
9473 }
9474 }
9475
9476 if (options_offset != 0)
9477 {
9478 Elf_External_Options *eopt;
9479 Elf_Internal_Shdr *sect = section_headers;
9480 Elf_Internal_Options *iopt;
9481 Elf_Internal_Options *option;
9482 size_t offset;
9483 int cnt;
9484
9485 /* Find the section header so that we get the size. */
9486 while (sect->sh_type != SHT_MIPS_OPTIONS)
9487 ++sect;
9488
9489 eopt = get_data (NULL, file, options_offset, sect->sh_size,
9490 _("options"));
9491 if (eopt)
9492 {
9493 iopt = malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt));
9494 if (iopt == NULL)
9495 {
9496 error (_("Out of memory"));
9497 return 0;
9498 }
9499
9500 offset = cnt = 0;
9501 option = iopt;
9502
9503 while (offset < sect->sh_size)
9504 {
9505 Elf_External_Options *eoption;
9506
9507 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9508
9509 option->kind = BYTE_GET (eoption->kind);
9510 option->size = BYTE_GET (eoption->size);
9511 option->section = BYTE_GET (eoption->section);
9512 option->info = BYTE_GET (eoption->info);
9513
9514 offset += option->size;
9515
9516 ++option;
9517 ++cnt;
9518 }
9519
9520 printf (_("\nSection '%s' contains %d entries:\n"),
9521 SECTION_NAME (sect), cnt);
9522
9523 option = iopt;
9524
9525 while (cnt-- > 0)
9526 {
9527 size_t len;
9528
9529 switch (option->kind)
9530 {
9531 case ODK_NULL:
9532 /* This shouldn't happen. */
9533 printf (" NULL %d %lx", option->section, option->info);
9534 break;
9535 case ODK_REGINFO:
9536 printf (" REGINFO ");
9537 if (elf_header.e_machine == EM_MIPS)
9538 {
9539 /* 32bit form. */
9540 Elf32_External_RegInfo *ereg;
9541 Elf32_RegInfo reginfo;
9542
9543 ereg = (Elf32_External_RegInfo *) (option + 1);
9544 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9545 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9546 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9547 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9548 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9549 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9550
9551 printf ("GPR %08lx GP 0x%lx\n",
9552 reginfo.ri_gprmask,
9553 (unsigned long) reginfo.ri_gp_value);
9554 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9555 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9556 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9557 }
9558 else
9559 {
9560 /* 64 bit form. */
9561 Elf64_External_RegInfo *ereg;
9562 Elf64_Internal_RegInfo reginfo;
9563
9564 ereg = (Elf64_External_RegInfo *) (option + 1);
9565 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9566 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9567 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9568 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9569 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9570 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9571
9572 printf ("GPR %08lx GP 0x",
9573 reginfo.ri_gprmask);
9574 printf_vma (reginfo.ri_gp_value);
9575 printf ("\n");
9576
9577 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9578 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9579 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9580 }
9581 ++option;
9582 continue;
9583 case ODK_EXCEPTIONS:
9584 fputs (" EXCEPTIONS fpe_min(", stdout);
9585 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9586 fputs (") fpe_max(", stdout);
9587 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9588 fputs (")", stdout);
9589
9590 if (option->info & OEX_PAGE0)
9591 fputs (" PAGE0", stdout);
9592 if (option->info & OEX_SMM)
9593 fputs (" SMM", stdout);
9594 if (option->info & OEX_FPDBUG)
9595 fputs (" FPDBUG", stdout);
9596 if (option->info & OEX_DISMISS)
9597 fputs (" DISMISS", stdout);
9598 break;
9599 case ODK_PAD:
9600 fputs (" PAD ", stdout);
9601 if (option->info & OPAD_PREFIX)
9602 fputs (" PREFIX", stdout);
9603 if (option->info & OPAD_POSTFIX)
9604 fputs (" POSTFIX", stdout);
9605 if (option->info & OPAD_SYMBOL)
9606 fputs (" SYMBOL", stdout);
9607 break;
9608 case ODK_HWPATCH:
9609 fputs (" HWPATCH ", stdout);
9610 if (option->info & OHW_R4KEOP)
9611 fputs (" R4KEOP", stdout);
9612 if (option->info & OHW_R8KPFETCH)
9613 fputs (" R8KPFETCH", stdout);
9614 if (option->info & OHW_R5KEOP)
9615 fputs (" R5KEOP", stdout);
9616 if (option->info & OHW_R5KCVTL)
9617 fputs (" R5KCVTL", stdout);
9618 break;
9619 case ODK_FILL:
9620 fputs (" FILL ", stdout);
9621 /* XXX Print content of info word? */
9622 break;
9623 case ODK_TAGS:
9624 fputs (" TAGS ", stdout);
9625 /* XXX Print content of info word? */
9626 break;
9627 case ODK_HWAND:
9628 fputs (" HWAND ", stdout);
9629 if (option->info & OHWA0_R4KEOP_CHECKED)
9630 fputs (" R4KEOP_CHECKED", stdout);
9631 if (option->info & OHWA0_R4KEOP_CLEAN)
9632 fputs (" R4KEOP_CLEAN", stdout);
9633 break;
9634 case ODK_HWOR:
9635 fputs (" HWOR ", stdout);
9636 if (option->info & OHWA0_R4KEOP_CHECKED)
9637 fputs (" R4KEOP_CHECKED", stdout);
9638 if (option->info & OHWA0_R4KEOP_CLEAN)
9639 fputs (" R4KEOP_CLEAN", stdout);
9640 break;
9641 case ODK_GP_GROUP:
9642 printf (" GP_GROUP %#06lx self-contained %#06lx",
9643 option->info & OGP_GROUP,
9644 (option->info & OGP_SELF) >> 16);
9645 break;
9646 case ODK_IDENT:
9647 printf (" IDENT %#06lx self-contained %#06lx",
9648 option->info & OGP_GROUP,
9649 (option->info & OGP_SELF) >> 16);
9650 break;
9651 default:
9652 /* This shouldn't happen. */
9653 printf (" %3d ??? %d %lx",
9654 option->kind, option->section, option->info);
9655 break;
9656 }
9657
9658 len = sizeof (*eopt);
9659 while (len < option->size)
9660 if (((char *) option)[len] >= ' '
9661 && ((char *) option)[len] < 0x7f)
9662 printf ("%c", ((char *) option)[len++]);
9663 else
9664 printf ("\\%03o", ((char *) option)[len++]);
9665
9666 fputs ("\n", stdout);
9667 ++option;
9668 }
9669
9670 free (eopt);
9671 }
9672 }
9673
9674 if (conflicts_offset != 0 && conflictsno != 0)
9675 {
9676 Elf32_Conflict *iconf;
9677 size_t cnt;
9678
9679 if (dynamic_symbols == NULL)
9680 {
9681 error (_("conflict list found without a dynamic symbol table"));
9682 return 0;
9683 }
9684
9685 iconf = malloc (conflictsno * sizeof (*iconf));
9686 if (iconf == NULL)
9687 {
9688 error (_("Out of memory"));
9689 return 0;
9690 }
9691
9692 if (is_32bit_elf)
9693 {
9694 Elf32_External_Conflict *econf32;
9695
9696 econf32 = get_data (NULL, file, conflicts_offset,
9697 conflictsno * sizeof (*econf32), _("conflict"));
9698 if (!econf32)
9699 return 0;
9700
9701 for (cnt = 0; cnt < conflictsno; ++cnt)
9702 iconf[cnt] = BYTE_GET (econf32[cnt]);
9703
9704 free (econf32);
9705 }
9706 else
9707 {
9708 Elf64_External_Conflict *econf64;
9709
9710 econf64 = get_data (NULL, file, conflicts_offset,
9711 conflictsno * sizeof (*econf64), _("conflict"));
9712 if (!econf64)
9713 return 0;
9714
9715 for (cnt = 0; cnt < conflictsno; ++cnt)
9716 iconf[cnt] = BYTE_GET (econf64[cnt]);
9717
9718 free (econf64);
9719 }
9720
9721 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9722 (long) conflictsno);
9723 puts (_(" Num: Index Value Name"));
9724
9725 for (cnt = 0; cnt < conflictsno; ++cnt)
9726 {
9727 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9728
9729 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9730 print_vma (psym->st_value, FULL_HEX);
9731 putchar (' ');
9732 print_symbol (25, dynamic_strings + psym->st_name);
9733 putchar ('\n');
9734 }
9735
9736 free (iconf);
9737 }
9738
9739 return 1;
9740 }
9741
9742 static int
9743 process_gnu_liblist (FILE *file)
9744 {
9745 Elf_Internal_Shdr *section, *string_sec;
9746 Elf32_External_Lib *elib;
9747 char *strtab;
9748 size_t cnt;
9749 unsigned i;
9750
9751 if (! do_arch)
9752 return 0;
9753
9754 for (i = 0, section = section_headers;
9755 i < elf_header.e_shnum;
9756 i++, section++)
9757 {
9758 switch (section->sh_type)
9759 {
9760 case SHT_GNU_LIBLIST:
9761 elib = get_data (NULL, file, section->sh_offset, section->sh_size,
9762 _("liblist"));
9763
9764 if (elib == NULL)
9765 break;
9766 string_sec = SECTION_HEADER (section->sh_link);
9767
9768 strtab = get_data (NULL, file, string_sec->sh_offset,
9769 string_sec->sh_size, _("liblist string table"));
9770
9771 if (strtab == NULL
9772 || section->sh_entsize != sizeof (Elf32_External_Lib))
9773 {
9774 free (elib);
9775 break;
9776 }
9777
9778 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9779 SECTION_NAME (section),
9780 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9781
9782 puts (" Library Time Stamp Checksum Version Flags");
9783
9784 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9785 ++cnt)
9786 {
9787 Elf32_Lib liblist;
9788 time_t time;
9789 char timebuf[20];
9790 struct tm *tmp;
9791
9792 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9793 time = BYTE_GET (elib[cnt].l_time_stamp);
9794 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9795 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9796 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9797
9798 tmp = gmtime (&time);
9799 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9800 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9801 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9802
9803 printf ("%3lu: ", (unsigned long) cnt);
9804 if (do_wide)
9805 printf ("%-20s", strtab + liblist.l_name);
9806 else
9807 printf ("%-20.20s", strtab + liblist.l_name);
9808 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9809 liblist.l_version, liblist.l_flags);
9810 }
9811
9812 free (elib);
9813 }
9814 }
9815
9816 return 1;
9817 }
9818
9819 static const char *
9820 get_note_type (unsigned e_type)
9821 {
9822 static char buff[64];
9823
9824 switch (e_type)
9825 {
9826 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9827 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9828 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9829 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9830 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9831 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9832 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9833 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9834 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9835 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9836 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9837 default:
9838 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9839 return buff;
9840 }
9841 }
9842
9843 static const char *
9844 get_netbsd_elfcore_note_type (unsigned e_type)
9845 {
9846 static char buff[64];
9847
9848 if (e_type == NT_NETBSDCORE_PROCINFO)
9849 {
9850 /* NetBSD core "procinfo" structure. */
9851 return _("NetBSD procinfo structure");
9852 }
9853
9854 /* As of Jan 2002 there are no other machine-independent notes
9855 defined for NetBSD core files. If the note type is less
9856 than the start of the machine-dependent note types, we don't
9857 understand it. */
9858
9859 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9860 {
9861 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9862 return buff;
9863 }
9864
9865 switch (elf_header.e_machine)
9866 {
9867 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9868 and PT_GETFPREGS == mach+2. */
9869
9870 case EM_OLD_ALPHA:
9871 case EM_ALPHA:
9872 case EM_SPARC:
9873 case EM_SPARC32PLUS:
9874 case EM_SPARCV9:
9875 switch (e_type)
9876 {
9877 case NT_NETBSDCORE_FIRSTMACH+0:
9878 return _("PT_GETREGS (reg structure)");
9879 case NT_NETBSDCORE_FIRSTMACH+2:
9880 return _("PT_GETFPREGS (fpreg structure)");
9881 default:
9882 break;
9883 }
9884 break;
9885
9886 /* On all other arch's, PT_GETREGS == mach+1 and
9887 PT_GETFPREGS == mach+3. */
9888 default:
9889 switch (e_type)
9890 {
9891 case NT_NETBSDCORE_FIRSTMACH+1:
9892 return _("PT_GETREGS (reg structure)");
9893 case NT_NETBSDCORE_FIRSTMACH+3:
9894 return _("PT_GETFPREGS (fpreg structure)");
9895 default:
9896 break;
9897 }
9898 }
9899
9900 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9901 return buff;
9902 }
9903
9904 /* Note that by the ELF standard, the name field is already null byte
9905 terminated, and namesz includes the terminating null byte.
9906 I.E. the value of namesz for the name "FSF" is 4.
9907
9908 If the value of namesz is zero, there is no name present. */
9909 static int
9910 process_note (Elf_Internal_Note *pnote)
9911 {
9912 const char *nt;
9913
9914 if (pnote->namesz == 0)
9915 {
9916 /* If there is no note name, then use the default set of
9917 note type strings. */
9918 nt = get_note_type (pnote->type);
9919 }
9920 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9921 {
9922 /* NetBSD-specific core file notes. */
9923 nt = get_netbsd_elfcore_note_type (pnote->type);
9924 }
9925 else
9926 {
9927 /* Don't recognize this note name; just use the default set of
9928 note type strings. */
9929 nt = get_note_type (pnote->type);
9930 }
9931
9932 printf (" %s\t\t0x%08lx\t%s\n",
9933 pnote->namesz ? pnote->namedata : "(NONE)",
9934 pnote->descsz, nt);
9935 return 1;
9936 }
9937
9938
9939 static int
9940 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
9941 {
9942 Elf_External_Note *pnotes;
9943 Elf_External_Note *external;
9944 int res = 1;
9945
9946 if (length <= 0)
9947 return 0;
9948
9949 pnotes = get_data (NULL, file, offset, length, _("notes"));
9950 if (!pnotes)
9951 return 0;
9952
9953 external = pnotes;
9954
9955 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9956 (unsigned long) offset, (unsigned long) length);
9957 printf (_(" Owner\t\tData size\tDescription\n"));
9958
9959 while (external < (Elf_External_Note *)((char *) pnotes + length))
9960 {
9961 Elf_External_Note *next;
9962 Elf_Internal_Note inote;
9963 char *temp = NULL;
9964
9965 inote.type = BYTE_GET (external->type);
9966 inote.namesz = BYTE_GET (external->namesz);
9967 inote.namedata = external->name;
9968 inote.descsz = BYTE_GET (external->descsz);
9969 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9970 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9971
9972 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9973
9974 if (((char *) next) > (((char *) pnotes) + length))
9975 {
9976 warn (_("corrupt note found at offset %x into core notes\n"),
9977 ((char *) external) - ((char *) pnotes));
9978 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9979 inote.type, inote.namesz, inote.descsz);
9980 break;
9981 }
9982
9983 external = next;
9984
9985 /* Verify that name is null terminated. It appears that at least
9986 one version of Linux (RedHat 6.0) generates corefiles that don't
9987 comply with the ELF spec by failing to include the null byte in
9988 namesz. */
9989 if (inote.namedata[inote.namesz] != '\0')
9990 {
9991 temp = malloc (inote.namesz + 1);
9992
9993 if (temp == NULL)
9994 {
9995 error (_("Out of memory\n"));
9996 res = 0;
9997 break;
9998 }
9999
10000 strncpy (temp, inote.namedata, inote.namesz);
10001 temp[inote.namesz] = 0;
10002
10003 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10004 inote.namedata = temp;
10005 }
10006
10007 res &= process_note (& inote);
10008
10009 if (temp != NULL)
10010 {
10011 free (temp);
10012 temp = NULL;
10013 }
10014 }
10015
10016 free (pnotes);
10017
10018 return res;
10019 }
10020
10021 static int
10022 process_corefile_note_segments (FILE *file)
10023 {
10024 Elf_Internal_Phdr *segment;
10025 unsigned int i;
10026 int res = 1;
10027
10028 if (! get_program_headers (file))
10029 return 0;
10030
10031 for (i = 0, segment = program_headers;
10032 i < elf_header.e_phnum;
10033 i++, segment++)
10034 {
10035 if (segment->p_type == PT_NOTE)
10036 res &= process_corefile_note_segment (file,
10037 (bfd_vma) segment->p_offset,
10038 (bfd_vma) segment->p_filesz);
10039 }
10040
10041 return res;
10042 }
10043
10044 static int
10045 process_corefile_contents (FILE *file)
10046 {
10047 /* If we have not been asked to display the notes then do nothing. */
10048 if (! do_notes)
10049 return 1;
10050
10051 /* If file is not a core file then exit. */
10052 if (elf_header.e_type != ET_CORE)
10053 return 1;
10054
10055 /* No program headers means no NOTE segment. */
10056 if (elf_header.e_phnum == 0)
10057 {
10058 printf (_("No note segments present in the core file.\n"));
10059 return 1;
10060 }
10061
10062 return process_corefile_note_segments (file);
10063 }
10064
10065 static int
10066 process_arch_specific (FILE *file)
10067 {
10068 if (! do_arch)
10069 return 1;
10070
10071 switch (elf_header.e_machine)
10072 {
10073 case EM_MIPS:
10074 case EM_MIPS_RS3_LE:
10075 return process_mips_specific (file);
10076 break;
10077 default:
10078 break;
10079 }
10080 return 1;
10081 }
10082
10083 static int
10084 get_file_header (FILE *file)
10085 {
10086 /* Read in the identity array. */
10087 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10088 return 0;
10089
10090 /* Determine how to read the rest of the header. */
10091 switch (elf_header.e_ident[EI_DATA])
10092 {
10093 default: /* fall through */
10094 case ELFDATANONE: /* fall through */
10095 case ELFDATA2LSB:
10096 byte_get = byte_get_little_endian;
10097 byte_put = byte_put_little_endian;
10098 break;
10099 case ELFDATA2MSB:
10100 byte_get = byte_get_big_endian;
10101 byte_put = byte_put_big_endian;
10102 break;
10103 }
10104
10105 /* For now we only support 32 bit and 64 bit ELF files. */
10106 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10107
10108 /* Read in the rest of the header. */
10109 if (is_32bit_elf)
10110 {
10111 Elf32_External_Ehdr ehdr32;
10112
10113 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10114 return 0;
10115
10116 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10117 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10118 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10119 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10120 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10121 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10122 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10123 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10124 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10125 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10126 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10127 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10128 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10129 }
10130 else
10131 {
10132 Elf64_External_Ehdr ehdr64;
10133
10134 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10135 we will not be able to cope with the 64bit data found in
10136 64 ELF files. Detect this now and abort before we start
10137 overwritting things. */
10138 if (sizeof (bfd_vma) < 8)
10139 {
10140 error (_("This instance of readelf has been built without support for a\n\
10141 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10142 return 0;
10143 }
10144
10145 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10146 return 0;
10147
10148 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10149 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10150 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10151 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
10152 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
10153 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
10154 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10155 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10156 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10157 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10158 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10159 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10160 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10161 }
10162
10163 if (elf_header.e_shoff)
10164 {
10165 /* There may be some extensions in the first section header. Don't
10166 bomb if we can't read it. */
10167 if (is_32bit_elf)
10168 get_32bit_section_headers (file, 1);
10169 else
10170 get_64bit_section_headers (file, 1);
10171 }
10172
10173 return 1;
10174 }
10175
10176 /* Process one ELF object file according to the command line options.
10177 This file may actually be stored in an archive. The file is
10178 positioned at the start of the ELF object. */
10179
10180 static int
10181 process_object (char *file_name, FILE *file)
10182 {
10183 unsigned int i;
10184
10185 if (! get_file_header (file))
10186 {
10187 error (_("%s: Failed to read file header\n"), file_name);
10188 return 1;
10189 }
10190
10191 /* Initialise per file variables. */
10192 for (i = NUM_ELEM (version_info); i--;)
10193 version_info[i] = 0;
10194
10195 for (i = NUM_ELEM (dynamic_info); i--;)
10196 dynamic_info[i] = 0;
10197
10198 /* Process the file. */
10199 if (show_name)
10200 printf (_("\nFile: %s\n"), file_name);
10201
10202 if (! process_file_header ())
10203 return 1;
10204
10205 if (! process_section_headers (file))
10206 {
10207 /* Without loaded section headers we
10208 cannot process lots of things. */
10209 do_unwind = do_version = do_dump = do_arch = 0;
10210
10211 if (! do_using_dynamic)
10212 do_syms = do_reloc = 0;
10213 }
10214
10215 if (process_program_headers (file))
10216 process_dynamic_segment (file);
10217
10218 process_relocs (file);
10219
10220 process_unwind (file);
10221
10222 process_symbol_table (file);
10223
10224 process_syminfo (file);
10225
10226 process_version_sections (file);
10227
10228 process_section_contents (file);
10229
10230 process_corefile_contents (file);
10231
10232 process_gnu_liblist (file);
10233
10234 process_arch_specific (file);
10235
10236 if (program_headers)
10237 {
10238 free (program_headers);
10239 program_headers = NULL;
10240 }
10241
10242 if (section_headers)
10243 {
10244 free (section_headers);
10245 section_headers = NULL;
10246 }
10247
10248 if (string_table)
10249 {
10250 free (string_table);
10251 string_table = NULL;
10252 string_table_length = 0;
10253 }
10254
10255 if (dynamic_strings)
10256 {
10257 free (dynamic_strings);
10258 dynamic_strings = NULL;
10259 }
10260
10261 if (dynamic_symbols)
10262 {
10263 free (dynamic_symbols);
10264 dynamic_symbols = NULL;
10265 num_dynamic_syms = 0;
10266 }
10267
10268 if (dynamic_syminfo)
10269 {
10270 free (dynamic_syminfo);
10271 dynamic_syminfo = NULL;
10272 }
10273
10274 return 0;
10275 }
10276
10277 /* Process an ELF archive. The file is positioned just after the
10278 ARMAG string. */
10279
10280 static int
10281 process_archive (char *file_name, FILE *file)
10282 {
10283 struct ar_hdr arhdr;
10284 size_t got;
10285 unsigned long size;
10286 char *longnames = NULL;
10287 unsigned long longnames_size = 0;
10288 size_t file_name_size;
10289 int ret;
10290
10291 show_name = 1;
10292
10293 got = fread (&arhdr, 1, sizeof arhdr, file);
10294 if (got != sizeof arhdr)
10295 {
10296 if (got == 0)
10297 return 0;
10298
10299 error (_("%s: failed to read archive header\n"), file_name);
10300 return 1;
10301 }
10302
10303 if (memcmp (arhdr.ar_name, "/ ", 16) == 0)
10304 {
10305 /* This is the archive symbol table. Skip it.
10306 FIXME: We should have an option to dump it. */
10307 size = strtoul (arhdr.ar_size, NULL, 10);
10308 if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
10309 {
10310 error (_("%s: failed to skip archive symbol table\n"), file_name);
10311 return 1;
10312 }
10313
10314 got = fread (&arhdr, 1, sizeof arhdr, file);
10315 if (got != sizeof arhdr)
10316 {
10317 if (got == 0)
10318 return 0;
10319
10320 error (_("%s: failed to read archive header\n"), file_name);
10321 return 1;
10322 }
10323 }
10324
10325 if (memcmp (arhdr.ar_name, "// ", 16) == 0)
10326 {
10327 /* This is the archive string table holding long member
10328 names. */
10329
10330 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10331
10332 longnames = malloc (longnames_size);
10333 if (longnames == NULL)
10334 {
10335 error (_("Out of memory\n"));
10336 return 1;
10337 }
10338
10339 if (fread (longnames, longnames_size, 1, file) != 1)
10340 {
10341 free (longnames);
10342 error(_("%s: failed to read string table\n"), file_name);
10343 return 1;
10344 }
10345
10346 if ((longnames_size & 1) != 0)
10347 getc (file);
10348
10349 got = fread (&arhdr, 1, sizeof arhdr, file);
10350 if (got != sizeof arhdr)
10351 {
10352 free (longnames);
10353
10354 if (got == 0)
10355 return 0;
10356
10357 error (_("%s: failed to read archive header\n"), file_name);
10358 return 1;
10359 }
10360 }
10361
10362 file_name_size = strlen (file_name);
10363 ret = 0;
10364
10365 while (1)
10366 {
10367 char *name;
10368 char *nameend;
10369 char *namealc;
10370
10371 if (arhdr.ar_name[0] == '/')
10372 {
10373 unsigned long off;
10374
10375 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10376 if (off >= longnames_size)
10377 {
10378 error (_("%s: invalid archive string table offset %lu\n"), off);
10379 ret = 1;
10380 break;
10381 }
10382
10383 name = longnames + off;
10384 nameend = memchr (name, '/', longnames_size - off);
10385 }
10386 else
10387 {
10388 name = arhdr.ar_name;
10389 nameend = memchr (name, '/', 16);
10390 }
10391
10392 if (nameend == NULL)
10393 {
10394 error (_("%s: bad archive file name\n"));
10395 ret = 1;
10396 break;
10397 }
10398
10399 namealc = malloc (file_name_size + (nameend - name) + 3);
10400 if (namealc == NULL)
10401 {
10402 error (_("Out of memory\n"));
10403 ret = 1;
10404 break;
10405 }
10406
10407 memcpy (namealc, file_name, file_name_size);
10408 namealc[file_name_size] = '(';
10409 memcpy (namealc + file_name_size + 1, name, nameend - name);
10410 namealc[file_name_size + 1 + (nameend - name)] = ')';
10411 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10412
10413 archive_file_offset = ftell (file);
10414 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10415
10416 ret |= process_object (namealc, file);
10417
10418 free (namealc);
10419
10420 if (fseek (file,
10421 (archive_file_offset
10422 + archive_file_size
10423 + (archive_file_size & 1)),
10424 SEEK_SET) != 0)
10425 {
10426 error (_("%s: failed to seek to next archive header\n"), file_name);
10427 ret = 1;
10428 break;
10429 }
10430
10431 got = fread (&arhdr, 1, sizeof arhdr, file);
10432 if (got != sizeof arhdr)
10433 {
10434 if (got == 0)
10435 break;
10436
10437 error (_("%s: failed to read archive header\n"), file_name);
10438 ret = 1;
10439 break;
10440 }
10441 }
10442
10443 if (longnames != 0)
10444 free (longnames);
10445
10446 return ret;
10447 }
10448
10449 static int
10450 process_file (char *file_name)
10451 {
10452 FILE *file;
10453 struct stat statbuf;
10454 char armag[SARMAG];
10455 int ret;
10456
10457 if (stat (file_name, &statbuf) < 0)
10458 {
10459 error (_("Cannot stat input file %s.\n"), file_name);
10460 return 1;
10461 }
10462
10463 file = fopen (file_name, "rb");
10464 if (file == NULL)
10465 {
10466 error (_("Input file %s not found.\n"), file_name);
10467 return 1;
10468 }
10469
10470 if (fread (armag, SARMAG, 1, file) != 1)
10471 {
10472 error (_("%s: Failed to read file header\n"), file_name);
10473 fclose (file);
10474 return 1;
10475 }
10476
10477 if (memcmp (armag, ARMAG, SARMAG) == 0)
10478 ret = process_archive (file_name, file);
10479 else
10480 {
10481 rewind (file);
10482 archive_file_size = archive_file_offset = 0;
10483 ret = process_object (file_name, file);
10484 }
10485
10486 fclose (file);
10487
10488 return ret;
10489 }
10490
10491 #ifdef SUPPORT_DISASSEMBLY
10492 /* Needed by the i386 disassembler. For extra credit, someone could
10493 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10494 symbols. */
10495
10496 void
10497 print_address (unsigned int addr, FILE *outfile)
10498 {
10499 fprintf (outfile,"0x%8.8x", addr);
10500 }
10501
10502 /* Needed by the i386 disassembler. */
10503 void
10504 db_task_printsym (unsigned int addr)
10505 {
10506 print_address (addr, stderr);
10507 }
10508 #endif
10509
10510 int
10511 main (int argc, char **argv)
10512 {
10513 int err;
10514 char *cmdline_dump_sects = NULL;
10515 unsigned num_cmdline_dump_sects = 0;
10516
10517 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10518 setlocale (LC_MESSAGES, "");
10519 #endif
10520 #if defined (HAVE_SETLOCALE)
10521 setlocale (LC_CTYPE, "");
10522 #endif
10523 bindtextdomain (PACKAGE, LOCALEDIR);
10524 textdomain (PACKAGE);
10525
10526 parse_args (argc, argv);
10527
10528 if (optind < (argc - 1))
10529 show_name = 1;
10530
10531 /* When processing more than one file remember the dump requests
10532 issued on command line to reset them after each file. */
10533 if (optind + 1 < argc && dump_sects != NULL)
10534 {
10535 cmdline_dump_sects = malloc (num_dump_sects);
10536 if (cmdline_dump_sects == NULL)
10537 error (_("Out of memory allocating dump request table."));
10538 else
10539 {
10540 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
10541 num_cmdline_dump_sects = num_dump_sects;
10542 }
10543 }
10544
10545 err = 0;
10546 while (optind < argc)
10547 {
10548 err |= process_file (argv[optind++]);
10549
10550 /* Reset dump requests. */
10551 if (optind < argc && dump_sects != NULL)
10552 {
10553 num_dump_sects = num_cmdline_dump_sects;
10554 if (num_cmdline_dump_sects > 0)
10555 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
10556 }
10557 }
10558
10559 if (dump_sects != NULL)
10560 free (dump_sects);
10561 if (cmdline_dump_sects != NULL)
10562 free (cmdline_dump_sects);
10563
10564 return err;
10565 }
git-cvsimport of binutils cvsroot