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