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