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