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