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