projects / binutils-gdb.git / blob
? search:


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