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