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