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