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