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