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