projects / binutils-gdb.git / blob
? search:


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