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