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