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