projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Implement generic SHF_EXCLUDE.
[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 /* Generic. */
4156 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4157 /* SPARC specific. */
4158 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4159 };
4160
4161 if (do_section_details)
4162 {
4163 sprintf (buff, "[%*.*lx]: ",
4164 field_size, field_size, (unsigned long) sh_flags);
4165 p += field_size + 4;
4166 }
4167
4168 while (sh_flags)
4169 {
4170 bfd_vma flag;
4171
4172 flag = sh_flags & - sh_flags;
4173 sh_flags &= ~ flag;
4174
4175 if (do_section_details)
4176 {
4177 switch (flag)
4178 {
4179 case SHF_WRITE: sindex = 0; break;
4180 case SHF_ALLOC: sindex = 1; break;
4181 case SHF_EXECINSTR: sindex = 2; break;
4182 case SHF_MERGE: sindex = 3; break;
4183 case SHF_STRINGS: sindex = 4; break;
4184 case SHF_INFO_LINK: sindex = 5; break;
4185 case SHF_LINK_ORDER: sindex = 6; break;
4186 case SHF_OS_NONCONFORMING: sindex = 7; break;
4187 case SHF_GROUP: sindex = 8; break;
4188 case SHF_TLS: sindex = 9; break;
4189 case SHF_EXCLUDE: sindex = 18; break;
4190
4191 default:
4192 sindex = -1;
4193 switch (elf_header.e_machine)
4194 {
4195 case EM_IA_64:
4196 if (flag == SHF_IA_64_SHORT)
4197 sindex = 10;
4198 else if (flag == SHF_IA_64_NORECOV)
4199 sindex = 11;
4200 #ifdef BFD64
4201 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4202 switch (flag)
4203 {
4204 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4205 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4206 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4207 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4208 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4209 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4210 default: break;
4211 }
4212 #endif
4213 break;
4214
4215 case EM_386:
4216 case EM_486:
4217 case EM_X86_64:
4218 case EM_L1OM:
4219 case EM_OLD_SPARCV9:
4220 case EM_SPARC32PLUS:
4221 case EM_SPARCV9:
4222 case EM_SPARC:
4223 if (flag == SHF_ORDERED)
4224 sindex = 19;
4225 break;
4226 default:
4227 break;
4228 }
4229 }
4230
4231 if (sindex != -1)
4232 {
4233 if (p != buff + field_size + 4)
4234 {
4235 if (size < (10 + 2))
4236 abort ();
4237 size -= 2;
4238 *p++ = ',';
4239 *p++ = ' ';
4240 }
4241
4242 size -= flags [sindex].len;
4243 p = stpcpy (p, flags [sindex].str);
4244 }
4245 else if (flag & SHF_MASKOS)
4246 os_flags |= flag;
4247 else if (flag & SHF_MASKPROC)
4248 proc_flags |= flag;
4249 else
4250 unknown_flags |= flag;
4251 }
4252 else
4253 {
4254 switch (flag)
4255 {
4256 case SHF_WRITE: *p = 'W'; break;
4257 case SHF_ALLOC: *p = 'A'; break;
4258 case SHF_EXECINSTR: *p = 'X'; break;
4259 case SHF_MERGE: *p = 'M'; break;
4260 case SHF_STRINGS: *p = 'S'; break;
4261 case SHF_INFO_LINK: *p = 'I'; break;
4262 case SHF_LINK_ORDER: *p = 'L'; break;
4263 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4264 case SHF_GROUP: *p = 'G'; break;
4265 case SHF_TLS: *p = 'T'; break;
4266 case SHF_EXCLUDE: *p = 'E'; break;
4267
4268 default:
4269 if ((elf_header.e_machine == EM_X86_64
4270 || elf_header.e_machine == EM_L1OM)
4271 && flag == SHF_X86_64_LARGE)
4272 *p = 'l';
4273 else if (flag & SHF_MASKOS)
4274 {
4275 *p = 'o';
4276 sh_flags &= ~ SHF_MASKOS;
4277 }
4278 else if (flag & SHF_MASKPROC)
4279 {
4280 *p = 'p';
4281 sh_flags &= ~ SHF_MASKPROC;
4282 }
4283 else
4284 *p = 'x';
4285 break;
4286 }
4287 p++;
4288 }
4289 }
4290
4291 if (do_section_details)
4292 {
4293 if (os_flags)
4294 {
4295 size -= 5 + field_size;
4296 if (p != buff + field_size + 4)
4297 {
4298 if (size < (2 + 1))
4299 abort ();
4300 size -= 2;
4301 *p++ = ',';
4302 *p++ = ' ';
4303 }
4304 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4305 (unsigned long) os_flags);
4306 p += 5 + field_size;
4307 }
4308 if (proc_flags)
4309 {
4310 size -= 7 + field_size;
4311 if (p != buff + field_size + 4)
4312 {
4313 if (size < (2 + 1))
4314 abort ();
4315 size -= 2;
4316 *p++ = ',';
4317 *p++ = ' ';
4318 }
4319 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4320 (unsigned long) proc_flags);
4321 p += 7 + field_size;
4322 }
4323 if (unknown_flags)
4324 {
4325 size -= 10 + field_size;
4326 if (p != buff + field_size + 4)
4327 {
4328 if (size < (2 + 1))
4329 abort ();
4330 size -= 2;
4331 *p++ = ',';
4332 *p++ = ' ';
4333 }
4334 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4335 (unsigned long) unknown_flags);
4336 p += 10 + field_size;
4337 }
4338 }
4339
4340 *p = '\0';
4341 return buff;
4342 }
4343
4344 static int
4345 process_section_headers (FILE * file)
4346 {
4347 Elf_Internal_Shdr * section;
4348 unsigned int i;
4349
4350 section_headers = NULL;
4351
4352 if (elf_header.e_shnum == 0)
4353 {
4354 if (do_sections)
4355 printf (_("\nThere are no sections in this file.\n"));
4356
4357 return 1;
4358 }
4359
4360 if (do_sections && !do_header)
4361 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4362 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4363
4364 if (is_32bit_elf)
4365 {
4366 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4367 return 0;
4368 }
4369 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4370 return 0;
4371
4372 /* Read in the string table, so that we have names to display. */
4373 if (elf_header.e_shstrndx != SHN_UNDEF
4374 && elf_header.e_shstrndx < elf_header.e_shnum)
4375 {
4376 section = section_headers + elf_header.e_shstrndx;
4377
4378 if (section->sh_size != 0)
4379 {
4380 string_table = (char *) get_data (NULL, file, section->sh_offset,
4381 1, section->sh_size,
4382 _("string table"));
4383
4384 string_table_length = string_table != NULL ? section->sh_size : 0;
4385 }
4386 }
4387
4388 /* Scan the sections for the dynamic symbol table
4389 and dynamic string table and debug sections. */
4390 dynamic_symbols = NULL;
4391 dynamic_strings = NULL;
4392 dynamic_syminfo = NULL;
4393 symtab_shndx_hdr = NULL;
4394
4395 eh_addr_size = is_32bit_elf ? 4 : 8;
4396 switch (elf_header.e_machine)
4397 {
4398 case EM_MIPS:
4399 case EM_MIPS_RS3_LE:
4400 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4401 FDE addresses. However, the ABI also has a semi-official ILP32
4402 variant for which the normal FDE address size rules apply.
4403
4404 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4405 section, where XX is the size of longs in bits. Unfortunately,
4406 earlier compilers provided no way of distinguishing ILP32 objects
4407 from LP64 objects, so if there's any doubt, we should assume that
4408 the official LP64 form is being used. */
4409 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4410 && find_section (".gcc_compiled_long32") == NULL)
4411 eh_addr_size = 8;
4412 break;
4413
4414 case EM_H8_300:
4415 case EM_H8_300H:
4416 switch (elf_header.e_flags & EF_H8_MACH)
4417 {
4418 case E_H8_MACH_H8300:
4419 case E_H8_MACH_H8300HN:
4420 case E_H8_MACH_H8300SN:
4421 case E_H8_MACH_H8300SXN:
4422 eh_addr_size = 2;
4423 break;
4424 case E_H8_MACH_H8300H:
4425 case E_H8_MACH_H8300S:
4426 case E_H8_MACH_H8300SX:
4427 eh_addr_size = 4;
4428 break;
4429 }
4430 break;
4431
4432 case EM_M32C_OLD:
4433 case EM_M32C:
4434 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4435 {
4436 case EF_M32C_CPU_M16C:
4437 eh_addr_size = 2;
4438 break;
4439 }
4440 break;
4441 }
4442
4443 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4444 do \
4445 { \
4446 size_t expected_entsize \
4447 = is_32bit_elf ? size32 : size64; \
4448 if (section->sh_entsize != expected_entsize) \
4449 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4450 i, (unsigned long int) section->sh_entsize, \
4451 (unsigned long int) expected_entsize); \
4452 section->sh_entsize = expected_entsize; \
4453 } \
4454 while (0)
4455 #define CHECK_ENTSIZE(section, i, type) \
4456 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4457 sizeof (Elf64_External_##type))
4458
4459 for (i = 0, section = section_headers;
4460 i < elf_header.e_shnum;
4461 i++, section++)
4462 {
4463 char * name = SECTION_NAME (section);
4464
4465 if (section->sh_type == SHT_DYNSYM)
4466 {
4467 if (dynamic_symbols != NULL)
4468 {
4469 error (_("File contains multiple dynamic symbol tables\n"));
4470 continue;
4471 }
4472
4473 CHECK_ENTSIZE (section, i, Sym);
4474 num_dynamic_syms = section->sh_size / section->sh_entsize;
4475 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4476 }
4477 else if (section->sh_type == SHT_STRTAB
4478 && streq (name, ".dynstr"))
4479 {
4480 if (dynamic_strings != NULL)
4481 {
4482 error (_("File contains multiple dynamic string tables\n"));
4483 continue;
4484 }
4485
4486 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4487 1, section->sh_size,
4488 _("dynamic strings"));
4489 dynamic_strings_length = section->sh_size;
4490 }
4491 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4492 {
4493 if (symtab_shndx_hdr != NULL)
4494 {
4495 error (_("File contains multiple symtab shndx tables\n"));
4496 continue;
4497 }
4498 symtab_shndx_hdr = section;
4499 }
4500 else if (section->sh_type == SHT_SYMTAB)
4501 CHECK_ENTSIZE (section, i, Sym);
4502 else if (section->sh_type == SHT_GROUP)
4503 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4504 else if (section->sh_type == SHT_REL)
4505 CHECK_ENTSIZE (section, i, Rel);
4506 else if (section->sh_type == SHT_RELA)
4507 CHECK_ENTSIZE (section, i, Rela);
4508 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4509 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4510 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4511 || do_debug_str || do_debug_loc || do_debug_ranges)
4512 && (const_strneq (name, ".debug_")
4513 || const_strneq (name, ".zdebug_")))
4514 {
4515 if (name[1] == 'z')
4516 name += sizeof (".zdebug_") - 1;
4517 else
4518 name += sizeof (".debug_") - 1;
4519
4520 if (do_debugging
4521 || (do_debug_info && streq (name, "info"))
4522 || (do_debug_info && streq (name, "types"))
4523 || (do_debug_abbrevs && streq (name, "abbrev"))
4524 || (do_debug_lines && streq (name, "line"))
4525 || (do_debug_pubnames && streq (name, "pubnames"))
4526 || (do_debug_pubtypes && streq (name, "pubtypes"))
4527 || (do_debug_aranges && streq (name, "aranges"))
4528 || (do_debug_ranges && streq (name, "ranges"))
4529 || (do_debug_frames && streq (name, "frame"))
4530 || (do_debug_macinfo && streq (name, "macinfo"))
4531 || (do_debug_str && streq (name, "str"))
4532 || (do_debug_loc && streq (name, "loc"))
4533 )
4534 request_dump_bynumber (i, DEBUG_DUMP);
4535 }
4536 /* Linkonce section to be combined with .debug_info at link time. */
4537 else if ((do_debugging || do_debug_info)
4538 && const_strneq (name, ".gnu.linkonce.wi."))
4539 request_dump_bynumber (i, DEBUG_DUMP);
4540 else if (do_debug_frames && streq (name, ".eh_frame"))
4541 request_dump_bynumber (i, DEBUG_DUMP);
4542 }
4543
4544 if (! do_sections)
4545 return 1;
4546
4547 if (elf_header.e_shnum > 1)
4548 printf (_("\nSection Headers:\n"));
4549 else
4550 printf (_("\nSection Header:\n"));
4551
4552 if (is_32bit_elf)
4553 {
4554 if (do_section_details)
4555 {
4556 printf (_(" [Nr] Name\n"));
4557 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4558 }
4559 else
4560 printf
4561 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4562 }
4563 else if (do_wide)
4564 {
4565 if (do_section_details)
4566 {
4567 printf (_(" [Nr] Name\n"));
4568 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4569 }
4570 else
4571 printf
4572 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4573 }
4574 else
4575 {
4576 if (do_section_details)
4577 {
4578 printf (_(" [Nr] Name\n"));
4579 printf (_(" Type Address Offset Link\n"));
4580 printf (_(" Size EntSize Info Align\n"));
4581 }
4582 else
4583 {
4584 printf (_(" [Nr] Name Type Address Offset\n"));
4585 printf (_(" Size EntSize Flags Link Info Align\n"));
4586 }
4587 }
4588
4589 if (do_section_details)
4590 printf (_(" Flags\n"));
4591
4592 for (i = 0, section = section_headers;
4593 i < elf_header.e_shnum;
4594 i++, section++)
4595 {
4596 if (do_section_details)
4597 {
4598 printf (" [%2u] %s\n",
4599 i,
4600 SECTION_NAME (section));
4601 if (is_32bit_elf || do_wide)
4602 printf (" %-15.15s ",
4603 get_section_type_name (section->sh_type));
4604 }
4605 else
4606 printf ((do_wide ? " [%2u] %-17s %-15s "
4607 : " [%2u] %-17.17s %-15.15s "),
4608 i,
4609 SECTION_NAME (section),
4610 get_section_type_name (section->sh_type));
4611
4612 if (is_32bit_elf)
4613 {
4614 const char * link_too_big = NULL;
4615
4616 print_vma (section->sh_addr, LONG_HEX);
4617
4618 printf ( " %6.6lx %6.6lx %2.2lx",
4619 (unsigned long) section->sh_offset,
4620 (unsigned long) section->sh_size,
4621 (unsigned long) section->sh_entsize);
4622
4623 if (do_section_details)
4624 fputs (" ", stdout);
4625 else
4626 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4627
4628 if (section->sh_link >= elf_header.e_shnum)
4629 {
4630 link_too_big = "";
4631 /* The sh_link value is out of range. Normally this indicates
4632 an error but it can have special values in Solaris binaries. */
4633 switch (elf_header.e_machine)
4634 {
4635 case EM_386:
4636 case EM_486:
4637 case EM_X86_64:
4638 case EM_L1OM:
4639 case EM_OLD_SPARCV9:
4640 case EM_SPARC32PLUS:
4641 case EM_SPARCV9:
4642 case EM_SPARC:
4643 if (section->sh_link == (SHN_BEFORE & 0xffff))
4644 link_too_big = "BEFORE";
4645 else if (section->sh_link == (SHN_AFTER & 0xffff))
4646 link_too_big = "AFTER";
4647 break;
4648 default:
4649 break;
4650 }
4651 }
4652
4653 if (do_section_details)
4654 {
4655 if (link_too_big != NULL && * link_too_big)
4656 printf ("<%s> ", link_too_big);
4657 else
4658 printf ("%2u ", section->sh_link);
4659 printf ("%3u %2lu\n", section->sh_info,
4660 (unsigned long) section->sh_addralign);
4661 }
4662 else
4663 printf ("%2u %3u %2lu\n",
4664 section->sh_link,
4665 section->sh_info,
4666 (unsigned long) section->sh_addralign);
4667
4668 if (link_too_big && ! * link_too_big)
4669 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4670 i, section->sh_link);
4671 }
4672 else if (do_wide)
4673 {
4674 print_vma (section->sh_addr, LONG_HEX);
4675
4676 if ((long) section->sh_offset == section->sh_offset)
4677 printf (" %6.6lx", (unsigned long) section->sh_offset);
4678 else
4679 {
4680 putchar (' ');
4681 print_vma (section->sh_offset, LONG_HEX);
4682 }
4683
4684 if ((unsigned long) section->sh_size == section->sh_size)
4685 printf (" %6.6lx", (unsigned long) section->sh_size);
4686 else
4687 {
4688 putchar (' ');
4689 print_vma (section->sh_size, LONG_HEX);
4690 }
4691
4692 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4693 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4694 else
4695 {
4696 putchar (' ');
4697 print_vma (section->sh_entsize, LONG_HEX);
4698 }
4699
4700 if (do_section_details)
4701 fputs (" ", stdout);
4702 else
4703 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4704
4705 printf ("%2u %3u ", section->sh_link, section->sh_info);
4706
4707 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4708 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4709 else
4710 {
4711 print_vma (section->sh_addralign, DEC);
4712 putchar ('\n');
4713 }
4714 }
4715 else if (do_section_details)
4716 {
4717 printf (" %-15.15s ",
4718 get_section_type_name (section->sh_type));
4719 print_vma (section->sh_addr, LONG_HEX);
4720 if ((long) section->sh_offset == section->sh_offset)
4721 printf (" %16.16lx", (unsigned long) section->sh_offset);
4722 else
4723 {
4724 printf (" ");
4725 print_vma (section->sh_offset, LONG_HEX);
4726 }
4727 printf (" %u\n ", section->sh_link);
4728 print_vma (section->sh_size, LONG_HEX);
4729 putchar (' ');
4730 print_vma (section->sh_entsize, LONG_HEX);
4731
4732 printf (" %-16u %lu\n",
4733 section->sh_info,
4734 (unsigned long) section->sh_addralign);
4735 }
4736 else
4737 {
4738 putchar (' ');
4739 print_vma (section->sh_addr, LONG_HEX);
4740 if ((long) section->sh_offset == section->sh_offset)
4741 printf (" %8.8lx", (unsigned long) section->sh_offset);
4742 else
4743 {
4744 printf (" ");
4745 print_vma (section->sh_offset, LONG_HEX);
4746 }
4747 printf ("\n ");
4748 print_vma (section->sh_size, LONG_HEX);
4749 printf (" ");
4750 print_vma (section->sh_entsize, LONG_HEX);
4751
4752 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4753
4754 printf (" %2u %3u %lu\n",
4755 section->sh_link,
4756 section->sh_info,
4757 (unsigned long) section->sh_addralign);
4758 }
4759
4760 if (do_section_details)
4761 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4762 }
4763
4764 if (!do_section_details)
4765 printf (_("Key to Flags:\n\
4766 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4767 I (info), L (link order), G (group), x (unknown)\n\
4768 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4769
4770 return 1;
4771 }
4772
4773 static const char *
4774 get_group_flags (unsigned int flags)
4775 {
4776 static char buff[32];
4777 switch (flags)
4778 {
4779 case 0:
4780 return "";
4781
4782 case GRP_COMDAT:
4783 return "COMDAT ";
4784
4785 default:
4786 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4787 break;
4788 }
4789 return buff;
4790 }
4791
4792 static int
4793 process_section_groups (FILE * file)
4794 {
4795 Elf_Internal_Shdr * section;
4796 unsigned int i;
4797 struct group * group;
4798 Elf_Internal_Shdr * symtab_sec;
4799 Elf_Internal_Shdr * strtab_sec;
4800 Elf_Internal_Sym * symtab;
4801 char * strtab;
4802 size_t strtab_size;
4803
4804 /* Don't process section groups unless needed. */
4805 if (!do_unwind && !do_section_groups)
4806 return 1;
4807
4808 if (elf_header.e_shnum == 0)
4809 {
4810 if (do_section_groups)
4811 printf (_("\nThere are no sections in this file.\n"));
4812
4813 return 1;
4814 }
4815
4816 if (section_headers == NULL)
4817 {
4818 error (_("Section headers are not available!\n"));
4819 abort ();
4820 }
4821
4822 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4823 sizeof (struct group *));
4824
4825 if (section_headers_groups == NULL)
4826 {
4827 error (_("Out of memory\n"));
4828 return 0;
4829 }
4830
4831 /* Scan the sections for the group section. */
4832 group_count = 0;
4833 for (i = 0, section = section_headers;
4834 i < elf_header.e_shnum;
4835 i++, section++)
4836 if (section->sh_type == SHT_GROUP)
4837 group_count++;
4838
4839 if (group_count == 0)
4840 {
4841 if (do_section_groups)
4842 printf (_("\nThere are no section groups in this file.\n"));
4843
4844 return 1;
4845 }
4846
4847 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4848
4849 if (section_groups == NULL)
4850 {
4851 error (_("Out of memory\n"));
4852 return 0;
4853 }
4854
4855 symtab_sec = NULL;
4856 strtab_sec = NULL;
4857 symtab = NULL;
4858 strtab = NULL;
4859 strtab_size = 0;
4860 for (i = 0, section = section_headers, group = section_groups;
4861 i < elf_header.e_shnum;
4862 i++, section++)
4863 {
4864 if (section->sh_type == SHT_GROUP)
4865 {
4866 char * name = SECTION_NAME (section);
4867 char * group_name;
4868 unsigned char * start;
4869 unsigned char * indices;
4870 unsigned int entry, j, size;
4871 Elf_Internal_Shdr * sec;
4872 Elf_Internal_Sym * sym;
4873
4874 /* Get the symbol table. */
4875 if (section->sh_link >= elf_header.e_shnum
4876 || ((sec = section_headers + section->sh_link)->sh_type
4877 != SHT_SYMTAB))
4878 {
4879 error (_("Bad sh_link in group section `%s'\n"), name);
4880 continue;
4881 }
4882
4883 if (symtab_sec != sec)
4884 {
4885 symtab_sec = sec;
4886 if (symtab)
4887 free (symtab);
4888 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4889 }
4890
4891 sym = symtab + section->sh_info;
4892
4893 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4894 {
4895 if (sym->st_shndx == 0
4896 || sym->st_shndx >= elf_header.e_shnum)
4897 {
4898 error (_("Bad sh_info in group section `%s'\n"), name);
4899 continue;
4900 }
4901
4902 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4903 strtab_sec = NULL;
4904 if (strtab)
4905 free (strtab);
4906 strtab = NULL;
4907 strtab_size = 0;
4908 }
4909 else
4910 {
4911 /* Get the string table. */
4912 if (symtab_sec->sh_link >= elf_header.e_shnum)
4913 {
4914 strtab_sec = NULL;
4915 if (strtab)
4916 free (strtab);
4917 strtab = NULL;
4918 strtab_size = 0;
4919 }
4920 else if (strtab_sec
4921 != (sec = section_headers + symtab_sec->sh_link))
4922 {
4923 strtab_sec = sec;
4924 if (strtab)
4925 free (strtab);
4926 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4927 1, strtab_sec->sh_size,
4928 _("string table"));
4929 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4930 }
4931 group_name = sym->st_name < strtab_size
4932 ? strtab + sym->st_name : _("<corrupt>");
4933 }
4934
4935 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4936 1, section->sh_size,
4937 _("section data"));
4938
4939 indices = start;
4940 size = (section->sh_size / section->sh_entsize) - 1;
4941 entry = byte_get (indices, 4);
4942 indices += 4;
4943
4944 if (do_section_groups)
4945 {
4946 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
4947 get_group_flags (entry), i, name, group_name, size);
4948
4949 printf (_(" [Index] Name\n"));
4950 }
4951
4952 group->group_index = i;
4953
4954 for (j = 0; j < size; j++)
4955 {
4956 struct group_list * g;
4957
4958 entry = byte_get (indices, 4);
4959 indices += 4;
4960
4961 if (entry >= elf_header.e_shnum)
4962 {
4963 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4964 entry, i, elf_header.e_shnum - 1);
4965 continue;
4966 }
4967
4968 if (section_headers_groups [entry] != NULL)
4969 {
4970 if (entry)
4971 {
4972 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4973 entry, i,
4974 section_headers_groups [entry]->group_index);
4975 continue;
4976 }
4977 else
4978 {
4979 /* Intel C/C++ compiler may put section 0 in a
4980 section group. We just warn it the first time
4981 and ignore it afterwards. */
4982 static int warned = 0;
4983 if (!warned)
4984 {
4985 error (_("section 0 in group section [%5u]\n"),
4986 section_headers_groups [entry]->group_index);
4987 warned++;
4988 }
4989 }
4990 }
4991
4992 section_headers_groups [entry] = group;
4993
4994 if (do_section_groups)
4995 {
4996 sec = section_headers + entry;
4997 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4998 }
4999
5000 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5001 g->section_index = entry;
5002 g->next = group->root;
5003 group->root = g;
5004 }
5005
5006 if (start)
5007 free (start);
5008
5009 group++;
5010 }
5011 }
5012
5013 if (symtab)
5014 free (symtab);
5015 if (strtab)
5016 free (strtab);
5017 return 1;
5018 }
5019
5020 static struct
5021 {
5022 const char * name;
5023 int reloc;
5024 int size;
5025 int rela;
5026 } dynamic_relocations [] =
5027 {
5028 { "REL", DT_REL, DT_RELSZ, FALSE },
5029 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5030 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5031 };
5032
5033 /* Process the reloc section. */
5034
5035 static int
5036 process_relocs (FILE * file)
5037 {
5038 unsigned long rel_size;
5039 unsigned long rel_offset;
5040
5041
5042 if (!do_reloc)
5043 return 1;
5044
5045 if (do_using_dynamic)
5046 {
5047 int is_rela;
5048 const char * name;
5049 int has_dynamic_reloc;
5050 unsigned int i;
5051
5052 has_dynamic_reloc = 0;
5053
5054 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5055 {
5056 is_rela = dynamic_relocations [i].rela;
5057 name = dynamic_relocations [i].name;
5058 rel_size = dynamic_info [dynamic_relocations [i].size];
5059 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5060
5061 has_dynamic_reloc |= rel_size;
5062
5063 if (is_rela == UNKNOWN)
5064 {
5065 if (dynamic_relocations [i].reloc == DT_JMPREL)
5066 switch (dynamic_info[DT_PLTREL])
5067 {
5068 case DT_REL:
5069 is_rela = FALSE;
5070 break;
5071 case DT_RELA:
5072 is_rela = TRUE;
5073 break;
5074 }
5075 }
5076
5077 if (rel_size)
5078 {
5079 printf
5080 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5081 name, rel_offset, rel_size);
5082
5083 dump_relocations (file,
5084 offset_from_vma (file, rel_offset, rel_size),
5085 rel_size,
5086 dynamic_symbols, num_dynamic_syms,
5087 dynamic_strings, dynamic_strings_length, is_rela);
5088 }
5089 }
5090
5091 if (! has_dynamic_reloc)
5092 printf (_("\nThere are no dynamic relocations in this file.\n"));
5093 }
5094 else
5095 {
5096 Elf_Internal_Shdr * section;
5097 unsigned long i;
5098 int found = 0;
5099
5100 for (i = 0, section = section_headers;
5101 i < elf_header.e_shnum;
5102 i++, section++)
5103 {
5104 if ( section->sh_type != SHT_RELA
5105 && section->sh_type != SHT_REL)
5106 continue;
5107
5108 rel_offset = section->sh_offset;
5109 rel_size = section->sh_size;
5110
5111 if (rel_size)
5112 {
5113 Elf_Internal_Shdr * strsec;
5114 int is_rela;
5115
5116 printf (_("\nRelocation section "));
5117
5118 if (string_table == NULL)
5119 printf ("%d", section->sh_name);
5120 else
5121 printf (_("'%s'"), SECTION_NAME (section));
5122
5123 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5124 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5125
5126 is_rela = section->sh_type == SHT_RELA;
5127
5128 if (section->sh_link != 0
5129 && section->sh_link < elf_header.e_shnum)
5130 {
5131 Elf_Internal_Shdr * symsec;
5132 Elf_Internal_Sym * symtab;
5133 unsigned long nsyms;
5134 unsigned long strtablen = 0;
5135 char * strtab = NULL;
5136
5137 symsec = section_headers + section->sh_link;
5138 if (symsec->sh_type != SHT_SYMTAB
5139 && symsec->sh_type != SHT_DYNSYM)
5140 continue;
5141
5142 nsyms = symsec->sh_size / symsec->sh_entsize;
5143 symtab = GET_ELF_SYMBOLS (file, symsec);
5144
5145 if (symtab == NULL)
5146 continue;
5147
5148 if (symsec->sh_link != 0
5149 && symsec->sh_link < elf_header.e_shnum)
5150 {
5151 strsec = section_headers + symsec->sh_link;
5152
5153 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5154 1, strsec->sh_size,
5155 _("string table"));
5156 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5157 }
5158
5159 dump_relocations (file, rel_offset, rel_size,
5160 symtab, nsyms, strtab, strtablen, is_rela);
5161 if (strtab)
5162 free (strtab);
5163 free (symtab);
5164 }
5165 else
5166 dump_relocations (file, rel_offset, rel_size,
5167 NULL, 0, NULL, 0, is_rela);
5168
5169 found = 1;
5170 }
5171 }
5172
5173 if (! found)
5174 printf (_("\nThere are no relocations in this file.\n"));
5175 }
5176
5177 return 1;
5178 }
5179
5180 /* Process the unwind section. */
5181
5182 #include "unwind-ia64.h"
5183
5184 /* An absolute address consists of a section and an offset. If the
5185 section is NULL, the offset itself is the address, otherwise, the
5186 address equals to LOAD_ADDRESS(section) + offset. */
5187
5188 struct absaddr
5189 {
5190 unsigned short section;
5191 bfd_vma offset;
5192 };
5193
5194 #define ABSADDR(a) \
5195 ((a).section \
5196 ? section_headers [(a).section].sh_addr + (a).offset \
5197 : (a).offset)
5198
5199 struct ia64_unw_table_entry
5200 {
5201 struct absaddr start;
5202 struct absaddr end;
5203 struct absaddr info;
5204 };
5205
5206 struct ia64_unw_aux_info
5207 {
5208
5209 struct ia64_unw_table_entry *table; /* Unwind table. */
5210 unsigned long table_len; /* Length of unwind table. */
5211 unsigned char * info; /* Unwind info. */
5212 unsigned long info_size; /* Size of unwind info. */
5213 bfd_vma info_addr; /* starting address of unwind info. */
5214 bfd_vma seg_base; /* Starting address of segment. */
5215 Elf_Internal_Sym * symtab; /* The symbol table. */
5216 unsigned long nsyms; /* Number of symbols. */
5217 char * strtab; /* The string table. */
5218 unsigned long strtab_size; /* Size of string table. */
5219 };
5220
5221 static void
5222 find_symbol_for_address (Elf_Internal_Sym * symtab,
5223 unsigned long nsyms,
5224 const char * strtab,
5225 unsigned long strtab_size,
5226 struct absaddr addr,
5227 const char ** symname,
5228 bfd_vma * offset)
5229 {
5230 bfd_vma dist = 0x100000;
5231 Elf_Internal_Sym * sym;
5232 Elf_Internal_Sym * best = NULL;
5233 unsigned long i;
5234
5235 REMOVE_ARCH_BITS (addr.offset);
5236
5237 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5238 {
5239 bfd_vma value = sym->st_value;
5240
5241 REMOVE_ARCH_BITS (value);
5242
5243 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5244 && sym->st_name != 0
5245 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5246 && addr.offset >= value
5247 && addr.offset - value < dist)
5248 {
5249 best = sym;
5250 dist = addr.offset - value;
5251 if (!dist)
5252 break;
5253 }
5254 }
5255 if (best)
5256 {
5257 *symname = (best->st_name >= strtab_size
5258 ? _("<corrupt>") : strtab + best->st_name);
5259 *offset = dist;
5260 return;
5261 }
5262 *symname = NULL;
5263 *offset = addr.offset;
5264 }
5265
5266 static void
5267 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5268 {
5269 struct ia64_unw_table_entry * tp;
5270 int in_body;
5271
5272 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5273 {
5274 bfd_vma stamp;
5275 bfd_vma offset;
5276 const unsigned char * dp;
5277 const unsigned char * head;
5278 const char * procname;
5279
5280 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5281 aux->strtab_size, tp->start, &procname, &offset);
5282
5283 fputs ("\n<", stdout);
5284
5285 if (procname)
5286 {
5287 fputs (procname, stdout);
5288
5289 if (offset)
5290 printf ("+%lx", (unsigned long) offset);
5291 }
5292
5293 fputs (">: [", stdout);
5294 print_vma (tp->start.offset, PREFIX_HEX);
5295 fputc ('-', stdout);
5296 print_vma (tp->end.offset, PREFIX_HEX);
5297 printf ("], info at +0x%lx\n",
5298 (unsigned long) (tp->info.offset - aux->seg_base));
5299
5300 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5301 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5302
5303 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5304 (unsigned) UNW_VER (stamp),
5305 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5306 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5307 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5308 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5309
5310 if (UNW_VER (stamp) != 1)
5311 {
5312 printf (_("\tUnknown version.\n"));
5313 continue;
5314 }
5315
5316 in_body = 0;
5317 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5318 dp = unw_decode (dp, in_body, & in_body);
5319 }
5320 }
5321
5322 static int
5323 slurp_ia64_unwind_table (FILE * file,
5324 struct ia64_unw_aux_info * aux,
5325 Elf_Internal_Shdr * sec)
5326 {
5327 unsigned long size, nrelas, i;
5328 Elf_Internal_Phdr * seg;
5329 struct ia64_unw_table_entry * tep;
5330 Elf_Internal_Shdr * relsec;
5331 Elf_Internal_Rela * rela;
5332 Elf_Internal_Rela * rp;
5333 unsigned char * table;
5334 unsigned char * tp;
5335 Elf_Internal_Sym * sym;
5336 const char * relname;
5337
5338 /* First, find the starting address of the segment that includes
5339 this section: */
5340
5341 if (elf_header.e_phnum)
5342 {
5343 if (! get_program_headers (file))
5344 return 0;
5345
5346 for (seg = program_headers;
5347 seg < program_headers + elf_header.e_phnum;
5348 ++seg)
5349 {
5350 if (seg->p_type != PT_LOAD)
5351 continue;
5352
5353 if (sec->sh_addr >= seg->p_vaddr
5354 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5355 {
5356 aux->seg_base = seg->p_vaddr;
5357 break;
5358 }
5359 }
5360 }
5361
5362 /* Second, build the unwind table from the contents of the unwind section: */
5363 size = sec->sh_size;
5364 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5365 _("unwind table"));
5366 if (!table)
5367 return 0;
5368
5369 aux->table = (struct ia64_unw_table_entry *)
5370 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5371 tep = aux->table;
5372 for (tp = table; tp < table + size; ++tep)
5373 {
5374 tep->start.section = SHN_UNDEF;
5375 tep->end.section = SHN_UNDEF;
5376 tep->info.section = SHN_UNDEF;
5377 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5378 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5379 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5380 tep->start.offset += aux->seg_base;
5381 tep->end.offset += aux->seg_base;
5382 tep->info.offset += aux->seg_base;
5383 }
5384 free (table);
5385
5386 /* Third, apply any relocations to the unwind table: */
5387 for (relsec = section_headers;
5388 relsec < section_headers + elf_header.e_shnum;
5389 ++relsec)
5390 {
5391 if (relsec->sh_type != SHT_RELA
5392 || relsec->sh_info >= elf_header.e_shnum
5393 || section_headers + relsec->sh_info != sec)
5394 continue;
5395
5396 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5397 & rela, & nrelas))
5398 return 0;
5399
5400 for (rp = rela; rp < rela + nrelas; ++rp)
5401 {
5402 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5403 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5404
5405 if (! const_strneq (relname, "R_IA64_SEGREL"))
5406 {
5407 warn (_("Skipping unexpected relocation type %s\n"), relname);
5408 continue;
5409 }
5410
5411 i = rp->r_offset / (3 * eh_addr_size);
5412
5413 switch (rp->r_offset/eh_addr_size % 3)
5414 {
5415 case 0:
5416 aux->table[i].start.section = sym->st_shndx;
5417 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5418 break;
5419 case 1:
5420 aux->table[i].end.section = sym->st_shndx;
5421 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5422 break;
5423 case 2:
5424 aux->table[i].info.section = sym->st_shndx;
5425 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5426 break;
5427 default:
5428 break;
5429 }
5430 }
5431
5432 free (rela);
5433 }
5434
5435 aux->table_len = size / (3 * eh_addr_size);
5436 return 1;
5437 }
5438
5439 static int
5440 ia64_process_unwind (FILE * file)
5441 {
5442 Elf_Internal_Shdr * sec;
5443 Elf_Internal_Shdr * unwsec = NULL;
5444 Elf_Internal_Shdr * strsec;
5445 unsigned long i, unwcount = 0, unwstart = 0;
5446 struct ia64_unw_aux_info aux;
5447
5448 memset (& aux, 0, sizeof (aux));
5449
5450 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5451 {
5452 if (sec->sh_type == SHT_SYMTAB
5453 && sec->sh_link < elf_header.e_shnum)
5454 {
5455 aux.nsyms = sec->sh_size / sec->sh_entsize;
5456 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5457
5458 strsec = section_headers + sec->sh_link;
5459 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5460 1, strsec->sh_size,
5461 _("string table"));
5462 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5463 }
5464 else if (sec->sh_type == SHT_IA_64_UNWIND)
5465 unwcount++;
5466 }
5467
5468 if (!unwcount)
5469 printf (_("\nThere are no unwind sections in this file.\n"));
5470
5471 while (unwcount-- > 0)
5472 {
5473 char * suffix;
5474 size_t len, len2;
5475
5476 for (i = unwstart, sec = section_headers + unwstart;
5477 i < elf_header.e_shnum; ++i, ++sec)
5478 if (sec->sh_type == SHT_IA_64_UNWIND)
5479 {
5480 unwsec = sec;
5481 break;
5482 }
5483
5484 unwstart = i + 1;
5485 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5486
5487 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5488 {
5489 /* We need to find which section group it is in. */
5490 struct group_list * g = section_headers_groups [i]->root;
5491
5492 for (; g != NULL; g = g->next)
5493 {
5494 sec = section_headers + g->section_index;
5495
5496 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5497 break;
5498 }
5499
5500 if (g == NULL)
5501 i = elf_header.e_shnum;
5502 }
5503 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5504 {
5505 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5506 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5507 suffix = SECTION_NAME (unwsec) + len;
5508 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5509 ++i, ++sec)
5510 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5511 && streq (SECTION_NAME (sec) + len2, suffix))
5512 break;
5513 }
5514 else
5515 {
5516 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5517 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5518 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5519 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5520 suffix = "";
5521 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5522 suffix = SECTION_NAME (unwsec) + len;
5523 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5524 ++i, ++sec)
5525 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5526 && streq (SECTION_NAME (sec) + len2, suffix))
5527 break;
5528 }
5529
5530 if (i == elf_header.e_shnum)
5531 {
5532 printf (_("\nCould not find unwind info section for "));
5533
5534 if (string_table == NULL)
5535 printf ("%d", unwsec->sh_name);
5536 else
5537 printf (_("'%s'"), SECTION_NAME (unwsec));
5538 }
5539 else
5540 {
5541 aux.info_size = sec->sh_size;
5542 aux.info_addr = sec->sh_addr;
5543 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5544 aux.info_size,
5545 _("unwind info"));
5546
5547 printf (_("\nUnwind section "));
5548
5549 if (string_table == NULL)
5550 printf ("%d", unwsec->sh_name);
5551 else
5552 printf (_("'%s'"), SECTION_NAME (unwsec));
5553
5554 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5555 (unsigned long) unwsec->sh_offset,
5556 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5557
5558 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5559
5560 if (aux.table_len > 0)
5561 dump_ia64_unwind (& aux);
5562
5563 if (aux.table)
5564 free ((char *) aux.table);
5565 if (aux.info)
5566 free ((char *) aux.info);
5567 aux.table = NULL;
5568 aux.info = NULL;
5569 }
5570 }
5571
5572 if (aux.symtab)
5573 free (aux.symtab);
5574 if (aux.strtab)
5575 free ((char *) aux.strtab);
5576
5577 return 1;
5578 }
5579
5580 struct hppa_unw_table_entry
5581 {
5582 struct absaddr start;
5583 struct absaddr end;
5584 unsigned int Cannot_unwind:1; /* 0 */
5585 unsigned int Millicode:1; /* 1 */
5586 unsigned int Millicode_save_sr0:1; /* 2 */
5587 unsigned int Region_description:2; /* 3..4 */
5588 unsigned int reserved1:1; /* 5 */
5589 unsigned int Entry_SR:1; /* 6 */
5590 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5591 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5592 unsigned int Args_stored:1; /* 16 */
5593 unsigned int Variable_Frame:1; /* 17 */
5594 unsigned int Separate_Package_Body:1; /* 18 */
5595 unsigned int Frame_Extension_Millicode:1; /* 19 */
5596 unsigned int Stack_Overflow_Check:1; /* 20 */
5597 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5598 unsigned int Ada_Region:1; /* 22 */
5599 unsigned int cxx_info:1; /* 23 */
5600 unsigned int cxx_try_catch:1; /* 24 */
5601 unsigned int sched_entry_seq:1; /* 25 */
5602 unsigned int reserved2:1; /* 26 */
5603 unsigned int Save_SP:1; /* 27 */
5604 unsigned int Save_RP:1; /* 28 */
5605 unsigned int Save_MRP_in_frame:1; /* 29 */
5606 unsigned int extn_ptr_defined:1; /* 30 */
5607 unsigned int Cleanup_defined:1; /* 31 */
5608
5609 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5610 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5611 unsigned int Large_frame:1; /* 2 */
5612 unsigned int Pseudo_SP_Set:1; /* 3 */
5613 unsigned int reserved4:1; /* 4 */
5614 unsigned int Total_frame_size:27; /* 5..31 */
5615 };
5616
5617 struct hppa_unw_aux_info
5618 {
5619 struct hppa_unw_table_entry *table; /* Unwind table. */
5620 unsigned long table_len; /* Length of unwind table. */
5621 bfd_vma seg_base; /* Starting address of segment. */
5622 Elf_Internal_Sym * symtab; /* The symbol table. */
5623 unsigned long nsyms; /* Number of symbols. */
5624 char * strtab; /* The string table. */
5625 unsigned long strtab_size; /* Size of string table. */
5626 };
5627
5628 static void
5629 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5630 {
5631 struct hppa_unw_table_entry * tp;
5632
5633 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5634 {
5635 bfd_vma offset;
5636 const char * procname;
5637
5638 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5639 aux->strtab_size, tp->start, &procname,
5640 &offset);
5641
5642 fputs ("\n<", stdout);
5643
5644 if (procname)
5645 {
5646 fputs (procname, stdout);
5647
5648 if (offset)
5649 printf ("+%lx", (unsigned long) offset);
5650 }
5651
5652 fputs (">: [", stdout);
5653 print_vma (tp->start.offset, PREFIX_HEX);
5654 fputc ('-', stdout);
5655 print_vma (tp->end.offset, PREFIX_HEX);
5656 printf ("]\n\t");
5657
5658 #define PF(_m) if (tp->_m) printf (#_m " ");
5659 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5660 PF(Cannot_unwind);
5661 PF(Millicode);
5662 PF(Millicode_save_sr0);
5663 /* PV(Region_description); */
5664 PF(Entry_SR);
5665 PV(Entry_FR);
5666 PV(Entry_GR);
5667 PF(Args_stored);
5668 PF(Variable_Frame);
5669 PF(Separate_Package_Body);
5670 PF(Frame_Extension_Millicode);
5671 PF(Stack_Overflow_Check);
5672 PF(Two_Instruction_SP_Increment);
5673 PF(Ada_Region);
5674 PF(cxx_info);
5675 PF(cxx_try_catch);
5676 PF(sched_entry_seq);
5677 PF(Save_SP);
5678 PF(Save_RP);
5679 PF(Save_MRP_in_frame);
5680 PF(extn_ptr_defined);
5681 PF(Cleanup_defined);
5682 PF(MPE_XL_interrupt_marker);
5683 PF(HP_UX_interrupt_marker);
5684 PF(Large_frame);
5685 PF(Pseudo_SP_Set);
5686 PV(Total_frame_size);
5687 #undef PF
5688 #undef PV
5689 }
5690
5691 printf ("\n");
5692 }
5693
5694 static int
5695 slurp_hppa_unwind_table (FILE * file,
5696 struct hppa_unw_aux_info * aux,
5697 Elf_Internal_Shdr * sec)
5698 {
5699 unsigned long size, unw_ent_size, nentries, nrelas, i;
5700 Elf_Internal_Phdr * seg;
5701 struct hppa_unw_table_entry * tep;
5702 Elf_Internal_Shdr * relsec;
5703 Elf_Internal_Rela * rela;
5704 Elf_Internal_Rela * rp;
5705 unsigned char * table;
5706 unsigned char * tp;
5707 Elf_Internal_Sym * sym;
5708 const char * relname;
5709
5710 /* First, find the starting address of the segment that includes
5711 this section. */
5712
5713 if (elf_header.e_phnum)
5714 {
5715 if (! get_program_headers (file))
5716 return 0;
5717
5718 for (seg = program_headers;
5719 seg < program_headers + elf_header.e_phnum;
5720 ++seg)
5721 {
5722 if (seg->p_type != PT_LOAD)
5723 continue;
5724
5725 if (sec->sh_addr >= seg->p_vaddr
5726 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5727 {
5728 aux->seg_base = seg->p_vaddr;
5729 break;
5730 }
5731 }
5732 }
5733
5734 /* Second, build the unwind table from the contents of the unwind
5735 section. */
5736 size = sec->sh_size;
5737 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5738 _("unwind table"));
5739 if (!table)
5740 return 0;
5741
5742 unw_ent_size = 16;
5743 nentries = size / unw_ent_size;
5744 size = unw_ent_size * nentries;
5745
5746 tep = aux->table = (struct hppa_unw_table_entry *)
5747 xcmalloc (nentries, sizeof (aux->table[0]));
5748
5749 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5750 {
5751 unsigned int tmp1, tmp2;
5752
5753 tep->start.section = SHN_UNDEF;
5754 tep->end.section = SHN_UNDEF;
5755
5756 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5757 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5758 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5759 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5760
5761 tep->start.offset += aux->seg_base;
5762 tep->end.offset += aux->seg_base;
5763
5764 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5765 tep->Millicode = (tmp1 >> 30) & 0x1;
5766 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5767 tep->Region_description = (tmp1 >> 27) & 0x3;
5768 tep->reserved1 = (tmp1 >> 26) & 0x1;
5769 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5770 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5771 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5772 tep->Args_stored = (tmp1 >> 15) & 0x1;
5773 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5774 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5775 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5776 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5777 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5778 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5779 tep->cxx_info = (tmp1 >> 8) & 0x1;
5780 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5781 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5782 tep->reserved2 = (tmp1 >> 5) & 0x1;
5783 tep->Save_SP = (tmp1 >> 4) & 0x1;
5784 tep->Save_RP = (tmp1 >> 3) & 0x1;
5785 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5786 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5787 tep->Cleanup_defined = tmp1 & 0x1;
5788
5789 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5790 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5791 tep->Large_frame = (tmp2 >> 29) & 0x1;
5792 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5793 tep->reserved4 = (tmp2 >> 27) & 0x1;
5794 tep->Total_frame_size = tmp2 & 0x7ffffff;
5795 }
5796 free (table);
5797
5798 /* Third, apply any relocations to the unwind table. */
5799 for (relsec = section_headers;
5800 relsec < section_headers + elf_header.e_shnum;
5801 ++relsec)
5802 {
5803 if (relsec->sh_type != SHT_RELA
5804 || relsec->sh_info >= elf_header.e_shnum
5805 || section_headers + relsec->sh_info != sec)
5806 continue;
5807
5808 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5809 & rela, & nrelas))
5810 return 0;
5811
5812 for (rp = rela; rp < rela + nrelas; ++rp)
5813 {
5814 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5815 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5816
5817 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5818 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5819 {
5820 warn (_("Skipping unexpected relocation type %s\n"), relname);
5821 continue;
5822 }
5823
5824 i = rp->r_offset / unw_ent_size;
5825
5826 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5827 {
5828 case 0:
5829 aux->table[i].start.section = sym->st_shndx;
5830 aux->table[i].start.offset = sym->st_value + rp->r_addend;
5831 break;
5832 case 1:
5833 aux->table[i].end.section = sym->st_shndx;
5834 aux->table[i].end.offset = sym->st_value + rp->r_addend;
5835 break;
5836 default:
5837 break;
5838 }
5839 }
5840
5841 free (rela);
5842 }
5843
5844 aux->table_len = nentries;
5845
5846 return 1;
5847 }
5848
5849 static int
5850 hppa_process_unwind (FILE * file)
5851 {
5852 struct hppa_unw_aux_info aux;
5853 Elf_Internal_Shdr * unwsec = NULL;
5854 Elf_Internal_Shdr * strsec;
5855 Elf_Internal_Shdr * sec;
5856 unsigned long i;
5857
5858 memset (& aux, 0, sizeof (aux));
5859
5860 if (string_table == NULL)
5861 return 1;
5862
5863 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5864 {
5865 if (sec->sh_type == SHT_SYMTAB
5866 && sec->sh_link < elf_header.e_shnum)
5867 {
5868 aux.nsyms = sec->sh_size / sec->sh_entsize;
5869 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5870
5871 strsec = section_headers + sec->sh_link;
5872 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5873 1, strsec->sh_size,
5874 _("string table"));
5875 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5876 }
5877 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5878 unwsec = sec;
5879 }
5880
5881 if (!unwsec)
5882 printf (_("\nThere are no unwind sections in this file.\n"));
5883
5884 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5885 {
5886 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5887 {
5888 printf (_("\nUnwind section "));
5889 printf (_("'%s'"), SECTION_NAME (sec));
5890
5891 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5892 (unsigned long) sec->sh_offset,
5893 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5894
5895 slurp_hppa_unwind_table (file, &aux, sec);
5896 if (aux.table_len > 0)
5897 dump_hppa_unwind (&aux);
5898
5899 if (aux.table)
5900 free ((char *) aux.table);
5901 aux.table = NULL;
5902 }
5903 }
5904
5905 if (aux.symtab)
5906 free (aux.symtab);
5907 if (aux.strtab)
5908 free ((char *) aux.strtab);
5909
5910 return 1;
5911 }
5912
5913 struct arm_section
5914 {
5915 unsigned char *data;
5916
5917 Elf_Internal_Shdr *sec;
5918 Elf_Internal_Rela *rela;
5919 unsigned long nrelas;
5920 unsigned int rel_type;
5921
5922 Elf_Internal_Rela *next_rela;
5923 };
5924
5925 struct arm_unw_aux_info
5926 {
5927 FILE *file;
5928
5929 Elf_Internal_Sym *symtab; /* The symbol table. */
5930 unsigned long nsyms; /* Number of symbols. */
5931 char *strtab; /* The string table. */
5932 unsigned long strtab_size; /* Size of string table. */
5933 };
5934
5935 static const char *
5936 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
5937 bfd_vma fn, struct absaddr addr)
5938 {
5939 const char *procname;
5940 bfd_vma sym_offset;
5941
5942 if (addr.section == SHN_UNDEF)
5943 addr.offset = fn;
5944
5945 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5946 aux->strtab_size, addr, &procname,
5947 &sym_offset);
5948
5949 print_vma (fn, PREFIX_HEX);
5950
5951 if (procname)
5952 {
5953 fputs (" <", stdout);
5954 fputs (procname, stdout);
5955
5956 if (sym_offset)
5957 printf ("+0x%lx", (unsigned long) sym_offset);
5958 fputc ('>', stdout);
5959 }
5960
5961 return procname;
5962 }
5963
5964 static void
5965 arm_free_section (struct arm_section *arm_sec)
5966 {
5967 if (arm_sec->data != NULL)
5968 free (arm_sec->data);
5969
5970 if (arm_sec->rela != NULL)
5971 free (arm_sec->rela);
5972 }
5973
5974 static int
5975 arm_section_get_word (struct arm_unw_aux_info *aux,
5976 struct arm_section *arm_sec,
5977 Elf_Internal_Shdr *sec, bfd_vma word_offset,
5978 unsigned int *wordp, struct absaddr *addr)
5979 {
5980 Elf_Internal_Rela *rp;
5981 Elf_Internal_Sym *sym;
5982 const char * relname;
5983 unsigned int word;
5984 bfd_boolean wrapped;
5985
5986 addr->section = SHN_UNDEF;
5987 addr->offset = 0;
5988
5989 if (sec != arm_sec->sec)
5990 {
5991 Elf_Internal_Shdr *relsec;
5992
5993 arm_free_section (arm_sec);
5994
5995 arm_sec->sec = sec;
5996 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
5997 sec->sh_size, _("unwind data"));
5998
5999 arm_sec->rela = NULL;
6000 arm_sec->nrelas = 0;
6001
6002 for (relsec = section_headers;
6003 relsec < section_headers + elf_header.e_shnum;
6004 ++relsec)
6005 {
6006 if (relsec->sh_info >= elf_header.e_shnum
6007 || section_headers + relsec->sh_info != sec)
6008 continue;
6009
6010 if (relsec->sh_type == SHT_REL)
6011 {
6012 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6013 relsec->sh_size,
6014 & arm_sec->rela, & arm_sec->nrelas))
6015 return 0;
6016 break;
6017 }
6018 else if (relsec->sh_type == SHT_RELA)
6019 {
6020 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6021 relsec->sh_size,
6022 & arm_sec->rela, & arm_sec->nrelas))
6023 return 0;
6024 break;
6025 }
6026 }
6027
6028 arm_sec->next_rela = arm_sec->rela;
6029 }
6030
6031 if (arm_sec->data == NULL)
6032 return 0;
6033
6034 word = byte_get (arm_sec->data + word_offset, 4);
6035
6036 wrapped = FALSE;
6037 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6038 {
6039 bfd_vma prelval, offset;
6040
6041 if (rp->r_offset > word_offset && !wrapped)
6042 {
6043 rp = arm_sec->rela;
6044 wrapped = TRUE;
6045 }
6046 if (rp->r_offset > word_offset)
6047 break;
6048
6049 if (rp->r_offset & 3)
6050 {
6051 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6052 (unsigned long) rp->r_offset);
6053 continue;
6054 }
6055
6056 if (rp->r_offset < word_offset)
6057 continue;
6058
6059 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6060
6061 if (streq (relname, "R_ARM_NONE"))
6062 continue;
6063
6064 if (! streq (relname, "R_ARM_PREL31"))
6065 {
6066 warn (_("Skipping unexpected relocation type %s\n"), relname);
6067 continue;
6068 }
6069
6070 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6071
6072 if (arm_sec->rel_type == SHT_REL)
6073 {
6074 offset = word & 0x7fffffff;
6075 if (offset & 0x40000000)
6076 offset |= ~ (bfd_vma) 0x7fffffff;
6077 }
6078 else
6079 offset = rp->r_addend;
6080
6081 offset += sym->st_value;
6082 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6083
6084 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6085 addr->section = sym->st_shndx;
6086 addr->offset = offset;
6087 break;
6088 }
6089
6090 *wordp = word;
6091 arm_sec->next_rela = rp;
6092
6093 return 1;
6094 }
6095
6096 static void
6097 decode_arm_unwind (struct arm_unw_aux_info *aux,
6098 unsigned int word, unsigned int remaining,
6099 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6100 struct arm_section *data_arm_sec)
6101 {
6102 int per_index;
6103 unsigned int more_words;
6104 struct absaddr addr;
6105
6106 #define ADVANCE \
6107 if (remaining == 0 && more_words) \
6108 { \
6109 data_offset += 4; \
6110 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6111 data_offset, &word, &addr)) \
6112 return; \
6113 remaining = 4; \
6114 more_words--; \
6115 } \
6116
6117 #define GET_OP(OP) \
6118 ADVANCE; \
6119 if (remaining) \
6120 { \
6121 remaining--; \
6122 (OP) = word >> 24; \
6123 word <<= 8; \
6124 } \
6125 else \
6126 { \
6127 printf (_("[Truncated opcode]\n")); \
6128 return; \
6129 } \
6130 printf (_("0x%02x "), OP)
6131
6132 if (remaining == 0)
6133 {
6134 /* Fetch the first word. */
6135 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6136 &word, &addr))
6137 return;
6138 remaining = 4;
6139 }
6140
6141 if ((word & 0x80000000) == 0)
6142 {
6143 /* Expand prel31 for personality routine. */
6144 bfd_vma fn;
6145 const char *procname;
6146
6147 fn = word;
6148 if (fn & 0x40000000)
6149 fn |= ~ (bfd_vma) 0x7fffffff;
6150 fn = fn + data_sec->sh_addr + data_offset;
6151
6152 printf (_(" Personality routine: "));
6153 procname = arm_print_vma_and_name (aux, fn, addr);
6154 fputc ('\n', stdout);
6155
6156 /* The GCC personality routines use the standard compact
6157 encoding, starting with one byte giving the number of
6158 words. */
6159 if (procname != NULL
6160 && (const_strneq (procname, "__gcc_personality_v0")
6161 || const_strneq (procname, "__gxx_personality_v0")
6162 || const_strneq (procname, "__gcj_personality_v0")
6163 || const_strneq (procname, "__gnu_objc_personality_v0")))
6164 {
6165 remaining = 0;
6166 more_words = 1;
6167 ADVANCE;
6168 if (!remaining)
6169 {
6170 printf (_(" [Truncated data]\n"));
6171 return;
6172 }
6173 more_words = word >> 24;
6174 word <<= 8;
6175 remaining--;
6176 }
6177 else
6178 return;
6179 }
6180 else
6181 {
6182
6183 per_index = (word >> 24) & 0x7f;
6184 if (per_index != 0 && per_index != 1 && per_index != 2)
6185 {
6186 printf (_(" [reserved compact index %d]\n"), per_index);
6187 return;
6188 }
6189
6190 printf (_(" Compact model %d\n"), per_index);
6191 if (per_index == 0)
6192 {
6193 more_words = 0;
6194 word <<= 8;
6195 remaining--;
6196 }
6197 else
6198 {
6199 more_words = (word >> 16) & 0xff;
6200 word <<= 16;
6201 remaining -= 2;
6202 }
6203 }
6204
6205 /* Decode the unwinding instructions. */
6206 while (1)
6207 {
6208 unsigned int op, op2;
6209
6210 ADVANCE;
6211 if (remaining == 0)
6212 break;
6213 remaining--;
6214 op = word >> 24;
6215 word <<= 8;
6216
6217 printf (_(" 0x%02x "), op);
6218
6219 if ((op & 0xc0) == 0x00)
6220 {
6221 int offset = ((op & 0x3f) << 2) + 4;
6222 printf (_(" vsp = vsp + %d"), offset);
6223 }
6224 else if ((op & 0xc0) == 0x40)
6225 {
6226 int offset = ((op & 0x3f) << 2) + 4;
6227 printf (_(" vsp = vsp - %d"), offset);
6228 }
6229 else if ((op & 0xf0) == 0x80)
6230 {
6231 GET_OP (op2);
6232 if (op == 0x80 && op2 == 0)
6233 printf (_("Refuse to unwind"));
6234 else
6235 {
6236 unsigned int mask = ((op & 0x0f) << 8) | op2;
6237 int first = 1;
6238 int i;
6239
6240 printf ("pop {");
6241 for (i = 0; i < 12; i++)
6242 if (mask & (1 << i))
6243 {
6244 if (first)
6245 first = 0;
6246 else
6247 printf (", ");
6248 printf ("r%d", 4 + i);
6249 }
6250 printf ("}");
6251 }
6252 }
6253 else if ((op & 0xf0) == 0x90)
6254 {
6255 if (op == 0x9d || op == 0x9f)
6256 printf (_(" [Reserved]"));
6257 else
6258 printf (_(" vsp = r%d"), op & 0x0f);
6259 }
6260 else if ((op & 0xf0) == 0xa0)
6261 {
6262 int end = 4 + (op & 0x07);
6263 int first = 1;
6264 int i;
6265 printf (" pop {");
6266 for (i = 4; i <= end; i++)
6267 {
6268 if (first)
6269 first = 0;
6270 else
6271 printf (", ");
6272 printf ("r%d", i);
6273 }
6274 if (op & 0x08)
6275 {
6276 if (first)
6277 printf (", ");
6278 printf ("r14");
6279 }
6280 printf ("}");
6281 }
6282 else if (op == 0xb0)
6283 printf (_(" finish"));
6284 else if (op == 0xb1)
6285 {
6286 GET_OP (op2);
6287 if (op2 == 0 || (op2 & 0xf0) != 0)
6288 printf (_("[Spare]"));
6289 else
6290 {
6291 unsigned int mask = op2 & 0x0f;
6292 int first = 1;
6293 int i;
6294 printf ("pop {");
6295 for (i = 0; i < 12; i++)
6296 if (mask & (1 << i))
6297 {
6298 if (first)
6299 first = 0;
6300 else
6301 printf (", ");
6302 printf ("r%d", i);
6303 }
6304 printf ("}");
6305 }
6306 }
6307 else if (op == 0xb2)
6308 {
6309 unsigned char buf[9];
6310 unsigned int i, len;
6311 unsigned long offset;
6312 for (i = 0; i < sizeof (buf); i++)
6313 {
6314 GET_OP (buf[i]);
6315 if ((buf[i] & 0x80) == 0)
6316 break;
6317 }
6318 assert (i < sizeof (buf));
6319 offset = read_uleb128 (buf, &len);
6320 assert (len == i + 1);
6321 offset = offset * 4 + 0x204;
6322 printf (_("vsp = vsp + %ld"), offset);
6323 }
6324 else
6325 {
6326 if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
6327 {
6328 GET_OP (op2);
6329 printf (_("[unsupported two-byte opcode]"));
6330 }
6331 else
6332 {
6333 printf (_(" [unsupported opcode]"));
6334 }
6335 }
6336 printf ("\n");
6337 }
6338
6339 /* Decode the descriptors. Not implemented. */
6340 }
6341
6342 static void
6343 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6344 {
6345 struct arm_section exidx_arm_sec, extab_arm_sec;
6346 unsigned int i, exidx_len;
6347
6348 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6349 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6350 exidx_len = exidx_sec->sh_size / 8;
6351
6352 for (i = 0; i < exidx_len; i++)
6353 {
6354 unsigned int exidx_fn, exidx_entry;
6355 struct absaddr fn_addr, entry_addr;
6356 bfd_vma fn;
6357
6358 fputc ('\n', stdout);
6359
6360 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6361 8 * i, &exidx_fn, &fn_addr)
6362 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6363 8 * i + 4, &exidx_entry, &entry_addr))
6364 {
6365 arm_free_section (&exidx_arm_sec);
6366 arm_free_section (&extab_arm_sec);
6367 return;
6368 }
6369
6370 fn = exidx_fn & 0x7fffffff;
6371 if (fn & 0x40000000)
6372 fn |= ~ (bfd_vma) 0x7fffffff;
6373 fn = fn + exidx_sec->sh_addr + 8 * i;
6374
6375 arm_print_vma_and_name (aux, fn, entry_addr);
6376 fputs (": ", stdout);
6377
6378 if (exidx_entry == 1)
6379 {
6380 print_vma (exidx_entry, PREFIX_HEX);
6381 fputs (" [cantunwind]\n", stdout);
6382 }
6383 else if (exidx_entry & 0x80000000)
6384 {
6385 print_vma (exidx_entry, PREFIX_HEX);
6386 fputc ('\n', stdout);
6387 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6388 }
6389 else
6390 {
6391 bfd_vma table, table_offset = 0;
6392 Elf_Internal_Shdr *table_sec;
6393
6394 fputs ("@", stdout);
6395 table = exidx_entry;
6396 if (table & 0x40000000)
6397 table |= ~ (bfd_vma) 0x7fffffff;
6398 table = table + exidx_sec->sh_addr + 8 * i + 4;
6399 print_vma (table, PREFIX_HEX);
6400 printf ("\n");
6401
6402 /* Locate the matching .ARM.extab. */
6403 if (entry_addr.section != SHN_UNDEF
6404 && entry_addr.section < elf_header.e_shnum)
6405 {
6406 table_sec = section_headers + entry_addr.section;
6407 table_offset = entry_addr.offset;
6408 }
6409 else
6410 {
6411 table_sec = find_section_by_address (table);
6412 if (table_sec != NULL)
6413 table_offset = table - table_sec->sh_addr;
6414 }
6415 if (table_sec == NULL)
6416 {
6417 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6418 (unsigned long) table);
6419 continue;
6420 }
6421 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6422 &extab_arm_sec);
6423 }
6424 }
6425
6426 printf ("\n");
6427
6428 arm_free_section (&exidx_arm_sec);
6429 arm_free_section (&extab_arm_sec);
6430 }
6431
6432 static int
6433 arm_process_unwind (FILE *file)
6434 {
6435 struct arm_unw_aux_info aux;
6436 Elf_Internal_Shdr *unwsec = NULL;
6437 Elf_Internal_Shdr *strsec;
6438 Elf_Internal_Shdr *sec;
6439 unsigned long i;
6440
6441 memset (& aux, 0, sizeof (aux));
6442 aux.file = file;
6443
6444 if (string_table == NULL)
6445 return 1;
6446
6447 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6448 {
6449 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6450 {
6451 aux.nsyms = sec->sh_size / sec->sh_entsize;
6452 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6453
6454 strsec = section_headers + sec->sh_link;
6455 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6456 1, strsec->sh_size, _("string table"));
6457 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6458 }
6459 else if (sec->sh_type == SHT_ARM_EXIDX)
6460 unwsec = sec;
6461 }
6462
6463 if (!unwsec)
6464 printf (_("\nThere are no unwind sections in this file.\n"));
6465
6466 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6467 {
6468 if (sec->sh_type == SHT_ARM_EXIDX)
6469 {
6470 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6471 SECTION_NAME (sec),
6472 (unsigned long) sec->sh_offset,
6473 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6474
6475 dump_arm_unwind (&aux, sec);
6476 }
6477 }
6478
6479 if (aux.symtab)
6480 free (aux.symtab);
6481 if (aux.strtab)
6482 free ((char *) aux.strtab);
6483
6484 return 1;
6485 }
6486
6487 static int
6488 process_unwind (FILE * file)
6489 {
6490 struct unwind_handler
6491 {
6492 int machtype;
6493 int (* handler)(FILE *);
6494 } handlers[] =
6495 {
6496 { EM_ARM, arm_process_unwind },
6497 { EM_IA_64, ia64_process_unwind },
6498 { EM_PARISC, hppa_process_unwind },
6499 { 0, 0 }
6500 };
6501 int i;
6502
6503 if (!do_unwind)
6504 return 1;
6505
6506 for (i = 0; handlers[i].handler != NULL; i++)
6507 if (elf_header.e_machine == handlers[i].machtype)
6508 return handlers[i].handler (file);
6509
6510 printf (_("\nThere are no unwind sections in this file.\n"));
6511 return 1;
6512 }
6513
6514 static void
6515 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
6516 {
6517 switch (entry->d_tag)
6518 {
6519 case DT_MIPS_FLAGS:
6520 if (entry->d_un.d_val == 0)
6521 printf (_("NONE\n"));
6522 else
6523 {
6524 static const char * opts[] =
6525 {
6526 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6527 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6528 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6529 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6530 "RLD_ORDER_SAFE"
6531 };
6532 unsigned int cnt;
6533 int first = 1;
6534
6535 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
6536 if (entry->d_un.d_val & (1 << cnt))
6537 {
6538 printf ("%s%s", first ? "" : " ", opts[cnt]);
6539 first = 0;
6540 }
6541 puts ("");
6542 }
6543 break;
6544
6545 case DT_MIPS_IVERSION:
6546 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6547 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
6548 else
6549 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
6550 break;
6551
6552 case DT_MIPS_TIME_STAMP:
6553 {
6554 char timebuf[20];
6555 struct tm * tmp;
6556
6557 time_t atime = entry->d_un.d_val;
6558 tmp = gmtime (&atime);
6559 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6560 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6561 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6562 printf (_("Time Stamp: %s\n"), timebuf);
6563 }
6564 break;
6565
6566 case DT_MIPS_RLD_VERSION:
6567 case DT_MIPS_LOCAL_GOTNO:
6568 case DT_MIPS_CONFLICTNO:
6569 case DT_MIPS_LIBLISTNO:
6570 case DT_MIPS_SYMTABNO:
6571 case DT_MIPS_UNREFEXTNO:
6572 case DT_MIPS_HIPAGENO:
6573 case DT_MIPS_DELTA_CLASS_NO:
6574 case DT_MIPS_DELTA_INSTANCE_NO:
6575 case DT_MIPS_DELTA_RELOC_NO:
6576 case DT_MIPS_DELTA_SYM_NO:
6577 case DT_MIPS_DELTA_CLASSSYM_NO:
6578 case DT_MIPS_COMPACT_SIZE:
6579 printf ("%ld\n", (long) entry->d_un.d_ptr);
6580 break;
6581
6582 default:
6583 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
6584 }
6585 }
6586
6587 static void
6588 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
6589 {
6590 switch (entry->d_tag)
6591 {
6592 case DT_HP_DLD_FLAGS:
6593 {
6594 static struct
6595 {
6596 long int bit;
6597 const char * str;
6598 }
6599 flags[] =
6600 {
6601 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6602 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6603 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6604 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6605 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6606 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6607 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6608 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6609 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6610 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
6611 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6612 { DT_HP_GST, "HP_GST" },
6613 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6614 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6615 { DT_HP_NODELETE, "HP_NODELETE" },
6616 { DT_HP_GROUP, "HP_GROUP" },
6617 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
6618 };
6619 int first = 1;
6620 size_t cnt;
6621 bfd_vma val = entry->d_un.d_val;
6622
6623 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
6624 if (val & flags[cnt].bit)
6625 {
6626 if (! first)
6627 putchar (' ');
6628 fputs (flags[cnt].str, stdout);
6629 first = 0;
6630 val ^= flags[cnt].bit;
6631 }
6632
6633 if (val != 0 || first)
6634 {
6635 if (! first)
6636 putchar (' ');
6637 print_vma (val, HEX);
6638 }
6639 }
6640 break;
6641
6642 default:
6643 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6644 break;
6645 }
6646 putchar ('\n');
6647 }
6648
6649 static void
6650 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
6651 {
6652 switch (entry->d_tag)
6653 {
6654 case DT_IA_64_PLT_RESERVE:
6655 /* First 3 slots reserved. */
6656 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6657 printf (" -- ");
6658 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
6659 break;
6660
6661 default:
6662 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6663 break;
6664 }
6665 putchar ('\n');
6666 }
6667
6668 static int
6669 get_32bit_dynamic_section (FILE * file)
6670 {
6671 Elf32_External_Dyn * edyn;
6672 Elf32_External_Dyn * ext;
6673 Elf_Internal_Dyn * entry;
6674
6675 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6676 dynamic_size, _("dynamic section"));
6677 if (!edyn)
6678 return 0;
6679
6680 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6681 might not have the luxury of section headers. Look for the DT_NULL
6682 terminator to determine the number of entries. */
6683 for (ext = edyn, dynamic_nent = 0;
6684 (char *) ext < (char *) edyn + dynamic_size;
6685 ext++)
6686 {
6687 dynamic_nent++;
6688 if (BYTE_GET (ext->d_tag) == DT_NULL)
6689 break;
6690 }
6691
6692 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
6693 sizeof (* entry));
6694 if (dynamic_section == NULL)
6695 {
6696 error (_("Out of memory\n"));
6697 free (edyn);
6698 return 0;
6699 }
6700
6701 for (ext = edyn, entry = dynamic_section;
6702 entry < dynamic_section + dynamic_nent;
6703 ext++, entry++)
6704 {
6705 entry->d_tag = BYTE_GET (ext->d_tag);
6706 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
6707 }
6708
6709 free (edyn);
6710
6711 return 1;
6712 }
6713
6714 static int
6715 get_64bit_dynamic_section (FILE * file)
6716 {
6717 Elf64_External_Dyn * edyn;
6718 Elf64_External_Dyn * ext;
6719 Elf_Internal_Dyn * entry;
6720
6721 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6722 dynamic_size, _("dynamic section"));
6723 if (!edyn)
6724 return 0;
6725
6726 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6727 might not have the luxury of section headers. Look for the DT_NULL
6728 terminator to determine the number of entries. */
6729 for (ext = edyn, dynamic_nent = 0;
6730 (char *) ext < (char *) edyn + dynamic_size;
6731 ext++)
6732 {
6733 dynamic_nent++;
6734 if (BYTE_GET (ext->d_tag) == DT_NULL)
6735 break;
6736 }
6737
6738 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
6739 sizeof (* entry));
6740 if (dynamic_section == NULL)
6741 {
6742 error (_("Out of memory\n"));
6743 free (edyn);
6744 return 0;
6745 }
6746
6747 for (ext = edyn, entry = dynamic_section;
6748 entry < dynamic_section + dynamic_nent;
6749 ext++, entry++)
6750 {
6751 entry->d_tag = BYTE_GET (ext->d_tag);
6752 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
6753 }
6754
6755 free (edyn);
6756
6757 return 1;
6758 }
6759
6760 static void
6761 print_dynamic_flags (bfd_vma flags)
6762 {
6763 int first = 1;
6764
6765 while (flags)
6766 {
6767 bfd_vma flag;
6768
6769 flag = flags & - flags;
6770 flags &= ~ flag;
6771
6772 if (first)
6773 first = 0;
6774 else
6775 putc (' ', stdout);
6776
6777 switch (flag)
6778 {
6779 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
6780 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
6781 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
6782 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
6783 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
6784 default: fputs (_("unknown"), stdout); break;
6785 }
6786 }
6787 puts ("");
6788 }
6789
6790 /* Parse and display the contents of the dynamic section. */
6791
6792 static int
6793 process_dynamic_section (FILE * file)
6794 {
6795 Elf_Internal_Dyn * entry;
6796
6797 if (dynamic_size == 0)
6798 {
6799 if (do_dynamic)
6800 printf (_("\nThere is no dynamic section in this file.\n"));
6801
6802 return 1;
6803 }
6804
6805 if (is_32bit_elf)
6806 {
6807 if (! get_32bit_dynamic_section (file))
6808 return 0;
6809 }
6810 else if (! get_64bit_dynamic_section (file))
6811 return 0;
6812
6813 /* Find the appropriate symbol table. */
6814 if (dynamic_symbols == NULL)
6815 {
6816 for (entry = dynamic_section;
6817 entry < dynamic_section + dynamic_nent;
6818 ++entry)
6819 {
6820 Elf_Internal_Shdr section;
6821
6822 if (entry->d_tag != DT_SYMTAB)
6823 continue;
6824
6825 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
6826
6827 /* Since we do not know how big the symbol table is,
6828 we default to reading in the entire file (!) and
6829 processing that. This is overkill, I know, but it
6830 should work. */
6831 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
6832
6833 if (archive_file_offset != 0)
6834 section.sh_size = archive_file_size - section.sh_offset;
6835 else
6836 {
6837 if (fseek (file, 0, SEEK_END))
6838 error (_("Unable to seek to end of file!\n"));
6839
6840 section.sh_size = ftell (file) - section.sh_offset;
6841 }
6842
6843 if (is_32bit_elf)
6844 section.sh_entsize = sizeof (Elf32_External_Sym);
6845 else
6846 section.sh_entsize = sizeof (Elf64_External_Sym);
6847
6848 num_dynamic_syms = section.sh_size / section.sh_entsize;
6849 if (num_dynamic_syms < 1)
6850 {
6851 error (_("Unable to determine the number of symbols to load\n"));
6852 continue;
6853 }
6854
6855 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
6856 }
6857 }
6858
6859 /* Similarly find a string table. */
6860 if (dynamic_strings == NULL)
6861 {
6862 for (entry = dynamic_section;
6863 entry < dynamic_section + dynamic_nent;
6864 ++entry)
6865 {
6866 unsigned long offset;
6867 long str_tab_len;
6868
6869 if (entry->d_tag != DT_STRTAB)
6870 continue;
6871
6872 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6873
6874 /* Since we do not know how big the string table is,
6875 we default to reading in the entire file (!) and
6876 processing that. This is overkill, I know, but it
6877 should work. */
6878
6879 offset = offset_from_vma (file, entry->d_un.d_val, 0);
6880
6881 if (archive_file_offset != 0)
6882 str_tab_len = archive_file_size - offset;
6883 else
6884 {
6885 if (fseek (file, 0, SEEK_END))
6886 error (_("Unable to seek to end of file\n"));
6887 str_tab_len = ftell (file) - offset;
6888 }
6889
6890 if (str_tab_len < 1)
6891 {
6892 error
6893 (_("Unable to determine the length of the dynamic string table\n"));
6894 continue;
6895 }
6896
6897 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
6898 str_tab_len,
6899 _("dynamic string table"));
6900 dynamic_strings_length = str_tab_len;
6901 break;
6902 }
6903 }
6904
6905 /* And find the syminfo section if available. */
6906 if (dynamic_syminfo == NULL)
6907 {
6908 unsigned long syminsz = 0;
6909
6910 for (entry = dynamic_section;
6911 entry < dynamic_section + dynamic_nent;
6912 ++entry)
6913 {
6914 if (entry->d_tag == DT_SYMINENT)
6915 {
6916 /* Note: these braces are necessary to avoid a syntax
6917 error from the SunOS4 C compiler. */
6918 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6919 }
6920 else if (entry->d_tag == DT_SYMINSZ)
6921 syminsz = entry->d_un.d_val;
6922 else if (entry->d_tag == DT_SYMINFO)
6923 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6924 syminsz);
6925 }
6926
6927 if (dynamic_syminfo_offset != 0 && syminsz != 0)
6928 {
6929 Elf_External_Syminfo * extsyminfo;
6930 Elf_External_Syminfo * extsym;
6931 Elf_Internal_Syminfo * syminfo;
6932
6933 /* There is a syminfo section. Read the data. */
6934 extsyminfo = (Elf_External_Syminfo *)
6935 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
6936 _("symbol information"));
6937 if (!extsyminfo)
6938 return 0;
6939
6940 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
6941 if (dynamic_syminfo == NULL)
6942 {
6943 error (_("Out of memory\n"));
6944 return 0;
6945 }
6946
6947 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6948 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6949 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6950 ++syminfo, ++extsym)
6951 {
6952 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6953 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6954 }
6955
6956 free (extsyminfo);
6957 }
6958 }
6959
6960 if (do_dynamic && dynamic_addr)
6961 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6962 dynamic_addr, dynamic_nent);
6963 if (do_dynamic)
6964 printf (_(" Tag Type Name/Value\n"));
6965
6966 for (entry = dynamic_section;
6967 entry < dynamic_section + dynamic_nent;
6968 entry++)
6969 {
6970 if (do_dynamic)
6971 {
6972 const char * dtype;
6973
6974 putchar (' ');
6975 print_vma (entry->d_tag, FULL_HEX);
6976 dtype = get_dynamic_type (entry->d_tag);
6977 printf (" (%s)%*s", dtype,
6978 ((is_32bit_elf ? 27 : 19)
6979 - (int) strlen (dtype)),
6980 " ");
6981 }
6982
6983 switch (entry->d_tag)
6984 {
6985 case DT_FLAGS:
6986 if (do_dynamic)
6987 print_dynamic_flags (entry->d_un.d_val);
6988 break;
6989
6990 case DT_AUXILIARY:
6991 case DT_FILTER:
6992 case DT_CONFIG:
6993 case DT_DEPAUDIT:
6994 case DT_AUDIT:
6995 if (do_dynamic)
6996 {
6997 switch (entry->d_tag)
6998 {
6999 case DT_AUXILIARY:
7000 printf (_("Auxiliary library"));
7001 break;
7002
7003 case DT_FILTER:
7004 printf (_("Filter library"));
7005 break;
7006
7007 case DT_CONFIG:
7008 printf (_("Configuration file"));
7009 break;
7010
7011 case DT_DEPAUDIT:
7012 printf (_("Dependency audit library"));
7013 break;
7014
7015 case DT_AUDIT:
7016 printf (_("Audit library"));
7017 break;
7018 }
7019
7020 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7021 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7022 else
7023 {
7024 printf (": ");
7025 print_vma (entry->d_un.d_val, PREFIX_HEX);
7026 putchar ('\n');
7027 }
7028 }
7029 break;
7030
7031 case DT_FEATURE:
7032 if (do_dynamic)
7033 {
7034 printf (_("Flags:"));
7035
7036 if (entry->d_un.d_val == 0)
7037 printf (_(" None\n"));
7038 else
7039 {
7040 unsigned long int val = entry->d_un.d_val;
7041
7042 if (val & DTF_1_PARINIT)
7043 {
7044 printf (" PARINIT");
7045 val ^= DTF_1_PARINIT;
7046 }
7047 if (val & DTF_1_CONFEXP)
7048 {
7049 printf (" CONFEXP");
7050 val ^= DTF_1_CONFEXP;
7051 }
7052 if (val != 0)
7053 printf (" %lx", val);
7054 puts ("");
7055 }
7056 }
7057 break;
7058
7059 case DT_POSFLAG_1:
7060 if (do_dynamic)
7061 {
7062 printf (_("Flags:"));
7063
7064 if (entry->d_un.d_val == 0)
7065 printf (_(" None\n"));
7066 else
7067 {
7068 unsigned long int val = entry->d_un.d_val;
7069
7070 if (val & DF_P1_LAZYLOAD)
7071 {
7072 printf (" LAZYLOAD");
7073 val ^= DF_P1_LAZYLOAD;
7074 }
7075 if (val & DF_P1_GROUPPERM)
7076 {
7077 printf (" GROUPPERM");
7078 val ^= DF_P1_GROUPPERM;
7079 }
7080 if (val != 0)
7081 printf (" %lx", val);
7082 puts ("");
7083 }
7084 }
7085 break;
7086
7087 case DT_FLAGS_1:
7088 if (do_dynamic)
7089 {
7090 printf (_("Flags:"));
7091 if (entry->d_un.d_val == 0)
7092 printf (_(" None\n"));
7093 else
7094 {
7095 unsigned long int val = entry->d_un.d_val;
7096
7097 if (val & DF_1_NOW)
7098 {
7099 printf (" NOW");
7100 val ^= DF_1_NOW;
7101 }
7102 if (val & DF_1_GLOBAL)
7103 {
7104 printf (" GLOBAL");
7105 val ^= DF_1_GLOBAL;
7106 }
7107 if (val & DF_1_GROUP)
7108 {
7109 printf (" GROUP");
7110 val ^= DF_1_GROUP;
7111 }
7112 if (val & DF_1_NODELETE)
7113 {
7114 printf (" NODELETE");
7115 val ^= DF_1_NODELETE;
7116 }
7117 if (val & DF_1_LOADFLTR)
7118 {
7119 printf (" LOADFLTR");
7120 val ^= DF_1_LOADFLTR;
7121 }
7122 if (val & DF_1_INITFIRST)
7123 {
7124 printf (" INITFIRST");
7125 val ^= DF_1_INITFIRST;
7126 }
7127 if (val & DF_1_NOOPEN)
7128 {
7129 printf (" NOOPEN");
7130 val ^= DF_1_NOOPEN;
7131 }
7132 if (val & DF_1_ORIGIN)
7133 {
7134 printf (" ORIGIN");
7135 val ^= DF_1_ORIGIN;
7136 }
7137 if (val & DF_1_DIRECT)
7138 {
7139 printf (" DIRECT");
7140 val ^= DF_1_DIRECT;
7141 }
7142 if (val & DF_1_TRANS)
7143 {
7144 printf (" TRANS");
7145 val ^= DF_1_TRANS;
7146 }
7147 if (val & DF_1_INTERPOSE)
7148 {
7149 printf (" INTERPOSE");
7150 val ^= DF_1_INTERPOSE;
7151 }
7152 if (val & DF_1_NODEFLIB)
7153 {
7154 printf (" NODEFLIB");
7155 val ^= DF_1_NODEFLIB;
7156 }
7157 if (val & DF_1_NODUMP)
7158 {
7159 printf (" NODUMP");
7160 val ^= DF_1_NODUMP;
7161 }
7162 if (val & DF_1_CONLFAT)
7163 {
7164 printf (" CONLFAT");
7165 val ^= DF_1_CONLFAT;
7166 }
7167 if (val != 0)
7168 printf (" %lx", val);
7169 puts ("");
7170 }
7171 }
7172 break;
7173
7174 case DT_PLTREL:
7175 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7176 if (do_dynamic)
7177 puts (get_dynamic_type (entry->d_un.d_val));
7178 break;
7179
7180 case DT_NULL :
7181 case DT_NEEDED :
7182 case DT_PLTGOT :
7183 case DT_HASH :
7184 case DT_STRTAB :
7185 case DT_SYMTAB :
7186 case DT_RELA :
7187 case DT_INIT :
7188 case DT_FINI :
7189 case DT_SONAME :
7190 case DT_RPATH :
7191 case DT_SYMBOLIC:
7192 case DT_REL :
7193 case DT_DEBUG :
7194 case DT_TEXTREL :
7195 case DT_JMPREL :
7196 case DT_RUNPATH :
7197 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7198
7199 if (do_dynamic)
7200 {
7201 char * name;
7202
7203 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7204 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7205 else
7206 name = NULL;
7207
7208 if (name)
7209 {
7210 switch (entry->d_tag)
7211 {
7212 case DT_NEEDED:
7213 printf (_("Shared library: [%s]"), name);
7214
7215 if (streq (name, program_interpreter))
7216 printf (_(" program interpreter"));
7217 break;
7218
7219 case DT_SONAME:
7220 printf (_("Library soname: [%s]"), name);
7221 break;
7222
7223 case DT_RPATH:
7224 printf (_("Library rpath: [%s]"), name);
7225 break;
7226
7227 case DT_RUNPATH:
7228 printf (_("Library runpath: [%s]"), name);
7229 break;
7230
7231 default:
7232 print_vma (entry->d_un.d_val, PREFIX_HEX);
7233 break;
7234 }
7235 }
7236 else
7237 print_vma (entry->d_un.d_val, PREFIX_HEX);
7238
7239 putchar ('\n');
7240 }
7241 break;
7242
7243 case DT_PLTRELSZ:
7244 case DT_RELASZ :
7245 case DT_STRSZ :
7246 case DT_RELSZ :
7247 case DT_RELAENT :
7248 case DT_SYMENT :
7249 case DT_RELENT :
7250 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7251 case DT_PLTPADSZ:
7252 case DT_MOVEENT :
7253 case DT_MOVESZ :
7254 case DT_INIT_ARRAYSZ:
7255 case DT_FINI_ARRAYSZ:
7256 case DT_GNU_CONFLICTSZ:
7257 case DT_GNU_LIBLISTSZ:
7258 if (do_dynamic)
7259 {
7260 print_vma (entry->d_un.d_val, UNSIGNED);
7261 printf (_(" (bytes)\n"));
7262 }
7263 break;
7264
7265 case DT_VERDEFNUM:
7266 case DT_VERNEEDNUM:
7267 case DT_RELACOUNT:
7268 case DT_RELCOUNT:
7269 if (do_dynamic)
7270 {
7271 print_vma (entry->d_un.d_val, UNSIGNED);
7272 putchar ('\n');
7273 }
7274 break;
7275
7276 case DT_SYMINSZ:
7277 case DT_SYMINENT:
7278 case DT_SYMINFO:
7279 case DT_USED:
7280 case DT_INIT_ARRAY:
7281 case DT_FINI_ARRAY:
7282 if (do_dynamic)
7283 {
7284 if (entry->d_tag == DT_USED
7285 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7286 {
7287 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7288
7289 if (*name)
7290 {
7291 printf (_("Not needed object: [%s]\n"), name);
7292 break;
7293 }
7294 }
7295
7296 print_vma (entry->d_un.d_val, PREFIX_HEX);
7297 putchar ('\n');
7298 }
7299 break;
7300
7301 case DT_BIND_NOW:
7302 /* The value of this entry is ignored. */
7303 if (do_dynamic)
7304 putchar ('\n');
7305 break;
7306
7307 case DT_GNU_PRELINKED:
7308 if (do_dynamic)
7309 {
7310 struct tm * tmp;
7311 time_t atime = entry->d_un.d_val;
7312
7313 tmp = gmtime (&atime);
7314 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7315 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7316 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7317
7318 }
7319 break;
7320
7321 case DT_GNU_HASH:
7322 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7323 if (do_dynamic)
7324 {
7325 print_vma (entry->d_un.d_val, PREFIX_HEX);
7326 putchar ('\n');
7327 }
7328 break;
7329
7330 default:
7331 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7332 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7333 entry->d_un.d_val;
7334
7335 if (do_dynamic)
7336 {
7337 switch (elf_header.e_machine)
7338 {
7339 case EM_MIPS:
7340 case EM_MIPS_RS3_LE:
7341 dynamic_section_mips_val (entry);
7342 break;
7343 case EM_PARISC:
7344 dynamic_section_parisc_val (entry);
7345 break;
7346 case EM_IA_64:
7347 dynamic_section_ia64_val (entry);
7348 break;
7349 default:
7350 print_vma (entry->d_un.d_val, PREFIX_HEX);
7351 putchar ('\n');
7352 }
7353 }
7354 break;
7355 }
7356 }
7357
7358 return 1;
7359 }
7360
7361 static char *
7362 get_ver_flags (unsigned int flags)
7363 {
7364 static char buff[32];
7365
7366 buff[0] = 0;
7367
7368 if (flags == 0)
7369 return _("none");
7370
7371 if (flags & VER_FLG_BASE)
7372 strcat (buff, "BASE ");
7373
7374 if (flags & VER_FLG_WEAK)
7375 {
7376 if (flags & VER_FLG_BASE)
7377 strcat (buff, "| ");
7378
7379 strcat (buff, "WEAK ");
7380 }
7381
7382 if (flags & VER_FLG_INFO)
7383 {
7384 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7385 strcat (buff, "| ");
7386
7387 strcat (buff, "INFO ");
7388 }
7389
7390 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7391 strcat (buff, _("| <unknown>"));
7392
7393 return buff;
7394 }
7395
7396 /* Display the contents of the version sections. */
7397
7398 static int
7399 process_version_sections (FILE * file)
7400 {
7401 Elf_Internal_Shdr * section;
7402 unsigned i;
7403 int found = 0;
7404
7405 if (! do_version)
7406 return 1;
7407
7408 for (i = 0, section = section_headers;
7409 i < elf_header.e_shnum;
7410 i++, section++)
7411 {
7412 switch (section->sh_type)
7413 {
7414 case SHT_GNU_verdef:
7415 {
7416 Elf_External_Verdef * edefs;
7417 unsigned int idx;
7418 unsigned int cnt;
7419 char * endbuf;
7420
7421 found = 1;
7422
7423 printf
7424 (_("\nVersion definition section '%s' contains %u entries:\n"),
7425 SECTION_NAME (section), section->sh_info);
7426
7427 printf (_(" Addr: 0x"));
7428 printf_vma (section->sh_addr);
7429 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7430 (unsigned long) section->sh_offset, section->sh_link,
7431 section->sh_link < elf_header.e_shnum
7432 ? SECTION_NAME (section_headers + section->sh_link)
7433 : _("<corrupt>"));
7434
7435 edefs = (Elf_External_Verdef *)
7436 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7437 _("version definition section"));
7438 endbuf = (char *) edefs + section->sh_size;
7439 if (!edefs)
7440 break;
7441
7442 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7443 {
7444 char * vstart;
7445 Elf_External_Verdef * edef;
7446 Elf_Internal_Verdef ent;
7447 Elf_External_Verdaux * eaux;
7448 Elf_Internal_Verdaux aux;
7449 int j;
7450 int isum;
7451
7452 vstart = ((char *) edefs) + idx;
7453 if (vstart + sizeof (*edef) > endbuf)
7454 break;
7455
7456 edef = (Elf_External_Verdef *) vstart;
7457
7458 ent.vd_version = BYTE_GET (edef->vd_version);
7459 ent.vd_flags = BYTE_GET (edef->vd_flags);
7460 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7461 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7462 ent.vd_hash = BYTE_GET (edef->vd_hash);
7463 ent.vd_aux = BYTE_GET (edef->vd_aux);
7464 ent.vd_next = BYTE_GET (edef->vd_next);
7465
7466 printf (_(" %#06x: Rev: %d Flags: %s"),
7467 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7468
7469 printf (_(" Index: %d Cnt: %d "),
7470 ent.vd_ndx, ent.vd_cnt);
7471
7472 vstart += ent.vd_aux;
7473
7474 eaux = (Elf_External_Verdaux *) vstart;
7475
7476 aux.vda_name = BYTE_GET (eaux->vda_name);
7477 aux.vda_next = BYTE_GET (eaux->vda_next);
7478
7479 if (VALID_DYNAMIC_NAME (aux.vda_name))
7480 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
7481 else
7482 printf (_("Name index: %ld\n"), aux.vda_name);
7483
7484 isum = idx + ent.vd_aux;
7485
7486 for (j = 1; j < ent.vd_cnt; j++)
7487 {
7488 isum += aux.vda_next;
7489 vstart += aux.vda_next;
7490
7491 eaux = (Elf_External_Verdaux *) vstart;
7492 if (vstart + sizeof (*eaux) > endbuf)
7493 break;
7494
7495 aux.vda_name = BYTE_GET (eaux->vda_name);
7496 aux.vda_next = BYTE_GET (eaux->vda_next);
7497
7498 if (VALID_DYNAMIC_NAME (aux.vda_name))
7499 printf (_(" %#06x: Parent %d: %s\n"),
7500 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
7501 else
7502 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7503 isum, j, aux.vda_name);
7504 }
7505 if (j < ent.vd_cnt)
7506 printf (_(" Version def aux past end of section\n"));
7507
7508 idx += ent.vd_next;
7509 }
7510 if (cnt < section->sh_info)
7511 printf (_(" Version definition past end of section\n"));
7512
7513 free (edefs);
7514 }
7515 break;
7516
7517 case SHT_GNU_verneed:
7518 {
7519 Elf_External_Verneed * eneed;
7520 unsigned int idx;
7521 unsigned int cnt;
7522 char * endbuf;
7523
7524 found = 1;
7525
7526 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7527 SECTION_NAME (section), section->sh_info);
7528
7529 printf (_(" Addr: 0x"));
7530 printf_vma (section->sh_addr);
7531 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7532 (unsigned long) section->sh_offset, section->sh_link,
7533 section->sh_link < elf_header.e_shnum
7534 ? SECTION_NAME (section_headers + section->sh_link)
7535 : _("<corrupt>"));
7536
7537 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7538 section->sh_offset, 1,
7539 section->sh_size,
7540 _("version need section"));
7541 endbuf = (char *) eneed + section->sh_size;
7542 if (!eneed)
7543 break;
7544
7545 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7546 {
7547 Elf_External_Verneed * entry;
7548 Elf_Internal_Verneed ent;
7549 int j;
7550 int isum;
7551 char * vstart;
7552
7553 vstart = ((char *) eneed) + idx;
7554 if (vstart + sizeof (*entry) > endbuf)
7555 break;
7556
7557 entry = (Elf_External_Verneed *) vstart;
7558
7559 ent.vn_version = BYTE_GET (entry->vn_version);
7560 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7561 ent.vn_file = BYTE_GET (entry->vn_file);
7562 ent.vn_aux = BYTE_GET (entry->vn_aux);
7563 ent.vn_next = BYTE_GET (entry->vn_next);
7564
7565 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7566
7567 if (VALID_DYNAMIC_NAME (ent.vn_file))
7568 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
7569 else
7570 printf (_(" File: %lx"), ent.vn_file);
7571
7572 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7573
7574 vstart += ent.vn_aux;
7575
7576 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7577 {
7578 Elf_External_Vernaux * eaux;
7579 Elf_Internal_Vernaux aux;
7580
7581 if (vstart + sizeof (*eaux) > endbuf)
7582 break;
7583 eaux = (Elf_External_Vernaux *) vstart;
7584
7585 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7586 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7587 aux.vna_other = BYTE_GET (eaux->vna_other);
7588 aux.vna_name = BYTE_GET (eaux->vna_name);
7589 aux.vna_next = BYTE_GET (eaux->vna_next);
7590
7591 if (VALID_DYNAMIC_NAME (aux.vna_name))
7592 printf (_(" %#06x: Name: %s"),
7593 isum, GET_DYNAMIC_NAME (aux.vna_name));
7594 else
7595 printf (_(" %#06x: Name index: %lx"),
7596 isum, aux.vna_name);
7597
7598 printf (_(" Flags: %s Version: %d\n"),
7599 get_ver_flags (aux.vna_flags), aux.vna_other);
7600
7601 isum += aux.vna_next;
7602 vstart += aux.vna_next;
7603 }
7604 if (j < ent.vn_cnt)
7605 printf (_(" Version need aux past end of section\n"));
7606
7607 idx += ent.vn_next;
7608 }
7609 if (cnt < section->sh_info)
7610 printf (_(" Version need past end of section\n"));
7611
7612 free (eneed);
7613 }
7614 break;
7615
7616 case SHT_GNU_versym:
7617 {
7618 Elf_Internal_Shdr * link_section;
7619 int total;
7620 int cnt;
7621 unsigned char * edata;
7622 unsigned short * data;
7623 char * strtab;
7624 Elf_Internal_Sym * symbols;
7625 Elf_Internal_Shdr * string_sec;
7626 long off;
7627
7628 if (section->sh_link >= elf_header.e_shnum)
7629 break;
7630
7631 link_section = section_headers + section->sh_link;
7632 total = section->sh_size / sizeof (Elf_External_Versym);
7633
7634 if (link_section->sh_link >= elf_header.e_shnum)
7635 break;
7636
7637 found = 1;
7638
7639 symbols = GET_ELF_SYMBOLS (file, link_section);
7640
7641 string_sec = section_headers + link_section->sh_link;
7642
7643 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
7644 string_sec->sh_size,
7645 _("version string table"));
7646 if (!strtab)
7647 break;
7648
7649 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7650 SECTION_NAME (section), total);
7651
7652 printf (_(" Addr: "));
7653 printf_vma (section->sh_addr);
7654 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7655 (unsigned long) section->sh_offset, section->sh_link,
7656 SECTION_NAME (link_section));
7657
7658 off = offset_from_vma (file,
7659 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7660 total * sizeof (short));
7661 edata = (unsigned char *) get_data (NULL, file, off, total,
7662 sizeof (short),
7663 _("version symbol data"));
7664 if (!edata)
7665 {
7666 free (strtab);
7667 break;
7668 }
7669
7670 data = (short unsigned int *) cmalloc (total, sizeof (short));
7671
7672 for (cnt = total; cnt --;)
7673 data[cnt] = byte_get (edata + cnt * sizeof (short),
7674 sizeof (short));
7675
7676 free (edata);
7677
7678 for (cnt = 0; cnt < total; cnt += 4)
7679 {
7680 int j, nn;
7681 int check_def, check_need;
7682 char * name;
7683
7684 printf (" %03x:", cnt);
7685
7686 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
7687 switch (data[cnt + j])
7688 {
7689 case 0:
7690 fputs (_(" 0 (*local*) "), stdout);
7691 break;
7692
7693 case 1:
7694 fputs (_(" 1 (*global*) "), stdout);
7695 break;
7696
7697 default:
7698 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
7699 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
7700
7701 check_def = 1;
7702 check_need = 1;
7703 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
7704 || section_headers[symbols[cnt + j].st_shndx].sh_type
7705 != SHT_NOBITS)
7706 {
7707 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
7708 check_def = 0;
7709 else
7710 check_need = 0;
7711 }
7712
7713 if (check_need
7714 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
7715 {
7716 Elf_Internal_Verneed ivn;
7717 unsigned long offset;
7718
7719 offset = offset_from_vma
7720 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7721 sizeof (Elf_External_Verneed));
7722
7723 do
7724 {
7725 Elf_Internal_Vernaux ivna;
7726 Elf_External_Verneed evn;
7727 Elf_External_Vernaux evna;
7728 unsigned long a_off;
7729
7730 get_data (&evn, file, offset, sizeof (evn), 1,
7731 _("version need"));
7732
7733 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7734 ivn.vn_next = BYTE_GET (evn.vn_next);
7735
7736 a_off = offset + ivn.vn_aux;
7737
7738 do
7739 {
7740 get_data (&evna, file, a_off, sizeof (evna),
7741 1, _("version need aux (2)"));
7742
7743 ivna.vna_next = BYTE_GET (evna.vna_next);
7744 ivna.vna_other = BYTE_GET (evna.vna_other);
7745
7746 a_off += ivna.vna_next;
7747 }
7748 while (ivna.vna_other != data[cnt + j]
7749 && ivna.vna_next != 0);
7750
7751 if (ivna.vna_other == data[cnt + j])
7752 {
7753 ivna.vna_name = BYTE_GET (evna.vna_name);
7754
7755 if (ivna.vna_name >= string_sec->sh_size)
7756 name = _("*invalid*");
7757 else
7758 name = strtab + ivna.vna_name;
7759 nn += printf ("(%s%-*s",
7760 name,
7761 12 - (int) strlen (name),
7762 ")");
7763 check_def = 0;
7764 break;
7765 }
7766
7767 offset += ivn.vn_next;
7768 }
7769 while (ivn.vn_next);
7770 }
7771
7772 if (check_def && data[cnt + j] != 0x8001
7773 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7774 {
7775 Elf_Internal_Verdef ivd;
7776 Elf_External_Verdef evd;
7777 unsigned long offset;
7778
7779 offset = offset_from_vma
7780 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7781 sizeof evd);
7782
7783 do
7784 {
7785 get_data (&evd, file, offset, sizeof (evd), 1,
7786 _("version def"));
7787
7788 ivd.vd_next = BYTE_GET (evd.vd_next);
7789 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7790
7791 offset += ivd.vd_next;
7792 }
7793 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
7794 && ivd.vd_next != 0);
7795
7796 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
7797 {
7798 Elf_External_Verdaux evda;
7799 Elf_Internal_Verdaux ivda;
7800
7801 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7802
7803 get_data (&evda, file,
7804 offset - ivd.vd_next + ivd.vd_aux,
7805 sizeof (evda), 1,
7806 _("version def aux"));
7807
7808 ivda.vda_name = BYTE_GET (evda.vda_name);
7809
7810 if (ivda.vda_name >= string_sec->sh_size)
7811 name = _("*invalid*");
7812 else
7813 name = strtab + ivda.vda_name;
7814 nn += printf ("(%s%-*s",
7815 name,
7816 12 - (int) strlen (name),
7817 ")");
7818 }
7819 }
7820
7821 if (nn < 18)
7822 printf ("%*c", 18 - nn, ' ');
7823 }
7824
7825 putchar ('\n');
7826 }
7827
7828 free (data);
7829 free (strtab);
7830 free (symbols);
7831 }
7832 break;
7833
7834 default:
7835 break;
7836 }
7837 }
7838
7839 if (! found)
7840 printf (_("\nNo version information found in this file.\n"));
7841
7842 return 1;
7843 }
7844
7845 static const char *
7846 get_symbol_binding (unsigned int binding)
7847 {
7848 static char buff[32];
7849
7850 switch (binding)
7851 {
7852 case STB_LOCAL: return "LOCAL";
7853 case STB_GLOBAL: return "GLOBAL";
7854 case STB_WEAK: return "WEAK";
7855 default:
7856 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
7857 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
7858 binding);
7859 else if (binding >= STB_LOOS && binding <= STB_HIOS)
7860 {
7861 if (binding == STB_GNU_UNIQUE
7862 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7863 /* GNU/Linux is still using the default value 0. */
7864 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7865 return "UNIQUE";
7866 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
7867 }
7868 else
7869 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
7870 return buff;
7871 }
7872 }
7873
7874 static const char *
7875 get_symbol_type (unsigned int type)
7876 {
7877 static char buff[32];
7878
7879 switch (type)
7880 {
7881 case STT_NOTYPE: return "NOTYPE";
7882 case STT_OBJECT: return "OBJECT";
7883 case STT_FUNC: return "FUNC";
7884 case STT_SECTION: return "SECTION";
7885 case STT_FILE: return "FILE";
7886 case STT_COMMON: return "COMMON";
7887 case STT_TLS: return "TLS";
7888 case STT_RELC: return "RELC";
7889 case STT_SRELC: return "SRELC";
7890 default:
7891 if (type >= STT_LOPROC && type <= STT_HIPROC)
7892 {
7893 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7894 return "THUMB_FUNC";
7895
7896 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7897 return "REGISTER";
7898
7899 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7900 return "PARISC_MILLI";
7901
7902 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7903 }
7904 else if (type >= STT_LOOS && type <= STT_HIOS)
7905 {
7906 if (elf_header.e_machine == EM_PARISC)
7907 {
7908 if (type == STT_HP_OPAQUE)
7909 return "HP_OPAQUE";
7910 if (type == STT_HP_STUB)
7911 return "HP_STUB";
7912 }
7913
7914 if (type == STT_GNU_IFUNC
7915 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7916 /* GNU/Linux is still using the default value 0. */
7917 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7918 return "IFUNC";
7919
7920 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7921 }
7922 else
7923 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7924 return buff;
7925 }
7926 }
7927
7928 static const char *
7929 get_symbol_visibility (unsigned int visibility)
7930 {
7931 switch (visibility)
7932 {
7933 case STV_DEFAULT: return "DEFAULT";
7934 case STV_INTERNAL: return "INTERNAL";
7935 case STV_HIDDEN: return "HIDDEN";
7936 case STV_PROTECTED: return "PROTECTED";
7937 default: abort ();
7938 }
7939 }
7940
7941 static const char *
7942 get_mips_symbol_other (unsigned int other)
7943 {
7944 switch (other)
7945 {
7946 case STO_OPTIONAL: return "OPTIONAL";
7947 case STO_MIPS16: return "MIPS16";
7948 case STO_MIPS_PLT: return "MIPS PLT";
7949 case STO_MIPS_PIC: return "MIPS PIC";
7950 default: return NULL;
7951 }
7952 }
7953
7954 static const char *
7955 get_symbol_other (unsigned int other)
7956 {
7957 const char * result = NULL;
7958 static char buff [32];
7959
7960 if (other == 0)
7961 return "";
7962
7963 switch (elf_header.e_machine)
7964 {
7965 case EM_MIPS:
7966 result = get_mips_symbol_other (other);
7967 default:
7968 break;
7969 }
7970
7971 if (result)
7972 return result;
7973
7974 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7975 return buff;
7976 }
7977
7978 static const char *
7979 get_symbol_index_type (unsigned int type)
7980 {
7981 static char buff[32];
7982
7983 switch (type)
7984 {
7985 case SHN_UNDEF: return "UND";
7986 case SHN_ABS: return "ABS";
7987 case SHN_COMMON: return "COM";
7988 default:
7989 if (type == SHN_IA_64_ANSI_COMMON
7990 && elf_header.e_machine == EM_IA_64
7991 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7992 return "ANSI_COM";
7993 else if ((elf_header.e_machine == EM_X86_64
7994 || elf_header.e_machine == EM_L1OM)
7995 && type == SHN_X86_64_LCOMMON)
7996 return "LARGE_COM";
7997 else if (type == SHN_MIPS_SCOMMON
7998 && elf_header.e_machine == EM_MIPS)
7999 return "SCOM";
8000 else if (type == SHN_MIPS_SUNDEFINED
8001 && elf_header.e_machine == EM_MIPS)
8002 return "SUND";
8003 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8004 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8005 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8006 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8007 else if (type >= SHN_LORESERVE)
8008 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8009 else
8010 sprintf (buff, "%3d", type);
8011 break;
8012 }
8013
8014 return buff;
8015 }
8016
8017 static bfd_vma *
8018 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8019 {
8020 unsigned char * e_data;
8021 bfd_vma * i_data;
8022
8023 e_data = (unsigned char *) cmalloc (number, ent_size);
8024
8025 if (e_data == NULL)
8026 {
8027 error (_("Out of memory\n"));
8028 return NULL;
8029 }
8030
8031 if (fread (e_data, ent_size, number, file) != number)
8032 {
8033 error (_("Unable to read in dynamic data\n"));
8034 return NULL;
8035 }
8036
8037 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8038
8039 if (i_data == NULL)
8040 {
8041 error (_("Out of memory\n"));
8042 free (e_data);
8043 return NULL;
8044 }
8045
8046 while (number--)
8047 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8048
8049 free (e_data);
8050
8051 return i_data;
8052 }
8053
8054 static void
8055 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8056 {
8057 Elf_Internal_Sym * psym;
8058 int n;
8059
8060 psym = dynamic_symbols + si;
8061
8062 n = print_vma (si, DEC_5);
8063 if (n < 5)
8064 fputs (" " + n, stdout);
8065 printf (" %3lu: ", hn);
8066 print_vma (psym->st_value, LONG_HEX);
8067 putchar (' ');
8068 print_vma (psym->st_size, DEC_5);
8069
8070 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8071 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8072 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8073 /* Check to see if any other bits in the st_other field are set.
8074 Note - displaying this information disrupts the layout of the
8075 table being generated, but for the moment this case is very
8076 rare. */
8077 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8078 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8079 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8080 if (VALID_DYNAMIC_NAME (psym->st_name))
8081 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8082 else
8083 printf (_(" <corrupt: %14ld>"), psym->st_name);
8084 putchar ('\n');
8085 }
8086
8087 /* Dump the symbol table. */
8088 static int
8089 process_symbol_table (FILE * file)
8090 {
8091 Elf_Internal_Shdr * section;
8092 bfd_vma nbuckets = 0;
8093 bfd_vma nchains = 0;
8094 bfd_vma * buckets = NULL;
8095 bfd_vma * chains = NULL;
8096 bfd_vma ngnubuckets = 0;
8097 bfd_vma * gnubuckets = NULL;
8098 bfd_vma * gnuchains = NULL;
8099 bfd_vma gnusymidx = 0;
8100
8101 if (!do_syms && !do_dyn_syms && !do_histogram)
8102 return 1;
8103
8104 if (dynamic_info[DT_HASH]
8105 && (do_histogram
8106 || (do_using_dynamic
8107 && !do_dyn_syms
8108 && dynamic_strings != NULL)))
8109 {
8110 unsigned char nb[8];
8111 unsigned char nc[8];
8112 int hash_ent_size = 4;
8113
8114 if ((elf_header.e_machine == EM_ALPHA
8115 || elf_header.e_machine == EM_S390
8116 || elf_header.e_machine == EM_S390_OLD)
8117 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8118 hash_ent_size = 8;
8119
8120 if (fseek (file,
8121 (archive_file_offset
8122 + offset_from_vma (file, dynamic_info[DT_HASH],
8123 sizeof nb + sizeof nc)),
8124 SEEK_SET))
8125 {
8126 error (_("Unable to seek to start of dynamic information\n"));
8127 goto no_hash;
8128 }
8129
8130 if (fread (nb, hash_ent_size, 1, file) != 1)
8131 {
8132 error (_("Failed to read in number of buckets\n"));
8133 goto no_hash;
8134 }
8135
8136 if (fread (nc, hash_ent_size, 1, file) != 1)
8137 {
8138 error (_("Failed to read in number of chains\n"));
8139 goto no_hash;
8140 }
8141
8142 nbuckets = byte_get (nb, hash_ent_size);
8143 nchains = byte_get (nc, hash_ent_size);
8144
8145 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8146 chains = get_dynamic_data (file, nchains, hash_ent_size);
8147
8148 no_hash:
8149 if (buckets == NULL || chains == NULL)
8150 {
8151 if (do_using_dynamic)
8152 return 0;
8153 free (buckets);
8154 free (chains);
8155 buckets = NULL;
8156 chains = NULL;
8157 nbuckets = 0;
8158 nchains = 0;
8159 }
8160 }
8161
8162 if (dynamic_info_DT_GNU_HASH
8163 && (do_histogram
8164 || (do_using_dynamic
8165 && !do_dyn_syms
8166 && dynamic_strings != NULL)))
8167 {
8168 unsigned char nb[16];
8169 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8170 bfd_vma buckets_vma;
8171
8172 if (fseek (file,
8173 (archive_file_offset
8174 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8175 sizeof nb)),
8176 SEEK_SET))
8177 {
8178 error (_("Unable to seek to start of dynamic information\n"));
8179 goto no_gnu_hash;
8180 }
8181
8182 if (fread (nb, 16, 1, file) != 1)
8183 {
8184 error (_("Failed to read in number of buckets\n"));
8185 goto no_gnu_hash;
8186 }
8187
8188 ngnubuckets = byte_get (nb, 4);
8189 gnusymidx = byte_get (nb + 4, 4);
8190 bitmaskwords = byte_get (nb + 8, 4);
8191 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8192 if (is_32bit_elf)
8193 buckets_vma += bitmaskwords * 4;
8194 else
8195 buckets_vma += bitmaskwords * 8;
8196
8197 if (fseek (file,
8198 (archive_file_offset
8199 + offset_from_vma (file, buckets_vma, 4)),
8200 SEEK_SET))
8201 {
8202 error (_("Unable to seek to start of dynamic information\n"));
8203 goto no_gnu_hash;
8204 }
8205
8206 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8207
8208 if (gnubuckets == NULL)
8209 goto no_gnu_hash;
8210
8211 for (i = 0; i < ngnubuckets; i++)
8212 if (gnubuckets[i] != 0)
8213 {
8214 if (gnubuckets[i] < gnusymidx)
8215 return 0;
8216
8217 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8218 maxchain = gnubuckets[i];
8219 }
8220
8221 if (maxchain == 0xffffffff)
8222 goto no_gnu_hash;
8223
8224 maxchain -= gnusymidx;
8225
8226 if (fseek (file,
8227 (archive_file_offset
8228 + offset_from_vma (file, buckets_vma
8229 + 4 * (ngnubuckets + maxchain), 4)),
8230 SEEK_SET))
8231 {
8232 error (_("Unable to seek to start of dynamic information\n"));
8233 goto no_gnu_hash;
8234 }
8235
8236 do
8237 {
8238 if (fread (nb, 4, 1, file) != 1)
8239 {
8240 error (_("Failed to determine last chain length\n"));
8241 goto no_gnu_hash;
8242 }
8243
8244 if (maxchain + 1 == 0)
8245 goto no_gnu_hash;
8246
8247 ++maxchain;
8248 }
8249 while ((byte_get (nb, 4) & 1) == 0);
8250
8251 if (fseek (file,
8252 (archive_file_offset
8253 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8254 SEEK_SET))
8255 {
8256 error (_("Unable to seek to start of dynamic information\n"));
8257 goto no_gnu_hash;
8258 }
8259
8260 gnuchains = get_dynamic_data (file, maxchain, 4);
8261
8262 no_gnu_hash:
8263 if (gnuchains == NULL)
8264 {
8265 free (gnubuckets);
8266 gnubuckets = NULL;
8267 ngnubuckets = 0;
8268 if (do_using_dynamic)
8269 return 0;
8270 }
8271 }
8272
8273 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8274 && do_syms
8275 && do_using_dynamic
8276 && dynamic_strings != NULL)
8277 {
8278 unsigned long hn;
8279
8280 if (dynamic_info[DT_HASH])
8281 {
8282 bfd_vma si;
8283
8284 printf (_("\nSymbol table for image:\n"));
8285 if (is_32bit_elf)
8286 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8287 else
8288 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8289
8290 for (hn = 0; hn < nbuckets; hn++)
8291 {
8292 if (! buckets[hn])
8293 continue;
8294
8295 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8296 print_dynamic_symbol (si, hn);
8297 }
8298 }
8299
8300 if (dynamic_info_DT_GNU_HASH)
8301 {
8302 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8303 if (is_32bit_elf)
8304 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8305 else
8306 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8307
8308 for (hn = 0; hn < ngnubuckets; ++hn)
8309 if (gnubuckets[hn] != 0)
8310 {
8311 bfd_vma si = gnubuckets[hn];
8312 bfd_vma off = si - gnusymidx;
8313
8314 do
8315 {
8316 print_dynamic_symbol (si, hn);
8317 si++;
8318 }
8319 while ((gnuchains[off++] & 1) == 0);
8320 }
8321 }
8322 }
8323 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8324 {
8325 unsigned int i;
8326
8327 for (i = 0, section = section_headers;
8328 i < elf_header.e_shnum;
8329 i++, section++)
8330 {
8331 unsigned int si;
8332 char * strtab = NULL;
8333 unsigned long int strtab_size = 0;
8334 Elf_Internal_Sym * symtab;
8335 Elf_Internal_Sym * psym;
8336
8337 if ((section->sh_type != SHT_SYMTAB
8338 && section->sh_type != SHT_DYNSYM)
8339 || (!do_syms
8340 && section->sh_type == SHT_SYMTAB))
8341 continue;
8342
8343 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8344 SECTION_NAME (section),
8345 (unsigned long) (section->sh_size / section->sh_entsize));
8346 if (is_32bit_elf)
8347 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8348 else
8349 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8350
8351 symtab = GET_ELF_SYMBOLS (file, section);
8352 if (symtab == NULL)
8353 continue;
8354
8355 if (section->sh_link == elf_header.e_shstrndx)
8356 {
8357 strtab = string_table;
8358 strtab_size = string_table_length;
8359 }
8360 else if (section->sh_link < elf_header.e_shnum)
8361 {
8362 Elf_Internal_Shdr * string_sec;
8363
8364 string_sec = section_headers + section->sh_link;
8365
8366 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8367 1, string_sec->sh_size,
8368 _("string table"));
8369 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8370 }
8371
8372 for (si = 0, psym = symtab;
8373 si < section->sh_size / section->sh_entsize;
8374 si++, psym++)
8375 {
8376 printf ("%6d: ", si);
8377 print_vma (psym->st_value, LONG_HEX);
8378 putchar (' ');
8379 print_vma (psym->st_size, DEC_5);
8380 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8381 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8382 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8383 /* Check to see if any other bits in the st_other field are set.
8384 Note - displaying this information disrupts the layout of the
8385 table being generated, but for the moment this case is very rare. */
8386 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8387 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8388 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8389 print_symbol (25, psym->st_name < strtab_size
8390 ? strtab + psym->st_name : _("<corrupt>"));
8391
8392 if (section->sh_type == SHT_DYNSYM &&
8393 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8394 {
8395 unsigned char data[2];
8396 unsigned short vers_data;
8397 unsigned long offset;
8398 int is_nobits;
8399 int check_def;
8400
8401 offset = offset_from_vma
8402 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8403 sizeof data + si * sizeof (vers_data));
8404
8405 get_data (&data, file, offset + si * sizeof (vers_data),
8406 sizeof (data), 1, _("version data"));
8407
8408 vers_data = byte_get (data, 2);
8409
8410 is_nobits = (psym->st_shndx < elf_header.e_shnum
8411 && section_headers[psym->st_shndx].sh_type
8412 == SHT_NOBITS);
8413
8414 check_def = (psym->st_shndx != SHN_UNDEF);
8415
8416 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8417 {
8418 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8419 && (is_nobits || ! check_def))
8420 {
8421 Elf_External_Verneed evn;
8422 Elf_Internal_Verneed ivn;
8423 Elf_Internal_Vernaux ivna;
8424
8425 /* We must test both. */
8426 offset = offset_from_vma
8427 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8428 sizeof evn);
8429
8430 do
8431 {
8432 unsigned long vna_off;
8433
8434 get_data (&evn, file, offset, sizeof (evn), 1,
8435 _("version need"));
8436
8437 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8438 ivn.vn_next = BYTE_GET (evn.vn_next);
8439
8440 vna_off = offset + ivn.vn_aux;
8441
8442 do
8443 {
8444 Elf_External_Vernaux evna;
8445
8446 get_data (&evna, file, vna_off,
8447 sizeof (evna), 1,
8448 _("version need aux (3)"));
8449
8450 ivna.vna_other = BYTE_GET (evna.vna_other);
8451 ivna.vna_next = BYTE_GET (evna.vna_next);
8452 ivna.vna_name = BYTE_GET (evna.vna_name);
8453
8454 vna_off += ivna.vna_next;
8455 }
8456 while (ivna.vna_other != vers_data
8457 && ivna.vna_next != 0);
8458
8459 if (ivna.vna_other == vers_data)
8460 break;
8461
8462 offset += ivn.vn_next;
8463 }
8464 while (ivn.vn_next != 0);
8465
8466 if (ivna.vna_other == vers_data)
8467 {
8468 printf ("@%s (%d)",
8469 ivna.vna_name < strtab_size
8470 ? strtab + ivna.vna_name : _("<corrupt>"),
8471 ivna.vna_other);
8472 check_def = 0;
8473 }
8474 else if (! is_nobits)
8475 error (_("bad dynamic symbol\n"));
8476 else
8477 check_def = 1;
8478 }
8479
8480 if (check_def)
8481 {
8482 if (vers_data != 0x8001
8483 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8484 {
8485 Elf_Internal_Verdef ivd;
8486 Elf_Internal_Verdaux ivda;
8487 Elf_External_Verdaux evda;
8488 unsigned long off;
8489
8490 off = offset_from_vma
8491 (file,
8492 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8493 sizeof (Elf_External_Verdef));
8494
8495 do
8496 {
8497 Elf_External_Verdef evd;
8498
8499 get_data (&evd, file, off, sizeof (evd),
8500 1, _("version def"));
8501
8502 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8503 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8504 ivd.vd_next = BYTE_GET (evd.vd_next);
8505
8506 off += ivd.vd_next;
8507 }
8508 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
8509 && ivd.vd_next != 0);
8510
8511 off -= ivd.vd_next;
8512 off += ivd.vd_aux;
8513
8514 get_data (&evda, file, off, sizeof (evda),
8515 1, _("version def aux"));
8516
8517 ivda.vda_name = BYTE_GET (evda.vda_name);
8518
8519 if (psym->st_name != ivda.vda_name)
8520 printf ((vers_data & VERSYM_HIDDEN)
8521 ? "@%s" : "@@%s",
8522 ivda.vda_name < strtab_size
8523 ? strtab + ivda.vda_name : _("<corrupt>"));
8524 }
8525 }
8526 }
8527 }
8528
8529 putchar ('\n');
8530 }
8531
8532 free (symtab);
8533 if (strtab != string_table)
8534 free (strtab);
8535 }
8536 }
8537 else if (do_syms)
8538 printf
8539 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8540
8541 if (do_histogram && buckets != NULL)
8542 {
8543 unsigned long * lengths;
8544 unsigned long * counts;
8545 unsigned long hn;
8546 bfd_vma si;
8547 unsigned long maxlength = 0;
8548 unsigned long nzero_counts = 0;
8549 unsigned long nsyms = 0;
8550
8551 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8552 (unsigned long) nbuckets);
8553 printf (_(" Length Number %% of total Coverage\n"));
8554
8555 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
8556 if (lengths == NULL)
8557 {
8558 error (_("Out of memory\n"));
8559 return 0;
8560 }
8561 for (hn = 0; hn < nbuckets; ++hn)
8562 {
8563 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
8564 {
8565 ++nsyms;
8566 if (maxlength < ++lengths[hn])
8567 ++maxlength;
8568 }
8569 }
8570
8571 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
8572 if (counts == NULL)
8573 {
8574 error (_("Out of memory\n"));
8575 return 0;
8576 }
8577
8578 for (hn = 0; hn < nbuckets; ++hn)
8579 ++counts[lengths[hn]];
8580
8581 if (nbuckets > 0)
8582 {
8583 unsigned long i;
8584 printf (" 0 %-10lu (%5.1f%%)\n",
8585 counts[0], (counts[0] * 100.0) / nbuckets);
8586 for (i = 1; i <= maxlength; ++i)
8587 {
8588 nzero_counts += counts[i] * i;
8589 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8590 i, counts[i], (counts[i] * 100.0) / nbuckets,
8591 (nzero_counts * 100.0) / nsyms);
8592 }
8593 }
8594
8595 free (counts);
8596 free (lengths);
8597 }
8598
8599 if (buckets != NULL)
8600 {
8601 free (buckets);
8602 free (chains);
8603 }
8604
8605 if (do_histogram && gnubuckets != NULL)
8606 {
8607 unsigned long * lengths;
8608 unsigned long * counts;
8609 unsigned long hn;
8610 unsigned long maxlength = 0;
8611 unsigned long nzero_counts = 0;
8612 unsigned long nsyms = 0;
8613
8614 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
8615 if (lengths == NULL)
8616 {
8617 error (_("Out of memory\n"));
8618 return 0;
8619 }
8620
8621 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8622 (unsigned long) ngnubuckets);
8623 printf (_(" Length Number %% of total Coverage\n"));
8624
8625 for (hn = 0; hn < ngnubuckets; ++hn)
8626 if (gnubuckets[hn] != 0)
8627 {
8628 bfd_vma off, length = 1;
8629
8630 for (off = gnubuckets[hn] - gnusymidx;
8631 (gnuchains[off] & 1) == 0; ++off)
8632 ++length;
8633 lengths[hn] = length;
8634 if (length > maxlength)
8635 maxlength = length;
8636 nsyms += length;
8637 }
8638
8639 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
8640 if (counts == NULL)
8641 {
8642 error (_("Out of memory\n"));
8643 return 0;
8644 }
8645
8646 for (hn = 0; hn < ngnubuckets; ++hn)
8647 ++counts[lengths[hn]];
8648
8649 if (ngnubuckets > 0)
8650 {
8651 unsigned long j;
8652 printf (" 0 %-10lu (%5.1f%%)\n",
8653 counts[0], (counts[0] * 100.0) / ngnubuckets);
8654 for (j = 1; j <= maxlength; ++j)
8655 {
8656 nzero_counts += counts[j] * j;
8657 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8658 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
8659 (nzero_counts * 100.0) / nsyms);
8660 }
8661 }
8662
8663 free (counts);
8664 free (lengths);
8665 free (gnubuckets);
8666 free (gnuchains);
8667 }
8668
8669 return 1;
8670 }
8671
8672 static int
8673 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
8674 {
8675 unsigned int i;
8676
8677 if (dynamic_syminfo == NULL
8678 || !do_dynamic)
8679 /* No syminfo, this is ok. */
8680 return 1;
8681
8682 /* There better should be a dynamic symbol section. */
8683 if (dynamic_symbols == NULL || dynamic_strings == NULL)
8684 return 0;
8685
8686 if (dynamic_addr)
8687 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
8688 dynamic_syminfo_offset, dynamic_syminfo_nent);
8689
8690 printf (_(" Num: Name BoundTo Flags\n"));
8691 for (i = 0; i < dynamic_syminfo_nent; ++i)
8692 {
8693 unsigned short int flags = dynamic_syminfo[i].si_flags;
8694
8695 printf ("%4d: ", i);
8696 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
8697 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
8698 else
8699 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
8700 putchar (' ');
8701
8702 switch (dynamic_syminfo[i].si_boundto)
8703 {
8704 case SYMINFO_BT_SELF:
8705 fputs ("SELF ", stdout);
8706 break;
8707 case SYMINFO_BT_PARENT:
8708 fputs ("PARENT ", stdout);
8709 break;
8710 default:
8711 if (dynamic_syminfo[i].si_boundto > 0
8712 && dynamic_syminfo[i].si_boundto < dynamic_nent
8713 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
8714 {
8715 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
8716 putchar (' ' );
8717 }
8718 else
8719 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
8720 break;
8721 }
8722
8723 if (flags & SYMINFO_FLG_DIRECT)
8724 printf (" DIRECT");
8725 if (flags & SYMINFO_FLG_PASSTHRU)
8726 printf (" PASSTHRU");
8727 if (flags & SYMINFO_FLG_COPY)
8728 printf (" COPY");
8729 if (flags & SYMINFO_FLG_LAZYLOAD)
8730 printf (" LAZYLOAD");
8731
8732 puts ("");
8733 }
8734
8735 return 1;
8736 }
8737
8738 /* Check to see if the given reloc needs to be handled in a target specific
8739 manner. If so then process the reloc and return TRUE otherwise return
8740 FALSE. */
8741
8742 static bfd_boolean
8743 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
8744 unsigned char * start,
8745 Elf_Internal_Sym * symtab)
8746 {
8747 unsigned int reloc_type = get_reloc_type (reloc->r_info);
8748
8749 switch (elf_header.e_machine)
8750 {
8751 case EM_MN10300:
8752 case EM_CYGNUS_MN10300:
8753 {
8754 static Elf_Internal_Sym * saved_sym = NULL;
8755
8756 switch (reloc_type)
8757 {
8758 case 34: /* R_MN10300_ALIGN */
8759 return TRUE;
8760 case 33: /* R_MN10300_SYM_DIFF */
8761 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
8762 return TRUE;
8763 case 1: /* R_MN10300_32 */
8764 case 2: /* R_MN10300_16 */
8765 if (saved_sym != NULL)
8766 {
8767 bfd_vma value;
8768
8769 value = reloc->r_addend
8770 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
8771 - saved_sym->st_value);
8772
8773 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
8774
8775 saved_sym = NULL;
8776 return TRUE;
8777 }
8778 break;
8779 default:
8780 if (saved_sym != NULL)
8781 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8782 break;
8783 }
8784 break;
8785 }
8786 }
8787
8788 return FALSE;
8789 }
8790
8791 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8792 DWARF debug sections. This is a target specific test. Note - we do not
8793 go through the whole including-target-headers-multiple-times route, (as
8794 we have already done with <elf/h8.h>) because this would become very
8795 messy and even then this function would have to contain target specific
8796 information (the names of the relocs instead of their numeric values).
8797 FIXME: This is not the correct way to solve this problem. The proper way
8798 is to have target specific reloc sizing and typing functions created by
8799 the reloc-macros.h header, in the same way that it already creates the
8800 reloc naming functions. */
8801
8802 static bfd_boolean
8803 is_32bit_abs_reloc (unsigned int reloc_type)
8804 {
8805 switch (elf_header.e_machine)
8806 {
8807 case EM_386:
8808 case EM_486:
8809 return reloc_type == 1; /* R_386_32. */
8810 case EM_68K:
8811 return reloc_type == 1; /* R_68K_32. */
8812 case EM_860:
8813 return reloc_type == 1; /* R_860_32. */
8814 case EM_ALPHA:
8815 return reloc_type == 1; /* XXX Is this right ? */
8816 case EM_ARC:
8817 return reloc_type == 1; /* R_ARC_32. */
8818 case EM_ARM:
8819 return reloc_type == 2; /* R_ARM_ABS32 */
8820 case EM_AVR_OLD:
8821 case EM_AVR:
8822 return reloc_type == 1;
8823 case EM_BLACKFIN:
8824 return reloc_type == 0x12; /* R_byte4_data. */
8825 case EM_CRIS:
8826 return reloc_type == 3; /* R_CRIS_32. */
8827 case EM_CR16:
8828 case EM_CR16_OLD:
8829 return reloc_type == 3; /* R_CR16_NUM32. */
8830 case EM_CRX:
8831 return reloc_type == 15; /* R_CRX_NUM32. */
8832 case EM_CYGNUS_FRV:
8833 return reloc_type == 1;
8834 case EM_CYGNUS_D10V:
8835 case EM_D10V:
8836 return reloc_type == 6; /* R_D10V_32. */
8837 case EM_CYGNUS_D30V:
8838 case EM_D30V:
8839 return reloc_type == 12; /* R_D30V_32_NORMAL. */
8840 case EM_DLX:
8841 return reloc_type == 3; /* R_DLX_RELOC_32. */
8842 case EM_CYGNUS_FR30:
8843 case EM_FR30:
8844 return reloc_type == 3; /* R_FR30_32. */
8845 case EM_H8S:
8846 case EM_H8_300:
8847 case EM_H8_300H:
8848 return reloc_type == 1; /* R_H8_DIR32. */
8849 case EM_IA_64:
8850 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
8851 case EM_IP2K_OLD:
8852 case EM_IP2K:
8853 return reloc_type == 2; /* R_IP2K_32. */
8854 case EM_IQ2000:
8855 return reloc_type == 2; /* R_IQ2000_32. */
8856 case EM_LATTICEMICO32:
8857 return reloc_type == 3; /* R_LM32_32. */
8858 case EM_M32C_OLD:
8859 case EM_M32C:
8860 return reloc_type == 3; /* R_M32C_32. */
8861 case EM_M32R:
8862 return reloc_type == 34; /* R_M32R_32_RELA. */
8863 case EM_MCORE:
8864 return reloc_type == 1; /* R_MCORE_ADDR32. */
8865 case EM_CYGNUS_MEP:
8866 return reloc_type == 4; /* R_MEP_32. */
8867 case EM_MIPS:
8868 return reloc_type == 2; /* R_MIPS_32. */
8869 case EM_MMIX:
8870 return reloc_type == 4; /* R_MMIX_32. */
8871 case EM_CYGNUS_MN10200:
8872 case EM_MN10200:
8873 return reloc_type == 1; /* R_MN10200_32. */
8874 case EM_CYGNUS_MN10300:
8875 case EM_MN10300:
8876 return reloc_type == 1; /* R_MN10300_32. */
8877 case EM_MSP430_OLD:
8878 case EM_MSP430:
8879 return reloc_type == 1; /* R_MSP43_32. */
8880 case EM_MT:
8881 return reloc_type == 2; /* R_MT_32. */
8882 case EM_ALTERA_NIOS2:
8883 case EM_NIOS32:
8884 return reloc_type == 1; /* R_NIOS_32. */
8885 case EM_OPENRISC:
8886 case EM_OR32:
8887 return reloc_type == 1; /* R_OR32_32. */
8888 case EM_PARISC:
8889 return (reloc_type == 1 /* R_PARISC_DIR32. */
8890 || reloc_type == 41); /* R_PARISC_SECREL32. */
8891 case EM_PJ:
8892 case EM_PJ_OLD:
8893 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8894 case EM_PPC64:
8895 return reloc_type == 1; /* R_PPC64_ADDR32. */
8896 case EM_PPC:
8897 return reloc_type == 1; /* R_PPC_ADDR32. */
8898 case EM_RX:
8899 return reloc_type == 1; /* R_RX_DIR32. */
8900 case EM_S370:
8901 return reloc_type == 1; /* R_I370_ADDR31. */
8902 case EM_S390_OLD:
8903 case EM_S390:
8904 return reloc_type == 4; /* R_S390_32. */
8905 case EM_SCORE:
8906 return reloc_type == 8; /* R_SCORE_ABS32. */
8907 case EM_SH:
8908 return reloc_type == 1; /* R_SH_DIR32. */
8909 case EM_SPARC32PLUS:
8910 case EM_SPARCV9:
8911 case EM_SPARC:
8912 return reloc_type == 3 /* R_SPARC_32. */
8913 || reloc_type == 23; /* R_SPARC_UA32. */
8914 case EM_SPU:
8915 return reloc_type == 6; /* R_SPU_ADDR32 */
8916 case EM_TI_C6000:
8917 return reloc_type == 1; /* R_C6000_ABS32. */
8918 case EM_CYGNUS_V850:
8919 case EM_V850:
8920 return reloc_type == 6; /* R_V850_ABS32. */
8921 case EM_VAX:
8922 return reloc_type == 1; /* R_VAX_32. */
8923 case EM_X86_64:
8924 case EM_L1OM:
8925 return reloc_type == 10; /* R_X86_64_32. */
8926 case EM_XC16X:
8927 case EM_C166:
8928 return reloc_type == 3; /* R_XC16C_ABS_32. */
8929 case EM_XSTORMY16:
8930 return reloc_type == 1; /* R_XSTROMY16_32. */
8931 case EM_XTENSA_OLD:
8932 case EM_XTENSA:
8933 return reloc_type == 1; /* R_XTENSA_32. */
8934 default:
8935 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8936 elf_header.e_machine);
8937 abort ();
8938 }
8939 }
8940
8941 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8942 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8943
8944 static bfd_boolean
8945 is_32bit_pcrel_reloc (unsigned int reloc_type)
8946 {
8947 switch (elf_header.e_machine)
8948 {
8949 case EM_386:
8950 case EM_486:
8951 return reloc_type == 2; /* R_386_PC32. */
8952 case EM_68K:
8953 return reloc_type == 4; /* R_68K_PC32. */
8954 case EM_ALPHA:
8955 return reloc_type == 10; /* R_ALPHA_SREL32. */
8956 case EM_ARM:
8957 return reloc_type == 3; /* R_ARM_REL32 */
8958 case EM_PARISC:
8959 return reloc_type == 9; /* R_PARISC_PCREL32. */
8960 case EM_PPC:
8961 return reloc_type == 26; /* R_PPC_REL32. */
8962 case EM_PPC64:
8963 return reloc_type == 26; /* R_PPC64_REL32. */
8964 case EM_S390_OLD:
8965 case EM_S390:
8966 return reloc_type == 5; /* R_390_PC32. */
8967 case EM_SH:
8968 return reloc_type == 2; /* R_SH_REL32. */
8969 case EM_SPARC32PLUS:
8970 case EM_SPARCV9:
8971 case EM_SPARC:
8972 return reloc_type == 6; /* R_SPARC_DISP32. */
8973 case EM_SPU:
8974 return reloc_type == 13; /* R_SPU_REL32. */
8975 case EM_X86_64:
8976 case EM_L1OM:
8977 return reloc_type == 2; /* R_X86_64_PC32. */
8978 case EM_XTENSA_OLD:
8979 case EM_XTENSA:
8980 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
8981 default:
8982 /* Do not abort or issue an error message here. Not all targets use
8983 pc-relative 32-bit relocs in their DWARF debug information and we
8984 have already tested for target coverage in is_32bit_abs_reloc. A
8985 more helpful warning message will be generated by apply_relocations
8986 anyway, so just return. */
8987 return FALSE;
8988 }
8989 }
8990
8991 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8992 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8993
8994 static bfd_boolean
8995 is_64bit_abs_reloc (unsigned int reloc_type)
8996 {
8997 switch (elf_header.e_machine)
8998 {
8999 case EM_ALPHA:
9000 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9001 case EM_IA_64:
9002 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9003 case EM_PARISC:
9004 return reloc_type == 80; /* R_PARISC_DIR64. */
9005 case EM_PPC64:
9006 return reloc_type == 38; /* R_PPC64_ADDR64. */
9007 case EM_SPARC32PLUS:
9008 case EM_SPARCV9:
9009 case EM_SPARC:
9010 return reloc_type == 54; /* R_SPARC_UA64. */
9011 case EM_X86_64:
9012 case EM_L1OM:
9013 return reloc_type == 1; /* R_X86_64_64. */
9014 case EM_S390_OLD:
9015 case EM_S390:
9016 return reloc_type == 22; /* R_S390_64 */
9017 case EM_MIPS:
9018 return reloc_type == 18; /* R_MIPS_64 */
9019 default:
9020 return FALSE;
9021 }
9022 }
9023
9024 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9025 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9026
9027 static bfd_boolean
9028 is_64bit_pcrel_reloc (unsigned int reloc_type)
9029 {
9030 switch (elf_header.e_machine)
9031 {
9032 case EM_ALPHA:
9033 return reloc_type == 11; /* R_ALPHA_SREL64 */
9034 case EM_IA_64:
9035 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9036 case EM_PARISC:
9037 return reloc_type == 72; /* R_PARISC_PCREL64 */
9038 case EM_PPC64:
9039 return reloc_type == 44; /* R_PPC64_REL64 */
9040 case EM_SPARC32PLUS:
9041 case EM_SPARCV9:
9042 case EM_SPARC:
9043 return reloc_type == 46; /* R_SPARC_DISP64 */
9044 case EM_X86_64:
9045 case EM_L1OM:
9046 return reloc_type == 24; /* R_X86_64_PC64 */
9047 case EM_S390_OLD:
9048 case EM_S390:
9049 return reloc_type == 23; /* R_S390_PC64 */
9050 default:
9051 return FALSE;
9052 }
9053 }
9054
9055 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9056 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9057
9058 static bfd_boolean
9059 is_24bit_abs_reloc (unsigned int reloc_type)
9060 {
9061 switch (elf_header.e_machine)
9062 {
9063 case EM_CYGNUS_MN10200:
9064 case EM_MN10200:
9065 return reloc_type == 4; /* R_MN10200_24. */
9066 default:
9067 return FALSE;
9068 }
9069 }
9070
9071 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9072 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9073
9074 static bfd_boolean
9075 is_16bit_abs_reloc (unsigned int reloc_type)
9076 {
9077 switch (elf_header.e_machine)
9078 {
9079 case EM_AVR_OLD:
9080 case EM_AVR:
9081 return reloc_type == 4; /* R_AVR_16. */
9082 case EM_CYGNUS_D10V:
9083 case EM_D10V:
9084 return reloc_type == 3; /* R_D10V_16. */
9085 case EM_H8S:
9086 case EM_H8_300:
9087 case EM_H8_300H:
9088 return reloc_type == R_H8_DIR16;
9089 case EM_IP2K_OLD:
9090 case EM_IP2K:
9091 return reloc_type == 1; /* R_IP2K_16. */
9092 case EM_M32C_OLD:
9093 case EM_M32C:
9094 return reloc_type == 1; /* R_M32C_16 */
9095 case EM_MSP430_OLD:
9096 case EM_MSP430:
9097 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9098 case EM_ALTERA_NIOS2:
9099 case EM_NIOS32:
9100 return reloc_type == 9; /* R_NIOS_16. */
9101 case EM_TI_C6000:
9102 return reloc_type == 2; /* R_C6000_ABS16. */
9103 case EM_XC16X:
9104 case EM_C166:
9105 return reloc_type == 2; /* R_XC16C_ABS_16. */
9106 default:
9107 return FALSE;
9108 }
9109 }
9110
9111 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9112 relocation entries (possibly formerly used for SHT_GROUP sections). */
9113
9114 static bfd_boolean
9115 is_none_reloc (unsigned int reloc_type)
9116 {
9117 switch (elf_header.e_machine)
9118 {
9119 case EM_68K: /* R_68K_NONE. */
9120 case EM_386: /* R_386_NONE. */
9121 case EM_SPARC32PLUS:
9122 case EM_SPARCV9:
9123 case EM_SPARC: /* R_SPARC_NONE. */
9124 case EM_MIPS: /* R_MIPS_NONE. */
9125 case EM_PARISC: /* R_PARISC_NONE. */
9126 case EM_ALPHA: /* R_ALPHA_NONE. */
9127 case EM_PPC: /* R_PPC_NONE. */
9128 case EM_PPC64: /* R_PPC64_NONE. */
9129 case EM_ARM: /* R_ARM_NONE. */
9130 case EM_IA_64: /* R_IA64_NONE. */
9131 case EM_SH: /* R_SH_NONE. */
9132 case EM_S390_OLD:
9133 case EM_S390: /* R_390_NONE. */
9134 case EM_CRIS: /* R_CRIS_NONE. */
9135 case EM_X86_64: /* R_X86_64_NONE. */
9136 case EM_L1OM: /* R_X86_64_NONE. */
9137 case EM_MN10300: /* R_MN10300_NONE. */
9138 case EM_M32R: /* R_M32R_NONE. */
9139 case EM_TI_C6000:/* R_C6000_NONE. */
9140 case EM_XC16X:
9141 case EM_C166: /* R_XC16X_NONE. */
9142 return reloc_type == 0;
9143 case EM_XTENSA_OLD:
9144 case EM_XTENSA:
9145 return (reloc_type == 0 /* R_XTENSA_NONE. */
9146 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9147 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9148 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9149 }
9150 return FALSE;
9151 }
9152
9153 /* Apply relocations to a section.
9154 Note: So far support has been added only for those relocations
9155 which can be found in debug sections.
9156 FIXME: Add support for more relocations ? */
9157
9158 static void
9159 apply_relocations (void * file,
9160 Elf_Internal_Shdr * section,
9161 unsigned char * start)
9162 {
9163 Elf_Internal_Shdr * relsec;
9164 unsigned char * end = start + section->sh_size;
9165
9166 if (elf_header.e_type != ET_REL)
9167 return;
9168
9169 /* Find the reloc section associated with the section. */
9170 for (relsec = section_headers;
9171 relsec < section_headers + elf_header.e_shnum;
9172 ++relsec)
9173 {
9174 bfd_boolean is_rela;
9175 unsigned long num_relocs;
9176 Elf_Internal_Rela * relocs;
9177 Elf_Internal_Rela * rp;
9178 Elf_Internal_Shdr * symsec;
9179 Elf_Internal_Sym * symtab;
9180 Elf_Internal_Sym * sym;
9181
9182 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9183 || relsec->sh_info >= elf_header.e_shnum
9184 || section_headers + relsec->sh_info != section
9185 || relsec->sh_size == 0
9186 || relsec->sh_link >= elf_header.e_shnum)
9187 continue;
9188
9189 is_rela = relsec->sh_type == SHT_RELA;
9190
9191 if (is_rela)
9192 {
9193 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9194 relsec->sh_size, & relocs, & num_relocs))
9195 return;
9196 }
9197 else
9198 {
9199 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9200 relsec->sh_size, & relocs, & num_relocs))
9201 return;
9202 }
9203
9204 /* SH uses RELA but uses in place value instead of the addend field. */
9205 if (elf_header.e_machine == EM_SH)
9206 is_rela = FALSE;
9207
9208 symsec = section_headers + relsec->sh_link;
9209 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9210
9211 for (rp = relocs; rp < relocs + num_relocs; ++rp)
9212 {
9213 bfd_vma addend;
9214 unsigned int reloc_type;
9215 unsigned int reloc_size;
9216 unsigned char * rloc;
9217
9218 reloc_type = get_reloc_type (rp->r_info);
9219
9220 if (target_specific_reloc_handling (rp, start, symtab))
9221 continue;
9222 else if (is_none_reloc (reloc_type))
9223 continue;
9224 else if (is_32bit_abs_reloc (reloc_type)
9225 || is_32bit_pcrel_reloc (reloc_type))
9226 reloc_size = 4;
9227 else if (is_64bit_abs_reloc (reloc_type)
9228 || is_64bit_pcrel_reloc (reloc_type))
9229 reloc_size = 8;
9230 else if (is_24bit_abs_reloc (reloc_type))
9231 reloc_size = 3;
9232 else if (is_16bit_abs_reloc (reloc_type))
9233 reloc_size = 2;
9234 else
9235 {
9236 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9237 reloc_type, SECTION_NAME (section));
9238 continue;
9239 }
9240
9241 rloc = start + rp->r_offset;
9242 if ((rloc + reloc_size) > end)
9243 {
9244 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9245 (unsigned long) rp->r_offset,
9246 SECTION_NAME (section));
9247 continue;
9248 }
9249
9250 sym = symtab + get_reloc_symindex (rp->r_info);
9251
9252 /* If the reloc has a symbol associated with it,
9253 make sure that it is of an appropriate type.
9254
9255 Relocations against symbols without type can happen.
9256 Gcc -feliminate-dwarf2-dups may generate symbols
9257 without type for debug info.
9258
9259 Icc generates relocations against function symbols
9260 instead of local labels.
9261
9262 Relocations against object symbols can happen, eg when
9263 referencing a global array. For an example of this see
9264 the _clz.o binary in libgcc.a. */
9265 if (sym != symtab
9266 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9267 {
9268 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9269 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9270 (long int)(rp - relocs),
9271 SECTION_NAME (relsec));
9272 continue;
9273 }
9274
9275 addend = 0;
9276 if (is_rela)
9277 addend += rp->r_addend;
9278 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9279 if (!is_rela
9280 || (elf_header.e_machine == EM_XTENSA
9281 && reloc_type == 1)
9282 || ((elf_header.e_machine == EM_PJ
9283 || elf_header.e_machine == EM_PJ_OLD)
9284 && reloc_type == 1))
9285 addend += byte_get (rloc, reloc_size);
9286
9287 if (is_32bit_pcrel_reloc (reloc_type)
9288 || is_64bit_pcrel_reloc (reloc_type))
9289 {
9290 /* On HPPA, all pc-relative relocations are biased by 8. */
9291 if (elf_header.e_machine == EM_PARISC)
9292 addend -= 8;
9293 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9294 reloc_size);
9295 }
9296 else
9297 byte_put (rloc, addend + sym->st_value, reloc_size);
9298 }
9299
9300 free (symtab);
9301 free (relocs);
9302 break;
9303 }
9304 }
9305
9306 #ifdef SUPPORT_DISASSEMBLY
9307 static int
9308 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9309 {
9310 printf (_("\nAssembly dump of section %s\n"),
9311 SECTION_NAME (section));
9312
9313 /* XXX -- to be done --- XXX */
9314
9315 return 1;
9316 }
9317 #endif
9318
9319 /* Reads in the contents of SECTION from FILE, returning a pointer
9320 to a malloc'ed buffer or NULL if something went wrong. */
9321
9322 static char *
9323 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9324 {
9325 bfd_size_type num_bytes;
9326
9327 num_bytes = section->sh_size;
9328
9329 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9330 {
9331 printf (_("\nSection '%s' has no data to dump.\n"),
9332 SECTION_NAME (section));
9333 return NULL;
9334 }
9335
9336 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9337 _("section contents"));
9338 }
9339
9340
9341 static void
9342 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9343 {
9344 Elf_Internal_Shdr * relsec;
9345 bfd_size_type num_bytes;
9346 char * data;
9347 char * end;
9348 char * start;
9349 char * name = SECTION_NAME (section);
9350 bfd_boolean some_strings_shown;
9351
9352 start = get_section_contents (section, file);
9353 if (start == NULL)
9354 return;
9355
9356 printf (_("\nString dump of section '%s':\n"), name);
9357
9358 /* If the section being dumped has relocations against it the user might
9359 be expecting these relocations to have been applied. Check for this
9360 case and issue a warning message in order to avoid confusion.
9361 FIXME: Maybe we ought to have an option that dumps a section with
9362 relocs applied ? */
9363 for (relsec = section_headers;
9364 relsec < section_headers + elf_header.e_shnum;
9365 ++relsec)
9366 {
9367 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9368 || relsec->sh_info >= elf_header.e_shnum
9369 || section_headers + relsec->sh_info != section
9370 || relsec->sh_size == 0
9371 || relsec->sh_link >= elf_header.e_shnum)
9372 continue;
9373
9374 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9375 break;
9376 }
9377
9378 num_bytes = section->sh_size;
9379 data = start;
9380 end = start + num_bytes;
9381 some_strings_shown = FALSE;
9382
9383 while (data < end)
9384 {
9385 while (!ISPRINT (* data))
9386 if (++ data >= end)
9387 break;
9388
9389 if (data < end)
9390 {
9391 #ifndef __MSVCRT__
9392 /* PR 11128: Use two separate invocations in order to work
9393 around bugs in the Solaris 8 implementation of printf. */
9394 printf (" [%6tx] ", data - start);
9395 printf ("%s\n", data);
9396 #else
9397 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9398 #endif
9399 data += strlen (data);
9400 some_strings_shown = TRUE;
9401 }
9402 }
9403
9404 if (! some_strings_shown)
9405 printf (_(" No strings found in this section."));
9406
9407 free (start);
9408
9409 putchar ('\n');
9410 }
9411
9412 static void
9413 dump_section_as_bytes (Elf_Internal_Shdr * section,
9414 FILE * file,
9415 bfd_boolean relocate)
9416 {
9417 Elf_Internal_Shdr * relsec;
9418 bfd_size_type bytes;
9419 bfd_vma addr;
9420 unsigned char * data;
9421 unsigned char * start;
9422
9423 start = (unsigned char *) get_section_contents (section, file);
9424 if (start == NULL)
9425 return;
9426
9427 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9428
9429 if (relocate)
9430 {
9431 apply_relocations (file, section, start);
9432 }
9433 else
9434 {
9435 /* If the section being dumped has relocations against it the user might
9436 be expecting these relocations to have been applied. Check for this
9437 case and issue a warning message in order to avoid confusion.
9438 FIXME: Maybe we ought to have an option that dumps a section with
9439 relocs applied ? */
9440 for (relsec = section_headers;
9441 relsec < section_headers + elf_header.e_shnum;
9442 ++relsec)
9443 {
9444 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9445 || relsec->sh_info >= elf_header.e_shnum
9446 || section_headers + relsec->sh_info != section
9447 || relsec->sh_size == 0
9448 || relsec->sh_link >= elf_header.e_shnum)
9449 continue;
9450
9451 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9452 break;
9453 }
9454 }
9455
9456 addr = section->sh_addr;
9457 bytes = section->sh_size;
9458 data = start;
9459
9460 while (bytes)
9461 {
9462 int j;
9463 int k;
9464 int lbytes;
9465
9466 lbytes = (bytes > 16 ? 16 : bytes);
9467
9468 printf (" 0x%8.8lx ", (unsigned long) addr);
9469
9470 for (j = 0; j < 16; j++)
9471 {
9472 if (j < lbytes)
9473 printf ("%2.2x", data[j]);
9474 else
9475 printf (" ");
9476
9477 if ((j & 3) == 3)
9478 printf (" ");
9479 }
9480
9481 for (j = 0; j < lbytes; j++)
9482 {
9483 k = data[j];
9484 if (k >= ' ' && k < 0x7f)
9485 printf ("%c", k);
9486 else
9487 printf (".");
9488 }
9489
9490 putchar ('\n');
9491
9492 data += lbytes;
9493 addr += lbytes;
9494 bytes -= lbytes;
9495 }
9496
9497 free (start);
9498
9499 putchar ('\n');
9500 }
9501
9502 /* Uncompresses a section that was compressed using zlib, in place.
9503 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9504
9505 static int
9506 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
9507 {
9508 #ifndef HAVE_ZLIB_H
9509 /* These are just to quiet gcc. */
9510 buffer = 0;
9511 size = 0;
9512 return FALSE;
9513 #else
9514 dwarf_size_type compressed_size = *size;
9515 unsigned char * compressed_buffer = *buffer;
9516 dwarf_size_type uncompressed_size;
9517 unsigned char * uncompressed_buffer;
9518 z_stream strm;
9519 int rc;
9520 dwarf_size_type header_size = 12;
9521
9522 /* Read the zlib header. In this case, it should be "ZLIB" followed
9523 by the uncompressed section size, 8 bytes in big-endian order. */
9524 if (compressed_size < header_size
9525 || ! streq ((char *) compressed_buffer, "ZLIB"))
9526 return 0;
9527
9528 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9529 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
9530 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
9531 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
9532 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
9533 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
9534 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
9535 uncompressed_size += compressed_buffer[11];
9536
9537 /* It is possible the section consists of several compressed
9538 buffers concatenated together, so we uncompress in a loop. */
9539 strm.zalloc = NULL;
9540 strm.zfree = NULL;
9541 strm.opaque = NULL;
9542 strm.avail_in = compressed_size - header_size;
9543 strm.next_in = (Bytef *) compressed_buffer + header_size;
9544 strm.avail_out = uncompressed_size;
9545 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
9546
9547 rc = inflateInit (& strm);
9548 while (strm.avail_in > 0)
9549 {
9550 if (rc != Z_OK)
9551 goto fail;
9552 strm.next_out = ((Bytef *) uncompressed_buffer
9553 + (uncompressed_size - strm.avail_out));
9554 rc = inflate (&strm, Z_FINISH);
9555 if (rc != Z_STREAM_END)
9556 goto fail;
9557 rc = inflateReset (& strm);
9558 }
9559 rc = inflateEnd (& strm);
9560 if (rc != Z_OK
9561 || strm.avail_out != 0)
9562 goto fail;
9563
9564 free (compressed_buffer);
9565 *buffer = uncompressed_buffer;
9566 *size = uncompressed_size;
9567 return 1;
9568
9569 fail:
9570 free (uncompressed_buffer);
9571 return 0;
9572 #endif /* HAVE_ZLIB_H */
9573 }
9574
9575 static int
9576 load_specific_debug_section (enum dwarf_section_display_enum debug,
9577 Elf_Internal_Shdr * sec, void * file)
9578 {
9579 struct dwarf_section * section = &debug_displays [debug].section;
9580 char buf [64];
9581 int section_is_compressed;
9582
9583 /* If it is already loaded, do nothing. */
9584 if (section->start != NULL)
9585 return 1;
9586
9587 section_is_compressed = section->name == section->compressed_name;
9588
9589 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
9590 section->address = sec->sh_addr;
9591 section->size = sec->sh_size;
9592 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
9593 sec->sh_offset, 1,
9594 sec->sh_size, buf);
9595 if (section->start == NULL)
9596 return 0;
9597
9598 if (section_is_compressed)
9599 if (! uncompress_section_contents (&section->start, &section->size))
9600 return 0;
9601
9602 if (debug_displays [debug].relocate)
9603 apply_relocations ((FILE *) file, sec, section->start);
9604
9605 return 1;
9606 }
9607
9608 int
9609 load_debug_section (enum dwarf_section_display_enum debug, void * file)
9610 {
9611 struct dwarf_section * section = &debug_displays [debug].section;
9612 Elf_Internal_Shdr * sec;
9613
9614 /* Locate the debug section. */
9615 sec = find_section (section->uncompressed_name);
9616 if (sec != NULL)
9617 section->name = section->uncompressed_name;
9618 else
9619 {
9620 sec = find_section (section->compressed_name);
9621 if (sec != NULL)
9622 section->name = section->compressed_name;
9623 }
9624 if (sec == NULL)
9625 return 0;
9626
9627 return load_specific_debug_section (debug, sec, (FILE *) file);
9628 }
9629
9630 void
9631 free_debug_section (enum dwarf_section_display_enum debug)
9632 {
9633 struct dwarf_section * section = &debug_displays [debug].section;
9634
9635 if (section->start == NULL)
9636 return;
9637
9638 free ((char *) section->start);
9639 section->start = NULL;
9640 section->address = 0;
9641 section->size = 0;
9642 }
9643
9644 static int
9645 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
9646 {
9647 char * name = SECTION_NAME (section);
9648 bfd_size_type length;
9649 int result = 1;
9650 int i;
9651
9652 length = section->sh_size;
9653 if (length == 0)
9654 {
9655 printf (_("\nSection '%s' has no debugging data.\n"), name);
9656 return 0;
9657 }
9658 if (section->sh_type == SHT_NOBITS)
9659 {
9660 /* There is no point in dumping the contents of a debugging section
9661 which has the NOBITS type - the bits in the file will be random.
9662 This can happen when a file containing a .eh_frame section is
9663 stripped with the --only-keep-debug command line option. */
9664 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
9665 return 0;
9666 }
9667
9668 if (const_strneq (name, ".gnu.linkonce.wi."))
9669 name = ".debug_info";
9670
9671 /* See if we know how to display the contents of this section. */
9672 for (i = 0; i < max; i++)
9673 if (streq (debug_displays[i].section.uncompressed_name, name)
9674 || streq (debug_displays[i].section.compressed_name, name))
9675 {
9676 struct dwarf_section * sec = &debug_displays [i].section;
9677 int secondary = (section != find_section (name));
9678
9679 if (secondary)
9680 free_debug_section ((enum dwarf_section_display_enum) i);
9681
9682 if (streq (sec->uncompressed_name, name))
9683 sec->name = sec->uncompressed_name;
9684 else
9685 sec->name = sec->compressed_name;
9686 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
9687 section, file))
9688 {
9689 result &= debug_displays[i].display (sec, file);
9690
9691 if (secondary || (i != info && i != abbrev))
9692 free_debug_section ((enum dwarf_section_display_enum) i);
9693 }
9694
9695 break;
9696 }
9697
9698 if (i == max)
9699 {
9700 printf (_("Unrecognized debug section: %s\n"), name);
9701 result = 0;
9702 }
9703
9704 return result;
9705 }
9706
9707 /* Set DUMP_SECTS for all sections where dumps were requested
9708 based on section name. */
9709
9710 static void
9711 initialise_dumps_byname (void)
9712 {
9713 struct dump_list_entry * cur;
9714
9715 for (cur = dump_sects_byname; cur; cur = cur->next)
9716 {
9717 unsigned int i;
9718 int any;
9719
9720 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
9721 if (streq (SECTION_NAME (section_headers + i), cur->name))
9722 {
9723 request_dump_bynumber (i, cur->type);
9724 any = 1;
9725 }
9726
9727 if (!any)
9728 warn (_("Section '%s' was not dumped because it does not exist!\n"),
9729 cur->name);
9730 }
9731 }
9732
9733 static void
9734 process_section_contents (FILE * file)
9735 {
9736 Elf_Internal_Shdr * section;
9737 unsigned int i;
9738
9739 if (! do_dump)
9740 return;
9741
9742 initialise_dumps_byname ();
9743
9744 for (i = 0, section = section_headers;
9745 i < elf_header.e_shnum && i < num_dump_sects;
9746 i++, section++)
9747 {
9748 #ifdef SUPPORT_DISASSEMBLY
9749 if (dump_sects[i] & DISASS_DUMP)
9750 disassemble_section (section, file);
9751 #endif
9752 if (dump_sects[i] & HEX_DUMP)
9753 dump_section_as_bytes (section, file, FALSE);
9754
9755 if (dump_sects[i] & RELOC_DUMP)
9756 dump_section_as_bytes (section, file, TRUE);
9757
9758 if (dump_sects[i] & STRING_DUMP)
9759 dump_section_as_strings (section, file);
9760
9761 if (dump_sects[i] & DEBUG_DUMP)
9762 display_debug_section (section, file);
9763 }
9764
9765 /* Check to see if the user requested a
9766 dump of a section that does not exist. */
9767 while (i++ < num_dump_sects)
9768 if (dump_sects[i])
9769 warn (_("Section %d was not dumped because it does not exist!\n"), i);
9770 }
9771
9772 static void
9773 process_mips_fpe_exception (int mask)
9774 {
9775 if (mask)
9776 {
9777 int first = 1;
9778 if (mask & OEX_FPU_INEX)
9779 fputs ("INEX", stdout), first = 0;
9780 if (mask & OEX_FPU_UFLO)
9781 printf ("%sUFLO", first ? "" : "|"), first = 0;
9782 if (mask & OEX_FPU_OFLO)
9783 printf ("%sOFLO", first ? "" : "|"), first = 0;
9784 if (mask & OEX_FPU_DIV0)
9785 printf ("%sDIV0", first ? "" : "|"), first = 0;
9786 if (mask & OEX_FPU_INVAL)
9787 printf ("%sINVAL", first ? "" : "|");
9788 }
9789 else
9790 fputs ("0", stdout);
9791 }
9792
9793 /* ARM EABI attributes section. */
9794 typedef struct
9795 {
9796 int tag;
9797 const char * name;
9798 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9799 int type;
9800 const char ** table;
9801 } arm_attr_public_tag;
9802
9803 static const char * arm_attr_tag_CPU_arch[] =
9804 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9805 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9806 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9807 static const char * arm_attr_tag_THUMB_ISA_use[] =
9808 {"No", "Thumb-1", "Thumb-2"};
9809 static const char * arm_attr_tag_FP_arch[] =
9810 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9811 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9812 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
9813 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
9814 static const char * arm_attr_tag_PCS_config[] =
9815 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9816 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9817 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
9818 {"V6", "SB", "TLS", "Unused"};
9819 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
9820 {"Absolute", "PC-relative", "SB-relative", "None"};
9821 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
9822 {"Absolute", "PC-relative", "None"};
9823 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
9824 {"None", "direct", "GOT-indirect"};
9825 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
9826 {"None", "??? 1", "2", "??? 3", "4"};
9827 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9828 static const char * arm_attr_tag_ABI_FP_denormal[] =
9829 {"Unused", "Needed", "Sign only"};
9830 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9831 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9832 static const char * arm_attr_tag_ABI_FP_number_model[] =
9833 {"Unused", "Finite", "RTABI", "IEEE 754"};
9834 static const char * arm_attr_tag_ABI_enum_size[] =
9835 {"Unused", "small", "int", "forced to int"};
9836 static const char * arm_attr_tag_ABI_HardFP_use[] =
9837 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
9838 static const char * arm_attr_tag_ABI_VFP_args[] =
9839 {"AAPCS", "VFP registers", "custom"};
9840 static const char * arm_attr_tag_ABI_WMMX_args[] =
9841 {"AAPCS", "WMMX registers", "custom"};
9842 static const char * arm_attr_tag_ABI_optimization_goals[] =
9843 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9844 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9845 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
9846 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9847 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9848 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9849 static const char * arm_attr_tag_FP_HP_extension[] =
9850 {"Not Allowed", "Allowed"};
9851 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
9852 {"None", "IEEE 754", "Alternative Format"};
9853 static const char * arm_attr_tag_MPextension_use[] =
9854 {"Not Allowed", "Allowed"};
9855 static const char * arm_attr_tag_DIV_use[] =
9856 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
9857 "Allowed in v7-A with integer division extension"};
9858 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9859 static const char * arm_attr_tag_Virtualization_use[] =
9860 {"Not Allowed", "TrustZone", "Virtualization Extensions",
9861 "TrustZone and Virtualization Extensions"};
9862 static const char * arm_attr_tag_MPextension_use_legacy[] =
9863 {"Not Allowed", "Allowed"};
9864
9865 #define LOOKUP(id, name) \
9866 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9867 static arm_attr_public_tag arm_attr_public_tags[] =
9868 {
9869 {4, "CPU_raw_name", 1, NULL},
9870 {5, "CPU_name", 1, NULL},
9871 LOOKUP(6, CPU_arch),
9872 {7, "CPU_arch_profile", 0, NULL},
9873 LOOKUP(8, ARM_ISA_use),
9874 LOOKUP(9, THUMB_ISA_use),
9875 LOOKUP(10, FP_arch),
9876 LOOKUP(11, WMMX_arch),
9877 LOOKUP(12, Advanced_SIMD_arch),
9878 LOOKUP(13, PCS_config),
9879 LOOKUP(14, ABI_PCS_R9_use),
9880 LOOKUP(15, ABI_PCS_RW_data),
9881 LOOKUP(16, ABI_PCS_RO_data),
9882 LOOKUP(17, ABI_PCS_GOT_use),
9883 LOOKUP(18, ABI_PCS_wchar_t),
9884 LOOKUP(19, ABI_FP_rounding),
9885 LOOKUP(20, ABI_FP_denormal),
9886 LOOKUP(21, ABI_FP_exceptions),
9887 LOOKUP(22, ABI_FP_user_exceptions),
9888 LOOKUP(23, ABI_FP_number_model),
9889 {24, "ABI_align_needed", 0, NULL},
9890 {25, "ABI_align_preserved", 0, NULL},
9891 LOOKUP(26, ABI_enum_size),
9892 LOOKUP(27, ABI_HardFP_use),
9893 LOOKUP(28, ABI_VFP_args),
9894 LOOKUP(29, ABI_WMMX_args),
9895 LOOKUP(30, ABI_optimization_goals),
9896 LOOKUP(31, ABI_FP_optimization_goals),
9897 {32, "compatibility", 0, NULL},
9898 LOOKUP(34, CPU_unaligned_access),
9899 LOOKUP(36, FP_HP_extension),
9900 LOOKUP(38, ABI_FP_16bit_format),
9901 LOOKUP(42, MPextension_use),
9902 LOOKUP(44, DIV_use),
9903 {64, "nodefaults", 0, NULL},
9904 {65, "also_compatible_with", 0, NULL},
9905 LOOKUP(66, T2EE_use),
9906 {67, "conformance", 1, NULL},
9907 LOOKUP(68, Virtualization_use),
9908 LOOKUP(70, MPextension_use_legacy)
9909 };
9910 #undef LOOKUP
9911
9912 static unsigned char *
9913 display_arm_attribute (unsigned char * p)
9914 {
9915 int tag;
9916 unsigned int len;
9917 int val;
9918 arm_attr_public_tag * attr;
9919 unsigned i;
9920 int type;
9921
9922 tag = read_uleb128 (p, &len);
9923 p += len;
9924 attr = NULL;
9925 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
9926 {
9927 if (arm_attr_public_tags[i].tag == tag)
9928 {
9929 attr = &arm_attr_public_tags[i];
9930 break;
9931 }
9932 }
9933
9934 if (attr)
9935 {
9936 printf (" Tag_%s: ", attr->name);
9937 switch (attr->type)
9938 {
9939 case 0:
9940 switch (tag)
9941 {
9942 case 7: /* Tag_CPU_arch_profile. */
9943 val = read_uleb128 (p, &len);
9944 p += len;
9945 switch (val)
9946 {
9947 case 0: printf (_("None\n")); break;
9948 case 'A': printf (_("Application\n")); break;
9949 case 'R': printf (_("Realtime\n")); break;
9950 case 'M': printf (_("Microcontroller\n")); break;
9951 case 'S': printf (_("Application or Realtime\n")); break;
9952 default: printf ("??? (%d)\n", val); break;
9953 }
9954 break;
9955
9956 case 24: /* Tag_align_needed. */
9957 val = read_uleb128 (p, &len);
9958 p += len;
9959 switch (val)
9960 {
9961 case 0: printf (_("None\n")); break;
9962 case 1: printf (_("8-byte\n")); break;
9963 case 2: printf (_("4-byte\n")); break;
9964 case 3: printf ("??? 3\n"); break;
9965 default:
9966 if (val <= 12)
9967 printf (_("8-byte and up to %d-byte extended\n"),
9968 1 << val);
9969 else
9970 printf ("??? (%d)\n", val);
9971 break;
9972 }
9973 break;
9974
9975 case 25: /* Tag_align_preserved. */
9976 val = read_uleb128 (p, &len);
9977 p += len;
9978 switch (val)
9979 {
9980 case 0: printf (_("None\n")); break;
9981 case 1: printf (_("8-byte, except leaf SP\n")); break;
9982 case 2: printf (_("8-byte\n")); break;
9983 case 3: printf ("??? 3\n"); break;
9984 default:
9985 if (val <= 12)
9986 printf (_("8-byte and up to %d-byte extended\n"),
9987 1 << val);
9988 else
9989 printf ("??? (%d)\n", val);
9990 break;
9991 }
9992 break;
9993
9994 case 32: /* Tag_compatibility. */
9995 val = read_uleb128 (p, &len);
9996 p += len;
9997 printf (_("flag = %d, vendor = %s\n"), val, p);
9998 p += strlen ((char *) p) + 1;
9999 break;
10000
10001 case 64: /* Tag_nodefaults. */
10002 p++;
10003 printf (_("True\n"));
10004 break;
10005
10006 case 65: /* Tag_also_compatible_with. */
10007 val = read_uleb128 (p, &len);
10008 p += len;
10009 if (val == 6 /* Tag_CPU_arch. */)
10010 {
10011 val = read_uleb128 (p, &len);
10012 p += len;
10013 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10014 printf ("??? (%d)\n", val);
10015 else
10016 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10017 }
10018 else
10019 printf ("???\n");
10020 while (*(p++) != '\0' /* NUL terminator. */);
10021 break;
10022
10023 default:
10024 abort ();
10025 }
10026 return p;
10027
10028 case 1:
10029 case 2:
10030 type = attr->type;
10031 break;
10032
10033 default:
10034 assert (attr->type & 0x80);
10035 val = read_uleb128 (p, &len);
10036 p += len;
10037 type = attr->type & 0x7f;
10038 if (val >= type)
10039 printf ("??? (%d)\n", val);
10040 else
10041 printf ("%s\n", attr->table[val]);
10042 return p;
10043 }
10044 }
10045 else
10046 {
10047 if (tag & 1)
10048 type = 1; /* String. */
10049 else
10050 type = 2; /* uleb128. */
10051 printf (" Tag_unknown_%d: ", tag);
10052 }
10053
10054 if (type == 1)
10055 {
10056 printf ("\"%s\"\n", p);
10057 p += strlen ((char *) p) + 1;
10058 }
10059 else
10060 {
10061 val = read_uleb128 (p, &len);
10062 p += len;
10063 printf ("%d (0x%x)\n", val, val);
10064 }
10065
10066 return p;
10067 }
10068
10069 static unsigned char *
10070 display_gnu_attribute (unsigned char * p,
10071 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10072 {
10073 int tag;
10074 unsigned int len;
10075 int val;
10076 int type;
10077
10078 tag = read_uleb128 (p, &len);
10079 p += len;
10080
10081 /* Tag_compatibility is the only generic GNU attribute defined at
10082 present. */
10083 if (tag == 32)
10084 {
10085 val = read_uleb128 (p, &len);
10086 p += len;
10087 printf (_("flag = %d, vendor = %s\n"), val, p);
10088 p += strlen ((char *) p) + 1;
10089 return p;
10090 }
10091
10092 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10093 return display_proc_gnu_attribute (p, tag);
10094
10095 if (tag & 1)
10096 type = 1; /* String. */
10097 else
10098 type = 2; /* uleb128. */
10099 printf (" Tag_unknown_%d: ", tag);
10100
10101 if (type == 1)
10102 {
10103 printf ("\"%s\"\n", p);
10104 p += strlen ((char *) p) + 1;
10105 }
10106 else
10107 {
10108 val = read_uleb128 (p, &len);
10109 p += len;
10110 printf ("%d (0x%x)\n", val, val);
10111 }
10112
10113 return p;
10114 }
10115
10116 static unsigned char *
10117 display_power_gnu_attribute (unsigned char * p, int tag)
10118 {
10119 int type;
10120 unsigned int len;
10121 int val;
10122
10123 if (tag == Tag_GNU_Power_ABI_FP)
10124 {
10125 val = read_uleb128 (p, &len);
10126 p += len;
10127 printf (" Tag_GNU_Power_ABI_FP: ");
10128
10129 switch (val)
10130 {
10131 case 0:
10132 printf (_("Hard or soft float\n"));
10133 break;
10134 case 1:
10135 printf (_("Hard float\n"));
10136 break;
10137 case 2:
10138 printf (_("Soft float\n"));
10139 break;
10140 case 3:
10141 printf (_("Single-precision hard float\n"));
10142 break;
10143 default:
10144 printf ("??? (%d)\n", val);
10145 break;
10146 }
10147 return p;
10148 }
10149
10150 if (tag == Tag_GNU_Power_ABI_Vector)
10151 {
10152 val = read_uleb128 (p, &len);
10153 p += len;
10154 printf (" Tag_GNU_Power_ABI_Vector: ");
10155 switch (val)
10156 {
10157 case 0:
10158 printf (_("Any\n"));
10159 break;
10160 case 1:
10161 printf (_("Generic\n"));
10162 break;
10163 case 2:
10164 printf ("AltiVec\n");
10165 break;
10166 case 3:
10167 printf ("SPE\n");
10168 break;
10169 default:
10170 printf ("??? (%d)\n", val);
10171 break;
10172 }
10173 return p;
10174 }
10175
10176 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10177 {
10178 val = read_uleb128 (p, &len);
10179 p += len;
10180 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10181 switch (val)
10182 {
10183 case 0:
10184 printf (_("Any\n"));
10185 break;
10186 case 1:
10187 printf ("r3/r4\n");
10188 break;
10189 case 2:
10190 printf (_("Memory\n"));
10191 break;
10192 default:
10193 printf ("??? (%d)\n", val);
10194 break;
10195 }
10196 return p;
10197 }
10198
10199 if (tag & 1)
10200 type = 1; /* String. */
10201 else
10202 type = 2; /* uleb128. */
10203 printf (" Tag_unknown_%d: ", tag);
10204
10205 if (type == 1)
10206 {
10207 printf ("\"%s\"\n", p);
10208 p += strlen ((char *) p) + 1;
10209 }
10210 else
10211 {
10212 val = read_uleb128 (p, &len);
10213 p += len;
10214 printf ("%d (0x%x)\n", val, val);
10215 }
10216
10217 return p;
10218 }
10219
10220 static unsigned char *
10221 display_mips_gnu_attribute (unsigned char * p, int tag)
10222 {
10223 int type;
10224 unsigned int len;
10225 int val;
10226
10227 if (tag == Tag_GNU_MIPS_ABI_FP)
10228 {
10229 val = read_uleb128 (p, &len);
10230 p += len;
10231 printf (" Tag_GNU_MIPS_ABI_FP: ");
10232
10233 switch (val)
10234 {
10235 case 0:
10236 printf (_("Hard or soft float\n"));
10237 break;
10238 case 1:
10239 printf (_("Hard float (double precision)\n"));
10240 break;
10241 case 2:
10242 printf (_("Hard float (single precision)\n"));
10243 break;
10244 case 3:
10245 printf (_("Soft float\n"));
10246 break;
10247 case 4:
10248 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10249 break;
10250 default:
10251 printf ("??? (%d)\n", val);
10252 break;
10253 }
10254 return p;
10255 }
10256
10257 if (tag & 1)
10258 type = 1; /* String. */
10259 else
10260 type = 2; /* uleb128. */
10261 printf (" Tag_unknown_%d: ", tag);
10262
10263 if (type == 1)
10264 {
10265 printf ("\"%s\"\n", p);
10266 p += strlen ((char *) p) + 1;
10267 }
10268 else
10269 {
10270 val = read_uleb128 (p, &len);
10271 p += len;
10272 printf ("%d (0x%x)\n", val, val);
10273 }
10274
10275 return p;
10276 }
10277
10278 static int
10279 process_attributes (FILE * file,
10280 const char * public_name,
10281 unsigned int proc_type,
10282 unsigned char * (* display_pub_attribute) (unsigned char *),
10283 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10284 {
10285 Elf_Internal_Shdr * sect;
10286 unsigned char * contents;
10287 unsigned char * p;
10288 unsigned char * end;
10289 bfd_vma section_len;
10290 bfd_vma len;
10291 unsigned i;
10292
10293 /* Find the section header so that we get the size. */
10294 for (i = 0, sect = section_headers;
10295 i < elf_header.e_shnum;
10296 i++, sect++)
10297 {
10298 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
10299 continue;
10300
10301 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10302 sect->sh_size, _("attributes"));
10303 if (contents == NULL)
10304 continue;
10305
10306 p = contents;
10307 if (*p == 'A')
10308 {
10309 len = sect->sh_size - 1;
10310 p++;
10311
10312 while (len > 0)
10313 {
10314 int namelen;
10315 bfd_boolean public_section;
10316 bfd_boolean gnu_section;
10317
10318 section_len = byte_get (p, 4);
10319 p += 4;
10320
10321 if (section_len > len)
10322 {
10323 printf (_("ERROR: Bad section length (%d > %d)\n"),
10324 (int) section_len, (int) len);
10325 section_len = len;
10326 }
10327
10328 len -= section_len;
10329 printf (_("Attribute Section: %s\n"), p);
10330
10331 if (public_name && streq ((char *) p, public_name))
10332 public_section = TRUE;
10333 else
10334 public_section = FALSE;
10335
10336 if (streq ((char *) p, "gnu"))
10337 gnu_section = TRUE;
10338 else
10339 gnu_section = FALSE;
10340
10341 namelen = strlen ((char *) p) + 1;
10342 p += namelen;
10343 section_len -= namelen + 4;
10344
10345 while (section_len > 0)
10346 {
10347 int tag = *(p++);
10348 int val;
10349 bfd_vma size;
10350
10351 size = byte_get (p, 4);
10352 if (size > section_len)
10353 {
10354 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10355 (int) size, (int) section_len);
10356 size = section_len;
10357 }
10358
10359 section_len -= size;
10360 end = p + size - 1;
10361 p += 4;
10362
10363 switch (tag)
10364 {
10365 case 1:
10366 printf (_("File Attributes\n"));
10367 break;
10368 case 2:
10369 printf (_("Section Attributes:"));
10370 goto do_numlist;
10371 case 3:
10372 printf (_("Symbol Attributes:"));
10373 do_numlist:
10374 for (;;)
10375 {
10376 unsigned int j;
10377
10378 val = read_uleb128 (p, &j);
10379 p += j;
10380 if (val == 0)
10381 break;
10382 printf (" %d", val);
10383 }
10384 printf ("\n");
10385 break;
10386 default:
10387 printf (_("Unknown tag: %d\n"), tag);
10388 public_section = FALSE;
10389 break;
10390 }
10391
10392 if (public_section)
10393 {
10394 while (p < end)
10395 p = display_pub_attribute (p);
10396 }
10397 else if (gnu_section)
10398 {
10399 while (p < end)
10400 p = display_gnu_attribute (p,
10401 display_proc_gnu_attribute);
10402 }
10403 else
10404 {
10405 /* ??? Do something sensible, like dump hex. */
10406 printf (_(" Unknown section contexts\n"));
10407 p = end;
10408 }
10409 }
10410 }
10411 }
10412 else
10413 printf (_("Unknown format '%c'\n"), *p);
10414
10415 free (contents);
10416 }
10417 return 1;
10418 }
10419
10420 static int
10421 process_arm_specific (FILE * file)
10422 {
10423 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
10424 display_arm_attribute, NULL);
10425 }
10426
10427 static int
10428 process_power_specific (FILE * file)
10429 {
10430 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10431 display_power_gnu_attribute);
10432 }
10433
10434 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10435 Print the Address, Access and Initial fields of an entry at VMA ADDR
10436 and return the VMA of the next entry. */
10437
10438 static bfd_vma
10439 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10440 {
10441 printf (" ");
10442 print_vma (addr, LONG_HEX);
10443 printf (" ");
10444 if (addr < pltgot + 0xfff0)
10445 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
10446 else
10447 printf ("%10s", "");
10448 printf (" ");
10449 if (data == NULL)
10450 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
10451 else
10452 {
10453 bfd_vma entry;
10454
10455 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10456 print_vma (entry, LONG_HEX);
10457 }
10458 return addr + (is_32bit_elf ? 4 : 8);
10459 }
10460
10461 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10462 PLTGOT. Print the Address and Initial fields of an entry at VMA
10463 ADDR and return the VMA of the next entry. */
10464
10465 static bfd_vma
10466 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10467 {
10468 printf (" ");
10469 print_vma (addr, LONG_HEX);
10470 printf (" ");
10471 if (data == NULL)
10472 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
10473 else
10474 {
10475 bfd_vma entry;
10476
10477 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
10478 print_vma (entry, LONG_HEX);
10479 }
10480 return addr + (is_32bit_elf ? 4 : 8);
10481 }
10482
10483 static int
10484 process_mips_specific (FILE * file)
10485 {
10486 Elf_Internal_Dyn * entry;
10487 size_t liblist_offset = 0;
10488 size_t liblistno = 0;
10489 size_t conflictsno = 0;
10490 size_t options_offset = 0;
10491 size_t conflicts_offset = 0;
10492 size_t pltrelsz = 0;
10493 size_t pltrel = 0;
10494 bfd_vma pltgot = 0;
10495 bfd_vma mips_pltgot = 0;
10496 bfd_vma jmprel = 0;
10497 bfd_vma local_gotno = 0;
10498 bfd_vma gotsym = 0;
10499 bfd_vma symtabno = 0;
10500
10501 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10502 display_mips_gnu_attribute);
10503
10504 /* We have a lot of special sections. Thanks SGI! */
10505 if (dynamic_section == NULL)
10506 /* No information available. */
10507 return 0;
10508
10509 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
10510 switch (entry->d_tag)
10511 {
10512 case DT_MIPS_LIBLIST:
10513 liblist_offset
10514 = offset_from_vma (file, entry->d_un.d_val,
10515 liblistno * sizeof (Elf32_External_Lib));
10516 break;
10517 case DT_MIPS_LIBLISTNO:
10518 liblistno = entry->d_un.d_val;
10519 break;
10520 case DT_MIPS_OPTIONS:
10521 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
10522 break;
10523 case DT_MIPS_CONFLICT:
10524 conflicts_offset
10525 = offset_from_vma (file, entry->d_un.d_val,
10526 conflictsno * sizeof (Elf32_External_Conflict));
10527 break;
10528 case DT_MIPS_CONFLICTNO:
10529 conflictsno = entry->d_un.d_val;
10530 break;
10531 case DT_PLTGOT:
10532 pltgot = entry->d_un.d_ptr;
10533 break;
10534 case DT_MIPS_LOCAL_GOTNO:
10535 local_gotno = entry->d_un.d_val;
10536 break;
10537 case DT_MIPS_GOTSYM:
10538 gotsym = entry->d_un.d_val;
10539 break;
10540 case DT_MIPS_SYMTABNO:
10541 symtabno = entry->d_un.d_val;
10542 break;
10543 case DT_MIPS_PLTGOT:
10544 mips_pltgot = entry->d_un.d_ptr;
10545 break;
10546 case DT_PLTREL:
10547 pltrel = entry->d_un.d_val;
10548 break;
10549 case DT_PLTRELSZ:
10550 pltrelsz = entry->d_un.d_val;
10551 break;
10552 case DT_JMPREL:
10553 jmprel = entry->d_un.d_ptr;
10554 break;
10555 default:
10556 break;
10557 }
10558
10559 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
10560 {
10561 Elf32_External_Lib * elib;
10562 size_t cnt;
10563
10564 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
10565 liblistno,
10566 sizeof (Elf32_External_Lib),
10567 _("liblist"));
10568 if (elib)
10569 {
10570 printf (_("\nSection '.liblist' contains %lu entries:\n"),
10571 (unsigned long) liblistno);
10572 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
10573 stdout);
10574
10575 for (cnt = 0; cnt < liblistno; ++cnt)
10576 {
10577 Elf32_Lib liblist;
10578 time_t atime;
10579 char timebuf[20];
10580 struct tm * tmp;
10581
10582 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10583 atime = BYTE_GET (elib[cnt].l_time_stamp);
10584 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10585 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10586 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10587
10588 tmp = gmtime (&atime);
10589 snprintf (timebuf, sizeof (timebuf),
10590 "%04u-%02u-%02uT%02u:%02u:%02u",
10591 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10592 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10593
10594 printf ("%3lu: ", (unsigned long) cnt);
10595 if (VALID_DYNAMIC_NAME (liblist.l_name))
10596 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
10597 else
10598 printf (_("<corrupt: %9ld>"), liblist.l_name);
10599 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
10600 liblist.l_version);
10601
10602 if (liblist.l_flags == 0)
10603 puts (_(" NONE"));
10604 else
10605 {
10606 static const struct
10607 {
10608 const char * name;
10609 int bit;
10610 }
10611 l_flags_vals[] =
10612 {
10613 { " EXACT_MATCH", LL_EXACT_MATCH },
10614 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
10615 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
10616 { " EXPORTS", LL_EXPORTS },
10617 { " DELAY_LOAD", LL_DELAY_LOAD },
10618 { " DELTA", LL_DELTA }
10619 };
10620 int flags = liblist.l_flags;
10621 size_t fcnt;
10622
10623 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
10624 if ((flags & l_flags_vals[fcnt].bit) != 0)
10625 {
10626 fputs (l_flags_vals[fcnt].name, stdout);
10627 flags ^= l_flags_vals[fcnt].bit;
10628 }
10629 if (flags != 0)
10630 printf (" %#x", (unsigned int) flags);
10631
10632 puts ("");
10633 }
10634 }
10635
10636 free (elib);
10637 }
10638 }
10639
10640 if (options_offset != 0)
10641 {
10642 Elf_External_Options * eopt;
10643 Elf_Internal_Shdr * sect = section_headers;
10644 Elf_Internal_Options * iopt;
10645 Elf_Internal_Options * option;
10646 size_t offset;
10647 int cnt;
10648
10649 /* Find the section header so that we get the size. */
10650 while (sect->sh_type != SHT_MIPS_OPTIONS)
10651 ++sect;
10652
10653 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
10654 sect->sh_size, _("options"));
10655 if (eopt)
10656 {
10657 iopt = (Elf_Internal_Options *)
10658 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
10659 if (iopt == NULL)
10660 {
10661 error (_("Out of memory\n"));
10662 return 0;
10663 }
10664
10665 offset = cnt = 0;
10666 option = iopt;
10667
10668 while (offset < sect->sh_size)
10669 {
10670 Elf_External_Options * eoption;
10671
10672 eoption = (Elf_External_Options *) ((char *) eopt + offset);
10673
10674 option->kind = BYTE_GET (eoption->kind);
10675 option->size = BYTE_GET (eoption->size);
10676 option->section = BYTE_GET (eoption->section);
10677 option->info = BYTE_GET (eoption->info);
10678
10679 offset += option->size;
10680
10681 ++option;
10682 ++cnt;
10683 }
10684
10685 printf (_("\nSection '%s' contains %d entries:\n"),
10686 SECTION_NAME (sect), cnt);
10687
10688 option = iopt;
10689
10690 while (cnt-- > 0)
10691 {
10692 size_t len;
10693
10694 switch (option->kind)
10695 {
10696 case ODK_NULL:
10697 /* This shouldn't happen. */
10698 printf (" NULL %d %lx", option->section, option->info);
10699 break;
10700 case ODK_REGINFO:
10701 printf (" REGINFO ");
10702 if (elf_header.e_machine == EM_MIPS)
10703 {
10704 /* 32bit form. */
10705 Elf32_External_RegInfo * ereg;
10706 Elf32_RegInfo reginfo;
10707
10708 ereg = (Elf32_External_RegInfo *) (option + 1);
10709 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10710 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10711 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10712 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10713 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10714 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10715
10716 printf ("GPR %08lx GP 0x%lx\n",
10717 reginfo.ri_gprmask,
10718 (unsigned long) reginfo.ri_gp_value);
10719 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10720 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10721 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10722 }
10723 else
10724 {
10725 /* 64 bit form. */
10726 Elf64_External_RegInfo * ereg;
10727 Elf64_Internal_RegInfo reginfo;
10728
10729 ereg = (Elf64_External_RegInfo *) (option + 1);
10730 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
10731 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
10732 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
10733 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
10734 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
10735 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
10736
10737 printf ("GPR %08lx GP 0x",
10738 reginfo.ri_gprmask);
10739 printf_vma (reginfo.ri_gp_value);
10740 printf ("\n");
10741
10742 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10743 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
10744 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
10745 }
10746 ++option;
10747 continue;
10748 case ODK_EXCEPTIONS:
10749 fputs (" EXCEPTIONS fpe_min(", stdout);
10750 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
10751 fputs (") fpe_max(", stdout);
10752 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
10753 fputs (")", stdout);
10754
10755 if (option->info & OEX_PAGE0)
10756 fputs (" PAGE0", stdout);
10757 if (option->info & OEX_SMM)
10758 fputs (" SMM", stdout);
10759 if (option->info & OEX_FPDBUG)
10760 fputs (" FPDBUG", stdout);
10761 if (option->info & OEX_DISMISS)
10762 fputs (" DISMISS", stdout);
10763 break;
10764 case ODK_PAD:
10765 fputs (" PAD ", stdout);
10766 if (option->info & OPAD_PREFIX)
10767 fputs (" PREFIX", stdout);
10768 if (option->info & OPAD_POSTFIX)
10769 fputs (" POSTFIX", stdout);
10770 if (option->info & OPAD_SYMBOL)
10771 fputs (" SYMBOL", stdout);
10772 break;
10773 case ODK_HWPATCH:
10774 fputs (" HWPATCH ", stdout);
10775 if (option->info & OHW_R4KEOP)
10776 fputs (" R4KEOP", stdout);
10777 if (option->info & OHW_R8KPFETCH)
10778 fputs (" R8KPFETCH", stdout);
10779 if (option->info & OHW_R5KEOP)
10780 fputs (" R5KEOP", stdout);
10781 if (option->info & OHW_R5KCVTL)
10782 fputs (" R5KCVTL", stdout);
10783 break;
10784 case ODK_FILL:
10785 fputs (" FILL ", stdout);
10786 /* XXX Print content of info word? */
10787 break;
10788 case ODK_TAGS:
10789 fputs (" TAGS ", stdout);
10790 /* XXX Print content of info word? */
10791 break;
10792 case ODK_HWAND:
10793 fputs (" HWAND ", stdout);
10794 if (option->info & OHWA0_R4KEOP_CHECKED)
10795 fputs (" R4KEOP_CHECKED", stdout);
10796 if (option->info & OHWA0_R4KEOP_CLEAN)
10797 fputs (" R4KEOP_CLEAN", stdout);
10798 break;
10799 case ODK_HWOR:
10800 fputs (" HWOR ", stdout);
10801 if (option->info & OHWA0_R4KEOP_CHECKED)
10802 fputs (" R4KEOP_CHECKED", stdout);
10803 if (option->info & OHWA0_R4KEOP_CLEAN)
10804 fputs (" R4KEOP_CLEAN", stdout);
10805 break;
10806 case ODK_GP_GROUP:
10807 printf (" GP_GROUP %#06lx self-contained %#06lx",
10808 option->info & OGP_GROUP,
10809 (option->info & OGP_SELF) >> 16);
10810 break;
10811 case ODK_IDENT:
10812 printf (" IDENT %#06lx self-contained %#06lx",
10813 option->info & OGP_GROUP,
10814 (option->info & OGP_SELF) >> 16);
10815 break;
10816 default:
10817 /* This shouldn't happen. */
10818 printf (" %3d ??? %d %lx",
10819 option->kind, option->section, option->info);
10820 break;
10821 }
10822
10823 len = sizeof (* eopt);
10824 while (len < option->size)
10825 if (((char *) option)[len] >= ' '
10826 && ((char *) option)[len] < 0x7f)
10827 printf ("%c", ((char *) option)[len++]);
10828 else
10829 printf ("\\%03o", ((char *) option)[len++]);
10830
10831 fputs ("\n", stdout);
10832 ++option;
10833 }
10834
10835 free (eopt);
10836 }
10837 }
10838
10839 if (conflicts_offset != 0 && conflictsno != 0)
10840 {
10841 Elf32_Conflict * iconf;
10842 size_t cnt;
10843
10844 if (dynamic_symbols == NULL)
10845 {
10846 error (_("conflict list found without a dynamic symbol table\n"));
10847 return 0;
10848 }
10849
10850 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
10851 if (iconf == NULL)
10852 {
10853 error (_("Out of memory\n"));
10854 return 0;
10855 }
10856
10857 if (is_32bit_elf)
10858 {
10859 Elf32_External_Conflict * econf32;
10860
10861 econf32 = (Elf32_External_Conflict *)
10862 get_data (NULL, file, conflicts_offset, conflictsno,
10863 sizeof (* econf32), _("conflict"));
10864 if (!econf32)
10865 return 0;
10866
10867 for (cnt = 0; cnt < conflictsno; ++cnt)
10868 iconf[cnt] = BYTE_GET (econf32[cnt]);
10869
10870 free (econf32);
10871 }
10872 else
10873 {
10874 Elf64_External_Conflict * econf64;
10875
10876 econf64 = (Elf64_External_Conflict *)
10877 get_data (NULL, file, conflicts_offset, conflictsno,
10878 sizeof (* econf64), _("conflict"));
10879 if (!econf64)
10880 return 0;
10881
10882 for (cnt = 0; cnt < conflictsno; ++cnt)
10883 iconf[cnt] = BYTE_GET (econf64[cnt]);
10884
10885 free (econf64);
10886 }
10887
10888 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10889 (unsigned long) conflictsno);
10890 puts (_(" Num: Index Value Name"));
10891
10892 for (cnt = 0; cnt < conflictsno; ++cnt)
10893 {
10894 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
10895
10896 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
10897 print_vma (psym->st_value, FULL_HEX);
10898 putchar (' ');
10899 if (VALID_DYNAMIC_NAME (psym->st_name))
10900 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10901 else
10902 printf (_("<corrupt: %14ld>"), psym->st_name);
10903 putchar ('\n');
10904 }
10905
10906 free (iconf);
10907 }
10908
10909 if (pltgot != 0 && local_gotno != 0)
10910 {
10911 bfd_vma ent, local_end, global_end;
10912 size_t i, offset;
10913 unsigned char * data;
10914 int addr_size;
10915
10916 ent = pltgot;
10917 addr_size = (is_32bit_elf ? 4 : 8);
10918 local_end = pltgot + local_gotno * addr_size;
10919 global_end = local_end + (symtabno - gotsym) * addr_size;
10920
10921 offset = offset_from_vma (file, pltgot, global_end - pltgot);
10922 data = (unsigned char *) get_data (NULL, file, offset,
10923 global_end - pltgot, 1, _("GOT"));
10924 printf (_("\nPrimary GOT:\n"));
10925 printf (_(" Canonical gp value: "));
10926 print_vma (pltgot + 0x7ff0, LONG_HEX);
10927 printf ("\n\n");
10928
10929 printf (_(" Reserved entries:\n"));
10930 printf (_(" %*s %10s %*s Purpose\n"),
10931 addr_size * 2, _("Address"), _("Access"),
10932 addr_size * 2, _("Initial"));
10933 ent = print_mips_got_entry (data, pltgot, ent);
10934 printf (_(" Lazy resolver\n"));
10935 if (data
10936 && (byte_get (data + ent - pltgot, addr_size)
10937 >> (addr_size * 8 - 1)) != 0)
10938 {
10939 ent = print_mips_got_entry (data, pltgot, ent);
10940 printf (_(" Module pointer (GNU extension)\n"));
10941 }
10942 printf ("\n");
10943
10944 if (ent < local_end)
10945 {
10946 printf (_(" Local entries:\n"));
10947 printf (_(" %*s %10s %*s\n"),
10948 addr_size * 2, _("Address"), _("Access"),
10949 addr_size * 2, _("Initial"));
10950 while (ent < local_end)
10951 {
10952 ent = print_mips_got_entry (data, pltgot, ent);
10953 printf ("\n");
10954 }
10955 printf ("\n");
10956 }
10957
10958 if (gotsym < symtabno)
10959 {
10960 int sym_width;
10961
10962 printf (_(" Global entries:\n"));
10963 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10964 addr_size * 2, _("Address"), _("Access"),
10965 addr_size * 2, _("Initial"),
10966 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
10967 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10968 for (i = gotsym; i < symtabno; i++)
10969 {
10970 Elf_Internal_Sym * psym;
10971
10972 psym = dynamic_symbols + i;
10973 ent = print_mips_got_entry (data, pltgot, ent);
10974 printf (" ");
10975 print_vma (psym->st_value, LONG_HEX);
10976 printf (" %-7s %3s ",
10977 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10978 get_symbol_index_type (psym->st_shndx));
10979 if (VALID_DYNAMIC_NAME (psym->st_name))
10980 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10981 else
10982 printf (_("<corrupt: %14ld>"), psym->st_name);
10983 printf ("\n");
10984 }
10985 printf ("\n");
10986 }
10987
10988 if (data)
10989 free (data);
10990 }
10991
10992 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
10993 {
10994 bfd_vma ent, end;
10995 size_t offset, rel_offset;
10996 unsigned long count, i;
10997 unsigned char * data;
10998 int addr_size, sym_width;
10999 Elf_Internal_Rela * rels;
11000
11001 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11002 if (pltrel == DT_RELA)
11003 {
11004 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11005 return 0;
11006 }
11007 else
11008 {
11009 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11010 return 0;
11011 }
11012
11013 ent = mips_pltgot;
11014 addr_size = (is_32bit_elf ? 4 : 8);
11015 end = mips_pltgot + (2 + count) * addr_size;
11016
11017 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11018 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11019 1, _("PLT GOT"));
11020 printf (_("\nPLT GOT:\n\n"));
11021 printf (_(" Reserved entries:\n"));
11022 printf (_(" %*s %*s Purpose\n"),
11023 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11024 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11025 printf (_(" PLT lazy resolver\n"));
11026 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11027 printf (_(" Module pointer\n"));
11028 printf ("\n");
11029
11030 printf (_(" Entries:\n"));
11031 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11032 addr_size * 2, _("Address"),
11033 addr_size * 2, _("Initial"),
11034 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11035 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11036 for (i = 0; i < count; i++)
11037 {
11038 Elf_Internal_Sym * psym;
11039
11040 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11041 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11042 printf (" ");
11043 print_vma (psym->st_value, LONG_HEX);
11044 printf (" %-7s %3s ",
11045 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11046 get_symbol_index_type (psym->st_shndx));
11047 if (VALID_DYNAMIC_NAME (psym->st_name))
11048 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11049 else
11050 printf (_("<corrupt: %14ld>"), psym->st_name);
11051 printf ("\n");
11052 }
11053 printf ("\n");
11054
11055 if (data)
11056 free (data);
11057 free (rels);
11058 }
11059
11060 return 1;
11061 }
11062
11063 static int
11064 process_gnu_liblist (FILE * file)
11065 {
11066 Elf_Internal_Shdr * section;
11067 Elf_Internal_Shdr * string_sec;
11068 Elf32_External_Lib * elib;
11069 char * strtab;
11070 size_t strtab_size;
11071 size_t cnt;
11072 unsigned i;
11073
11074 if (! do_arch)
11075 return 0;
11076
11077 for (i = 0, section = section_headers;
11078 i < elf_header.e_shnum;
11079 i++, section++)
11080 {
11081 switch (section->sh_type)
11082 {
11083 case SHT_GNU_LIBLIST:
11084 if (section->sh_link >= elf_header.e_shnum)
11085 break;
11086
11087 elib = (Elf32_External_Lib *)
11088 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11089 _("liblist"));
11090
11091 if (elib == NULL)
11092 break;
11093 string_sec = section_headers + section->sh_link;
11094
11095 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11096 string_sec->sh_size,
11097 _("liblist string table"));
11098 strtab_size = string_sec->sh_size;
11099
11100 if (strtab == NULL
11101 || section->sh_entsize != sizeof (Elf32_External_Lib))
11102 {
11103 free (elib);
11104 break;
11105 }
11106
11107 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11108 SECTION_NAME (section),
11109 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11110
11111 puts (_(" Library Time Stamp Checksum Version Flags"));
11112
11113 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11114 ++cnt)
11115 {
11116 Elf32_Lib liblist;
11117 time_t atime;
11118 char timebuf[20];
11119 struct tm * tmp;
11120
11121 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11122 atime = BYTE_GET (elib[cnt].l_time_stamp);
11123 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11124 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11125 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11126
11127 tmp = gmtime (&atime);
11128 snprintf (timebuf, sizeof (timebuf),
11129 "%04u-%02u-%02uT%02u:%02u:%02u",
11130 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11131 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11132
11133 printf ("%3lu: ", (unsigned long) cnt);
11134 if (do_wide)
11135 printf ("%-20s", liblist.l_name < strtab_size
11136 ? strtab + liblist.l_name : _("<corrupt>"));
11137 else
11138 printf ("%-20.20s", liblist.l_name < strtab_size
11139 ? strtab + liblist.l_name : _("<corrupt>"));
11140 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11141 liblist.l_version, liblist.l_flags);
11142 }
11143
11144 free (elib);
11145 }
11146 }
11147
11148 return 1;
11149 }
11150
11151 static const char *
11152 get_note_type (unsigned e_type)
11153 {
11154 static char buff[64];
11155
11156 if (elf_header.e_type == ET_CORE)
11157 switch (e_type)
11158 {
11159 case NT_AUXV:
11160 return _("NT_AUXV (auxiliary vector)");
11161 case NT_PRSTATUS:
11162 return _("NT_PRSTATUS (prstatus structure)");
11163 case NT_FPREGSET:
11164 return _("NT_FPREGSET (floating point registers)");
11165 case NT_PRPSINFO:
11166 return _("NT_PRPSINFO (prpsinfo structure)");
11167 case NT_TASKSTRUCT:
11168 return _("NT_TASKSTRUCT (task structure)");
11169 case NT_PRXFPREG:
11170 return _("NT_PRXFPREG (user_xfpregs structure)");
11171 case NT_PPC_VMX:
11172 return _("NT_PPC_VMX (ppc Altivec registers)");
11173 case NT_PPC_VSX:
11174 return _("NT_PPC_VSX (ppc VSX registers)");
11175 case NT_X86_XSTATE:
11176 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11177 case NT_S390_HIGH_GPRS:
11178 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11179 case NT_S390_TIMER:
11180 return _("NT_S390_TIMER (s390 timer register)");
11181 case NT_S390_TODCMP:
11182 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11183 case NT_S390_TODPREG:
11184 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11185 case NT_S390_CTRS:
11186 return _("NT_S390_CTRS (s390 control registers)");
11187 case NT_S390_PREFIX:
11188 return _("NT_S390_PREFIX (s390 prefix register)");
11189 case NT_PSTATUS:
11190 return _("NT_PSTATUS (pstatus structure)");
11191 case NT_FPREGS:
11192 return _("NT_FPREGS (floating point registers)");
11193 case NT_PSINFO:
11194 return _("NT_PSINFO (psinfo structure)");
11195 case NT_LWPSTATUS:
11196 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11197 case NT_LWPSINFO:
11198 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11199 case NT_WIN32PSTATUS:
11200 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11201 default:
11202 break;
11203 }
11204 else
11205 switch (e_type)
11206 {
11207 case NT_VERSION:
11208 return _("NT_VERSION (version)");
11209 case NT_ARCH:
11210 return _("NT_ARCH (architecture)");
11211 default:
11212 break;
11213 }
11214
11215 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11216 return buff;
11217 }
11218
11219 static const char *
11220 get_gnu_elf_note_type (unsigned e_type)
11221 {
11222 static char buff[64];
11223
11224 switch (e_type)
11225 {
11226 case NT_GNU_ABI_TAG:
11227 return _("NT_GNU_ABI_TAG (ABI version tag)");
11228 case NT_GNU_HWCAP:
11229 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11230 case NT_GNU_BUILD_ID:
11231 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11232 case NT_GNU_GOLD_VERSION:
11233 return _("NT_GNU_GOLD_VERSION (gold version)");
11234 default:
11235 break;
11236 }
11237
11238 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11239 return buff;
11240 }
11241
11242 static const char *
11243 get_netbsd_elfcore_note_type (unsigned e_type)
11244 {
11245 static char buff[64];
11246
11247 if (e_type == NT_NETBSDCORE_PROCINFO)
11248 {
11249 /* NetBSD core "procinfo" structure. */
11250 return _("NetBSD procinfo structure");
11251 }
11252
11253 /* As of Jan 2002 there are no other machine-independent notes
11254 defined for NetBSD core files. If the note type is less
11255 than the start of the machine-dependent note types, we don't
11256 understand it. */
11257
11258 if (e_type < NT_NETBSDCORE_FIRSTMACH)
11259 {
11260 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11261 return buff;
11262 }
11263
11264 switch (elf_header.e_machine)
11265 {
11266 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11267 and PT_GETFPREGS == mach+2. */
11268
11269 case EM_OLD_ALPHA:
11270 case EM_ALPHA:
11271 case EM_SPARC:
11272 case EM_SPARC32PLUS:
11273 case EM_SPARCV9:
11274 switch (e_type)
11275 {
11276 case NT_NETBSDCORE_FIRSTMACH + 0:
11277 return _("PT_GETREGS (reg structure)");
11278 case NT_NETBSDCORE_FIRSTMACH + 2:
11279 return _("PT_GETFPREGS (fpreg structure)");
11280 default:
11281 break;
11282 }
11283 break;
11284
11285 /* On all other arch's, PT_GETREGS == mach+1 and
11286 PT_GETFPREGS == mach+3. */
11287 default:
11288 switch (e_type)
11289 {
11290 case NT_NETBSDCORE_FIRSTMACH + 1:
11291 return _("PT_GETREGS (reg structure)");
11292 case NT_NETBSDCORE_FIRSTMACH + 3:
11293 return _("PT_GETFPREGS (fpreg structure)");
11294 default:
11295 break;
11296 }
11297 }
11298
11299 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11300 e_type - NT_NETBSDCORE_FIRSTMACH);
11301 return buff;
11302 }
11303
11304 /* Note that by the ELF standard, the name field is already null byte
11305 terminated, and namesz includes the terminating null byte.
11306 I.E. the value of namesz for the name "FSF" is 4.
11307
11308 If the value of namesz is zero, there is no name present. */
11309 static int
11310 process_note (Elf_Internal_Note * pnote)
11311 {
11312 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11313 const char * nt;
11314
11315 if (pnote->namesz == 0)
11316 /* If there is no note name, then use the default set of
11317 note type strings. */
11318 nt = get_note_type (pnote->type);
11319
11320 else if (const_strneq (pnote->namedata, "GNU"))
11321 /* GNU-specific object file notes. */
11322 nt = get_gnu_elf_note_type (pnote->type);
11323
11324 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
11325 /* NetBSD-specific core file notes. */
11326 nt = get_netbsd_elfcore_note_type (pnote->type);
11327
11328 else if (strneq (pnote->namedata, "SPU/", 4))
11329 {
11330 /* SPU-specific core file notes. */
11331 nt = pnote->namedata + 4;
11332 name = "SPU";
11333 }
11334
11335 else
11336 /* Don't recognize this note name; just use the default set of
11337 note type strings. */
11338 nt = get_note_type (pnote->type);
11339
11340 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
11341 return 1;
11342 }
11343
11344
11345 static int
11346 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
11347 {
11348 Elf_External_Note * pnotes;
11349 Elf_External_Note * external;
11350 int res = 1;
11351
11352 if (length <= 0)
11353 return 0;
11354
11355 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
11356 _("notes"));
11357 if (!pnotes)
11358 return 0;
11359
11360 external = pnotes;
11361
11362 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11363 (unsigned long) offset, (unsigned long) length);
11364 printf (_(" Owner\t\tData size\tDescription\n"));
11365
11366 while (external < (Elf_External_Note *) ((char *) pnotes + length))
11367 {
11368 Elf_External_Note * next;
11369 Elf_Internal_Note inote;
11370 char * temp = NULL;
11371
11372 inote.type = BYTE_GET (external->type);
11373 inote.namesz = BYTE_GET (external->namesz);
11374 inote.namedata = external->name;
11375 inote.descsz = BYTE_GET (external->descsz);
11376 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11377 inote.descpos = offset + (inote.descdata - (char *) pnotes);
11378
11379 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
11380
11381 if (((char *) next) > (((char *) pnotes) + length))
11382 {
11383 warn (_("corrupt note found at offset %lx into core notes\n"),
11384 (unsigned long) ((char *) external - (char *) pnotes));
11385 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11386 inote.type, inote.namesz, inote.descsz);
11387 break;
11388 }
11389
11390 external = next;
11391
11392 /* Verify that name is null terminated. It appears that at least
11393 one version of Linux (RedHat 6.0) generates corefiles that don't
11394 comply with the ELF spec by failing to include the null byte in
11395 namesz. */
11396 if (inote.namedata[inote.namesz] != '\0')
11397 {
11398 temp = (char *) malloc (inote.namesz + 1);
11399
11400 if (temp == NULL)
11401 {
11402 error (_("Out of memory\n"));
11403 res = 0;
11404 break;
11405 }
11406
11407 strncpy (temp, inote.namedata, inote.namesz);
11408 temp[inote.namesz] = 0;
11409
11410 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11411 inote.namedata = temp;
11412 }
11413
11414 res &= process_note (& inote);
11415
11416 if (temp != NULL)
11417 {
11418 free (temp);
11419 temp = NULL;
11420 }
11421 }
11422
11423 free (pnotes);
11424
11425 return res;
11426 }
11427
11428 static int
11429 process_corefile_note_segments (FILE * file)
11430 {
11431 Elf_Internal_Phdr * segment;
11432 unsigned int i;
11433 int res = 1;
11434
11435 if (! get_program_headers (file))
11436 return 0;
11437
11438 for (i = 0, segment = program_headers;
11439 i < elf_header.e_phnum;
11440 i++, segment++)
11441 {
11442 if (segment->p_type == PT_NOTE)
11443 res &= process_corefile_note_segment (file,
11444 (bfd_vma) segment->p_offset,
11445 (bfd_vma) segment->p_filesz);
11446 }
11447
11448 return res;
11449 }
11450
11451 static int
11452 process_note_sections (FILE * file)
11453 {
11454 Elf_Internal_Shdr * section;
11455 unsigned long i;
11456 int res = 1;
11457
11458 for (i = 0, section = section_headers;
11459 i < elf_header.e_shnum;
11460 i++, section++)
11461 if (section->sh_type == SHT_NOTE)
11462 res &= process_corefile_note_segment (file,
11463 (bfd_vma) section->sh_offset,
11464 (bfd_vma) section->sh_size);
11465
11466 return res;
11467 }
11468
11469 static int
11470 process_notes (FILE * file)
11471 {
11472 /* If we have not been asked to display the notes then do nothing. */
11473 if (! do_notes)
11474 return 1;
11475
11476 if (elf_header.e_type != ET_CORE)
11477 return process_note_sections (file);
11478
11479 /* No program headers means no NOTE segment. */
11480 if (elf_header.e_phnum > 0)
11481 return process_corefile_note_segments (file);
11482
11483 printf (_("No note segments present in the core file.\n"));
11484 return 1;
11485 }
11486
11487 static int
11488 process_arch_specific (FILE * file)
11489 {
11490 if (! do_arch)
11491 return 1;
11492
11493 switch (elf_header.e_machine)
11494 {
11495 case EM_ARM:
11496 return process_arm_specific (file);
11497 case EM_MIPS:
11498 case EM_MIPS_RS3_LE:
11499 return process_mips_specific (file);
11500 break;
11501 case EM_PPC:
11502 return process_power_specific (file);
11503 break;
11504 default:
11505 break;
11506 }
11507 return 1;
11508 }
11509
11510 static int
11511 get_file_header (FILE * file)
11512 {
11513 /* Read in the identity array. */
11514 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
11515 return 0;
11516
11517 /* Determine how to read the rest of the header. */
11518 switch (elf_header.e_ident[EI_DATA])
11519 {
11520 default: /* fall through */
11521 case ELFDATANONE: /* fall through */
11522 case ELFDATA2LSB:
11523 byte_get = byte_get_little_endian;
11524 byte_put = byte_put_little_endian;
11525 break;
11526 case ELFDATA2MSB:
11527 byte_get = byte_get_big_endian;
11528 byte_put = byte_put_big_endian;
11529 break;
11530 }
11531
11532 /* For now we only support 32 bit and 64 bit ELF files. */
11533 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
11534
11535 /* Read in the rest of the header. */
11536 if (is_32bit_elf)
11537 {
11538 Elf32_External_Ehdr ehdr32;
11539
11540 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
11541 return 0;
11542
11543 elf_header.e_type = BYTE_GET (ehdr32.e_type);
11544 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
11545 elf_header.e_version = BYTE_GET (ehdr32.e_version);
11546 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
11547 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
11548 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
11549 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
11550 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
11551 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
11552 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
11553 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
11554 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
11555 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
11556 }
11557 else
11558 {
11559 Elf64_External_Ehdr ehdr64;
11560
11561 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11562 we will not be able to cope with the 64bit data found in
11563 64 ELF files. Detect this now and abort before we start
11564 overwriting things. */
11565 if (sizeof (bfd_vma) < 8)
11566 {
11567 error (_("This instance of readelf has been built without support for a\n\
11568 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11569 return 0;
11570 }
11571
11572 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
11573 return 0;
11574
11575 elf_header.e_type = BYTE_GET (ehdr64.e_type);
11576 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
11577 elf_header.e_version = BYTE_GET (ehdr64.e_version);
11578 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
11579 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
11580 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
11581 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
11582 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
11583 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
11584 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
11585 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
11586 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
11587 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
11588 }
11589
11590 if (elf_header.e_shoff)
11591 {
11592 /* There may be some extensions in the first section header. Don't
11593 bomb if we can't read it. */
11594 if (is_32bit_elf)
11595 get_32bit_section_headers (file, 1);
11596 else
11597 get_64bit_section_headers (file, 1);
11598 }
11599
11600 return 1;
11601 }
11602
11603 /* Process one ELF object file according to the command line options.
11604 This file may actually be stored in an archive. The file is
11605 positioned at the start of the ELF object. */
11606
11607 static int
11608 process_object (char * file_name, FILE * file)
11609 {
11610 unsigned int i;
11611
11612 if (! get_file_header (file))
11613 {
11614 error (_("%s: Failed to read file header\n"), file_name);
11615 return 1;
11616 }
11617
11618 /* Initialise per file variables. */
11619 for (i = ARRAY_SIZE (version_info); i--;)
11620 version_info[i] = 0;
11621
11622 for (i = ARRAY_SIZE (dynamic_info); i--;)
11623 dynamic_info[i] = 0;
11624
11625 /* Process the file. */
11626 if (show_name)
11627 printf (_("\nFile: %s\n"), file_name);
11628
11629 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11630 Note we do this even if cmdline_dump_sects is empty because we
11631 must make sure that the dump_sets array is zeroed out before each
11632 object file is processed. */
11633 if (num_dump_sects > num_cmdline_dump_sects)
11634 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
11635
11636 if (num_cmdline_dump_sects > 0)
11637 {
11638 if (num_dump_sects == 0)
11639 /* A sneaky way of allocating the dump_sects array. */
11640 request_dump_bynumber (num_cmdline_dump_sects, 0);
11641
11642 assert (num_dump_sects >= num_cmdline_dump_sects);
11643 memcpy (dump_sects, cmdline_dump_sects,
11644 num_cmdline_dump_sects * sizeof (* dump_sects));
11645 }
11646
11647 if (! process_file_header ())
11648 return 1;
11649
11650 if (! process_section_headers (file))
11651 {
11652 /* Without loaded section headers we cannot process lots of
11653 things. */
11654 do_unwind = do_version = do_dump = do_arch = 0;
11655
11656 if (! do_using_dynamic)
11657 do_syms = do_dyn_syms = do_reloc = 0;
11658 }
11659
11660 if (! process_section_groups (file))
11661 {
11662 /* Without loaded section groups we cannot process unwind. */
11663 do_unwind = 0;
11664 }
11665
11666 if (process_program_headers (file))
11667 process_dynamic_section (file);
11668
11669 process_relocs (file);
11670
11671 process_unwind (file);
11672
11673 process_symbol_table (file);
11674
11675 process_syminfo (file);
11676
11677 process_version_sections (file);
11678
11679 process_section_contents (file);
11680
11681 process_notes (file);
11682
11683 process_gnu_liblist (file);
11684
11685 process_arch_specific (file);
11686
11687 if (program_headers)
11688 {
11689 free (program_headers);
11690 program_headers = NULL;
11691 }
11692
11693 if (section_headers)
11694 {
11695 free (section_headers);
11696 section_headers = NULL;
11697 }
11698
11699 if (string_table)
11700 {
11701 free (string_table);
11702 string_table = NULL;
11703 string_table_length = 0;
11704 }
11705
11706 if (dynamic_strings)
11707 {
11708 free (dynamic_strings);
11709 dynamic_strings = NULL;
11710 dynamic_strings_length = 0;
11711 }
11712
11713 if (dynamic_symbols)
11714 {
11715 free (dynamic_symbols);
11716 dynamic_symbols = NULL;
11717 num_dynamic_syms = 0;
11718 }
11719
11720 if (dynamic_syminfo)
11721 {
11722 free (dynamic_syminfo);
11723 dynamic_syminfo = NULL;
11724 }
11725
11726 if (section_headers_groups)
11727 {
11728 free (section_headers_groups);
11729 section_headers_groups = NULL;
11730 }
11731
11732 if (section_groups)
11733 {
11734 struct group_list * g;
11735 struct group_list * next;
11736
11737 for (i = 0; i < group_count; i++)
11738 {
11739 for (g = section_groups [i].root; g != NULL; g = next)
11740 {
11741 next = g->next;
11742 free (g);
11743 }
11744 }
11745
11746 free (section_groups);
11747 section_groups = NULL;
11748 }
11749
11750 free_debug_memory ();
11751
11752 return 0;
11753 }
11754
11755 /* Return the path name for a proxy entry in a thin archive, adjusted relative
11756 to the path name of the thin archive itself if necessary. Always returns
11757 a pointer to malloc'ed memory. */
11758
11759 static char *
11760 adjust_relative_path (char * file_name, char * name, int name_len)
11761 {
11762 char * member_file_name;
11763 const char * base_name = lbasename (file_name);
11764
11765 /* This is a proxy entry for a thin archive member.
11766 If the extended name table contains an absolute path
11767 name, or if the archive is in the current directory,
11768 use the path name as given. Otherwise, we need to
11769 find the member relative to the directory where the
11770 archive is located. */
11771 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
11772 {
11773 member_file_name = (char *) malloc (name_len + 1);
11774 if (member_file_name == NULL)
11775 {
11776 error (_("Out of memory\n"));
11777 return NULL;
11778 }
11779 memcpy (member_file_name, name, name_len);
11780 member_file_name[name_len] = '\0';
11781 }
11782 else
11783 {
11784 /* Concatenate the path components of the archive file name
11785 to the relative path name from the extended name table. */
11786 size_t prefix_len = base_name - file_name;
11787 member_file_name = (char *) malloc (prefix_len + name_len + 1);
11788 if (member_file_name == NULL)
11789 {
11790 error (_("Out of memory\n"));
11791 return NULL;
11792 }
11793 memcpy (member_file_name, file_name, prefix_len);
11794 memcpy (member_file_name + prefix_len, name, name_len);
11795 member_file_name[prefix_len + name_len] = '\0';
11796 }
11797 return member_file_name;
11798 }
11799
11800 /* Structure to hold information about an archive file. */
11801
11802 struct archive_info
11803 {
11804 char * file_name; /* Archive file name. */
11805 FILE * file; /* Open file descriptor. */
11806 unsigned long index_num; /* Number of symbols in table. */
11807 unsigned long * index_array; /* The array of member offsets. */
11808 char * sym_table; /* The symbol table. */
11809 unsigned long sym_size; /* Size of the symbol table. */
11810 char * longnames; /* The long file names table. */
11811 unsigned long longnames_size; /* Size of the long file names table. */
11812 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
11813 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
11814 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
11815 struct ar_hdr arhdr; /* Current archive header. */
11816 };
11817
11818 /* Read the symbol table and long-name table from an archive. */
11819
11820 static int
11821 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11822 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
11823 {
11824 size_t got;
11825 unsigned long size;
11826
11827 arch->file_name = strdup (file_name);
11828 arch->file = file;
11829 arch->index_num = 0;
11830 arch->index_array = NULL;
11831 arch->sym_table = NULL;
11832 arch->sym_size = 0;
11833 arch->longnames = NULL;
11834 arch->longnames_size = 0;
11835 arch->nested_member_origin = 0;
11836 arch->is_thin_archive = is_thin_archive;
11837 arch->next_arhdr_offset = SARMAG;
11838
11839 /* Read the first archive member header. */
11840 if (fseek (file, SARMAG, SEEK_SET) != 0)
11841 {
11842 error (_("%s: failed to seek to first archive header\n"), file_name);
11843 return 1;
11844 }
11845 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11846 if (got != sizeof arch->arhdr)
11847 {
11848 if (got == 0)
11849 return 0;
11850
11851 error (_("%s: failed to read archive header\n"), file_name);
11852 return 1;
11853 }
11854
11855 /* See if this is the archive symbol table. */
11856 if (const_strneq (arch->arhdr.ar_name, "/ ")
11857 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
11858 {
11859 size = strtoul (arch->arhdr.ar_size, NULL, 10);
11860 size = size + (size & 1);
11861
11862 arch->next_arhdr_offset += sizeof arch->arhdr + size;
11863
11864 if (read_symbols)
11865 {
11866 unsigned long i;
11867 /* A buffer used to hold numbers read in from an archive index.
11868 These are always 4 bytes long and stored in big-endian format. */
11869 #define SIZEOF_AR_INDEX_NUMBERS 4
11870 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11871 unsigned char * index_buffer;
11872
11873 /* Check the size of the archive index. */
11874 if (size < SIZEOF_AR_INDEX_NUMBERS)
11875 {
11876 error (_("%s: the archive index is empty\n"), file_name);
11877 return 1;
11878 }
11879
11880 /* Read the numer of entries in the archive index. */
11881 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11882 if (got != sizeof (integer_buffer))
11883 {
11884 error (_("%s: failed to read archive index\n"), file_name);
11885 return 1;
11886 }
11887 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
11888 size -= SIZEOF_AR_INDEX_NUMBERS;
11889
11890 /* Read in the archive index. */
11891 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
11892 {
11893 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11894 file_name, arch->index_num);
11895 return 1;
11896 }
11897 index_buffer = (unsigned char *)
11898 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
11899 if (index_buffer == NULL)
11900 {
11901 error (_("Out of memory whilst trying to read archive symbol index\n"));
11902 return 1;
11903 }
11904 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11905 if (got != arch->index_num)
11906 {
11907 free (index_buffer);
11908 error (_("%s: failed to read archive index\n"), file_name);
11909 return 1;
11910 }
11911 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
11912
11913 /* Convert the index numbers into the host's numeric format. */
11914 arch->index_array = (long unsigned int *)
11915 malloc (arch->index_num * sizeof (* arch->index_array));
11916 if (arch->index_array == NULL)
11917 {
11918 free (index_buffer);
11919 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11920 return 1;
11921 }
11922
11923 for (i = 0; i < arch->index_num; i++)
11924 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11925 SIZEOF_AR_INDEX_NUMBERS);
11926 free (index_buffer);
11927
11928 /* The remaining space in the header is taken up by the symbol table. */
11929 if (size < 1)
11930 {
11931 error (_("%s: the archive has an index but no symbols\n"), file_name);
11932 return 1;
11933 }
11934 arch->sym_table = (char *) malloc (size);
11935 arch->sym_size = size;
11936 if (arch->sym_table == NULL)
11937 {
11938 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11939 return 1;
11940 }
11941 got = fread (arch->sym_table, 1, size, file);
11942 if (got != size)
11943 {
11944 error (_("%s: failed to read archive index symbol table\n"), file_name);
11945 return 1;
11946 }
11947 }
11948 else
11949 {
11950 if (fseek (file, size, SEEK_CUR) != 0)
11951 {
11952 error (_("%s: failed to skip archive symbol table\n"), file_name);
11953 return 1;
11954 }
11955 }
11956
11957 /* Read the next archive header. */
11958 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11959 if (got != sizeof arch->arhdr)
11960 {
11961 if (got == 0)
11962 return 0;
11963 error (_("%s: failed to read archive header following archive index\n"), file_name);
11964 return 1;
11965 }
11966 }
11967 else if (read_symbols)
11968 printf (_("%s has no archive index\n"), file_name);
11969
11970 if (const_strneq (arch->arhdr.ar_name, "// "))
11971 {
11972 /* This is the archive string table holding long member names. */
11973 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11974 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
11975
11976 arch->longnames = (char *) malloc (arch->longnames_size);
11977 if (arch->longnames == NULL)
11978 {
11979 error (_("Out of memory reading long symbol names in archive\n"));
11980 return 1;
11981 }
11982
11983 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
11984 {
11985 free (arch->longnames);
11986 arch->longnames = NULL;
11987 error (_("%s: failed to read long symbol name string table\n"), file_name);
11988 return 1;
11989 }
11990
11991 if ((arch->longnames_size & 1) != 0)
11992 getc (file);
11993 }
11994
11995 return 0;
11996 }
11997
11998 /* Release the memory used for the archive information. */
11999
12000 static void
12001 release_archive (struct archive_info * arch)
12002 {
12003 if (arch->file_name != NULL)
12004 free (arch->file_name);
12005 if (arch->index_array != NULL)
12006 free (arch->index_array);
12007 if (arch->sym_table != NULL)
12008 free (arch->sym_table);
12009 if (arch->longnames != NULL)
12010 free (arch->longnames);
12011 }
12012
12013 /* Open and setup a nested archive, if not already open. */
12014
12015 static int
12016 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
12017 {
12018 FILE * member_file;
12019
12020 /* Have we already setup this archive? */
12021 if (nested_arch->file_name != NULL
12022 && streq (nested_arch->file_name, member_file_name))
12023 return 0;
12024
12025 /* Close previous file and discard cached information. */
12026 if (nested_arch->file != NULL)
12027 fclose (nested_arch->file);
12028 release_archive (nested_arch);
12029
12030 member_file = fopen (member_file_name, "rb");
12031 if (member_file == NULL)
12032 return 1;
12033 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
12034 }
12035
12036 static char *
12037 get_archive_member_name_at (struct archive_info * arch,
12038 unsigned long offset,
12039 struct archive_info * nested_arch);
12040
12041 /* Get the name of an archive member from the current archive header.
12042 For simple names, this will modify the ar_name field of the current
12043 archive header. For long names, it will return a pointer to the
12044 longnames table. For nested archives, it will open the nested archive
12045 and get the name recursively. NESTED_ARCH is a single-entry cache so
12046 we don't keep rereading the same information from a nested archive. */
12047
12048 static char *
12049 get_archive_member_name (struct archive_info * arch,
12050 struct archive_info * nested_arch)
12051 {
12052 unsigned long j, k;
12053
12054 if (arch->arhdr.ar_name[0] == '/')
12055 {
12056 /* We have a long name. */
12057 char * endp;
12058 char * member_file_name;
12059 char * member_name;
12060
12061 arch->nested_member_origin = 0;
12062 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
12063 if (arch->is_thin_archive && endp != NULL && * endp == ':')
12064 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
12065
12066 while ((j < arch->longnames_size)
12067 && (arch->longnames[j] != '\n')
12068 && (arch->longnames[j] != '\0'))
12069 j++;
12070 if (arch->longnames[j-1] == '/')
12071 j--;
12072 arch->longnames[j] = '\0';
12073
12074 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
12075 return arch->longnames + k;
12076
12077 /* This is a proxy for a member of a nested archive.
12078 Find the name of the member in that archive. */
12079 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
12080 if (member_file_name != NULL
12081 && setup_nested_archive (nested_arch, member_file_name) == 0
12082 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
12083 {
12084 free (member_file_name);
12085 return member_name;
12086 }
12087 free (member_file_name);
12088
12089 /* Last resort: just return the name of the nested archive. */
12090 return arch->longnames + k;
12091 }
12092
12093 /* We have a normal (short) name. */
12094 j = 0;
12095 while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
12096 j++;
12097 arch->arhdr.ar_name[j] = '\0';
12098 return arch->arhdr.ar_name;
12099 }
12100
12101 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12102
12103 static char *
12104 get_archive_member_name_at (struct archive_info * arch,
12105 unsigned long offset,
12106 struct archive_info * nested_arch)
12107 {
12108 size_t got;
12109
12110 if (fseek (arch->file, offset, SEEK_SET) != 0)
12111 {
12112 error (_("%s: failed to seek to next file name\n"), arch->file_name);
12113 return NULL;
12114 }
12115 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
12116 if (got != sizeof arch->arhdr)
12117 {
12118 error (_("%s: failed to read archive header\n"), arch->file_name);
12119 return NULL;
12120 }
12121 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
12122 {
12123 error (_("%s: did not find a valid archive header\n"), arch->file_name);
12124 return NULL;
12125 }
12126
12127 return get_archive_member_name (arch, nested_arch);
12128 }
12129
12130 /* Construct a string showing the name of the archive member, qualified
12131 with the name of the containing archive file. For thin archives, we
12132 use square brackets to denote the indirection. For nested archives,
12133 we show the qualified name of the external member inside the square
12134 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12135
12136 static char *
12137 make_qualified_name (struct archive_info * arch,
12138 struct archive_info * nested_arch,
12139 char * member_name)
12140 {
12141 size_t len;
12142 char * name;
12143
12144 len = strlen (arch->file_name) + strlen (member_name) + 3;
12145 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12146 len += strlen (nested_arch->file_name) + 2;
12147
12148 name = (char *) malloc (len);
12149 if (name == NULL)
12150 {
12151 error (_("Out of memory\n"));
12152 return NULL;
12153 }
12154
12155 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12156 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
12157 else if (arch->is_thin_archive)
12158 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
12159 else
12160 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
12161
12162 return name;
12163 }
12164
12165 /* Process an ELF archive.
12166 On entry the file is positioned just after the ARMAG string. */
12167
12168 static int
12169 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12170 {
12171 struct archive_info arch;
12172 struct archive_info nested_arch;
12173 size_t got;
12174 int ret;
12175
12176 show_name = 1;
12177
12178 /* The ARCH structure is used to hold information about this archive. */
12179 arch.file_name = NULL;
12180 arch.file = NULL;
12181 arch.index_array = NULL;
12182 arch.sym_table = NULL;
12183 arch.longnames = NULL;
12184
12185 /* The NESTED_ARCH structure is used as a single-item cache of information
12186 about a nested archive (when members of a thin archive reside within
12187 another regular archive file). */
12188 nested_arch.file_name = NULL;
12189 nested_arch.file = NULL;
12190 nested_arch.index_array = NULL;
12191 nested_arch.sym_table = NULL;
12192 nested_arch.longnames = NULL;
12193
12194 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12195 {
12196 ret = 1;
12197 goto out;
12198 }
12199
12200 if (do_archive_index)
12201 {
12202 if (arch.sym_table == NULL)
12203 error (_("%s: unable to dump the index as none was found\n"), file_name);
12204 else
12205 {
12206 unsigned int i, l;
12207 unsigned long current_pos;
12208
12209 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12210 file_name, arch.index_num, arch.sym_size);
12211 current_pos = ftell (file);
12212
12213 for (i = l = 0; i < arch.index_num; i++)
12214 {
12215 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12216 {
12217 char * member_name;
12218
12219 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12220
12221 if (member_name != NULL)
12222 {
12223 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12224
12225 if (qualified_name != NULL)
12226 {
12227 printf (_("Binary %s contains:\n"), qualified_name);
12228 free (qualified_name);
12229 }
12230 }
12231 }
12232
12233 if (l >= arch.sym_size)
12234 {
12235 error (_("%s: end of the symbol table reached before the end of the index\n"),
12236 file_name);
12237 break;
12238 }
12239 printf ("\t%s\n", arch.sym_table + l);
12240 l += strlen (arch.sym_table + l) + 1;
12241 }
12242
12243 if (l & 01)
12244 ++l;
12245 if (l < arch.sym_size)
12246 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12247 file_name);
12248
12249 if (fseek (file, current_pos, SEEK_SET) != 0)
12250 {
12251 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12252 ret = 1;
12253 goto out;
12254 }
12255 }
12256
12257 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12258 && !do_segments && !do_header && !do_dump && !do_version
12259 && !do_histogram && !do_debugging && !do_arch && !do_notes
12260 && !do_section_groups && !do_dyn_syms)
12261 {
12262 ret = 0; /* Archive index only. */
12263 goto out;
12264 }
12265 }
12266
12267 ret = 0;
12268
12269 while (1)
12270 {
12271 char * name;
12272 size_t namelen;
12273 char * qualified_name;
12274
12275 /* Read the next archive header. */
12276 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12277 {
12278 error (_("%s: failed to seek to next archive header\n"), file_name);
12279 return 1;
12280 }
12281 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12282 if (got != sizeof arch.arhdr)
12283 {
12284 if (got == 0)
12285 break;
12286 error (_("%s: failed to read archive header\n"), file_name);
12287 ret = 1;
12288 break;
12289 }
12290 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12291 {
12292 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12293 ret = 1;
12294 break;
12295 }
12296
12297 arch.next_arhdr_offset += sizeof arch.arhdr;
12298
12299 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12300 if (archive_file_size & 01)
12301 ++archive_file_size;
12302
12303 name = get_archive_member_name (&arch, &nested_arch);
12304 if (name == NULL)
12305 {
12306 error (_("%s: bad archive file name\n"), file_name);
12307 ret = 1;
12308 break;
12309 }
12310 namelen = strlen (name);
12311
12312 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12313 if (qualified_name == NULL)
12314 {
12315 error (_("%s: bad archive file name\n"), file_name);
12316 ret = 1;
12317 break;
12318 }
12319
12320 if (is_thin_archive && arch.nested_member_origin == 0)
12321 {
12322 /* This is a proxy for an external member of a thin archive. */
12323 FILE * member_file;
12324 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12325 if (member_file_name == NULL)
12326 {
12327 ret = 1;
12328 break;
12329 }
12330
12331 member_file = fopen (member_file_name, "rb");
12332 if (member_file == NULL)
12333 {
12334 error (_("Input file '%s' is not readable.\n"), member_file_name);
12335 free (member_file_name);
12336 ret = 1;
12337 break;
12338 }
12339
12340 archive_file_offset = arch.nested_member_origin;
12341
12342 ret |= process_object (qualified_name, member_file);
12343
12344 fclose (member_file);
12345 free (member_file_name);
12346 }
12347 else if (is_thin_archive)
12348 {
12349 /* This is a proxy for a member of a nested archive. */
12350 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12351
12352 /* The nested archive file will have been opened and setup by
12353 get_archive_member_name. */
12354 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12355 {
12356 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12357 ret = 1;
12358 break;
12359 }
12360
12361 ret |= process_object (qualified_name, nested_arch.file);
12362 }
12363 else
12364 {
12365 archive_file_offset = arch.next_arhdr_offset;
12366 arch.next_arhdr_offset += archive_file_size;
12367
12368 ret |= process_object (qualified_name, file);
12369 }
12370
12371 free (qualified_name);
12372 }
12373
12374 out:
12375 if (nested_arch.file != NULL)
12376 fclose (nested_arch.file);
12377 release_archive (&nested_arch);
12378 release_archive (&arch);
12379
12380 return ret;
12381 }
12382
12383 static int
12384 process_file (char * file_name)
12385 {
12386 FILE * file;
12387 struct stat statbuf;
12388 char armag[SARMAG];
12389 int ret;
12390
12391 if (stat (file_name, &statbuf) < 0)
12392 {
12393 if (errno == ENOENT)
12394 error (_("'%s': No such file\n"), file_name);
12395 else
12396 error (_("Could not locate '%s'. System error message: %s\n"),
12397 file_name, strerror (errno));
12398 return 1;
12399 }
12400
12401 if (! S_ISREG (statbuf.st_mode))
12402 {
12403 error (_("'%s' is not an ordinary file\n"), file_name);
12404 return 1;
12405 }
12406
12407 file = fopen (file_name, "rb");
12408 if (file == NULL)
12409 {
12410 error (_("Input file '%s' is not readable.\n"), file_name);
12411 return 1;
12412 }
12413
12414 if (fread (armag, SARMAG, 1, file) != 1)
12415 {
12416 error (_("%s: Failed to read file's magic number\n"), file_name);
12417 fclose (file);
12418 return 1;
12419 }
12420
12421 if (memcmp (armag, ARMAG, SARMAG) == 0)
12422 ret = process_archive (file_name, file, FALSE);
12423 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12424 ret = process_archive (file_name, file, TRUE);
12425 else
12426 {
12427 if (do_archive_index)
12428 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12429 file_name);
12430
12431 rewind (file);
12432 archive_file_size = archive_file_offset = 0;
12433 ret = process_object (file_name, file);
12434 }
12435
12436 fclose (file);
12437
12438 return ret;
12439 }
12440
12441 #ifdef SUPPORT_DISASSEMBLY
12442 /* Needed by the i386 disassembler. For extra credit, someone could
12443 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12444 symbols. */
12445
12446 void
12447 print_address (unsigned int addr, FILE * outfile)
12448 {
12449 fprintf (outfile,"0x%8.8x", addr);
12450 }
12451
12452 /* Needed by the i386 disassembler. */
12453 void
12454 db_task_printsym (unsigned int addr)
12455 {
12456 print_address (addr, stderr);
12457 }
12458 #endif
12459
12460 int
12461 main (int argc, char ** argv)
12462 {
12463 int err;
12464
12465 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12466 setlocale (LC_MESSAGES, "");
12467 #endif
12468 #if defined (HAVE_SETLOCALE)
12469 setlocale (LC_CTYPE, "");
12470 #endif
12471 bindtextdomain (PACKAGE, LOCALEDIR);
12472 textdomain (PACKAGE);
12473
12474 expandargv (&argc, &argv);
12475
12476 parse_args (argc, argv);
12477
12478 if (num_dump_sects > 0)
12479 {
12480 /* Make a copy of the dump_sects array. */
12481 cmdline_dump_sects = (dump_type *)
12482 malloc (num_dump_sects * sizeof (* dump_sects));
12483 if (cmdline_dump_sects == NULL)
12484 error (_("Out of memory allocating dump request table.\n"));
12485 else
12486 {
12487 memcpy (cmdline_dump_sects, dump_sects,
12488 num_dump_sects * sizeof (* dump_sects));
12489 num_cmdline_dump_sects = num_dump_sects;
12490 }
12491 }
12492
12493 if (optind < (argc - 1))
12494 show_name = 1;
12495
12496 err = 0;
12497 while (optind < argc)
12498 err |= process_file (argv[optind++]);
12499
12500 if (dump_sects != NULL)
12501 free (dump_sects);
12502 if (cmdline_dump_sects != NULL)
12503 free (cmdline_dump_sects);
12504
12505 return err;
12506 }
GDB Binutils - Deliverables
This page took 0.276692 seconds and 5 git commands to generate.