?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* options.cc (version_script): Fix small typo in previous
[binutils.git] / binutils / readelf.c
blobb345afb5027f02a18be180e635ee080eb790fea3
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 printf (_("Key to Flags:\n\
4865 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4866 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4867 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4868
4869 return 1;
4870 }
4871
4872 static const char *
4873 get_group_flags (unsigned int flags)
4874 {
4875 static char buff[32];
4876 switch (flags)
4877 {
4878 case 0:
4879 return "";
4880
4881 case GRP_COMDAT:
4882 return "COMDAT ";
4883
4884 default:
4885 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4886 break;
4887 }
4888 return buff;
4889 }
4890
4891 static int
4892 process_section_groups (FILE * file)
4893 {
4894 Elf_Internal_Shdr * section;
4895 unsigned int i;
4896 struct group * group;
4897 Elf_Internal_Shdr * symtab_sec;
4898 Elf_Internal_Shdr * strtab_sec;
4899 Elf_Internal_Sym * symtab;
4900 char * strtab;
4901 size_t strtab_size;
4902
4903 /* Don't process section groups unless needed. */
4904 if (!do_unwind && !do_section_groups)
4905 return 1;
4906
4907 if (elf_header.e_shnum == 0)
4908 {
4909 if (do_section_groups)
4910 printf (_("\nThere are no sections in this file.\n"));
4911
4912 return 1;
4913 }
4914
4915 if (section_headers == NULL)
4916 {
4917 error (_("Section headers are not available!\n"));
4918 abort ();
4919 }
4920
4921 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4922 sizeof (struct group *));
4923
4924 if (section_headers_groups == NULL)
4925 {
4926 error (_("Out of memory\n"));
4927 return 0;
4928 }
4929
4930 /* Scan the sections for the group section. */
4931 group_count = 0;
4932 for (i = 0, section = section_headers;
4933 i < elf_header.e_shnum;
4934 i++, section++)
4935 if (section->sh_type == SHT_GROUP)
4936 group_count++;
4937
4938 if (group_count == 0)
4939 {
4940 if (do_section_groups)
4941 printf (_("\nThere are no section groups in this file.\n"));
4942
4943 return 1;
4944 }
4945
4946 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4947
4948 if (section_groups == NULL)
4949 {
4950 error (_("Out of memory\n"));
4951 return 0;
4952 }
4953
4954 symtab_sec = NULL;
4955 strtab_sec = NULL;
4956 symtab = NULL;
4957 strtab = NULL;
4958 strtab_size = 0;
4959 for (i = 0, section = section_headers, group = section_groups;
4960 i < elf_header.e_shnum;
4961 i++, section++)
4962 {
4963 if (section->sh_type == SHT_GROUP)
4964 {
4965 char * name = SECTION_NAME (section);
4966 char * group_name;
4967 unsigned char * start;
4968 unsigned char * indices;
4969 unsigned int entry, j, size;
4970 Elf_Internal_Shdr * sec;
4971 Elf_Internal_Sym * sym;
4972
4973 /* Get the symbol table. */
4974 if (section->sh_link >= elf_header.e_shnum
4975 || ((sec = section_headers + section->sh_link)->sh_type
4976 != SHT_SYMTAB))
4977 {
4978 error (_("Bad sh_link in group section `%s'\n"), name);
4979 continue;
4980 }
4981
4982 if (symtab_sec != sec)
4983 {
4984 symtab_sec = sec;
4985 if (symtab)
4986 free (symtab);
4987 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4988 }
4989
4990 if (symtab == NULL)
4991 {
4992 error (_("Corrupt header in group section `%s'\n"), name);
4993 continue;
4994 }
4995
4996 sym = symtab + section->sh_info;
4997
4998 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4999 {
5000 if (sym->st_shndx == 0
5001 || sym->st_shndx >= elf_header.e_shnum)
5002 {
5003 error (_("Bad sh_info in group section `%s'\n"), name);
5004 continue;
5005 }
5006
5007 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5008 strtab_sec = NULL;
5009 if (strtab)
5010 free (strtab);
5011 strtab = NULL;
5012 strtab_size = 0;
5013 }
5014 else
5015 {
5016 /* Get the string table. */
5017 if (symtab_sec->sh_link >= elf_header.e_shnum)
5018 {
5019 strtab_sec = NULL;
5020 if (strtab)
5021 free (strtab);
5022 strtab = NULL;
5023 strtab_size = 0;
5024 }
5025 else if (strtab_sec
5026 != (sec = section_headers + symtab_sec->sh_link))
5027 {
5028 strtab_sec = sec;
5029 if (strtab)
5030 free (strtab);
5031 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5032 1, strtab_sec->sh_size,
5033 _("string table"));
5034 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5035 }
5036 group_name = sym->st_name < strtab_size
5037 ? strtab + sym->st_name : _("<corrupt>");
5038 }
5039
5040 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5041 1, section->sh_size,
5042 _("section data"));
5043
5044 indices = start;
5045 size = (section->sh_size / section->sh_entsize) - 1;
5046 entry = byte_get (indices, 4);
5047 indices += 4;
5048
5049 if (do_section_groups)
5050 {
5051 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5052 get_group_flags (entry), i, name, group_name, size);
5053
5054 printf (_(" [Index] Name\n"));
5055 }
5056
5057 group->group_index = i;
5058
5059 for (j = 0; j < size; j++)
5060 {
5061 struct group_list * g;
5062
5063 entry = byte_get (indices, 4);
5064 indices += 4;
5065
5066 if (entry >= elf_header.e_shnum)
5067 {
5068 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5069 entry, i, elf_header.e_shnum - 1);
5070 continue;
5071 }
5072
5073 if (section_headers_groups [entry] != NULL)
5074 {
5075 if (entry)
5076 {
5077 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5078 entry, i,
5079 section_headers_groups [entry]->group_index);
5080 continue;
5081 }
5082 else
5083 {
5084 /* Intel C/C++ compiler may put section 0 in a
5085 section group. We just warn it the first time
5086 and ignore it afterwards. */
5087 static int warned = 0;
5088 if (!warned)
5089 {
5090 error (_("section 0 in group section [%5u]\n"),
5091 section_headers_groups [entry]->group_index);
5092 warned++;
5093 }
5094 }
5095 }
5096
5097 section_headers_groups [entry] = group;
5098
5099 if (do_section_groups)
5100 {
5101 sec = section_headers + entry;
5102 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5103 }
5104
5105 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5106 g->section_index = entry;
5107 g->next = group->root;
5108 group->root = g;
5109 }
5110
5111 if (start)
5112 free (start);
5113
5114 group++;
5115 }
5116 }
5117
5118 if (symtab)
5119 free (symtab);
5120 if (strtab)
5121 free (strtab);
5122 return 1;
5123 }
5124
5125 /* Data used to display dynamic fixups. */
5126
5127 struct ia64_vms_dynfixup
5128 {
5129 bfd_vma needed_ident; /* Library ident number. */
5130 bfd_vma needed; /* Index in the dstrtab of the library name. */
5131 bfd_vma fixup_needed; /* Index of the library. */
5132 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5133 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5134 };
5135
5136 /* Data used to display dynamic relocations. */
5137
5138 struct ia64_vms_dynimgrela
5139 {
5140 bfd_vma img_rela_cnt; /* Number of relocations. */
5141 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5142 };
5143
5144 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5145 library). */
5146
5147 static void
5148 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5149 const char *strtab, unsigned int strtab_sz)
5150 {
5151 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5152 long i;
5153 const char *lib_name;
5154
5155 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5156 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5157 _("dynamic section image fixups"));
5158 if (!imfs)
5159 return;
5160
5161 if (fixup->needed < strtab_sz)
5162 lib_name = strtab + fixup->needed;
5163 else
5164 {
5165 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5166 (unsigned long) fixup->needed);
5167 lib_name = "???";
5168 }
5169 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5170 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5171 printf
5172 (_("Seg Offset Type SymVec DataType\n"));
5173
5174 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5175 {
5176 unsigned int type;
5177 const char *rtype;
5178
5179 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5180 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5181 type = BYTE_GET (imfs [i].type);
5182 rtype = elf_ia64_reloc_type (type);
5183 if (rtype == NULL)
5184 printf (" 0x%08x ", type);
5185 else
5186 printf (" %-32s ", rtype);
5187 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5188 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5189 }
5190
5191 free (imfs);
5192 }
5193
5194 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5195
5196 static void
5197 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5198 {
5199 Elf64_External_VMS_IMAGE_RELA *imrs;
5200 long i;
5201
5202 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5203 1, imgrela->img_rela_cnt * sizeof (*imrs),
5204 _("dynamic section image relas"));
5205 if (!imrs)
5206 return;
5207
5208 printf (_("\nImage relocs\n"));
5209 printf
5210 (_("Seg Offset Type Addend Seg Sym Off\n"));
5211
5212 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5213 {
5214 unsigned int type;
5215 const char *rtype;
5216
5217 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5218 printf ("%08" BFD_VMA_FMT "x ",
5219 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5220 type = BYTE_GET (imrs [i].type);
5221 rtype = elf_ia64_reloc_type (type);
5222 if (rtype == NULL)
5223 printf ("0x%08x ", type);
5224 else
5225 printf ("%-31s ", rtype);
5226 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5227 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5228 printf ("%08" BFD_VMA_FMT "x\n",
5229 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5230 }
5231
5232 free (imrs);
5233 }
5234
5235 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5236
5237 static int
5238 process_ia64_vms_dynamic_relocs (FILE *file)
5239 {
5240 struct ia64_vms_dynfixup fixup;
5241 struct ia64_vms_dynimgrela imgrela;
5242 Elf_Internal_Dyn *entry;
5243 int res = 0;
5244 bfd_vma strtab_off = 0;
5245 bfd_vma strtab_sz = 0;
5246 char *strtab = NULL;
5247
5248 memset (&fixup, 0, sizeof (fixup));
5249 memset (&imgrela, 0, sizeof (imgrela));
5250
5251 /* Note: the order of the entries is specified by the OpenVMS specs. */
5252 for (entry = dynamic_section;
5253 entry < dynamic_section + dynamic_nent;
5254 entry++)
5255 {
5256 switch (entry->d_tag)
5257 {
5258 case DT_IA_64_VMS_STRTAB_OFFSET:
5259 strtab_off = entry->d_un.d_val;
5260 break;
5261 case DT_STRSZ:
5262 strtab_sz = entry->d_un.d_val;
5263 if (strtab == NULL)
5264 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5265 1, strtab_sz, _("dynamic string section"));
5266 break;
5267
5268 case DT_IA_64_VMS_NEEDED_IDENT:
5269 fixup.needed_ident = entry->d_un.d_val;
5270 break;
5271 case DT_NEEDED:
5272 fixup.needed = entry->d_un.d_val;
5273 break;
5274 case DT_IA_64_VMS_FIXUP_NEEDED:
5275 fixup.fixup_needed = entry->d_un.d_val;
5276 break;
5277 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5278 fixup.fixup_rela_cnt = entry->d_un.d_val;
5279 break;
5280 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5281 fixup.fixup_rela_off = entry->d_un.d_val;
5282 res++;
5283 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5284 break;
5285
5286 case DT_IA_64_VMS_IMG_RELA_CNT:
5287 imgrela.img_rela_cnt = entry->d_un.d_val;
5288 break;
5289 case DT_IA_64_VMS_IMG_RELA_OFF:
5290 imgrela.img_rela_off = entry->d_un.d_val;
5291 res++;
5292 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5293 break;
5294
5295 default:
5296 break;
5297 }
5298 }
5299
5300 if (strtab != NULL)
5301 free (strtab);
5302
5303 return res;
5304 }
5305
5306 static struct
5307 {
5308 const char * name;
5309 int reloc;
5310 int size;
5311 int rela;
5312 } dynamic_relocations [] =
5313 {
5314 { "REL", DT_REL, DT_RELSZ, FALSE },
5315 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5316 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5317 };
5318
5319 /* Process the reloc section. */
5320
5321 static int
5322 process_relocs (FILE * file)
5323 {
5324 unsigned long rel_size;
5325 unsigned long rel_offset;
5326
5327
5328 if (!do_reloc)
5329 return 1;
5330
5331 if (do_using_dynamic)
5332 {
5333 int is_rela;
5334 const char * name;
5335 int has_dynamic_reloc;
5336 unsigned int i;
5337
5338 has_dynamic_reloc = 0;
5339
5340 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5341 {
5342 is_rela = dynamic_relocations [i].rela;
5343 name = dynamic_relocations [i].name;
5344 rel_size = dynamic_info [dynamic_relocations [i].size];
5345 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5346
5347 has_dynamic_reloc |= rel_size;
5348
5349 if (is_rela == UNKNOWN)
5350 {
5351 if (dynamic_relocations [i].reloc == DT_JMPREL)
5352 switch (dynamic_info[DT_PLTREL])
5353 {
5354 case DT_REL:
5355 is_rela = FALSE;
5356 break;
5357 case DT_RELA:
5358 is_rela = TRUE;
5359 break;
5360 }
5361 }
5362
5363 if (rel_size)
5364 {
5365 printf
5366 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5367 name, rel_offset, rel_size);
5368
5369 dump_relocations (file,
5370 offset_from_vma (file, rel_offset, rel_size),
5371 rel_size,
5372 dynamic_symbols, num_dynamic_syms,
5373 dynamic_strings, dynamic_strings_length, is_rela);
5374 }
5375 }
5376
5377 if (is_ia64_vms ())
5378 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5379
5380 if (! has_dynamic_reloc)
5381 printf (_("\nThere are no dynamic relocations in this file.\n"));
5382 }
5383 else
5384 {
5385 Elf_Internal_Shdr * section;
5386 unsigned long i;
5387 int found = 0;
5388
5389 for (i = 0, section = section_headers;
5390 i < elf_header.e_shnum;
5391 i++, section++)
5392 {
5393 if ( section->sh_type != SHT_RELA
5394 && section->sh_type != SHT_REL)
5395 continue;
5396
5397 rel_offset = section->sh_offset;
5398 rel_size = section->sh_size;
5399
5400 if (rel_size)
5401 {
5402 Elf_Internal_Shdr * strsec;
5403 int is_rela;
5404
5405 printf (_("\nRelocation section "));
5406
5407 if (string_table == NULL)
5408 printf ("%d", section->sh_name);
5409 else
5410 printf (_("'%s'"), SECTION_NAME (section));
5411
5412 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5413 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5414
5415 is_rela = section->sh_type == SHT_RELA;
5416
5417 if (section->sh_link != 0
5418 && section->sh_link < elf_header.e_shnum)
5419 {
5420 Elf_Internal_Shdr * symsec;
5421 Elf_Internal_Sym * symtab;
5422 unsigned long nsyms;
5423 unsigned long strtablen = 0;
5424 char * strtab = NULL;
5425
5426 symsec = section_headers + section->sh_link;
5427 if (symsec->sh_type != SHT_SYMTAB
5428 && symsec->sh_type != SHT_DYNSYM)
5429 continue;
5430
5431 nsyms = symsec->sh_size / symsec->sh_entsize;
5432 symtab = GET_ELF_SYMBOLS (file, symsec);
5433
5434 if (symtab == NULL)
5435 continue;
5436
5437 if (symsec->sh_link != 0
5438 && symsec->sh_link < elf_header.e_shnum)
5439 {
5440 strsec = section_headers + symsec->sh_link;
5441
5442 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5443 1, strsec->sh_size,
5444 _("string table"));
5445 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5446 }
5447
5448 dump_relocations (file, rel_offset, rel_size,
5449 symtab, nsyms, strtab, strtablen, is_rela);
5450 if (strtab)
5451 free (strtab);
5452 free (symtab);
5453 }
5454 else
5455 dump_relocations (file, rel_offset, rel_size,
5456 NULL, 0, NULL, 0, is_rela);
5457
5458 found = 1;
5459 }
5460 }
5461
5462 if (! found)
5463 printf (_("\nThere are no relocations in this file.\n"));
5464 }
5465
5466 return 1;
5467 }
5468
5469 /* Process the unwind section. */
5470
5471 #include "unwind-ia64.h"
5472
5473 /* An absolute address consists of a section and an offset. If the
5474 section is NULL, the offset itself is the address, otherwise, the
5475 address equals to LOAD_ADDRESS(section) + offset. */
5476
5477 struct absaddr
5478 {
5479 unsigned short section;
5480 bfd_vma offset;
5481 };
5482
5483 #define ABSADDR(a) \
5484 ((a).section \
5485 ? section_headers [(a).section].sh_addr + (a).offset \
5486 : (a).offset)
5487
5488 struct ia64_unw_table_entry
5489 {
5490 struct absaddr start;
5491 struct absaddr end;
5492 struct absaddr info;
5493 };
5494
5495 struct ia64_unw_aux_info
5496 {
5497
5498 struct ia64_unw_table_entry *table; /* Unwind table. */
5499 unsigned long table_len; /* Length of unwind table. */
5500 unsigned char * info; /* Unwind info. */
5501 unsigned long info_size; /* Size of unwind info. */
5502 bfd_vma info_addr; /* starting address of unwind info. */
5503 bfd_vma seg_base; /* Starting address of segment. */
5504 Elf_Internal_Sym * symtab; /* The symbol table. */
5505 unsigned long nsyms; /* Number of symbols. */
5506 char * strtab; /* The string table. */
5507 unsigned long strtab_size; /* Size of string table. */
5508 };
5509
5510 static void
5511 find_symbol_for_address (Elf_Internal_Sym * symtab,
5512 unsigned long nsyms,
5513 const char * strtab,
5514 unsigned long strtab_size,
5515 struct absaddr addr,
5516 const char ** symname,
5517 bfd_vma * offset)
5518 {
5519 bfd_vma dist = 0x100000;
5520 Elf_Internal_Sym * sym;
5521 Elf_Internal_Sym * best = NULL;
5522 unsigned long i;
5523
5524 REMOVE_ARCH_BITS (addr.offset);
5525
5526 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5527 {
5528 bfd_vma value = sym->st_value;
5529
5530 REMOVE_ARCH_BITS (value);
5531
5532 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5533 && sym->st_name != 0
5534 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5535 && addr.offset >= value
5536 && addr.offset - value < dist)
5537 {
5538 best = sym;
5539 dist = addr.offset - value;
5540 if (!dist)
5541 break;
5542 }
5543 }
5544 if (best)
5545 {
5546 *symname = (best->st_name >= strtab_size
5547 ? _("<corrupt>") : strtab + best->st_name);
5548 *offset = dist;
5549 return;
5550 }
5551 *symname = NULL;
5552 *offset = addr.offset;
5553 }
5554
5555 static void
5556 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5557 {
5558 struct ia64_unw_table_entry * tp;
5559 int in_body;
5560
5561 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5562 {
5563 bfd_vma stamp;
5564 bfd_vma offset;
5565 const unsigned char * dp;
5566 const unsigned char * head;
5567 const char * procname;
5568
5569 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5570 aux->strtab_size, tp->start, &procname, &offset);
5571
5572 fputs ("\n<", stdout);
5573
5574 if (procname)
5575 {
5576 fputs (procname, stdout);
5577
5578 if (offset)
5579 printf ("+%lx", (unsigned long) offset);
5580 }
5581
5582 fputs (">: [", stdout);
5583 print_vma (tp->start.offset, PREFIX_HEX);
5584 fputc ('-', stdout);
5585 print_vma (tp->end.offset, PREFIX_HEX);
5586 printf ("], info at +0x%lx\n",
5587 (unsigned long) (tp->info.offset - aux->seg_base));
5588
5589 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5590 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5591
5592 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5593 (unsigned) UNW_VER (stamp),
5594 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5595 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5596 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5597 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5598
5599 if (UNW_VER (stamp) != 1)
5600 {
5601 printf (_("\tUnknown version.\n"));
5602 continue;
5603 }
5604
5605 in_body = 0;
5606 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5607 dp = unw_decode (dp, in_body, & in_body);
5608 }
5609 }
5610
5611 static int
5612 slurp_ia64_unwind_table (FILE * file,
5613 struct ia64_unw_aux_info * aux,
5614 Elf_Internal_Shdr * sec)
5615 {
5616 unsigned long size, nrelas, i;
5617 Elf_Internal_Phdr * seg;
5618 struct ia64_unw_table_entry * tep;
5619 Elf_Internal_Shdr * relsec;
5620 Elf_Internal_Rela * rela;
5621 Elf_Internal_Rela * rp;
5622 unsigned char * table;
5623 unsigned char * tp;
5624 Elf_Internal_Sym * sym;
5625 const char * relname;
5626
5627 /* First, find the starting address of the segment that includes
5628 this section: */
5629
5630 if (elf_header.e_phnum)
5631 {
5632 if (! get_program_headers (file))
5633 return 0;
5634
5635 for (seg = program_headers;
5636 seg < program_headers + elf_header.e_phnum;
5637 ++seg)
5638 {
5639 if (seg->p_type != PT_LOAD)
5640 continue;
5641
5642 if (sec->sh_addr >= seg->p_vaddr
5643 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5644 {
5645 aux->seg_base = seg->p_vaddr;
5646 break;
5647 }
5648 }
5649 }
5650
5651 /* Second, build the unwind table from the contents of the unwind section: */
5652 size = sec->sh_size;
5653 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5654 _("unwind table"));
5655 if (!table)
5656 return 0;
5657
5658 aux->table = (struct ia64_unw_table_entry *)
5659 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5660 tep = aux->table;
5661 for (tp = table; tp < table + size; ++tep)
5662 {
5663 tep->start.section = SHN_UNDEF;
5664 tep->end.section = SHN_UNDEF;
5665 tep->info.section = SHN_UNDEF;
5666 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5667 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5668 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5669 tep->start.offset += aux->seg_base;
5670 tep->end.offset += aux->seg_base;
5671 tep->info.offset += aux->seg_base;
5672 }
5673 free (table);
5674
5675 /* Third, apply any relocations to the unwind table: */
5676 for (relsec = section_headers;
5677 relsec < section_headers + elf_header.e_shnum;
5678 ++relsec)
5679 {
5680 if (relsec->sh_type != SHT_RELA
5681 || relsec->sh_info >= elf_header.e_shnum
5682 || section_headers + relsec->sh_info != sec)
5683 continue;
5684
5685 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5686 & rela, & nrelas))
5687 return 0;
5688
5689 for (rp = rela; rp < rela + nrelas; ++rp)
5690 {
5691 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5692 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5693
5694 if (! const_strneq (relname, "R_IA64_SEGREL"))
5695 {
5696 warn (_("Skipping unexpected relocation type %s\n"), relname);
5697 continue;
5698 }
5699
5700 i = rp->r_offset / (3 * eh_addr_size);
5701
5702 switch (rp->r_offset/eh_addr_size % 3)
5703 {
5704 case 0:
5705 aux->table[i].start.section = sym->st_shndx;
5706 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5707 break;
5708 case 1:
5709 aux->table[i].end.section = sym->st_shndx;
5710 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5711 break;
5712 case 2:
5713 aux->table[i].info.section = sym->st_shndx;
5714 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5715 break;
5716 default:
5717 break;
5718 }
5719 }
5720
5721 free (rela);
5722 }
5723
5724 aux->table_len = size / (3 * eh_addr_size);
5725 return 1;
5726 }
5727
5728 static int
5729 ia64_process_unwind (FILE * file)
5730 {
5731 Elf_Internal_Shdr * sec;
5732 Elf_Internal_Shdr * unwsec = NULL;
5733 Elf_Internal_Shdr * strsec;
5734 unsigned long i, unwcount = 0, unwstart = 0;
5735 struct ia64_unw_aux_info aux;
5736
5737 memset (& aux, 0, sizeof (aux));
5738
5739 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5740 {
5741 if (sec->sh_type == SHT_SYMTAB
5742 && sec->sh_link < elf_header.e_shnum)
5743 {
5744 aux.nsyms = sec->sh_size / sec->sh_entsize;
5745 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5746
5747 strsec = section_headers + sec->sh_link;
5748 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5749 1, strsec->sh_size,
5750 _("string table"));
5751 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5752 }
5753 else if (sec->sh_type == SHT_IA_64_UNWIND)
5754 unwcount++;
5755 }
5756
5757 if (!unwcount)
5758 printf (_("\nThere are no unwind sections in this file.\n"));
5759
5760 while (unwcount-- > 0)
5761 {
5762 char * suffix;
5763 size_t len, len2;
5764
5765 for (i = unwstart, sec = section_headers + unwstart;
5766 i < elf_header.e_shnum; ++i, ++sec)
5767 if (sec->sh_type == SHT_IA_64_UNWIND)
5768 {
5769 unwsec = sec;
5770 break;
5771 }
5772
5773 unwstart = i + 1;
5774 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5775
5776 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5777 {
5778 /* We need to find which section group it is in. */
5779 struct group_list * g = section_headers_groups [i]->root;
5780
5781 for (; g != NULL; g = g->next)
5782 {
5783 sec = section_headers + g->section_index;
5784
5785 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5786 break;
5787 }
5788
5789 if (g == NULL)
5790 i = elf_header.e_shnum;
5791 }
5792 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5793 {
5794 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5795 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5796 suffix = SECTION_NAME (unwsec) + len;
5797 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5798 ++i, ++sec)
5799 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5800 && streq (SECTION_NAME (sec) + len2, suffix))
5801 break;
5802 }
5803 else
5804 {
5805 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5806 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5807 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5808 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5809 suffix = "";
5810 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5811 suffix = SECTION_NAME (unwsec) + len;
5812 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5813 ++i, ++sec)
5814 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5815 && streq (SECTION_NAME (sec) + len2, suffix))
5816 break;
5817 }
5818
5819 if (i == elf_header.e_shnum)
5820 {
5821 printf (_("\nCould not find unwind info section for "));
5822
5823 if (string_table == NULL)
5824 printf ("%d", unwsec->sh_name);
5825 else
5826 printf (_("'%s'"), SECTION_NAME (unwsec));
5827 }
5828 else
5829 {
5830 aux.info_size = sec->sh_size;
5831 aux.info_addr = sec->sh_addr;
5832 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5833 aux.info_size,
5834 _("unwind info"));
5835
5836 printf (_("\nUnwind section "));
5837
5838 if (string_table == NULL)
5839 printf ("%d", unwsec->sh_name);
5840 else
5841 printf (_("'%s'"), SECTION_NAME (unwsec));
5842
5843 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5844 (unsigned long) unwsec->sh_offset,
5845 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5846
5847 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5848
5849 if (aux.table_len > 0)
5850 dump_ia64_unwind (& aux);
5851
5852 if (aux.table)
5853 free ((char *) aux.table);
5854 if (aux.info)
5855 free ((char *) aux.info);
5856 aux.table = NULL;
5857 aux.info = NULL;
5858 }
5859 }
5860
5861 if (aux.symtab)
5862 free (aux.symtab);
5863 if (aux.strtab)
5864 free ((char *) aux.strtab);
5865
5866 return 1;
5867 }
5868
5869 struct hppa_unw_table_entry
5870 {
5871 struct absaddr start;
5872 struct absaddr end;
5873 unsigned int Cannot_unwind:1; /* 0 */
5874 unsigned int Millicode:1; /* 1 */
5875 unsigned int Millicode_save_sr0:1; /* 2 */
5876 unsigned int Region_description:2; /* 3..4 */
5877 unsigned int reserved1:1; /* 5 */
5878 unsigned int Entry_SR:1; /* 6 */
5879 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5880 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5881 unsigned int Args_stored:1; /* 16 */
5882 unsigned int Variable_Frame:1; /* 17 */
5883 unsigned int Separate_Package_Body:1; /* 18 */
5884 unsigned int Frame_Extension_Millicode:1; /* 19 */
5885 unsigned int Stack_Overflow_Check:1; /* 20 */
5886 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5887 unsigned int Ada_Region:1; /* 22 */
5888 unsigned int cxx_info:1; /* 23 */
5889 unsigned int cxx_try_catch:1; /* 24 */
5890 unsigned int sched_entry_seq:1; /* 25 */
5891 unsigned int reserved2:1; /* 26 */
5892 unsigned int Save_SP:1; /* 27 */
5893 unsigned int Save_RP:1; /* 28 */
5894 unsigned int Save_MRP_in_frame:1; /* 29 */
5895 unsigned int extn_ptr_defined:1; /* 30 */
5896 unsigned int Cleanup_defined:1; /* 31 */
5897
5898 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5899 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5900 unsigned int Large_frame:1; /* 2 */
5901 unsigned int Pseudo_SP_Set:1; /* 3 */
5902 unsigned int reserved4:1; /* 4 */
5903 unsigned int Total_frame_size:27; /* 5..31 */
5904 };
5905
5906 struct hppa_unw_aux_info
5907 {
5908 struct hppa_unw_table_entry *table; /* Unwind table. */
5909 unsigned long table_len; /* Length of unwind table. */
5910 bfd_vma seg_base; /* Starting address of segment. */
5911 Elf_Internal_Sym * symtab; /* The symbol table. */
5912 unsigned long nsyms; /* Number of symbols. */
5913 char * strtab; /* The string table. */
5914 unsigned long strtab_size; /* Size of string table. */
5915 };
5916
5917 static void
5918 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5919 {
5920 struct hppa_unw_table_entry * tp;
5921
5922 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5923 {
5924 bfd_vma offset;
5925 const char * procname;
5926
5927 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5928 aux->strtab_size, tp->start, &procname,
5929 &offset);
5930
5931 fputs ("\n<", stdout);
5932
5933 if (procname)
5934 {
5935 fputs (procname, stdout);
5936
5937 if (offset)
5938 printf ("+%lx", (unsigned long) offset);
5939 }
5940
5941 fputs (">: [", stdout);
5942 print_vma (tp->start.offset, PREFIX_HEX);
5943 fputc ('-', stdout);
5944 print_vma (tp->end.offset, PREFIX_HEX);
5945 printf ("]\n\t");
5946
5947 #define PF(_m) if (tp->_m) printf (#_m " ");
5948 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5949 PF(Cannot_unwind);
5950 PF(Millicode);
5951 PF(Millicode_save_sr0);
5952 /* PV(Region_description); */
5953 PF(Entry_SR);
5954 PV(Entry_FR);
5955 PV(Entry_GR);
5956 PF(Args_stored);
5957 PF(Variable_Frame);
5958 PF(Separate_Package_Body);
5959 PF(Frame_Extension_Millicode);
5960 PF(Stack_Overflow_Check);
5961 PF(Two_Instruction_SP_Increment);
5962 PF(Ada_Region);
5963 PF(cxx_info);
5964 PF(cxx_try_catch);
5965 PF(sched_entry_seq);
5966 PF(Save_SP);
5967 PF(Save_RP);
5968 PF(Save_MRP_in_frame);
5969 PF(extn_ptr_defined);
5970 PF(Cleanup_defined);
5971 PF(MPE_XL_interrupt_marker);
5972 PF(HP_UX_interrupt_marker);
5973 PF(Large_frame);
5974 PF(Pseudo_SP_Set);
5975 PV(Total_frame_size);
5976 #undef PF
5977 #undef PV
5978 }
5979
5980 printf ("\n");
5981 }
5982
5983 static int
5984 slurp_hppa_unwind_table (FILE * file,
5985 struct hppa_unw_aux_info * aux,
5986 Elf_Internal_Shdr * sec)
5987 {
5988 unsigned long size, unw_ent_size, nentries, nrelas, i;
5989 Elf_Internal_Phdr * seg;
5990 struct hppa_unw_table_entry * tep;
5991 Elf_Internal_Shdr * relsec;
5992 Elf_Internal_Rela * rela;
5993 Elf_Internal_Rela * rp;
5994 unsigned char * table;
5995 unsigned char * tp;
5996 Elf_Internal_Sym * sym;
5997 const char * relname;
5998
5999 /* First, find the starting address of the segment that includes
6000 this section. */
6001
6002 if (elf_header.e_phnum)
6003 {
6004 if (! get_program_headers (file))
6005 return 0;
6006
6007 for (seg = program_headers;
6008 seg < program_headers + elf_header.e_phnum;
6009 ++seg)
6010 {
6011 if (seg->p_type != PT_LOAD)
6012 continue;
6013
6014 if (sec->sh_addr >= seg->p_vaddr
6015 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6016 {
6017 aux->seg_base = seg->p_vaddr;
6018 break;
6019 }
6020 }
6021 }
6022
6023 /* Second, build the unwind table from the contents of the unwind
6024 section. */
6025 size = sec->sh_size;
6026 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6027 _("unwind table"));
6028 if (!table)
6029 return 0;
6030
6031 unw_ent_size = 16;
6032 nentries = size / unw_ent_size;
6033 size = unw_ent_size * nentries;
6034
6035 tep = aux->table = (struct hppa_unw_table_entry *)
6036 xcmalloc (nentries, sizeof (aux->table[0]));
6037
6038 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6039 {
6040 unsigned int tmp1, tmp2;
6041
6042 tep->start.section = SHN_UNDEF;
6043 tep->end.section = SHN_UNDEF;
6044
6045 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6046 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6047 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6048 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6049
6050 tep->start.offset += aux->seg_base;
6051 tep->end.offset += aux->seg_base;
6052
6053 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6054 tep->Millicode = (tmp1 >> 30) & 0x1;
6055 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6056 tep->Region_description = (tmp1 >> 27) & 0x3;
6057 tep->reserved1 = (tmp1 >> 26) & 0x1;
6058 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6059 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6060 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6061 tep->Args_stored = (tmp1 >> 15) & 0x1;
6062 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6063 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6064 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6065 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6066 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6067 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6068 tep->cxx_info = (tmp1 >> 8) & 0x1;
6069 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6070 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6071 tep->reserved2 = (tmp1 >> 5) & 0x1;
6072 tep->Save_SP = (tmp1 >> 4) & 0x1;
6073 tep->Save_RP = (tmp1 >> 3) & 0x1;
6074 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6075 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6076 tep->Cleanup_defined = tmp1 & 0x1;
6077
6078 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6079 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6080 tep->Large_frame = (tmp2 >> 29) & 0x1;
6081 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6082 tep->reserved4 = (tmp2 >> 27) & 0x1;
6083 tep->Total_frame_size = tmp2 & 0x7ffffff;
6084 }
6085 free (table);
6086
6087 /* Third, apply any relocations to the unwind table. */
6088 for (relsec = section_headers;
6089 relsec < section_headers + elf_header.e_shnum;
6090 ++relsec)
6091 {
6092 if (relsec->sh_type != SHT_RELA
6093 || relsec->sh_info >= elf_header.e_shnum
6094 || section_headers + relsec->sh_info != sec)
6095 continue;
6096
6097 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6098 & rela, & nrelas))
6099 return 0;
6100
6101 for (rp = rela; rp < rela + nrelas; ++rp)
6102 {
6103 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6104 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6105
6106 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6107 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6108 {
6109 warn (_("Skipping unexpected relocation type %s\n"), relname);
6110 continue;
6111 }
6112
6113 i = rp->r_offset / unw_ent_size;
6114
6115 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6116 {
6117 case 0:
6118 aux->table[i].start.section = sym->st_shndx;
6119 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6120 break;
6121 case 1:
6122 aux->table[i].end.section = sym->st_shndx;
6123 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6124 break;
6125 default:
6126 break;
6127 }
6128 }
6129
6130 free (rela);
6131 }
6132
6133 aux->table_len = nentries;
6134
6135 return 1;
6136 }
6137
6138 static int
6139 hppa_process_unwind (FILE * file)
6140 {
6141 struct hppa_unw_aux_info aux;
6142 Elf_Internal_Shdr * unwsec = NULL;
6143 Elf_Internal_Shdr * strsec;
6144 Elf_Internal_Shdr * sec;
6145 unsigned long i;
6146
6147 memset (& aux, 0, sizeof (aux));
6148
6149 if (string_table == NULL)
6150 return 1;
6151
6152 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6153 {
6154 if (sec->sh_type == SHT_SYMTAB
6155 && sec->sh_link < elf_header.e_shnum)
6156 {
6157 aux.nsyms = sec->sh_size / sec->sh_entsize;
6158 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6159
6160 strsec = section_headers + sec->sh_link;
6161 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6162 1, strsec->sh_size,
6163 _("string table"));
6164 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6165 }
6166 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6167 unwsec = sec;
6168 }
6169
6170 if (!unwsec)
6171 printf (_("\nThere are no unwind sections in this file.\n"));
6172
6173 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6174 {
6175 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6176 {
6177 printf (_("\nUnwind section "));
6178 printf (_("'%s'"), SECTION_NAME (sec));
6179
6180 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6181 (unsigned long) sec->sh_offset,
6182 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6183
6184 slurp_hppa_unwind_table (file, &aux, sec);
6185 if (aux.table_len > 0)
6186 dump_hppa_unwind (&aux);
6187
6188 if (aux.table)
6189 free ((char *) aux.table);
6190 aux.table = NULL;
6191 }
6192 }
6193
6194 if (aux.symtab)
6195 free (aux.symtab);
6196 if (aux.strtab)
6197 free ((char *) aux.strtab);
6198
6199 return 1;
6200 }
6201
6202 struct arm_section
6203 {
6204 unsigned char *data;
6205
6206 Elf_Internal_Shdr *sec;
6207 Elf_Internal_Rela *rela;
6208 unsigned long nrelas;
6209 unsigned int rel_type;
6210
6211 Elf_Internal_Rela *next_rela;
6212 };
6213
6214 struct arm_unw_aux_info
6215 {
6216 FILE *file;
6217
6218 Elf_Internal_Sym *symtab; /* The symbol table. */
6219 unsigned long nsyms; /* Number of symbols. */
6220 char *strtab; /* The string table. */
6221 unsigned long strtab_size; /* Size of string table. */
6222 };
6223
6224 static const char *
6225 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6226 bfd_vma fn, struct absaddr addr)
6227 {
6228 const char *procname;
6229 bfd_vma sym_offset;
6230
6231 if (addr.section == SHN_UNDEF)
6232 addr.offset = fn;
6233
6234 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6235 aux->strtab_size, addr, &procname,
6236 &sym_offset);
6237
6238 print_vma (fn, PREFIX_HEX);
6239
6240 if (procname)
6241 {
6242 fputs (" <", stdout);
6243 fputs (procname, stdout);
6244
6245 if (sym_offset)
6246 printf ("+0x%lx", (unsigned long) sym_offset);
6247 fputc ('>', stdout);
6248 }
6249
6250 return procname;
6251 }
6252
6253 static void
6254 arm_free_section (struct arm_section *arm_sec)
6255 {
6256 if (arm_sec->data != NULL)
6257 free (arm_sec->data);
6258
6259 if (arm_sec->rela != NULL)
6260 free (arm_sec->rela);
6261 }
6262
6263 static int
6264 arm_section_get_word (struct arm_unw_aux_info *aux,
6265 struct arm_section *arm_sec,
6266 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6267 unsigned int *wordp, struct absaddr *addr)
6268 {
6269 Elf_Internal_Rela *rp;
6270 Elf_Internal_Sym *sym;
6271 const char * relname;
6272 unsigned int word;
6273 bfd_boolean wrapped;
6274
6275 addr->section = SHN_UNDEF;
6276 addr->offset = 0;
6277
6278 if (sec != arm_sec->sec)
6279 {
6280 Elf_Internal_Shdr *relsec;
6281
6282 arm_free_section (arm_sec);
6283
6284 arm_sec->sec = sec;
6285 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6286 sec->sh_size, _("unwind data"));
6287
6288 arm_sec->rela = NULL;
6289 arm_sec->nrelas = 0;
6290
6291 for (relsec = section_headers;
6292 relsec < section_headers + elf_header.e_shnum;
6293 ++relsec)
6294 {
6295 if (relsec->sh_info >= elf_header.e_shnum
6296 || section_headers + relsec->sh_info != sec)
6297 continue;
6298
6299 if (relsec->sh_type == SHT_REL)
6300 {
6301 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6302 relsec->sh_size,
6303 & arm_sec->rela, & arm_sec->nrelas))
6304 return 0;
6305 break;
6306 }
6307 else if (relsec->sh_type == SHT_RELA)
6308 {
6309 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6310 relsec->sh_size,
6311 & arm_sec->rela, & arm_sec->nrelas))
6312 return 0;
6313 break;
6314 }
6315 }
6316
6317 arm_sec->next_rela = arm_sec->rela;
6318 }
6319
6320 if (arm_sec->data == NULL)
6321 return 0;
6322
6323 word = byte_get (arm_sec->data + word_offset, 4);
6324
6325 wrapped = FALSE;
6326 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6327 {
6328 bfd_vma prelval, offset;
6329
6330 if (rp->r_offset > word_offset && !wrapped)
6331 {
6332 rp = arm_sec->rela;
6333 wrapped = TRUE;
6334 }
6335 if (rp->r_offset > word_offset)
6336 break;
6337
6338 if (rp->r_offset & 3)
6339 {
6340 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6341 (unsigned long) rp->r_offset);
6342 continue;
6343 }
6344
6345 if (rp->r_offset < word_offset)
6346 continue;
6347
6348 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6349
6350 if (streq (relname, "R_ARM_NONE"))
6351 continue;
6352
6353 if (! streq (relname, "R_ARM_PREL31"))
6354 {
6355 warn (_("Skipping unexpected relocation type %s\n"), relname);
6356 continue;
6357 }
6358
6359 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6360
6361 if (arm_sec->rel_type == SHT_REL)
6362 {
6363 offset = word & 0x7fffffff;
6364 if (offset & 0x40000000)
6365 offset |= ~ (bfd_vma) 0x7fffffff;
6366 }
6367 else
6368 offset = rp->r_addend;
6369
6370 offset += sym->st_value;
6371 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6372
6373 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6374 addr->section = sym->st_shndx;
6375 addr->offset = offset;
6376 break;
6377 }
6378
6379 *wordp = word;
6380 arm_sec->next_rela = rp;
6381
6382 return 1;
6383 }
6384
6385 static void
6386 decode_arm_unwind (struct arm_unw_aux_info *aux,
6387 unsigned int word, unsigned int remaining,
6388 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6389 struct arm_section *data_arm_sec)
6390 {
6391 int per_index;
6392 unsigned int more_words;
6393 struct absaddr addr;
6394
6395 #define ADVANCE \
6396 if (remaining == 0 && more_words) \
6397 { \
6398 data_offset += 4; \
6399 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6400 data_offset, &word, &addr)) \
6401 return; \
6402 remaining = 4; \
6403 more_words--; \
6404 } \
6405
6406 #define GET_OP(OP) \
6407 ADVANCE; \
6408 if (remaining) \
6409 { \
6410 remaining--; \
6411 (OP) = word >> 24; \
6412 word <<= 8; \
6413 } \
6414 else \
6415 { \
6416 printf (_("[Truncated opcode]\n")); \
6417 return; \
6418 } \
6419 printf (_("0x%02x "), OP)
6420
6421 if (remaining == 0)
6422 {
6423 /* Fetch the first word. */
6424 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6425 &word, &addr))
6426 return;
6427 remaining = 4;
6428 }
6429
6430 if ((word & 0x80000000) == 0)
6431 {
6432 /* Expand prel31 for personality routine. */
6433 bfd_vma fn;
6434 const char *procname;
6435
6436 fn = word;
6437 if (fn & 0x40000000)
6438 fn |= ~ (bfd_vma) 0x7fffffff;
6439 fn = fn + data_sec->sh_addr + data_offset;
6440
6441 printf (_(" Personality routine: "));
6442 procname = arm_print_vma_and_name (aux, fn, addr);
6443 fputc ('\n', stdout);
6444
6445 /* The GCC personality routines use the standard compact
6446 encoding, starting with one byte giving the number of
6447 words. */
6448 if (procname != NULL
6449 && (const_strneq (procname, "__gcc_personality_v0")
6450 || const_strneq (procname, "__gxx_personality_v0")
6451 || const_strneq (procname, "__gcj_personality_v0")
6452 || const_strneq (procname, "__gnu_objc_personality_v0")))
6453 {
6454 remaining = 0;
6455 more_words = 1;
6456 ADVANCE;
6457 if (!remaining)
6458 {
6459 printf (_(" [Truncated data]\n"));
6460 return;
6461 }
6462 more_words = word >> 24;
6463 word <<= 8;
6464 remaining--;
6465 }
6466 else
6467 return;
6468 }
6469 else
6470 {
6471 per_index = (word >> 24) & 0x7f;
6472 if (per_index != 0 && per_index != 1 && per_index != 2)
6473 {
6474 printf (_(" [reserved compact index %d]\n"), per_index);
6475 return;
6476 }
6477
6478 printf (_(" Compact model %d\n"), per_index);
6479 if (per_index == 0)
6480 {
6481 more_words = 0;
6482 word <<= 8;
6483 remaining--;
6484 }
6485 else
6486 {
6487 more_words = (word >> 16) & 0xff;
6488 word <<= 16;
6489 remaining -= 2;
6490 }
6491 }
6492
6493 /* Decode the unwinding instructions. */
6494 while (1)
6495 {
6496 unsigned int op, op2;
6497
6498 ADVANCE;
6499 if (remaining == 0)
6500 break;
6501 remaining--;
6502 op = word >> 24;
6503 word <<= 8;
6504
6505 printf (_(" 0x%02x "), op);
6506
6507 if ((op & 0xc0) == 0x00)
6508 {
6509 int offset = ((op & 0x3f) << 2) + 4;
6510 printf (_(" vsp = vsp + %d"), offset);
6511 }
6512 else if ((op & 0xc0) == 0x40)
6513 {
6514 int offset = ((op & 0x3f) << 2) + 4;
6515 printf (_(" vsp = vsp - %d"), offset);
6516 }
6517 else if ((op & 0xf0) == 0x80)
6518 {
6519 GET_OP (op2);
6520 if (op == 0x80 && op2 == 0)
6521 printf (_("Refuse to unwind"));
6522 else
6523 {
6524 unsigned int mask = ((op & 0x0f) << 8) | op2;
6525 int first = 1;
6526 int i;
6527
6528 printf ("pop {");
6529 for (i = 0; i < 12; i++)
6530 if (mask & (1 << i))
6531 {
6532 if (first)
6533 first = 0;
6534 else
6535 printf (", ");
6536 printf ("r%d", 4 + i);
6537 }
6538 printf ("}");
6539 }
6540 }
6541 else if ((op & 0xf0) == 0x90)
6542 {
6543 if (op == 0x9d || op == 0x9f)
6544 printf (_(" [Reserved]"));
6545 else
6546 printf (_(" vsp = r%d"), op & 0x0f);
6547 }
6548 else if ((op & 0xf0) == 0xa0)
6549 {
6550 int end = 4 + (op & 0x07);
6551 int first = 1;
6552 int i;
6553 printf (" pop {");
6554 for (i = 4; i <= end; i++)
6555 {
6556 if (first)
6557 first = 0;
6558 else
6559 printf (", ");
6560 printf ("r%d", i);
6561 }
6562 if (op & 0x08)
6563 {
6564 if (first)
6565 printf (", ");
6566 printf ("r14");
6567 }
6568 printf ("}");
6569 }
6570 else if (op == 0xb0)
6571 printf (_(" finish"));
6572 else if (op == 0xb1)
6573 {
6574 GET_OP (op2);
6575 if (op2 == 0 || (op2 & 0xf0) != 0)
6576 printf (_("[Spare]"));
6577 else
6578 {
6579 unsigned int mask = op2 & 0x0f;
6580 int first = 1;
6581 int i;
6582 printf ("pop {");
6583 for (i = 0; i < 12; i++)
6584 if (mask & (1 << i))
6585 {
6586 if (first)
6587 first = 0;
6588 else
6589 printf (", ");
6590 printf ("r%d", i);
6591 }
6592 printf ("}");
6593 }
6594 }
6595 else if (op == 0xb2)
6596 {
6597 unsigned char buf[9];
6598 unsigned int i, len;
6599 unsigned long offset;
6600 for (i = 0; i < sizeof (buf); i++)
6601 {
6602 GET_OP (buf[i]);
6603 if ((buf[i] & 0x80) == 0)
6604 break;
6605 }
6606 assert (i < sizeof (buf));
6607 offset = read_uleb128 (buf, &len);
6608 assert (len == i + 1);
6609 offset = offset * 4 + 0x204;
6610 printf (_("vsp = vsp + %ld"), offset);
6611 }
6612 else
6613 {
6614 if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
6615 {
6616 GET_OP (op2);
6617 printf (_("[unsupported two-byte opcode]"));
6618 }
6619 else
6620 {
6621 printf (_(" [unsupported opcode]"));
6622 }
6623 }
6624 printf ("\n");
6625 }
6626
6627 /* Decode the descriptors. Not implemented. */
6628 }
6629
6630 static void
6631 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6632 {
6633 struct arm_section exidx_arm_sec, extab_arm_sec;
6634 unsigned int i, exidx_len;
6635
6636 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6637 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6638 exidx_len = exidx_sec->sh_size / 8;
6639
6640 for (i = 0; i < exidx_len; i++)
6641 {
6642 unsigned int exidx_fn, exidx_entry;
6643 struct absaddr fn_addr, entry_addr;
6644 bfd_vma fn;
6645
6646 fputc ('\n', stdout);
6647
6648 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6649 8 * i, &exidx_fn, &fn_addr)
6650 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6651 8 * i + 4, &exidx_entry, &entry_addr))
6652 {
6653 arm_free_section (&exidx_arm_sec);
6654 arm_free_section (&extab_arm_sec);
6655 return;
6656 }
6657
6658 fn = exidx_fn & 0x7fffffff;
6659 if (fn & 0x40000000)
6660 fn |= ~ (bfd_vma) 0x7fffffff;
6661 fn = fn + exidx_sec->sh_addr + 8 * i;
6662
6663 arm_print_vma_and_name (aux, fn, entry_addr);
6664 fputs (": ", stdout);
6665
6666 if (exidx_entry == 1)
6667 {
6668 print_vma (exidx_entry, PREFIX_HEX);
6669 fputs (" [cantunwind]\n", stdout);
6670 }
6671 else if (exidx_entry & 0x80000000)
6672 {
6673 print_vma (exidx_entry, PREFIX_HEX);
6674 fputc ('\n', stdout);
6675 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6676 }
6677 else
6678 {
6679 bfd_vma table, table_offset = 0;
6680 Elf_Internal_Shdr *table_sec;
6681
6682 fputs ("@", stdout);
6683 table = exidx_entry;
6684 if (table & 0x40000000)
6685 table |= ~ (bfd_vma) 0x7fffffff;
6686 table = table + exidx_sec->sh_addr + 8 * i + 4;
6687 print_vma (table, PREFIX_HEX);
6688 printf ("\n");
6689
6690 /* Locate the matching .ARM.extab. */
6691 if (entry_addr.section != SHN_UNDEF
6692 && entry_addr.section < elf_header.e_shnum)
6693 {
6694 table_sec = section_headers + entry_addr.section;
6695 table_offset = entry_addr.offset;
6696 }
6697 else
6698 {
6699 table_sec = find_section_by_address (table);
6700 if (table_sec != NULL)
6701 table_offset = table - table_sec->sh_addr;
6702 }
6703 if (table_sec == NULL)
6704 {
6705 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6706 (unsigned long) table);
6707 continue;
6708 }
6709 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6710 &extab_arm_sec);
6711 }
6712 }
6713
6714 printf ("\n");
6715
6716 arm_free_section (&exidx_arm_sec);
6717 arm_free_section (&extab_arm_sec);
6718 }
6719
6720 static int
6721 arm_process_unwind (FILE *file)
6722 {
6723 struct arm_unw_aux_info aux;
6724 Elf_Internal_Shdr *unwsec = NULL;
6725 Elf_Internal_Shdr *strsec;
6726 Elf_Internal_Shdr *sec;
6727 unsigned long i;
6728
6729 memset (& aux, 0, sizeof (aux));
6730 aux.file = file;
6731
6732 if (string_table == NULL)
6733 return 1;
6734
6735 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6736 {
6737 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6738 {
6739 aux.nsyms = sec->sh_size / sec->sh_entsize;
6740 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6741
6742 strsec = section_headers + sec->sh_link;
6743 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6744 1, strsec->sh_size, _("string table"));
6745 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6746 }
6747 else if (sec->sh_type == SHT_ARM_EXIDX)
6748 unwsec = sec;
6749 }
6750
6751 if (!unwsec)
6752 printf (_("\nThere are no unwind sections in this file.\n"));
6753
6754 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6755 {
6756 if (sec->sh_type == SHT_ARM_EXIDX)
6757 {
6758 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6759 SECTION_NAME (sec),
6760 (unsigned long) sec->sh_offset,
6761 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6762
6763 dump_arm_unwind (&aux, sec);
6764 }
6765 }
6766
6767 if (aux.symtab)
6768 free (aux.symtab);
6769 if (aux.strtab)
6770 free ((char *) aux.strtab);
6771
6772 return 1;
6773 }
6774
6775 static int
6776 process_unwind (FILE * file)
6777 {
6778 struct unwind_handler
6779 {
6780 int machtype;
6781 int (* handler)(FILE *);
6782 } handlers[] =
6783 {
6784 { EM_ARM, arm_process_unwind },
6785 { EM_IA_64, ia64_process_unwind },
6786 { EM_PARISC, hppa_process_unwind },
6787 { 0, 0 }
6788 };
6789 int i;
6790
6791 if (!do_unwind)
6792 return 1;
6793
6794 for (i = 0; handlers[i].handler != NULL; i++)
6795 if (elf_header.e_machine == handlers[i].machtype)
6796 return handlers[i].handler (file);
6797
6798 printf (_("\nThere are no unwind sections in this file.\n"));
6799 return 1;
6800 }
6801
6802 static void
6803 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
6804 {
6805 switch (entry->d_tag)
6806 {
6807 case DT_MIPS_FLAGS:
6808 if (entry->d_un.d_val == 0)
6809 printf (_("NONE\n"));
6810 else
6811 {
6812 static const char * opts[] =
6813 {
6814 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6815 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6816 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6817 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6818 "RLD_ORDER_SAFE"
6819 };
6820 unsigned int cnt;
6821 int first = 1;
6822
6823 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
6824 if (entry->d_un.d_val & (1 << cnt))
6825 {
6826 printf ("%s%s", first ? "" : " ", opts[cnt]);
6827 first = 0;
6828 }
6829 puts ("");
6830 }
6831 break;
6832
6833 case DT_MIPS_IVERSION:
6834 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6835 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
6836 else
6837 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
6838 break;
6839
6840 case DT_MIPS_TIME_STAMP:
6841 {
6842 char timebuf[20];
6843 struct tm * tmp;
6844
6845 time_t atime = entry->d_un.d_val;
6846 tmp = gmtime (&atime);
6847 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6848 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6849 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6850 printf (_("Time Stamp: %s\n"), timebuf);
6851 }
6852 break;
6853
6854 case DT_MIPS_RLD_VERSION:
6855 case DT_MIPS_LOCAL_GOTNO:
6856 case DT_MIPS_CONFLICTNO:
6857 case DT_MIPS_LIBLISTNO:
6858 case DT_MIPS_SYMTABNO:
6859 case DT_MIPS_UNREFEXTNO:
6860 case DT_MIPS_HIPAGENO:
6861 case DT_MIPS_DELTA_CLASS_NO:
6862 case DT_MIPS_DELTA_INSTANCE_NO:
6863 case DT_MIPS_DELTA_RELOC_NO:
6864 case DT_MIPS_DELTA_SYM_NO:
6865 case DT_MIPS_DELTA_CLASSSYM_NO:
6866 case DT_MIPS_COMPACT_SIZE:
6867 printf ("%ld\n", (long) entry->d_un.d_ptr);
6868 break;
6869
6870 default:
6871 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
6872 }
6873 }
6874
6875 static void
6876 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
6877 {
6878 switch (entry->d_tag)
6879 {
6880 case DT_HP_DLD_FLAGS:
6881 {
6882 static struct
6883 {
6884 long int bit;
6885 const char * str;
6886 }
6887 flags[] =
6888 {
6889 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6890 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6891 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6892 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6893 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6894 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6895 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6896 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6897 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6898 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
6899 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6900 { DT_HP_GST, "HP_GST" },
6901 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6902 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6903 { DT_HP_NODELETE, "HP_NODELETE" },
6904 { DT_HP_GROUP, "HP_GROUP" },
6905 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
6906 };
6907 int first = 1;
6908 size_t cnt;
6909 bfd_vma val = entry->d_un.d_val;
6910
6911 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
6912 if (val & flags[cnt].bit)
6913 {
6914 if (! first)
6915 putchar (' ');
6916 fputs (flags[cnt].str, stdout);
6917 first = 0;
6918 val ^= flags[cnt].bit;
6919 }
6920
6921 if (val != 0 || first)
6922 {
6923 if (! first)
6924 putchar (' ');
6925 print_vma (val, HEX);
6926 }
6927 }
6928 break;
6929
6930 default:
6931 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6932 break;
6933 }
6934 putchar ('\n');
6935 }
6936
6937 #ifdef BFD64
6938
6939 /* VMS vs Unix time offset and factor. */
6940
6941 #define VMS_EPOCH_OFFSET 35067168000000000LL
6942 #define VMS_GRANULARITY_FACTOR 10000000
6943
6944 /* Display a VMS time in a human readable format. */
6945
6946 static void
6947 print_vms_time (bfd_int64_t vmstime)
6948 {
6949 struct tm *tm;
6950 time_t unxtime;
6951
6952 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
6953 tm = gmtime (&unxtime);
6954 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6955 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
6956 tm->tm_hour, tm->tm_min, tm->tm_sec);
6957 }
6958 #endif /* BFD64 */
6959
6960 static void
6961 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
6962 {
6963 switch (entry->d_tag)
6964 {
6965 case DT_IA_64_PLT_RESERVE:
6966 /* First 3 slots reserved. */
6967 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6968 printf (" -- ");
6969 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
6970 break;
6971
6972 case DT_IA_64_VMS_LINKTIME:
6973 #ifdef BFD64
6974 print_vms_time (entry->d_un.d_val);
6975 #endif
6976 break;
6977
6978 case DT_IA_64_VMS_LNKFLAGS:
6979 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6980 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
6981 printf (" CALL_DEBUG");
6982 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
6983 printf (" NOP0BUFS");
6984 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
6985 printf (" P0IMAGE");
6986 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
6987 printf (" MKTHREADS");
6988 if (entry->d_un.d_val & VMS_LF_UPCALLS)
6989 printf (" UPCALLS");
6990 if (entry->d_un.d_val & VMS_LF_IMGSTA)
6991 printf (" IMGSTA");
6992 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
6993 printf (" INITIALIZE");
6994 if (entry->d_un.d_val & VMS_LF_MAIN)
6995 printf (" MAIN");
6996 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
6997 printf (" EXE_INIT");
6998 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
6999 printf (" TBK_IN_IMG");
7000 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7001 printf (" DBG_IN_IMG");
7002 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7003 printf (" TBK_IN_DSF");
7004 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7005 printf (" DBG_IN_DSF");
7006 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7007 printf (" SIGNATURES");
7008 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7009 printf (" REL_SEG_OFF");
7010 break;
7011
7012 default:
7013 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7014 break;
7015 }
7016 putchar ('\n');
7017 }
7018
7019 static int
7020 get_32bit_dynamic_section (FILE * file)
7021 {
7022 Elf32_External_Dyn * edyn;
7023 Elf32_External_Dyn * ext;
7024 Elf_Internal_Dyn * entry;
7025
7026 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7027 dynamic_size, _("dynamic section"));
7028 if (!edyn)
7029 return 0;
7030
7031 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7032 might not have the luxury of section headers. Look for the DT_NULL
7033 terminator to determine the number of entries. */
7034 for (ext = edyn, dynamic_nent = 0;
7035 (char *) ext < (char *) edyn + dynamic_size;
7036 ext++)
7037 {
7038 dynamic_nent++;
7039 if (BYTE_GET (ext->d_tag) == DT_NULL)
7040 break;
7041 }
7042
7043 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7044 sizeof (* entry));
7045 if (dynamic_section == NULL)
7046 {
7047 error (_("Out of memory\n"));
7048 free (edyn);
7049 return 0;
7050 }
7051
7052 for (ext = edyn, entry = dynamic_section;
7053 entry < dynamic_section + dynamic_nent;
7054 ext++, entry++)
7055 {
7056 entry->d_tag = BYTE_GET (ext->d_tag);
7057 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7058 }
7059
7060 free (edyn);
7061
7062 return 1;
7063 }
7064
7065 static int
7066 get_64bit_dynamic_section (FILE * file)
7067 {
7068 Elf64_External_Dyn * edyn;
7069 Elf64_External_Dyn * ext;
7070 Elf_Internal_Dyn * entry;
7071
7072 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7073 dynamic_size, _("dynamic section"));
7074 if (!edyn)
7075 return 0;
7076
7077 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7078 might not have the luxury of section headers. Look for the DT_NULL
7079 terminator to determine the number of entries. */
7080 for (ext = edyn, dynamic_nent = 0;
7081 (char *) ext < (char *) edyn + dynamic_size;
7082 ext++)
7083 {
7084 dynamic_nent++;
7085 if (BYTE_GET (ext->d_tag) == DT_NULL)
7086 break;
7087 }
7088
7089 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7090 sizeof (* entry));
7091 if (dynamic_section == NULL)
7092 {
7093 error (_("Out of memory\n"));
7094 free (edyn);
7095 return 0;
7096 }
7097
7098 for (ext = edyn, entry = dynamic_section;
7099 entry < dynamic_section + dynamic_nent;
7100 ext++, entry++)
7101 {
7102 entry->d_tag = BYTE_GET (ext->d_tag);
7103 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7104 }
7105
7106 free (edyn);
7107
7108 return 1;
7109 }
7110
7111 static void
7112 print_dynamic_flags (bfd_vma flags)
7113 {
7114 int first = 1;
7115
7116 while (flags)
7117 {
7118 bfd_vma flag;
7119
7120 flag = flags & - flags;
7121 flags &= ~ flag;
7122
7123 if (first)
7124 first = 0;
7125 else
7126 putc (' ', stdout);
7127
7128 switch (flag)
7129 {
7130 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7131 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7132 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7133 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7134 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7135 default: fputs (_("unknown"), stdout); break;
7136 }
7137 }
7138 puts ("");
7139 }
7140
7141 /* Parse and display the contents of the dynamic section. */
7142
7143 static int
7144 process_dynamic_section (FILE * file)
7145 {
7146 Elf_Internal_Dyn * entry;
7147
7148 if (dynamic_size == 0)
7149 {
7150 if (do_dynamic)
7151 printf (_("\nThere is no dynamic section in this file.\n"));
7152
7153 return 1;
7154 }
7155
7156 if (is_32bit_elf)
7157 {
7158 if (! get_32bit_dynamic_section (file))
7159 return 0;
7160 }
7161 else if (! get_64bit_dynamic_section (file))
7162 return 0;
7163
7164 /* Find the appropriate symbol table. */
7165 if (dynamic_symbols == NULL)
7166 {
7167 for (entry = dynamic_section;
7168 entry < dynamic_section + dynamic_nent;
7169 ++entry)
7170 {
7171 Elf_Internal_Shdr section;
7172
7173 if (entry->d_tag != DT_SYMTAB)
7174 continue;
7175
7176 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7177
7178 /* Since we do not know how big the symbol table is,
7179 we default to reading in the entire file (!) and
7180 processing that. This is overkill, I know, but it
7181 should work. */
7182 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7183
7184 if (archive_file_offset != 0)
7185 section.sh_size = archive_file_size - section.sh_offset;
7186 else
7187 {
7188 if (fseek (file, 0, SEEK_END))
7189 error (_("Unable to seek to end of file!\n"));
7190
7191 section.sh_size = ftell (file) - section.sh_offset;
7192 }
7193
7194 if (is_32bit_elf)
7195 section.sh_entsize = sizeof (Elf32_External_Sym);
7196 else
7197 section.sh_entsize = sizeof (Elf64_External_Sym);
7198
7199 num_dynamic_syms = section.sh_size / section.sh_entsize;
7200 if (num_dynamic_syms < 1)
7201 {
7202 error (_("Unable to determine the number of symbols to load\n"));
7203 continue;
7204 }
7205
7206 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
7207 }
7208 }
7209
7210 /* Similarly find a string table. */
7211 if (dynamic_strings == NULL)
7212 {
7213 for (entry = dynamic_section;
7214 entry < dynamic_section + dynamic_nent;
7215 ++entry)
7216 {
7217 unsigned long offset;
7218 long str_tab_len;
7219
7220 if (entry->d_tag != DT_STRTAB)
7221 continue;
7222
7223 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7224
7225 /* Since we do not know how big the string table is,
7226 we default to reading in the entire file (!) and
7227 processing that. This is overkill, I know, but it
7228 should work. */
7229
7230 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7231
7232 if (archive_file_offset != 0)
7233 str_tab_len = archive_file_size - offset;
7234 else
7235 {
7236 if (fseek (file, 0, SEEK_END))
7237 error (_("Unable to seek to end of file\n"));
7238 str_tab_len = ftell (file) - offset;
7239 }
7240
7241 if (str_tab_len < 1)
7242 {
7243 error
7244 (_("Unable to determine the length of the dynamic string table\n"));
7245 continue;
7246 }
7247
7248 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7249 str_tab_len,
7250 _("dynamic string table"));
7251 dynamic_strings_length = str_tab_len;
7252 break;
7253 }
7254 }
7255
7256 /* And find the syminfo section if available. */
7257 if (dynamic_syminfo == NULL)
7258 {
7259 unsigned long syminsz = 0;
7260
7261 for (entry = dynamic_section;
7262 entry < dynamic_section + dynamic_nent;
7263 ++entry)
7264 {
7265 if (entry->d_tag == DT_SYMINENT)
7266 {
7267 /* Note: these braces are necessary to avoid a syntax
7268 error from the SunOS4 C compiler. */
7269 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7270 }
7271 else if (entry->d_tag == DT_SYMINSZ)
7272 syminsz = entry->d_un.d_val;
7273 else if (entry->d_tag == DT_SYMINFO)
7274 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7275 syminsz);
7276 }
7277
7278 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7279 {
7280 Elf_External_Syminfo * extsyminfo;
7281 Elf_External_Syminfo * extsym;
7282 Elf_Internal_Syminfo * syminfo;
7283
7284 /* There is a syminfo section. Read the data. */
7285 extsyminfo = (Elf_External_Syminfo *)
7286 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7287 _("symbol information"));
7288 if (!extsyminfo)
7289 return 0;
7290
7291 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7292 if (dynamic_syminfo == NULL)
7293 {
7294 error (_("Out of memory\n"));
7295 return 0;
7296 }
7297
7298 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7299 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7300 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7301 ++syminfo, ++extsym)
7302 {
7303 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7304 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7305 }
7306
7307 free (extsyminfo);
7308 }
7309 }
7310
7311 if (do_dynamic && dynamic_addr)
7312 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7313 dynamic_addr, dynamic_nent);
7314 if (do_dynamic)
7315 printf (_(" Tag Type Name/Value\n"));
7316
7317 for (entry = dynamic_section;
7318 entry < dynamic_section + dynamic_nent;
7319 entry++)
7320 {
7321 if (do_dynamic)
7322 {
7323 const char * dtype;
7324
7325 putchar (' ');
7326 print_vma (entry->d_tag, FULL_HEX);
7327 dtype = get_dynamic_type (entry->d_tag);
7328 printf (" (%s)%*s", dtype,
7329 ((is_32bit_elf ? 27 : 19)
7330 - (int) strlen (dtype)),
7331 " ");
7332 }
7333
7334 switch (entry->d_tag)
7335 {
7336 case DT_FLAGS:
7337 if (do_dynamic)
7338 print_dynamic_flags (entry->d_un.d_val);
7339 break;
7340
7341 case DT_AUXILIARY:
7342 case DT_FILTER:
7343 case DT_CONFIG:
7344 case DT_DEPAUDIT:
7345 case DT_AUDIT:
7346 if (do_dynamic)
7347 {
7348 switch (entry->d_tag)
7349 {
7350 case DT_AUXILIARY:
7351 printf (_("Auxiliary library"));
7352 break;
7353
7354 case DT_FILTER:
7355 printf (_("Filter library"));
7356 break;
7357
7358 case DT_CONFIG:
7359 printf (_("Configuration file"));
7360 break;
7361
7362 case DT_DEPAUDIT:
7363 printf (_("Dependency audit library"));
7364 break;
7365
7366 case DT_AUDIT:
7367 printf (_("Audit library"));
7368 break;
7369 }
7370
7371 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7372 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7373 else
7374 {
7375 printf (": ");
7376 print_vma (entry->d_un.d_val, PREFIX_HEX);
7377 putchar ('\n');
7378 }
7379 }
7380 break;
7381
7382 case DT_FEATURE:
7383 if (do_dynamic)
7384 {
7385 printf (_("Flags:"));
7386
7387 if (entry->d_un.d_val == 0)
7388 printf (_(" None\n"));
7389 else
7390 {
7391 unsigned long int val = entry->d_un.d_val;
7392
7393 if (val & DTF_1_PARINIT)
7394 {
7395 printf (" PARINIT");
7396 val ^= DTF_1_PARINIT;
7397 }
7398 if (val & DTF_1_CONFEXP)
7399 {
7400 printf (" CONFEXP");
7401 val ^= DTF_1_CONFEXP;
7402 }
7403 if (val != 0)
7404 printf (" %lx", val);
7405 puts ("");
7406 }
7407 }
7408 break;
7409
7410 case DT_POSFLAG_1:
7411 if (do_dynamic)
7412 {
7413 printf (_("Flags:"));
7414
7415 if (entry->d_un.d_val == 0)
7416 printf (_(" None\n"));
7417 else
7418 {
7419 unsigned long int val = entry->d_un.d_val;
7420
7421 if (val & DF_P1_LAZYLOAD)
7422 {
7423 printf (" LAZYLOAD");
7424 val ^= DF_P1_LAZYLOAD;
7425 }
7426 if (val & DF_P1_GROUPPERM)
7427 {
7428 printf (" GROUPPERM");
7429 val ^= DF_P1_GROUPPERM;
7430 }
7431 if (val != 0)
7432 printf (" %lx", val);
7433 puts ("");
7434 }
7435 }
7436 break;
7437
7438 case DT_FLAGS_1:
7439 if (do_dynamic)
7440 {
7441 printf (_("Flags:"));
7442 if (entry->d_un.d_val == 0)
7443 printf (_(" None\n"));
7444 else
7445 {
7446 unsigned long int val = entry->d_un.d_val;
7447
7448 if (val & DF_1_NOW)
7449 {
7450 printf (" NOW");
7451 val ^= DF_1_NOW;
7452 }
7453 if (val & DF_1_GLOBAL)
7454 {
7455 printf (" GLOBAL");
7456 val ^= DF_1_GLOBAL;
7457 }
7458 if (val & DF_1_GROUP)
7459 {
7460 printf (" GROUP");
7461 val ^= DF_1_GROUP;
7462 }
7463 if (val & DF_1_NODELETE)
7464 {
7465 printf (" NODELETE");
7466 val ^= DF_1_NODELETE;
7467 }
7468 if (val & DF_1_LOADFLTR)
7469 {
7470 printf (" LOADFLTR");
7471 val ^= DF_1_LOADFLTR;
7472 }
7473 if (val & DF_1_INITFIRST)
7474 {
7475 printf (" INITFIRST");
7476 val ^= DF_1_INITFIRST;
7477 }
7478 if (val & DF_1_NOOPEN)
7479 {
7480 printf (" NOOPEN");
7481 val ^= DF_1_NOOPEN;
7482 }
7483 if (val & DF_1_ORIGIN)
7484 {
7485 printf (" ORIGIN");
7486 val ^= DF_1_ORIGIN;
7487 }
7488 if (val & DF_1_DIRECT)
7489 {
7490 printf (" DIRECT");
7491 val ^= DF_1_DIRECT;
7492 }
7493 if (val & DF_1_TRANS)
7494 {
7495 printf (" TRANS");
7496 val ^= DF_1_TRANS;
7497 }
7498 if (val & DF_1_INTERPOSE)
7499 {
7500 printf (" INTERPOSE");
7501 val ^= DF_1_INTERPOSE;
7502 }
7503 if (val & DF_1_NODEFLIB)
7504 {
7505 printf (" NODEFLIB");
7506 val ^= DF_1_NODEFLIB;
7507 }
7508 if (val & DF_1_NODUMP)
7509 {
7510 printf (" NODUMP");
7511 val ^= DF_1_NODUMP;
7512 }
7513 if (val & DF_1_CONLFAT)
7514 {
7515 printf (" CONLFAT");
7516 val ^= DF_1_CONLFAT;
7517 }
7518 if (val != 0)
7519 printf (" %lx", val);
7520 puts ("");
7521 }
7522 }
7523 break;
7524
7525 case DT_PLTREL:
7526 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7527 if (do_dynamic)
7528 puts (get_dynamic_type (entry->d_un.d_val));
7529 break;
7530
7531 case DT_NULL :
7532 case DT_NEEDED :
7533 case DT_PLTGOT :
7534 case DT_HASH :
7535 case DT_STRTAB :
7536 case DT_SYMTAB :
7537 case DT_RELA :
7538 case DT_INIT :
7539 case DT_FINI :
7540 case DT_SONAME :
7541 case DT_RPATH :
7542 case DT_SYMBOLIC:
7543 case DT_REL :
7544 case DT_DEBUG :
7545 case DT_TEXTREL :
7546 case DT_JMPREL :
7547 case DT_RUNPATH :
7548 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7549
7550 if (do_dynamic)
7551 {
7552 char * name;
7553
7554 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7555 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7556 else
7557 name = NULL;
7558
7559 if (name)
7560 {
7561 switch (entry->d_tag)
7562 {
7563 case DT_NEEDED:
7564 printf (_("Shared library: [%s]"), name);
7565
7566 if (streq (name, program_interpreter))
7567 printf (_(" program interpreter"));
7568 break;
7569
7570 case DT_SONAME:
7571 printf (_("Library soname: [%s]"), name);
7572 break;
7573
7574 case DT_RPATH:
7575 printf (_("Library rpath: [%s]"), name);
7576 break;
7577
7578 case DT_RUNPATH:
7579 printf (_("Library runpath: [%s]"), name);
7580 break;
7581
7582 default:
7583 print_vma (entry->d_un.d_val, PREFIX_HEX);
7584 break;
7585 }
7586 }
7587 else
7588 print_vma (entry->d_un.d_val, PREFIX_HEX);
7589
7590 putchar ('\n');
7591 }
7592 break;
7593
7594 case DT_PLTRELSZ:
7595 case DT_RELASZ :
7596 case DT_STRSZ :
7597 case DT_RELSZ :
7598 case DT_RELAENT :
7599 case DT_SYMENT :
7600 case DT_RELENT :
7601 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7602 case DT_PLTPADSZ:
7603 case DT_MOVEENT :
7604 case DT_MOVESZ :
7605 case DT_INIT_ARRAYSZ:
7606 case DT_FINI_ARRAYSZ:
7607 case DT_GNU_CONFLICTSZ:
7608 case DT_GNU_LIBLISTSZ:
7609 if (do_dynamic)
7610 {
7611 print_vma (entry->d_un.d_val, UNSIGNED);
7612 printf (_(" (bytes)\n"));
7613 }
7614 break;
7615
7616 case DT_VERDEFNUM:
7617 case DT_VERNEEDNUM:
7618 case DT_RELACOUNT:
7619 case DT_RELCOUNT:
7620 if (do_dynamic)
7621 {
7622 print_vma (entry->d_un.d_val, UNSIGNED);
7623 putchar ('\n');
7624 }
7625 break;
7626
7627 case DT_SYMINSZ:
7628 case DT_SYMINENT:
7629 case DT_SYMINFO:
7630 case DT_USED:
7631 case DT_INIT_ARRAY:
7632 case DT_FINI_ARRAY:
7633 if (do_dynamic)
7634 {
7635 if (entry->d_tag == DT_USED
7636 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7637 {
7638 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7639
7640 if (*name)
7641 {
7642 printf (_("Not needed object: [%s]\n"), name);
7643 break;
7644 }
7645 }
7646
7647 print_vma (entry->d_un.d_val, PREFIX_HEX);
7648 putchar ('\n');
7649 }
7650 break;
7651
7652 case DT_BIND_NOW:
7653 /* The value of this entry is ignored. */
7654 if (do_dynamic)
7655 putchar ('\n');
7656 break;
7657
7658 case DT_GNU_PRELINKED:
7659 if (do_dynamic)
7660 {
7661 struct tm * tmp;
7662 time_t atime = entry->d_un.d_val;
7663
7664 tmp = gmtime (&atime);
7665 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7666 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7667 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7668
7669 }
7670 break;
7671
7672 case DT_GNU_HASH:
7673 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7674 if (do_dynamic)
7675 {
7676 print_vma (entry->d_un.d_val, PREFIX_HEX);
7677 putchar ('\n');
7678 }
7679 break;
7680
7681 default:
7682 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7683 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7684 entry->d_un.d_val;
7685
7686 if (do_dynamic)
7687 {
7688 switch (elf_header.e_machine)
7689 {
7690 case EM_MIPS:
7691 case EM_MIPS_RS3_LE:
7692 dynamic_section_mips_val (entry);
7693 break;
7694 case EM_PARISC:
7695 dynamic_section_parisc_val (entry);
7696 break;
7697 case EM_IA_64:
7698 dynamic_section_ia64_val (entry);
7699 break;
7700 default:
7701 print_vma (entry->d_un.d_val, PREFIX_HEX);
7702 putchar ('\n');
7703 }
7704 }
7705 break;
7706 }
7707 }
7708
7709 return 1;
7710 }
7711
7712 static char *
7713 get_ver_flags (unsigned int flags)
7714 {
7715 static char buff[32];
7716
7717 buff[0] = 0;
7718
7719 if (flags == 0)
7720 return _("none");
7721
7722 if (flags & VER_FLG_BASE)
7723 strcat (buff, "BASE ");
7724
7725 if (flags & VER_FLG_WEAK)
7726 {
7727 if (flags & VER_FLG_BASE)
7728 strcat (buff, "| ");
7729
7730 strcat (buff, "WEAK ");
7731 }
7732
7733 if (flags & VER_FLG_INFO)
7734 {
7735 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7736 strcat (buff, "| ");
7737
7738 strcat (buff, "INFO ");
7739 }
7740
7741 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7742 strcat (buff, _("| <unknown>"));
7743
7744 return buff;
7745 }
7746
7747 /* Display the contents of the version sections. */
7748
7749 static int
7750 process_version_sections (FILE * file)
7751 {
7752 Elf_Internal_Shdr * section;
7753 unsigned i;
7754 int found = 0;
7755
7756 if (! do_version)
7757 return 1;
7758
7759 for (i = 0, section = section_headers;
7760 i < elf_header.e_shnum;
7761 i++, section++)
7762 {
7763 switch (section->sh_type)
7764 {
7765 case SHT_GNU_verdef:
7766 {
7767 Elf_External_Verdef * edefs;
7768 unsigned int idx;
7769 unsigned int cnt;
7770 char * endbuf;
7771
7772 found = 1;
7773
7774 printf
7775 (_("\nVersion definition section '%s' contains %u entries:\n"),
7776 SECTION_NAME (section), section->sh_info);
7777
7778 printf (_(" Addr: 0x"));
7779 printf_vma (section->sh_addr);
7780 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7781 (unsigned long) section->sh_offset, section->sh_link,
7782 section->sh_link < elf_header.e_shnum
7783 ? SECTION_NAME (section_headers + section->sh_link)
7784 : _("<corrupt>"));
7785
7786 edefs = (Elf_External_Verdef *)
7787 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7788 _("version definition section"));
7789 endbuf = (char *) edefs + section->sh_size;
7790 if (!edefs)
7791 break;
7792
7793 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7794 {
7795 char * vstart;
7796 Elf_External_Verdef * edef;
7797 Elf_Internal_Verdef ent;
7798 Elf_External_Verdaux * eaux;
7799 Elf_Internal_Verdaux aux;
7800 int j;
7801 int isum;
7802
7803 /* Check for negative or very large indicies. */
7804 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
7805 break;
7806
7807 vstart = ((char *) edefs) + idx;
7808 if (vstart + sizeof (*edef) > endbuf)
7809 break;
7810
7811 edef = (Elf_External_Verdef *) vstart;
7812
7813 ent.vd_version = BYTE_GET (edef->vd_version);
7814 ent.vd_flags = BYTE_GET (edef->vd_flags);
7815 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7816 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7817 ent.vd_hash = BYTE_GET (edef->vd_hash);
7818 ent.vd_aux = BYTE_GET (edef->vd_aux);
7819 ent.vd_next = BYTE_GET (edef->vd_next);
7820
7821 printf (_(" %#06x: Rev: %d Flags: %s"),
7822 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7823
7824 printf (_(" Index: %d Cnt: %d "),
7825 ent.vd_ndx, ent.vd_cnt);
7826
7827 /* Check for overflow. */
7828 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
7829 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
7830 break;
7831
7832 vstart += ent.vd_aux;
7833
7834 eaux = (Elf_External_Verdaux *) vstart;
7835
7836 aux.vda_name = BYTE_GET (eaux->vda_name);
7837 aux.vda_next = BYTE_GET (eaux->vda_next);
7838
7839 if (VALID_DYNAMIC_NAME (aux.vda_name))
7840 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
7841 else
7842 printf (_("Name index: %ld\n"), aux.vda_name);
7843
7844 isum = idx + ent.vd_aux;
7845
7846 for (j = 1; j < ent.vd_cnt; j++)
7847 {
7848 /* Check for overflow. */
7849 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
7850 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
7851 break;
7852
7853 isum += aux.vda_next;
7854 vstart += aux.vda_next;
7855
7856 eaux = (Elf_External_Verdaux *) vstart;
7857 if (vstart + sizeof (*eaux) > endbuf)
7858 break;
7859
7860 aux.vda_name = BYTE_GET (eaux->vda_name);
7861 aux.vda_next = BYTE_GET (eaux->vda_next);
7862
7863 if (VALID_DYNAMIC_NAME (aux.vda_name))
7864 printf (_(" %#06x: Parent %d: %s\n"),
7865 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
7866 else
7867 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7868 isum, j, aux.vda_name);
7869 }
7870
7871 if (j < ent.vd_cnt)
7872 printf (_(" Version def aux past end of section\n"));
7873
7874 idx += ent.vd_next;
7875 }
7876
7877 if (cnt < section->sh_info)
7878 printf (_(" Version definition past end of section\n"));
7879
7880 free (edefs);
7881 }
7882 break;
7883
7884 case SHT_GNU_verneed:
7885 {
7886 Elf_External_Verneed * eneed;
7887 unsigned int idx;
7888 unsigned int cnt;
7889 char * endbuf;
7890
7891 found = 1;
7892
7893 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7894 SECTION_NAME (section), section->sh_info);
7895
7896 printf (_(" Addr: 0x"));
7897 printf_vma (section->sh_addr);
7898 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7899 (unsigned long) section->sh_offset, section->sh_link,
7900 section->sh_link < elf_header.e_shnum
7901 ? SECTION_NAME (section_headers + section->sh_link)
7902 : _("<corrupt>"));
7903
7904 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7905 section->sh_offset, 1,
7906 section->sh_size,
7907 _("version need section"));
7908 endbuf = (char *) eneed + section->sh_size;
7909 if (!eneed)
7910 break;
7911
7912 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7913 {
7914 Elf_External_Verneed * entry;
7915 Elf_Internal_Verneed ent;
7916 int j;
7917 int isum;
7918 char * vstart;
7919
7920 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
7921 break;
7922
7923 vstart = ((char *) eneed) + idx;
7924 if (vstart + sizeof (*entry) > endbuf)
7925 break;
7926
7927 entry = (Elf_External_Verneed *) vstart;
7928
7929 ent.vn_version = BYTE_GET (entry->vn_version);
7930 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7931 ent.vn_file = BYTE_GET (entry->vn_file);
7932 ent.vn_aux = BYTE_GET (entry->vn_aux);
7933 ent.vn_next = BYTE_GET (entry->vn_next);
7934
7935 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7936
7937 if (VALID_DYNAMIC_NAME (ent.vn_file))
7938 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
7939 else
7940 printf (_(" File: %lx"), ent.vn_file);
7941
7942 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7943
7944 /* Check for overflow. */
7945 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
7946 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
7947 break;
7948
7949 vstart += ent.vn_aux;
7950
7951 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7952 {
7953 Elf_External_Vernaux * eaux;
7954 Elf_Internal_Vernaux aux;
7955
7956 if (vstart + sizeof (*eaux) > endbuf)
7957 break;
7958 eaux = (Elf_External_Vernaux *) vstart;
7959
7960 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7961 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7962 aux.vna_other = BYTE_GET (eaux->vna_other);
7963 aux.vna_name = BYTE_GET (eaux->vna_name);
7964 aux.vna_next = BYTE_GET (eaux->vna_next);
7965
7966 if (VALID_DYNAMIC_NAME (aux.vna_name))
7967 printf (_(" %#06x: Name: %s"),
7968 isum, GET_DYNAMIC_NAME (aux.vna_name));
7969 else
7970 printf (_(" %#06x: Name index: %lx"),
7971 isum, aux.vna_name);
7972
7973 printf (_(" Flags: %s Version: %d\n"),
7974 get_ver_flags (aux.vna_flags), aux.vna_other);
7975
7976 /* Check for overflow. */
7977 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
7978 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
7979 break;
7980
7981 isum += aux.vna_next;
7982 vstart += aux.vna_next;
7983 }
7984 if (j < ent.vn_cnt)
7985 printf (_(" Version need aux past end of section\n"));
7986
7987 idx += ent.vn_next;
7988 }
7989 if (cnt < section->sh_info)
7990 printf (_(" Version need past end of section\n"));
7991
7992 free (eneed);
7993 }
7994 break;
7995
7996 case SHT_GNU_versym:
7997 {
7998 Elf_Internal_Shdr * link_section;
7999 int total;
8000 int cnt;
8001 unsigned char * edata;
8002 unsigned short * data;
8003 char * strtab;
8004 Elf_Internal_Sym * symbols;
8005 Elf_Internal_Shdr * string_sec;
8006 long off;
8007
8008 if (section->sh_link >= elf_header.e_shnum)
8009 break;
8010
8011 link_section = section_headers + section->sh_link;
8012 total = section->sh_size / sizeof (Elf_External_Versym);
8013
8014 if (link_section->sh_link >= elf_header.e_shnum)
8015 break;
8016
8017 found = 1;
8018
8019 symbols = GET_ELF_SYMBOLS (file, link_section);
8020 if (symbols == NULL)
8021 break;
8022
8023 string_sec = section_headers + link_section->sh_link;
8024
8025 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8026 string_sec->sh_size,
8027 _("version string table"));
8028 if (!strtab)
8029 break;
8030
8031 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8032 SECTION_NAME (section), total);
8033
8034 printf (_(" Addr: "));
8035 printf_vma (section->sh_addr);
8036 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8037 (unsigned long) section->sh_offset, section->sh_link,
8038 SECTION_NAME (link_section));
8039
8040 off = offset_from_vma (file,
8041 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8042 total * sizeof (short));
8043 edata = (unsigned char *) get_data (NULL, file, off, total,
8044 sizeof (short),
8045 _("version symbol data"));
8046 if (!edata)
8047 {
8048 free (strtab);
8049 break;
8050 }
8051
8052 data = (short unsigned int *) cmalloc (total, sizeof (short));
8053
8054 for (cnt = total; cnt --;)
8055 data[cnt] = byte_get (edata + cnt * sizeof (short),
8056 sizeof (short));
8057
8058 free (edata);
8059
8060 for (cnt = 0; cnt < total; cnt += 4)
8061 {
8062 int j, nn;
8063 int check_def, check_need;
8064 char * name;
8065
8066 printf (" %03x:", cnt);
8067
8068 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8069 switch (data[cnt + j])
8070 {
8071 case 0:
8072 fputs (_(" 0 (*local*) "), stdout);
8073 break;
8074
8075 case 1:
8076 fputs (_(" 1 (*global*) "), stdout);
8077 break;
8078
8079 default:
8080 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8081 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8082
8083 /* If this index value is greater than the size of the symbols
8084 array, break to avoid an out-of-bounds read, */
8085 if ((unsigned long)(cnt + j) >=
8086 ((unsigned long)link_section->sh_size /
8087 (unsigned long)link_section->sh_entsize))
8088 {
8089 warn (_("invalid index into symbol array\n"));
8090 break;
8091 }
8092
8093 check_def = 1;
8094 check_need = 1;
8095 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8096 || section_headers[symbols[cnt + j].st_shndx].sh_type
8097 != SHT_NOBITS)
8098 {
8099 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8100 check_def = 0;
8101 else
8102 check_need = 0;
8103 }
8104
8105 if (check_need
8106 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8107 {
8108 Elf_Internal_Verneed ivn;
8109 unsigned long offset;
8110
8111 offset = offset_from_vma
8112 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8113 sizeof (Elf_External_Verneed));
8114
8115 do
8116 {
8117 Elf_Internal_Vernaux ivna;
8118 Elf_External_Verneed evn;
8119 Elf_External_Vernaux evna;
8120 unsigned long a_off;
8121
8122 get_data (&evn, file, offset, sizeof (evn), 1,
8123 _("version need"));
8124
8125 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8126 ivn.vn_next = BYTE_GET (evn.vn_next);
8127
8128 a_off = offset + ivn.vn_aux;
8129
8130 do
8131 {
8132 get_data (&evna, file, a_off, sizeof (evna),
8133 1, _("version need aux (2)"));
8134
8135 ivna.vna_next = BYTE_GET (evna.vna_next);
8136 ivna.vna_other = BYTE_GET (evna.vna_other);
8137
8138 a_off += ivna.vna_next;
8139 }
8140 while (ivna.vna_other != data[cnt + j]
8141 && ivna.vna_next != 0);
8142
8143 if (ivna.vna_other == data[cnt + j])
8144 {
8145 ivna.vna_name = BYTE_GET (evna.vna_name);
8146
8147 if (ivna.vna_name >= string_sec->sh_size)
8148 name = _("*invalid*");
8149 else
8150 name = strtab + ivna.vna_name;
8151 nn += printf ("(%s%-*s",
8152 name,
8153 12 - (int) strlen (name),
8154 ")");
8155 check_def = 0;
8156 break;
8157 }
8158
8159 offset += ivn.vn_next;
8160 }
8161 while (ivn.vn_next);
8162 }
8163
8164 if (check_def && data[cnt + j] != 0x8001
8165 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8166 {
8167 Elf_Internal_Verdef ivd;
8168 Elf_External_Verdef evd;
8169 unsigned long offset;
8170
8171 offset = offset_from_vma
8172 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8173 sizeof evd);
8174
8175 do
8176 {
8177 get_data (&evd, file, offset, sizeof (evd), 1,
8178 _("version def"));
8179
8180 ivd.vd_next = BYTE_GET (evd.vd_next);
8181 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8182
8183 offset += ivd.vd_next;
8184 }
8185 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8186 && ivd.vd_next != 0);
8187
8188 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8189 {
8190 Elf_External_Verdaux evda;
8191 Elf_Internal_Verdaux ivda;
8192
8193 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8194
8195 get_data (&evda, file,
8196 offset - ivd.vd_next + ivd.vd_aux,
8197 sizeof (evda), 1,
8198 _("version def aux"));
8199
8200 ivda.vda_name = BYTE_GET (evda.vda_name);
8201
8202 if (ivda.vda_name >= string_sec->sh_size)
8203 name = _("*invalid*");
8204 else
8205 name = strtab + ivda.vda_name;
8206 nn += printf ("(%s%-*s",
8207 name,
8208 12 - (int) strlen (name),
8209 ")");
8210 }
8211 }
8212
8213 if (nn < 18)
8214 printf ("%*c", 18 - nn, ' ');
8215 }
8216
8217 putchar ('\n');
8218 }
8219
8220 free (data);
8221 free (strtab);
8222 free (symbols);
8223 }
8224 break;
8225
8226 default:
8227 break;
8228 }
8229 }
8230
8231 if (! found)
8232 printf (_("\nNo version information found in this file.\n"));
8233
8234 return 1;
8235 }
8236
8237 static const char *
8238 get_symbol_binding (unsigned int binding)
8239 {
8240 static char buff[32];
8241
8242 switch (binding)
8243 {
8244 case STB_LOCAL: return "LOCAL";
8245 case STB_GLOBAL: return "GLOBAL";
8246 case STB_WEAK: return "WEAK";
8247 default:
8248 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8249 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8250 binding);
8251 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8252 {
8253 if (binding == STB_GNU_UNIQUE
8254 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8255 /* GNU/Linux is still using the default value 0. */
8256 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8257 return "UNIQUE";
8258 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8259 }
8260 else
8261 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8262 return buff;
8263 }
8264 }
8265
8266 static const char *
8267 get_symbol_type (unsigned int type)
8268 {
8269 static char buff[32];
8270
8271 switch (type)
8272 {
8273 case STT_NOTYPE: return "NOTYPE";
8274 case STT_OBJECT: return "OBJECT";
8275 case STT_FUNC: return "FUNC";
8276 case STT_SECTION: return "SECTION";
8277 case STT_FILE: return "FILE";
8278 case STT_COMMON: return "COMMON";
8279 case STT_TLS: return "TLS";
8280 case STT_RELC: return "RELC";
8281 case STT_SRELC: return "SRELC";
8282 default:
8283 if (type >= STT_LOPROC && type <= STT_HIPROC)
8284 {
8285 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8286 return "THUMB_FUNC";
8287
8288 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8289 return "REGISTER";
8290
8291 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8292 return "PARISC_MILLI";
8293
8294 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8295 }
8296 else if (type >= STT_LOOS && type <= STT_HIOS)
8297 {
8298 if (elf_header.e_machine == EM_PARISC)
8299 {
8300 if (type == STT_HP_OPAQUE)
8301 return "HP_OPAQUE";
8302 if (type == STT_HP_STUB)
8303 return "HP_STUB";
8304 }
8305
8306 if (type == STT_GNU_IFUNC
8307 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8308 /* GNU/Linux is still using the default value 0. */
8309 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8310 return "IFUNC";
8311
8312 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8313 }
8314 else
8315 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8316 return buff;
8317 }
8318 }
8319
8320 static const char *
8321 get_symbol_visibility (unsigned int visibility)
8322 {
8323 switch (visibility)
8324 {
8325 case STV_DEFAULT: return "DEFAULT";
8326 case STV_INTERNAL: return "INTERNAL";
8327 case STV_HIDDEN: return "HIDDEN";
8328 case STV_PROTECTED: return "PROTECTED";
8329 default: abort ();
8330 }
8331 }
8332
8333 static const char *
8334 get_mips_symbol_other (unsigned int other)
8335 {
8336 switch (other)
8337 {
8338 case STO_OPTIONAL: return "OPTIONAL";
8339 case STO_MIPS16: return "MIPS16";
8340 case STO_MIPS_PLT: return "MIPS PLT";
8341 case STO_MIPS_PIC: return "MIPS PIC";
8342 default: return NULL;
8343 }
8344 }
8345
8346 static const char *
8347 get_ia64_symbol_other (unsigned int other)
8348 {
8349 if (is_ia64_vms ())
8350 {
8351 static char res[32];
8352
8353 res[0] = 0;
8354
8355 /* Function types is for images and .STB files only. */
8356 switch (elf_header.e_type)
8357 {
8358 case ET_DYN:
8359 case ET_EXEC:
8360 switch (VMS_ST_FUNC_TYPE (other))
8361 {
8362 case VMS_SFT_CODE_ADDR:
8363 strcat (res, " CA");
8364 break;
8365 case VMS_SFT_SYMV_IDX:
8366 strcat (res, " VEC");
8367 break;
8368 case VMS_SFT_FD:
8369 strcat (res, " FD");
8370 break;
8371 case VMS_SFT_RESERVE:
8372 strcat (res, " RSV");
8373 break;
8374 default:
8375 abort ();
8376 }
8377 break;
8378 default:
8379 break;
8380 }
8381 switch (VMS_ST_LINKAGE (other))
8382 {
8383 case VMS_STL_IGNORE:
8384 strcat (res, " IGN");
8385 break;
8386 case VMS_STL_RESERVE:
8387 strcat (res, " RSV");
8388 break;
8389 case VMS_STL_STD:
8390 strcat (res, " STD");
8391 break;
8392 case VMS_STL_LNK:
8393 strcat (res, " LNK");
8394 break;
8395 default:
8396 abort ();
8397 }
8398
8399 if (res[0] != 0)
8400 return res + 1;
8401 else
8402 return res;
8403 }
8404 return NULL;
8405 }
8406
8407 static const char *
8408 get_symbol_other (unsigned int other)
8409 {
8410 const char * result = NULL;
8411 static char buff [32];
8412
8413 if (other == 0)
8414 return "";
8415
8416 switch (elf_header.e_machine)
8417 {
8418 case EM_MIPS:
8419 result = get_mips_symbol_other (other);
8420 break;
8421 case EM_IA_64:
8422 result = get_ia64_symbol_other (other);
8423 break;
8424 default:
8425 break;
8426 }
8427
8428 if (result)
8429 return result;
8430
8431 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8432 return buff;
8433 }
8434
8435 static const char *
8436 get_symbol_index_type (unsigned int type)
8437 {
8438 static char buff[32];
8439
8440 switch (type)
8441 {
8442 case SHN_UNDEF: return "UND";
8443 case SHN_ABS: return "ABS";
8444 case SHN_COMMON: return "COM";
8445 default:
8446 if (type == SHN_IA_64_ANSI_COMMON
8447 && elf_header.e_machine == EM_IA_64
8448 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8449 return "ANSI_COM";
8450 else if ((elf_header.e_machine == EM_X86_64
8451 || elf_header.e_machine == EM_L1OM)
8452 && type == SHN_X86_64_LCOMMON)
8453 return "LARGE_COM";
8454 else if (type == SHN_MIPS_SCOMMON
8455 && elf_header.e_machine == EM_MIPS)
8456 return "SCOM";
8457 else if (type == SHN_MIPS_SUNDEFINED
8458 && elf_header.e_machine == EM_MIPS)
8459 return "SUND";
8460 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8461 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8462 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8463 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8464 else if (type >= SHN_LORESERVE)
8465 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8466 else
8467 sprintf (buff, "%3d", type);
8468 break;
8469 }
8470
8471 return buff;
8472 }
8473
8474 static bfd_vma *
8475 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8476 {
8477 unsigned char * e_data;
8478 bfd_vma * i_data;
8479
8480 e_data = (unsigned char *) cmalloc (number, ent_size);
8481
8482 if (e_data == NULL)
8483 {
8484 error (_("Out of memory\n"));
8485 return NULL;
8486 }
8487
8488 if (fread (e_data, ent_size, number, file) != number)
8489 {
8490 error (_("Unable to read in dynamic data\n"));
8491 return NULL;
8492 }
8493
8494 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8495
8496 if (i_data == NULL)
8497 {
8498 error (_("Out of memory\n"));
8499 free (e_data);
8500 return NULL;
8501 }
8502
8503 while (number--)
8504 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8505
8506 free (e_data);
8507
8508 return i_data;
8509 }
8510
8511 static void
8512 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8513 {
8514 Elf_Internal_Sym * psym;
8515 int n;
8516
8517 psym = dynamic_symbols + si;
8518
8519 n = print_vma (si, DEC_5);
8520 if (n < 5)
8521 fputs (" " + n, stdout);
8522 printf (" %3lu: ", hn);
8523 print_vma (psym->st_value, LONG_HEX);
8524 putchar (' ');
8525 print_vma (psym->st_size, DEC_5);
8526
8527 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8528 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8529 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8530 /* Check to see if any other bits in the st_other field are set.
8531 Note - displaying this information disrupts the layout of the
8532 table being generated, but for the moment this case is very
8533 rare. */
8534 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8535 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8536 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8537 if (VALID_DYNAMIC_NAME (psym->st_name))
8538 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8539 else
8540 printf (_(" <corrupt: %14ld>"), psym->st_name);
8541 putchar ('\n');
8542 }
8543
8544 /* Dump the symbol table. */
8545 static int
8546 process_symbol_table (FILE * file)
8547 {
8548 Elf_Internal_Shdr * section;
8549 bfd_vma nbuckets = 0;
8550 bfd_vma nchains = 0;
8551 bfd_vma * buckets = NULL;
8552 bfd_vma * chains = NULL;
8553 bfd_vma ngnubuckets = 0;
8554 bfd_vma * gnubuckets = NULL;
8555 bfd_vma * gnuchains = NULL;
8556 bfd_vma gnusymidx = 0;
8557
8558 if (!do_syms && !do_dyn_syms && !do_histogram)
8559 return 1;
8560
8561 if (dynamic_info[DT_HASH]
8562 && (do_histogram
8563 || (do_using_dynamic
8564 && !do_dyn_syms
8565 && dynamic_strings != NULL)))
8566 {
8567 unsigned char nb[8];
8568 unsigned char nc[8];
8569 int hash_ent_size = 4;
8570
8571 if ((elf_header.e_machine == EM_ALPHA
8572 || elf_header.e_machine == EM_S390
8573 || elf_header.e_machine == EM_S390_OLD)
8574 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8575 hash_ent_size = 8;
8576
8577 if (fseek (file,
8578 (archive_file_offset
8579 + offset_from_vma (file, dynamic_info[DT_HASH],
8580 sizeof nb + sizeof nc)),
8581 SEEK_SET))
8582 {
8583 error (_("Unable to seek to start of dynamic information\n"));
8584 goto no_hash;
8585 }
8586
8587 if (fread (nb, hash_ent_size, 1, file) != 1)
8588 {
8589 error (_("Failed to read in number of buckets\n"));
8590 goto no_hash;
8591 }
8592
8593 if (fread (nc, hash_ent_size, 1, file) != 1)
8594 {
8595 error (_("Failed to read in number of chains\n"));
8596 goto no_hash;
8597 }
8598
8599 nbuckets = byte_get (nb, hash_ent_size);
8600 nchains = byte_get (nc, hash_ent_size);
8601
8602 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8603 chains = get_dynamic_data (file, nchains, hash_ent_size);
8604
8605 no_hash:
8606 if (buckets == NULL || chains == NULL)
8607 {
8608 if (do_using_dynamic)
8609 return 0;
8610 free (buckets);
8611 free (chains);
8612 buckets = NULL;
8613 chains = NULL;
8614 nbuckets = 0;
8615 nchains = 0;
8616 }
8617 }
8618
8619 if (dynamic_info_DT_GNU_HASH
8620 && (do_histogram
8621 || (do_using_dynamic
8622 && !do_dyn_syms
8623 && dynamic_strings != NULL)))
8624 {
8625 unsigned char nb[16];
8626 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8627 bfd_vma buckets_vma;
8628
8629 if (fseek (file,
8630 (archive_file_offset
8631 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8632 sizeof nb)),
8633 SEEK_SET))
8634 {
8635 error (_("Unable to seek to start of dynamic information\n"));
8636 goto no_gnu_hash;
8637 }
8638
8639 if (fread (nb, 16, 1, file) != 1)
8640 {
8641 error (_("Failed to read in number of buckets\n"));
8642 goto no_gnu_hash;
8643 }
8644
8645 ngnubuckets = byte_get (nb, 4);
8646 gnusymidx = byte_get (nb + 4, 4);
8647 bitmaskwords = byte_get (nb + 8, 4);
8648 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8649 if (is_32bit_elf)
8650 buckets_vma += bitmaskwords * 4;
8651 else
8652 buckets_vma += bitmaskwords * 8;
8653
8654 if (fseek (file,
8655 (archive_file_offset
8656 + offset_from_vma (file, buckets_vma, 4)),
8657 SEEK_SET))
8658 {
8659 error (_("Unable to seek to start of dynamic information\n"));
8660 goto no_gnu_hash;
8661 }
8662
8663 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8664
8665 if (gnubuckets == NULL)
8666 goto no_gnu_hash;
8667
8668 for (i = 0; i < ngnubuckets; i++)
8669 if (gnubuckets[i] != 0)
8670 {
8671 if (gnubuckets[i] < gnusymidx)
8672 return 0;
8673
8674 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8675 maxchain = gnubuckets[i];
8676 }
8677
8678 if (maxchain == 0xffffffff)
8679 goto no_gnu_hash;
8680
8681 maxchain -= gnusymidx;
8682
8683 if (fseek (file,
8684 (archive_file_offset
8685 + offset_from_vma (file, buckets_vma
8686 + 4 * (ngnubuckets + maxchain), 4)),
8687 SEEK_SET))
8688 {
8689 error (_("Unable to seek to start of dynamic information\n"));
8690 goto no_gnu_hash;
8691 }
8692
8693 do
8694 {
8695 if (fread (nb, 4, 1, file) != 1)
8696 {
8697 error (_("Failed to determine last chain length\n"));
8698 goto no_gnu_hash;
8699 }
8700
8701 if (maxchain + 1 == 0)
8702 goto no_gnu_hash;
8703
8704 ++maxchain;
8705 }
8706 while ((byte_get (nb, 4) & 1) == 0);
8707
8708 if (fseek (file,
8709 (archive_file_offset
8710 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8711 SEEK_SET))
8712 {
8713 error (_("Unable to seek to start of dynamic information\n"));
8714 goto no_gnu_hash;
8715 }
8716
8717 gnuchains = get_dynamic_data (file, maxchain, 4);
8718
8719 no_gnu_hash:
8720 if (gnuchains == NULL)
8721 {
8722 free (gnubuckets);
8723 gnubuckets = NULL;
8724 ngnubuckets = 0;
8725 if (do_using_dynamic)
8726 return 0;
8727 }
8728 }
8729
8730 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8731 && do_syms
8732 && do_using_dynamic
8733 && dynamic_strings != NULL)
8734 {
8735 unsigned long hn;
8736
8737 if (dynamic_info[DT_HASH])
8738 {
8739 bfd_vma si;
8740
8741 printf (_("\nSymbol table for image:\n"));
8742 if (is_32bit_elf)
8743 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8744 else
8745 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8746
8747 for (hn = 0; hn < nbuckets; hn++)
8748 {
8749 if (! buckets[hn])
8750 continue;
8751
8752 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8753 print_dynamic_symbol (si, hn);
8754 }
8755 }
8756
8757 if (dynamic_info_DT_GNU_HASH)
8758 {
8759 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8760 if (is_32bit_elf)
8761 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8762 else
8763 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8764
8765 for (hn = 0; hn < ngnubuckets; ++hn)
8766 if (gnubuckets[hn] != 0)
8767 {
8768 bfd_vma si = gnubuckets[hn];
8769 bfd_vma off = si - gnusymidx;
8770
8771 do
8772 {
8773 print_dynamic_symbol (si, hn);
8774 si++;
8775 }
8776 while ((gnuchains[off++] & 1) == 0);
8777 }
8778 }
8779 }
8780 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8781 {
8782 unsigned int i;
8783
8784 for (i = 0, section = section_headers;
8785 i < elf_header.e_shnum;
8786 i++, section++)
8787 {
8788 unsigned int si;
8789 char * strtab = NULL;
8790 unsigned long int strtab_size = 0;
8791 Elf_Internal_Sym * symtab;
8792 Elf_Internal_Sym * psym;
8793
8794 if ((section->sh_type != SHT_SYMTAB
8795 && section->sh_type != SHT_DYNSYM)
8796 || (!do_syms
8797 && section->sh_type == SHT_SYMTAB))
8798 continue;
8799
8800 if (section->sh_entsize == 0)
8801 {
8802 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8803 SECTION_NAME (section));
8804 continue;
8805 }
8806
8807 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8808 SECTION_NAME (section),
8809 (unsigned long) (section->sh_size / section->sh_entsize));
8810
8811 if (is_32bit_elf)
8812 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8813 else
8814 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8815
8816 symtab = GET_ELF_SYMBOLS (file, section);
8817 if (symtab == NULL)
8818 continue;
8819
8820 if (section->sh_link == elf_header.e_shstrndx)
8821 {
8822 strtab = string_table;
8823 strtab_size = string_table_length;
8824 }
8825 else if (section->sh_link < elf_header.e_shnum)
8826 {
8827 Elf_Internal_Shdr * string_sec;
8828
8829 string_sec = section_headers + section->sh_link;
8830
8831 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8832 1, string_sec->sh_size,
8833 _("string table"));
8834 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8835 }
8836
8837 for (si = 0, psym = symtab;
8838 si < section->sh_size / section->sh_entsize;
8839 si++, psym++)
8840 {
8841 printf ("%6d: ", si);
8842 print_vma (psym->st_value, LONG_HEX);
8843 putchar (' ');
8844 print_vma (psym->st_size, DEC_5);
8845 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8846 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8847 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8848 /* Check to see if any other bits in the st_other field are set.
8849 Note - displaying this information disrupts the layout of the
8850 table being generated, but for the moment this case is very rare. */
8851 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8852 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8853 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8854 print_symbol (25, psym->st_name < strtab_size
8855 ? strtab + psym->st_name : _("<corrupt>"));
8856
8857 if (section->sh_type == SHT_DYNSYM &&
8858 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8859 {
8860 unsigned char data[2];
8861 unsigned short vers_data;
8862 unsigned long offset;
8863 int is_nobits;
8864 int check_def;
8865
8866 offset = offset_from_vma
8867 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8868 sizeof data + si * sizeof (vers_data));
8869
8870 get_data (&data, file, offset + si * sizeof (vers_data),
8871 sizeof (data), 1, _("version data"));
8872
8873 vers_data = byte_get (data, 2);
8874
8875 is_nobits = (psym->st_shndx < elf_header.e_shnum
8876 && section_headers[psym->st_shndx].sh_type
8877 == SHT_NOBITS);
8878
8879 check_def = (psym->st_shndx != SHN_UNDEF);
8880
8881 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8882 {
8883 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8884 && (is_nobits || ! check_def))
8885 {
8886 Elf_External_Verneed evn;
8887 Elf_Internal_Verneed ivn;
8888 Elf_Internal_Vernaux ivna;
8889
8890 /* We must test both. */
8891 offset = offset_from_vma
8892 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8893 sizeof evn);
8894
8895 do
8896 {
8897 unsigned long vna_off;
8898
8899 get_data (&evn, file, offset, sizeof (evn), 1,
8900 _("version need"));
8901
8902 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8903 ivn.vn_next = BYTE_GET (evn.vn_next);
8904
8905 vna_off = offset + ivn.vn_aux;
8906
8907 do
8908 {
8909 Elf_External_Vernaux evna;
8910
8911 get_data (&evna, file, vna_off,
8912 sizeof (evna), 1,
8913 _("version need aux (3)"));
8914
8915 ivna.vna_other = BYTE_GET (evna.vna_other);
8916 ivna.vna_next = BYTE_GET (evna.vna_next);
8917 ivna.vna_name = BYTE_GET (evna.vna_name);
8918
8919 vna_off += ivna.vna_next;
8920 }
8921 while (ivna.vna_other != vers_data
8922 && ivna.vna_next != 0);
8923
8924 if (ivna.vna_other == vers_data)
8925 break;
8926
8927 offset += ivn.vn_next;
8928 }
8929 while (ivn.vn_next != 0);
8930
8931 if (ivna.vna_other == vers_data)
8932 {
8933 printf ("@%s (%d)",
8934 ivna.vna_name < strtab_size
8935 ? strtab + ivna.vna_name : _("<corrupt>"),
8936 ivna.vna_other);
8937 check_def = 0;
8938 }
8939 else if (! is_nobits)
8940 error (_("bad dynamic symbol\n"));
8941 else
8942 check_def = 1;
8943 }
8944
8945 if (check_def)
8946 {
8947 if (vers_data != 0x8001
8948 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8949 {
8950 Elf_Internal_Verdef ivd;
8951 Elf_Internal_Verdaux ivda;
8952 Elf_External_Verdaux evda;
8953 unsigned long off;
8954
8955 off = offset_from_vma
8956 (file,
8957 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8958 sizeof (Elf_External_Verdef));
8959
8960 do
8961 {
8962 Elf_External_Verdef evd;
8963
8964 get_data (&evd, file, off, sizeof (evd),
8965 1, _("version def"));
8966
8967 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8968 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8969 ivd.vd_next = BYTE_GET (evd.vd_next);
8970
8971 off += ivd.vd_next;
8972 }
8973 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
8974 && ivd.vd_next != 0);
8975
8976 off -= ivd.vd_next;
8977 off += ivd.vd_aux;
8978
8979 get_data (&evda, file, off, sizeof (evda),
8980 1, _("version def aux"));
8981
8982 ivda.vda_name = BYTE_GET (evda.vda_name);
8983
8984 if (psym->st_name != ivda.vda_name)
8985 printf ((vers_data & VERSYM_HIDDEN)
8986 ? "@%s" : "@@%s",
8987 ivda.vda_name < strtab_size
8988 ? strtab + ivda.vda_name : _("<corrupt>"));
8989 }
8990 }
8991 }
8992 }
8993
8994 putchar ('\n');
8995 }
8996
8997 free (symtab);
8998 if (strtab != string_table)
8999 free (strtab);
9000 }
9001 }
9002 else if (do_syms)
9003 printf
9004 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9005
9006 if (do_histogram && buckets != NULL)
9007 {
9008 unsigned long * lengths;
9009 unsigned long * counts;
9010 unsigned long hn;
9011 bfd_vma si;
9012 unsigned long maxlength = 0;
9013 unsigned long nzero_counts = 0;
9014 unsigned long nsyms = 0;
9015
9016 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9017 (unsigned long) nbuckets);
9018 printf (_(" Length Number %% of total Coverage\n"));
9019
9020 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9021 if (lengths == NULL)
9022 {
9023 error (_("Out of memory\n"));
9024 return 0;
9025 }
9026 for (hn = 0; hn < nbuckets; ++hn)
9027 {
9028 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9029 {
9030 ++nsyms;
9031 if (maxlength < ++lengths[hn])
9032 ++maxlength;
9033 }
9034 }
9035
9036 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9037 if (counts == NULL)
9038 {
9039 error (_("Out of memory\n"));
9040 return 0;
9041 }
9042
9043 for (hn = 0; hn < nbuckets; ++hn)
9044 ++counts[lengths[hn]];
9045
9046 if (nbuckets > 0)
9047 {
9048 unsigned long i;
9049 printf (" 0 %-10lu (%5.1f%%)\n",
9050 counts[0], (counts[0] * 100.0) / nbuckets);
9051 for (i = 1; i <= maxlength; ++i)
9052 {
9053 nzero_counts += counts[i] * i;
9054 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9055 i, counts[i], (counts[i] * 100.0) / nbuckets,
9056 (nzero_counts * 100.0) / nsyms);
9057 }
9058 }
9059
9060 free (counts);
9061 free (lengths);
9062 }
9063
9064 if (buckets != NULL)
9065 {
9066 free (buckets);
9067 free (chains);
9068 }
9069
9070 if (do_histogram && gnubuckets != NULL)
9071 {
9072 unsigned long * lengths;
9073 unsigned long * counts;
9074 unsigned long hn;
9075 unsigned long maxlength = 0;
9076 unsigned long nzero_counts = 0;
9077 unsigned long nsyms = 0;
9078
9079 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9080 if (lengths == NULL)
9081 {
9082 error (_("Out of memory\n"));
9083 return 0;
9084 }
9085
9086 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9087 (unsigned long) ngnubuckets);
9088 printf (_(" Length Number %% of total Coverage\n"));
9089
9090 for (hn = 0; hn < ngnubuckets; ++hn)
9091 if (gnubuckets[hn] != 0)
9092 {
9093 bfd_vma off, length = 1;
9094
9095 for (off = gnubuckets[hn] - gnusymidx;
9096 (gnuchains[off] & 1) == 0; ++off)
9097 ++length;
9098 lengths[hn] = length;
9099 if (length > maxlength)
9100 maxlength = length;
9101 nsyms += length;
9102 }
9103
9104 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9105 if (counts == NULL)
9106 {
9107 error (_("Out of memory\n"));
9108 return 0;
9109 }
9110
9111 for (hn = 0; hn < ngnubuckets; ++hn)
9112 ++counts[lengths[hn]];
9113
9114 if (ngnubuckets > 0)
9115 {
9116 unsigned long j;
9117 printf (" 0 %-10lu (%5.1f%%)\n",
9118 counts[0], (counts[0] * 100.0) / ngnubuckets);
9119 for (j = 1; j <= maxlength; ++j)
9120 {
9121 nzero_counts += counts[j] * j;
9122 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9123 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9124 (nzero_counts * 100.0) / nsyms);
9125 }
9126 }
9127
9128 free (counts);
9129 free (lengths);
9130 free (gnubuckets);
9131 free (gnuchains);
9132 }
9133
9134 return 1;
9135 }
9136
9137 static int
9138 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9139 {
9140 unsigned int i;
9141
9142 if (dynamic_syminfo == NULL
9143 || !do_dynamic)
9144 /* No syminfo, this is ok. */
9145 return 1;
9146
9147 /* There better should be a dynamic symbol section. */
9148 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9149 return 0;
9150
9151 if (dynamic_addr)
9152 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9153 dynamic_syminfo_offset, dynamic_syminfo_nent);
9154
9155 printf (_(" Num: Name BoundTo Flags\n"));
9156 for (i = 0; i < dynamic_syminfo_nent; ++i)
9157 {
9158 unsigned short int flags = dynamic_syminfo[i].si_flags;
9159
9160 printf ("%4d: ", i);
9161 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9162 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9163 else
9164 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9165 putchar (' ');
9166
9167 switch (dynamic_syminfo[i].si_boundto)
9168 {
9169 case SYMINFO_BT_SELF:
9170 fputs ("SELF ", stdout);
9171 break;
9172 case SYMINFO_BT_PARENT:
9173 fputs ("PARENT ", stdout);
9174 break;
9175 default:
9176 if (dynamic_syminfo[i].si_boundto > 0
9177 && dynamic_syminfo[i].si_boundto < dynamic_nent
9178 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9179 {
9180 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9181 putchar (' ' );
9182 }
9183 else
9184 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9185 break;
9186 }
9187
9188 if (flags & SYMINFO_FLG_DIRECT)
9189 printf (" DIRECT");
9190 if (flags & SYMINFO_FLG_PASSTHRU)
9191 printf (" PASSTHRU");
9192 if (flags & SYMINFO_FLG_COPY)
9193 printf (" COPY");
9194 if (flags & SYMINFO_FLG_LAZYLOAD)
9195 printf (" LAZYLOAD");
9196
9197 puts ("");
9198 }
9199
9200 return 1;
9201 }
9202
9203 /* Check to see if the given reloc needs to be handled in a target specific
9204 manner. If so then process the reloc and return TRUE otherwise return
9205 FALSE. */
9206
9207 static bfd_boolean
9208 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9209 unsigned char * start,
9210 Elf_Internal_Sym * symtab)
9211 {
9212 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9213
9214 switch (elf_header.e_machine)
9215 {
9216 case EM_MN10300:
9217 case EM_CYGNUS_MN10300:
9218 {
9219 static Elf_Internal_Sym * saved_sym = NULL;
9220
9221 switch (reloc_type)
9222 {
9223 case 34: /* R_MN10300_ALIGN */
9224 return TRUE;
9225 case 33: /* R_MN10300_SYM_DIFF */
9226 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9227 return TRUE;
9228 case 1: /* R_MN10300_32 */
9229 case 2: /* R_MN10300_16 */
9230 if (saved_sym != NULL)
9231 {
9232 bfd_vma value;
9233
9234 value = reloc->r_addend
9235 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9236 - saved_sym->st_value);
9237
9238 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9239
9240 saved_sym = NULL;
9241 return TRUE;
9242 }
9243 break;
9244 default:
9245 if (saved_sym != NULL)
9246 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9247 break;
9248 }
9249 break;
9250 }
9251 }
9252
9253 return FALSE;
9254 }
9255
9256 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9257 DWARF debug sections. This is a target specific test. Note - we do not
9258 go through the whole including-target-headers-multiple-times route, (as
9259 we have already done with <elf/h8.h>) because this would become very
9260 messy and even then this function would have to contain target specific
9261 information (the names of the relocs instead of their numeric values).
9262 FIXME: This is not the correct way to solve this problem. The proper way
9263 is to have target specific reloc sizing and typing functions created by
9264 the reloc-macros.h header, in the same way that it already creates the
9265 reloc naming functions. */
9266
9267 static bfd_boolean
9268 is_32bit_abs_reloc (unsigned int reloc_type)
9269 {
9270 switch (elf_header.e_machine)
9271 {
9272 case EM_386:
9273 case EM_486:
9274 return reloc_type == 1; /* R_386_32. */
9275 case EM_68K:
9276 return reloc_type == 1; /* R_68K_32. */
9277 case EM_860:
9278 return reloc_type == 1; /* R_860_32. */
9279 case EM_ALPHA:
9280 return reloc_type == 1; /* XXX Is this right ? */
9281 case EM_ARC:
9282 return reloc_type == 1; /* R_ARC_32. */
9283 case EM_ARM:
9284 return reloc_type == 2; /* R_ARM_ABS32 */
9285 case EM_AVR_OLD:
9286 case EM_AVR:
9287 return reloc_type == 1;
9288 case EM_BLACKFIN:
9289 return reloc_type == 0x12; /* R_byte4_data. */
9290 case EM_CRIS:
9291 return reloc_type == 3; /* R_CRIS_32. */
9292 case EM_CR16:
9293 case EM_CR16_OLD:
9294 return reloc_type == 3; /* R_CR16_NUM32. */
9295 case EM_CRX:
9296 return reloc_type == 15; /* R_CRX_NUM32. */
9297 case EM_CYGNUS_FRV:
9298 return reloc_type == 1;
9299 case EM_CYGNUS_D10V:
9300 case EM_D10V:
9301 return reloc_type == 6; /* R_D10V_32. */
9302 case EM_CYGNUS_D30V:
9303 case EM_D30V:
9304 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9305 case EM_DLX:
9306 return reloc_type == 3; /* R_DLX_RELOC_32. */
9307 case EM_CYGNUS_FR30:
9308 case EM_FR30:
9309 return reloc_type == 3; /* R_FR30_32. */
9310 case EM_H8S:
9311 case EM_H8_300:
9312 case EM_H8_300H:
9313 return reloc_type == 1; /* R_H8_DIR32. */
9314 case EM_IA_64:
9315 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9316 case EM_IP2K_OLD:
9317 case EM_IP2K:
9318 return reloc_type == 2; /* R_IP2K_32. */
9319 case EM_IQ2000:
9320 return reloc_type == 2; /* R_IQ2000_32. */
9321 case EM_LATTICEMICO32:
9322 return reloc_type == 3; /* R_LM32_32. */
9323 case EM_M32C_OLD:
9324 case EM_M32C:
9325 return reloc_type == 3; /* R_M32C_32. */
9326 case EM_M32R:
9327 return reloc_type == 34; /* R_M32R_32_RELA. */
9328 case EM_MCORE:
9329 return reloc_type == 1; /* R_MCORE_ADDR32. */
9330 case EM_CYGNUS_MEP:
9331 return reloc_type == 4; /* R_MEP_32. */
9332 case EM_MIPS:
9333 return reloc_type == 2; /* R_MIPS_32. */
9334 case EM_MMIX:
9335 return reloc_type == 4; /* R_MMIX_32. */
9336 case EM_CYGNUS_MN10200:
9337 case EM_MN10200:
9338 return reloc_type == 1; /* R_MN10200_32. */
9339 case EM_CYGNUS_MN10300:
9340 case EM_MN10300:
9341 return reloc_type == 1; /* R_MN10300_32. */
9342 case EM_MOXIE:
9343 return reloc_type == 1; /* R_MOXIE_32. */
9344 case EM_MSP430_OLD:
9345 case EM_MSP430:
9346 return reloc_type == 1; /* R_MSP43_32. */
9347 case EM_MT:
9348 return reloc_type == 2; /* R_MT_32. */
9349 case EM_ALTERA_NIOS2:
9350 case EM_NIOS32:
9351 return reloc_type == 1; /* R_NIOS_32. */
9352 case EM_OPENRISC:
9353 case EM_OR32:
9354 return reloc_type == 1; /* R_OR32_32. */
9355 case EM_PARISC:
9356 return (reloc_type == 1 /* R_PARISC_DIR32. */
9357 || reloc_type == 41); /* R_PARISC_SECREL32. */
9358 case EM_PJ:
9359 case EM_PJ_OLD:
9360 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9361 case EM_PPC64:
9362 return reloc_type == 1; /* R_PPC64_ADDR32. */
9363 case EM_PPC:
9364 return reloc_type == 1; /* R_PPC_ADDR32. */
9365 case EM_RX:
9366 return reloc_type == 1; /* R_RX_DIR32. */
9367 case EM_S370:
9368 return reloc_type == 1; /* R_I370_ADDR31. */
9369 case EM_S390_OLD:
9370 case EM_S390:
9371 return reloc_type == 4; /* R_S390_32. */
9372 case EM_SCORE:
9373 return reloc_type == 8; /* R_SCORE_ABS32. */
9374 case EM_SH:
9375 return reloc_type == 1; /* R_SH_DIR32. */
9376 case EM_SPARC32PLUS:
9377 case EM_SPARCV9:
9378 case EM_SPARC:
9379 return reloc_type == 3 /* R_SPARC_32. */
9380 || reloc_type == 23; /* R_SPARC_UA32. */
9381 case EM_SPU:
9382 return reloc_type == 6; /* R_SPU_ADDR32 */
9383 case EM_TI_C6000:
9384 return reloc_type == 1; /* R_C6000_ABS32. */
9385 case EM_CYGNUS_V850:
9386 case EM_V850:
9387 return reloc_type == 6; /* R_V850_ABS32. */
9388 case EM_VAX:
9389 return reloc_type == 1; /* R_VAX_32. */
9390 case EM_X86_64:
9391 case EM_L1OM:
9392 return reloc_type == 10; /* R_X86_64_32. */
9393 case EM_XC16X:
9394 case EM_C166:
9395 return reloc_type == 3; /* R_XC16C_ABS_32. */
9396 case EM_XSTORMY16:
9397 return reloc_type == 1; /* R_XSTROMY16_32. */
9398 case EM_XTENSA_OLD:
9399 case EM_XTENSA:
9400 return reloc_type == 1; /* R_XTENSA_32. */
9401 default:
9402 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9403 elf_header.e_machine);
9404 abort ();
9405 }
9406 }
9407
9408 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9409 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9410
9411 static bfd_boolean
9412 is_32bit_pcrel_reloc (unsigned int reloc_type)
9413 {
9414 switch (elf_header.e_machine)
9415 {
9416 case EM_386:
9417 case EM_486:
9418 return reloc_type == 2; /* R_386_PC32. */
9419 case EM_68K:
9420 return reloc_type == 4; /* R_68K_PC32. */
9421 case EM_ALPHA:
9422 return reloc_type == 10; /* R_ALPHA_SREL32. */
9423 case EM_ARM:
9424 return reloc_type == 3; /* R_ARM_REL32 */
9425 case EM_PARISC:
9426 return reloc_type == 9; /* R_PARISC_PCREL32. */
9427 case EM_PPC:
9428 return reloc_type == 26; /* R_PPC_REL32. */
9429 case EM_PPC64:
9430 return reloc_type == 26; /* R_PPC64_REL32. */
9431 case EM_S390_OLD:
9432 case EM_S390:
9433 return reloc_type == 5; /* R_390_PC32. */
9434 case EM_SH:
9435 return reloc_type == 2; /* R_SH_REL32. */
9436 case EM_SPARC32PLUS:
9437 case EM_SPARCV9:
9438 case EM_SPARC:
9439 return reloc_type == 6; /* R_SPARC_DISP32. */
9440 case EM_SPU:
9441 return reloc_type == 13; /* R_SPU_REL32. */
9442 case EM_X86_64:
9443 case EM_L1OM:
9444 return reloc_type == 2; /* R_X86_64_PC32. */
9445 case EM_XTENSA_OLD:
9446 case EM_XTENSA:
9447 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9448 default:
9449 /* Do not abort or issue an error message here. Not all targets use
9450 pc-relative 32-bit relocs in their DWARF debug information and we
9451 have already tested for target coverage in is_32bit_abs_reloc. A
9452 more helpful warning message will be generated by apply_relocations
9453 anyway, so just return. */
9454 return FALSE;
9455 }
9456 }
9457
9458 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9459 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9460
9461 static bfd_boolean
9462 is_64bit_abs_reloc (unsigned int reloc_type)
9463 {
9464 switch (elf_header.e_machine)
9465 {
9466 case EM_ALPHA:
9467 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9468 case EM_IA_64:
9469 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9470 case EM_PARISC:
9471 return reloc_type == 80; /* R_PARISC_DIR64. */
9472 case EM_PPC64:
9473 return reloc_type == 38; /* R_PPC64_ADDR64. */
9474 case EM_SPARC32PLUS:
9475 case EM_SPARCV9:
9476 case EM_SPARC:
9477 return reloc_type == 54; /* R_SPARC_UA64. */
9478 case EM_X86_64:
9479 case EM_L1OM:
9480 return reloc_type == 1; /* R_X86_64_64. */
9481 case EM_S390_OLD:
9482 case EM_S390:
9483 return reloc_type == 22; /* R_S390_64 */
9484 case EM_MIPS:
9485 return reloc_type == 18; /* R_MIPS_64 */
9486 default:
9487 return FALSE;
9488 }
9489 }
9490
9491 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9492 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9493
9494 static bfd_boolean
9495 is_64bit_pcrel_reloc (unsigned int reloc_type)
9496 {
9497 switch (elf_header.e_machine)
9498 {
9499 case EM_ALPHA:
9500 return reloc_type == 11; /* R_ALPHA_SREL64 */
9501 case EM_IA_64:
9502 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9503 case EM_PARISC:
9504 return reloc_type == 72; /* R_PARISC_PCREL64 */
9505 case EM_PPC64:
9506 return reloc_type == 44; /* R_PPC64_REL64 */
9507 case EM_SPARC32PLUS:
9508 case EM_SPARCV9:
9509 case EM_SPARC:
9510 return reloc_type == 46; /* R_SPARC_DISP64 */
9511 case EM_X86_64:
9512 case EM_L1OM:
9513 return reloc_type == 24; /* R_X86_64_PC64 */
9514 case EM_S390_OLD:
9515 case EM_S390:
9516 return reloc_type == 23; /* R_S390_PC64 */
9517 default:
9518 return FALSE;
9519 }
9520 }
9521
9522 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9523 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9524
9525 static bfd_boolean
9526 is_24bit_abs_reloc (unsigned int reloc_type)
9527 {
9528 switch (elf_header.e_machine)
9529 {
9530 case EM_CYGNUS_MN10200:
9531 case EM_MN10200:
9532 return reloc_type == 4; /* R_MN10200_24. */
9533 default:
9534 return FALSE;
9535 }
9536 }
9537
9538 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9539 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9540
9541 static bfd_boolean
9542 is_16bit_abs_reloc (unsigned int reloc_type)
9543 {
9544 switch (elf_header.e_machine)
9545 {
9546 case EM_AVR_OLD:
9547 case EM_AVR:
9548 return reloc_type == 4; /* R_AVR_16. */
9549 case EM_CYGNUS_D10V:
9550 case EM_D10V:
9551 return reloc_type == 3; /* R_D10V_16. */
9552 case EM_H8S:
9553 case EM_H8_300:
9554 case EM_H8_300H:
9555 return reloc_type == R_H8_DIR16;
9556 case EM_IP2K_OLD:
9557 case EM_IP2K:
9558 return reloc_type == 1; /* R_IP2K_16. */
9559 case EM_M32C_OLD:
9560 case EM_M32C:
9561 return reloc_type == 1; /* R_M32C_16 */
9562 case EM_MSP430_OLD:
9563 case EM_MSP430:
9564 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9565 case EM_ALTERA_NIOS2:
9566 case EM_NIOS32:
9567 return reloc_type == 9; /* R_NIOS_16. */
9568 case EM_TI_C6000:
9569 return reloc_type == 2; /* R_C6000_ABS16. */
9570 case EM_XC16X:
9571 case EM_C166:
9572 return reloc_type == 2; /* R_XC16C_ABS_16. */
9573 default:
9574 return FALSE;
9575 }
9576 }
9577
9578 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9579 relocation entries (possibly formerly used for SHT_GROUP sections). */
9580
9581 static bfd_boolean
9582 is_none_reloc (unsigned int reloc_type)
9583 {
9584 switch (elf_header.e_machine)
9585 {
9586 case EM_68K: /* R_68K_NONE. */
9587 case EM_386: /* R_386_NONE. */
9588 case EM_SPARC32PLUS:
9589 case EM_SPARCV9:
9590 case EM_SPARC: /* R_SPARC_NONE. */
9591 case EM_MIPS: /* R_MIPS_NONE. */
9592 case EM_PARISC: /* R_PARISC_NONE. */
9593 case EM_ALPHA: /* R_ALPHA_NONE. */
9594 case EM_PPC: /* R_PPC_NONE. */
9595 case EM_PPC64: /* R_PPC64_NONE. */
9596 case EM_ARM: /* R_ARM_NONE. */
9597 case EM_IA_64: /* R_IA64_NONE. */
9598 case EM_SH: /* R_SH_NONE. */
9599 case EM_S390_OLD:
9600 case EM_S390: /* R_390_NONE. */
9601 case EM_CRIS: /* R_CRIS_NONE. */
9602 case EM_X86_64: /* R_X86_64_NONE. */
9603 case EM_L1OM: /* R_X86_64_NONE. */
9604 case EM_MN10300: /* R_MN10300_NONE. */
9605 case EM_MOXIE: /* R_MOXIE_NONE. */
9606 case EM_M32R: /* R_M32R_NONE. */
9607 case EM_TI_C6000:/* R_C6000_NONE. */
9608 case EM_XC16X:
9609 case EM_C166: /* R_XC16X_NONE. */
9610 return reloc_type == 0;
9611 case EM_XTENSA_OLD:
9612 case EM_XTENSA:
9613 return (reloc_type == 0 /* R_XTENSA_NONE. */
9614 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9615 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9616 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9617 }
9618 return FALSE;
9619 }
9620
9621 /* Apply relocations to a section.
9622 Note: So far support has been added only for those relocations
9623 which can be found in debug sections.
9624 FIXME: Add support for more relocations ? */
9625
9626 static void
9627 apply_relocations (void * file,
9628 Elf_Internal_Shdr * section,
9629 unsigned char * start)
9630 {
9631 Elf_Internal_Shdr * relsec;
9632 unsigned char * end = start + section->sh_size;
9633
9634 if (elf_header.e_type != ET_REL)
9635 return;
9636
9637 /* Find the reloc section associated with the section. */
9638 for (relsec = section_headers;
9639 relsec < section_headers + elf_header.e_shnum;
9640 ++relsec)
9641 {
9642 bfd_boolean is_rela;
9643 unsigned long num_relocs;
9644 Elf_Internal_Rela * relocs;
9645 Elf_Internal_Rela * rp;
9646 Elf_Internal_Shdr * symsec;
9647 Elf_Internal_Sym * symtab;
9648 Elf_Internal_Sym * sym;
9649
9650 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9651 || relsec->sh_info >= elf_header.e_shnum
9652 || section_headers + relsec->sh_info != section
9653 || relsec->sh_size == 0
9654 || relsec->sh_link >= elf_header.e_shnum)
9655 continue;
9656
9657 is_rela = relsec->sh_type == SHT_RELA;
9658
9659 if (is_rela)
9660 {
9661 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9662 relsec->sh_size, & relocs, & num_relocs))
9663 return;
9664 }
9665 else
9666 {
9667 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9668 relsec->sh_size, & relocs, & num_relocs))
9669 return;
9670 }
9671
9672 /* SH uses RELA but uses in place value instead of the addend field. */
9673 if (elf_header.e_machine == EM_SH)
9674 is_rela = FALSE;
9675
9676 symsec = section_headers + relsec->sh_link;
9677 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9678
9679 for (rp = relocs; rp < relocs + num_relocs; ++rp)
9680 {
9681 bfd_vma addend;
9682 unsigned int reloc_type;
9683 unsigned int reloc_size;
9684 unsigned char * rloc;
9685
9686 reloc_type = get_reloc_type (rp->r_info);
9687
9688 if (target_specific_reloc_handling (rp, start, symtab))
9689 continue;
9690 else if (is_none_reloc (reloc_type))
9691 continue;
9692 else if (is_32bit_abs_reloc (reloc_type)
9693 || is_32bit_pcrel_reloc (reloc_type))
9694 reloc_size = 4;
9695 else if (is_64bit_abs_reloc (reloc_type)
9696 || is_64bit_pcrel_reloc (reloc_type))
9697 reloc_size = 8;
9698 else if (is_24bit_abs_reloc (reloc_type))
9699 reloc_size = 3;
9700 else if (is_16bit_abs_reloc (reloc_type))
9701 reloc_size = 2;
9702 else
9703 {
9704 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9705 reloc_type, SECTION_NAME (section));
9706 continue;
9707 }
9708
9709 rloc = start + rp->r_offset;
9710 if ((rloc + reloc_size) > end)
9711 {
9712 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9713 (unsigned long) rp->r_offset,
9714 SECTION_NAME (section));
9715 continue;
9716 }
9717
9718 sym = symtab + get_reloc_symindex (rp->r_info);
9719
9720 /* If the reloc has a symbol associated with it,
9721 make sure that it is of an appropriate type.
9722
9723 Relocations against symbols without type can happen.
9724 Gcc -feliminate-dwarf2-dups may generate symbols
9725 without type for debug info.
9726
9727 Icc generates relocations against function symbols
9728 instead of local labels.
9729
9730 Relocations against object symbols can happen, eg when
9731 referencing a global array. For an example of this see
9732 the _clz.o binary in libgcc.a. */
9733 if (sym != symtab
9734 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9735 {
9736 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9737 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9738 (long int)(rp - relocs),
9739 SECTION_NAME (relsec));
9740 continue;
9741 }
9742
9743 addend = 0;
9744 if (is_rela)
9745 addend += rp->r_addend;
9746 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9747 partial_inplace. */
9748 if (!is_rela
9749 || (elf_header.e_machine == EM_XTENSA
9750 && reloc_type == 1)
9751 || ((elf_header.e_machine == EM_PJ
9752 || elf_header.e_machine == EM_PJ_OLD)
9753 && reloc_type == 1)
9754 || ((elf_header.e_machine == EM_D30V
9755 || elf_header.e_machine == EM_CYGNUS_D30V)
9756 && reloc_type == 12))
9757 addend += byte_get (rloc, reloc_size);
9758
9759 if (is_32bit_pcrel_reloc (reloc_type)
9760 || is_64bit_pcrel_reloc (reloc_type))
9761 {
9762 /* On HPPA, all pc-relative relocations are biased by 8. */
9763 if (elf_header.e_machine == EM_PARISC)
9764 addend -= 8;
9765 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9766 reloc_size);
9767 }
9768 else
9769 byte_put (rloc, addend + sym->st_value, reloc_size);
9770 }
9771
9772 free (symtab);
9773 free (relocs);
9774 break;
9775 }
9776 }
9777
9778 #ifdef SUPPORT_DISASSEMBLY
9779 static int
9780 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9781 {
9782 printf (_("\nAssembly dump of section %s\n"),
9783 SECTION_NAME (section));
9784
9785 /* XXX -- to be done --- XXX */
9786
9787 return 1;
9788 }
9789 #endif
9790
9791 /* Reads in the contents of SECTION from FILE, returning a pointer
9792 to a malloc'ed buffer or NULL if something went wrong. */
9793
9794 static char *
9795 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9796 {
9797 bfd_size_type num_bytes;
9798
9799 num_bytes = section->sh_size;
9800
9801 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9802 {
9803 printf (_("\nSection '%s' has no data to dump.\n"),
9804 SECTION_NAME (section));
9805 return NULL;
9806 }
9807
9808 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9809 _("section contents"));
9810 }
9811
9812
9813 static void
9814 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9815 {
9816 Elf_Internal_Shdr * relsec;
9817 bfd_size_type num_bytes;
9818 char * data;
9819 char * end;
9820 char * start;
9821 char * name = SECTION_NAME (section);
9822 bfd_boolean some_strings_shown;
9823
9824 start = get_section_contents (section, file);
9825 if (start == NULL)
9826 return;
9827
9828 printf (_("\nString dump of section '%s':\n"), name);
9829
9830 /* If the section being dumped has relocations against it the user might
9831 be expecting these relocations to have been applied. Check for this
9832 case and issue a warning message in order to avoid confusion.
9833 FIXME: Maybe we ought to have an option that dumps a section with
9834 relocs applied ? */
9835 for (relsec = section_headers;
9836 relsec < section_headers + elf_header.e_shnum;
9837 ++relsec)
9838 {
9839 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9840 || relsec->sh_info >= elf_header.e_shnum
9841 || section_headers + relsec->sh_info != section
9842 || relsec->sh_size == 0
9843 || relsec->sh_link >= elf_header.e_shnum)
9844 continue;
9845
9846 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9847 break;
9848 }
9849
9850 num_bytes = section->sh_size;
9851 data = start;
9852 end = start + num_bytes;
9853 some_strings_shown = FALSE;
9854
9855 while (data < end)
9856 {
9857 while (!ISPRINT (* data))
9858 if (++ data >= end)
9859 break;
9860
9861 if (data < end)
9862 {
9863 #ifndef __MSVCRT__
9864 /* PR 11128: Use two separate invocations in order to work
9865 around bugs in the Solaris 8 implementation of printf. */
9866 printf (" [%6tx] ", data - start);
9867 printf ("%s\n", data);
9868 #else
9869 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9870 #endif
9871 data += strlen (data);
9872 some_strings_shown = TRUE;
9873 }
9874 }
9875
9876 if (! some_strings_shown)
9877 printf (_(" No strings found in this section."));
9878
9879 free (start);
9880
9881 putchar ('\n');
9882 }
9883
9884 static void
9885 dump_section_as_bytes (Elf_Internal_Shdr * section,
9886 FILE * file,
9887 bfd_boolean relocate)
9888 {
9889 Elf_Internal_Shdr * relsec;
9890 bfd_size_type bytes;
9891 bfd_vma addr;
9892 unsigned char * data;
9893 unsigned char * start;
9894
9895 start = (unsigned char *) get_section_contents (section, file);
9896 if (start == NULL)
9897 return;
9898
9899 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9900
9901 if (relocate)
9902 {
9903 apply_relocations (file, section, start);
9904 }
9905 else
9906 {
9907 /* If the section being dumped has relocations against it the user might
9908 be expecting these relocations to have been applied. Check for this
9909 case and issue a warning message in order to avoid confusion.
9910 FIXME: Maybe we ought to have an option that dumps a section with
9911 relocs applied ? */
9912 for (relsec = section_headers;
9913 relsec < section_headers + elf_header.e_shnum;
9914 ++relsec)
9915 {
9916 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9917 || relsec->sh_info >= elf_header.e_shnum
9918 || section_headers + relsec->sh_info != section
9919 || relsec->sh_size == 0
9920 || relsec->sh_link >= elf_header.e_shnum)
9921 continue;
9922
9923 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9924 break;
9925 }
9926 }
9927
9928 addr = section->sh_addr;
9929 bytes = section->sh_size;
9930 data = start;
9931
9932 while (bytes)
9933 {
9934 int j;
9935 int k;
9936 int lbytes;
9937
9938 lbytes = (bytes > 16 ? 16 : bytes);
9939
9940 printf (" 0x%8.8lx ", (unsigned long) addr);
9941
9942 for (j = 0; j < 16; j++)
9943 {
9944 if (j < lbytes)
9945 printf ("%2.2x", data[j]);
9946 else
9947 printf (" ");
9948
9949 if ((j & 3) == 3)
9950 printf (" ");
9951 }
9952
9953 for (j = 0; j < lbytes; j++)
9954 {
9955 k = data[j];
9956 if (k >= ' ' && k < 0x7f)
9957 printf ("%c", k);
9958 else
9959 printf (".");
9960 }
9961
9962 putchar ('\n');
9963
9964 data += lbytes;
9965 addr += lbytes;
9966 bytes -= lbytes;
9967 }
9968
9969 free (start);
9970
9971 putchar ('\n');
9972 }
9973
9974 /* Uncompresses a section that was compressed using zlib, in place.
9975 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9976
9977 static int
9978 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
9979 dwarf_size_type *size ATTRIBUTE_UNUSED)
9980 {
9981 #ifndef HAVE_ZLIB_H
9982 return FALSE;
9983 #else
9984 dwarf_size_type compressed_size = *size;
9985 unsigned char * compressed_buffer = *buffer;
9986 dwarf_size_type uncompressed_size;
9987 unsigned char * uncompressed_buffer;
9988 z_stream strm;
9989 int rc;
9990 dwarf_size_type header_size = 12;
9991
9992 /* Read the zlib header. In this case, it should be "ZLIB" followed
9993 by the uncompressed section size, 8 bytes in big-endian order. */
9994 if (compressed_size < header_size
9995 || ! streq ((char *) compressed_buffer, "ZLIB"))
9996 return 0;
9997
9998 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9999 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10000 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10001 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10002 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10003 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10004 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10005 uncompressed_size += compressed_buffer[11];
10006
10007 /* It is possible the section consists of several compressed
10008 buffers concatenated together, so we uncompress in a loop. */
10009 strm.zalloc = NULL;
10010 strm.zfree = NULL;
10011 strm.opaque = NULL;
10012 strm.avail_in = compressed_size - header_size;
10013 strm.next_in = (Bytef *) compressed_buffer + header_size;
10014 strm.avail_out = uncompressed_size;
10015 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10016
10017 rc = inflateInit (& strm);
10018 while (strm.avail_in > 0)
10019 {
10020 if (rc != Z_OK)
10021 goto fail;
10022 strm.next_out = ((Bytef *) uncompressed_buffer
10023 + (uncompressed_size - strm.avail_out));
10024 rc = inflate (&strm, Z_FINISH);
10025 if (rc != Z_STREAM_END)
10026 goto fail;
10027 rc = inflateReset (& strm);
10028 }
10029 rc = inflateEnd (& strm);
10030 if (rc != Z_OK
10031 || strm.avail_out != 0)
10032 goto fail;
10033
10034 free (compressed_buffer);
10035 *buffer = uncompressed_buffer;
10036 *size = uncompressed_size;
10037 return 1;
10038
10039 fail:
10040 free (uncompressed_buffer);
10041 return 0;
10042 #endif /* HAVE_ZLIB_H */
10043 }
10044
10045 static int
10046 load_specific_debug_section (enum dwarf_section_display_enum debug,
10047 Elf_Internal_Shdr * sec, void * file)
10048 {
10049 struct dwarf_section * section = &debug_displays [debug].section;
10050 char buf [64];
10051 int section_is_compressed;
10052
10053 /* If it is already loaded, do nothing. */
10054 if (section->start != NULL)
10055 return 1;
10056
10057 section_is_compressed = section->name == section->compressed_name;
10058
10059 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10060 section->address = sec->sh_addr;
10061 section->size = sec->sh_size;
10062 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10063 sec->sh_offset, 1,
10064 sec->sh_size, buf);
10065 if (section->start == NULL)
10066 return 0;
10067
10068 if (section_is_compressed)
10069 {
10070 if (! uncompress_section_contents (&section->start, &section->size))
10071 return 0;
10072 sec->sh_size = section->size;
10073 }
10074
10075 if (debug_displays [debug].relocate)
10076 apply_relocations ((FILE *) file, sec, section->start);
10077
10078 return 1;
10079 }
10080
10081 int
10082 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10083 {
10084 struct dwarf_section * section = &debug_displays [debug].section;
10085 Elf_Internal_Shdr * sec;
10086
10087 /* Locate the debug section. */
10088 sec = find_section (section->uncompressed_name);
10089 if (sec != NULL)
10090 section->name = section->uncompressed_name;
10091 else
10092 {
10093 sec = find_section (section->compressed_name);
10094 if (sec != NULL)
10095 section->name = section->compressed_name;
10096 }
10097 if (sec == NULL)
10098 return 0;
10099
10100 return load_specific_debug_section (debug, sec, (FILE *) file);
10101 }
10102
10103 void
10104 free_debug_section (enum dwarf_section_display_enum debug)
10105 {
10106 struct dwarf_section * section = &debug_displays [debug].section;
10107
10108 if (section->start == NULL)
10109 return;
10110
10111 free ((char *) section->start);
10112 section->start = NULL;
10113 section->address = 0;
10114 section->size = 0;
10115 }
10116
10117 static int
10118 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10119 {
10120 char * name = SECTION_NAME (section);
10121 bfd_size_type length;
10122 int result = 1;
10123 int i;
10124
10125 length = section->sh_size;
10126 if (length == 0)
10127 {
10128 printf (_("\nSection '%s' has no debugging data.\n"), name);
10129 return 0;
10130 }
10131 if (section->sh_type == SHT_NOBITS)
10132 {
10133 /* There is no point in dumping the contents of a debugging section
10134 which has the NOBITS type - the bits in the file will be random.
10135 This can happen when a file containing a .eh_frame section is
10136 stripped with the --only-keep-debug command line option. */
10137 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10138 return 0;
10139 }
10140
10141 if (const_strneq (name, ".gnu.linkonce.wi."))
10142 name = ".debug_info";
10143
10144 /* See if we know how to display the contents of this section. */
10145 for (i = 0; i < max; i++)
10146 if (streq (debug_displays[i].section.uncompressed_name, name)
10147 || streq (debug_displays[i].section.compressed_name, name))
10148 {
10149 struct dwarf_section * sec = &debug_displays [i].section;
10150 int secondary = (section != find_section (name));
10151
10152 if (secondary)
10153 free_debug_section ((enum dwarf_section_display_enum) i);
10154
10155 if (streq (sec->uncompressed_name, name))
10156 sec->name = sec->uncompressed_name;
10157 else
10158 sec->name = sec->compressed_name;
10159 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10160 section, file))
10161 {
10162 result &= debug_displays[i].display (sec, file);
10163
10164 if (secondary || (i != info && i != abbrev))
10165 free_debug_section ((enum dwarf_section_display_enum) i);
10166 }
10167
10168 break;
10169 }
10170
10171 if (i == max)
10172 {
10173 printf (_("Unrecognized debug section: %s\n"), name);
10174 result = 0;
10175 }
10176
10177 return result;
10178 }
10179
10180 /* Set DUMP_SECTS for all sections where dumps were requested
10181 based on section name. */
10182
10183 static void
10184 initialise_dumps_byname (void)
10185 {
10186 struct dump_list_entry * cur;
10187
10188 for (cur = dump_sects_byname; cur; cur = cur->next)
10189 {
10190 unsigned int i;
10191 int any;
10192
10193 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10194 if (streq (SECTION_NAME (section_headers + i), cur->name))
10195 {
10196 request_dump_bynumber (i, cur->type);
10197 any = 1;
10198 }
10199
10200 if (!any)
10201 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10202 cur->name);
10203 }
10204 }
10205
10206 static void
10207 process_section_contents (FILE * file)
10208 {
10209 Elf_Internal_Shdr * section;
10210 unsigned int i;
10211
10212 if (! do_dump)
10213 return;
10214
10215 initialise_dumps_byname ();
10216
10217 for (i = 0, section = section_headers;
10218 i < elf_header.e_shnum && i < num_dump_sects;
10219 i++, section++)
10220 {
10221 #ifdef SUPPORT_DISASSEMBLY
10222 if (dump_sects[i] & DISASS_DUMP)
10223 disassemble_section (section, file);
10224 #endif
10225 if (dump_sects[i] & HEX_DUMP)
10226 dump_section_as_bytes (section, file, FALSE);
10227
10228 if (dump_sects[i] & RELOC_DUMP)
10229 dump_section_as_bytes (section, file, TRUE);
10230
10231 if (dump_sects[i] & STRING_DUMP)
10232 dump_section_as_strings (section, file);
10233
10234 if (dump_sects[i] & DEBUG_DUMP)
10235 display_debug_section (section, file);
10236 }
10237
10238 /* Check to see if the user requested a
10239 dump of a section that does not exist. */
10240 while (i++ < num_dump_sects)
10241 if (dump_sects[i])
10242 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10243 }
10244
10245 static void
10246 process_mips_fpe_exception (int mask)
10247 {
10248 if (mask)
10249 {
10250 int first = 1;
10251 if (mask & OEX_FPU_INEX)
10252 fputs ("INEX", stdout), first = 0;
10253 if (mask & OEX_FPU_UFLO)
10254 printf ("%sUFLO", first ? "" : "|"), first = 0;
10255 if (mask & OEX_FPU_OFLO)
10256 printf ("%sOFLO", first ? "" : "|"), first = 0;
10257 if (mask & OEX_FPU_DIV0)
10258 printf ("%sDIV0", first ? "" : "|"), first = 0;
10259 if (mask & OEX_FPU_INVAL)
10260 printf ("%sINVAL", first ? "" : "|");
10261 }
10262 else
10263 fputs ("0", stdout);
10264 }
10265
10266 /* ARM EABI attributes section. */
10267 typedef struct
10268 {
10269 int tag;
10270 const char * name;
10271 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10272 int type;
10273 const char ** table;
10274 } arm_attr_public_tag;
10275
10276 static const char * arm_attr_tag_CPU_arch[] =
10277 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10278 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10279 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10280 static const char * arm_attr_tag_THUMB_ISA_use[] =
10281 {"No", "Thumb-1", "Thumb-2"};
10282 static const char * arm_attr_tag_FP_arch[] =
10283 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10284 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10285 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10286 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10287 static const char * arm_attr_tag_PCS_config[] =
10288 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10289 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10290 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10291 {"V6", "SB", "TLS", "Unused"};
10292 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10293 {"Absolute", "PC-relative", "SB-relative", "None"};
10294 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10295 {"Absolute", "PC-relative", "None"};
10296 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10297 {"None", "direct", "GOT-indirect"};
10298 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10299 {"None", "??? 1", "2", "??? 3", "4"};
10300 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10301 static const char * arm_attr_tag_ABI_FP_denormal[] =
10302 {"Unused", "Needed", "Sign only"};
10303 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10304 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10305 static const char * arm_attr_tag_ABI_FP_number_model[] =
10306 {"Unused", "Finite", "RTABI", "IEEE 754"};
10307 static const char * arm_attr_tag_ABI_enum_size[] =
10308 {"Unused", "small", "int", "forced to int"};
10309 static const char * arm_attr_tag_ABI_HardFP_use[] =
10310 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10311 static const char * arm_attr_tag_ABI_VFP_args[] =
10312 {"AAPCS", "VFP registers", "custom"};
10313 static const char * arm_attr_tag_ABI_WMMX_args[] =
10314 {"AAPCS", "WMMX registers", "custom"};
10315 static const char * arm_attr_tag_ABI_optimization_goals[] =
10316 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10317 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10318 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10319 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10320 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10321 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10322 static const char * arm_attr_tag_FP_HP_extension[] =
10323 {"Not Allowed", "Allowed"};
10324 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10325 {"None", "IEEE 754", "Alternative Format"};
10326 static const char * arm_attr_tag_MPextension_use[] =
10327 {"Not Allowed", "Allowed"};
10328 static const char * arm_attr_tag_DIV_use[] =
10329 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10330 "Allowed in v7-A with integer division extension"};
10331 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10332 static const char * arm_attr_tag_Virtualization_use[] =
10333 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10334 "TrustZone and Virtualization Extensions"};
10335 static const char * arm_attr_tag_MPextension_use_legacy[] =
10336 {"Not Allowed", "Allowed"};
10337
10338 #define LOOKUP(id, name) \
10339 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10340 static arm_attr_public_tag arm_attr_public_tags[] =
10341 {
10342 {4, "CPU_raw_name", 1, NULL},
10343 {5, "CPU_name", 1, NULL},
10344 LOOKUP(6, CPU_arch),
10345 {7, "CPU_arch_profile", 0, NULL},
10346 LOOKUP(8, ARM_ISA_use),
10347 LOOKUP(9, THUMB_ISA_use),
10348 LOOKUP(10, FP_arch),
10349 LOOKUP(11, WMMX_arch),
10350 LOOKUP(12, Advanced_SIMD_arch),
10351 LOOKUP(13, PCS_config),
10352 LOOKUP(14, ABI_PCS_R9_use),
10353 LOOKUP(15, ABI_PCS_RW_data),
10354 LOOKUP(16, ABI_PCS_RO_data),
10355 LOOKUP(17, ABI_PCS_GOT_use),
10356 LOOKUP(18, ABI_PCS_wchar_t),
10357 LOOKUP(19, ABI_FP_rounding),
10358 LOOKUP(20, ABI_FP_denormal),
10359 LOOKUP(21, ABI_FP_exceptions),
10360 LOOKUP(22, ABI_FP_user_exceptions),
10361 LOOKUP(23, ABI_FP_number_model),
10362 {24, "ABI_align_needed", 0, NULL},
10363 {25, "ABI_align_preserved", 0, NULL},
10364 LOOKUP(26, ABI_enum_size),
10365 LOOKUP(27, ABI_HardFP_use),
10366 LOOKUP(28, ABI_VFP_args),
10367 LOOKUP(29, ABI_WMMX_args),
10368 LOOKUP(30, ABI_optimization_goals),
10369 LOOKUP(31, ABI_FP_optimization_goals),
10370 {32, "compatibility", 0, NULL},
10371 LOOKUP(34, CPU_unaligned_access),
10372 LOOKUP(36, FP_HP_extension),
10373 LOOKUP(38, ABI_FP_16bit_format),
10374 LOOKUP(42, MPextension_use),
10375 LOOKUP(44, DIV_use),
10376 {64, "nodefaults", 0, NULL},
10377 {65, "also_compatible_with", 0, NULL},
10378 LOOKUP(66, T2EE_use),
10379 {67, "conformance", 1, NULL},
10380 LOOKUP(68, Virtualization_use),
10381 LOOKUP(70, MPextension_use_legacy)
10382 };
10383 #undef LOOKUP
10384
10385 static unsigned char *
10386 display_arm_attribute (unsigned char * p)
10387 {
10388 int tag;
10389 unsigned int len;
10390 int val;
10391 arm_attr_public_tag * attr;
10392 unsigned i;
10393 int type;
10394
10395 tag = read_uleb128 (p, &len);
10396 p += len;
10397 attr = NULL;
10398 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10399 {
10400 if (arm_attr_public_tags[i].tag == tag)
10401 {
10402 attr = &arm_attr_public_tags[i];
10403 break;
10404 }
10405 }
10406
10407 if (attr)
10408 {
10409 printf (" Tag_%s: ", attr->name);
10410 switch (attr->type)
10411 {
10412 case 0:
10413 switch (tag)
10414 {
10415 case 7: /* Tag_CPU_arch_profile. */
10416 val = read_uleb128 (p, &len);
10417 p += len;
10418 switch (val)
10419 {
10420 case 0: printf (_("None\n")); break;
10421 case 'A': printf (_("Application\n")); break;
10422 case 'R': printf (_("Realtime\n")); break;
10423 case 'M': printf (_("Microcontroller\n")); break;
10424 case 'S': printf (_("Application or Realtime\n")); break;
10425 default: printf ("??? (%d)\n", val); break;
10426 }
10427 break;
10428
10429 case 24: /* Tag_align_needed. */
10430 val = read_uleb128 (p, &len);
10431 p += len;
10432 switch (val)
10433 {
10434 case 0: printf (_("None\n")); break;
10435 case 1: printf (_("8-byte\n")); break;
10436 case 2: printf (_("4-byte\n")); break;
10437 case 3: printf ("??? 3\n"); break;
10438 default:
10439 if (val <= 12)
10440 printf (_("8-byte and up to %d-byte extended\n"),
10441 1 << val);
10442 else
10443 printf ("??? (%d)\n", val);
10444 break;
10445 }
10446 break;
10447
10448 case 25: /* Tag_align_preserved. */
10449 val = read_uleb128 (p, &len);
10450 p += len;
10451 switch (val)
10452 {
10453 case 0: printf (_("None\n")); break;
10454 case 1: printf (_("8-byte, except leaf SP\n")); break;
10455 case 2: printf (_("8-byte\n")); break;
10456 case 3: printf ("??? 3\n"); break;
10457 default:
10458 if (val <= 12)
10459 printf (_("8-byte and up to %d-byte extended\n"),
10460 1 << val);
10461 else
10462 printf ("??? (%d)\n", val);
10463 break;
10464 }
10465 break;
10466
10467 case 32: /* Tag_compatibility. */
10468 val = read_uleb128 (p, &len);
10469 p += len;
10470 printf (_("flag = %d, vendor = %s\n"), val, p);
10471 p += strlen ((char *) p) + 1;
10472 break;
10473
10474 case 64: /* Tag_nodefaults. */
10475 p++;
10476 printf (_("True\n"));
10477 break;
10478
10479 case 65: /* Tag_also_compatible_with. */
10480 val = read_uleb128 (p, &len);
10481 p += len;
10482 if (val == 6 /* Tag_CPU_arch. */)
10483 {
10484 val = read_uleb128 (p, &len);
10485 p += len;
10486 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10487 printf ("??? (%d)\n", val);
10488 else
10489 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10490 }
10491 else
10492 printf ("???\n");
10493 while (*(p++) != '\0' /* NUL terminator. */);
10494 break;
10495
10496 default:
10497 abort ();
10498 }
10499 return p;
10500
10501 case 1:
10502 case 2:
10503 type = attr->type;
10504 break;
10505
10506 default:
10507 assert (attr->type & 0x80);
10508 val = read_uleb128 (p, &len);
10509 p += len;
10510 type = attr->type & 0x7f;
10511 if (val >= type)
10512 printf ("??? (%d)\n", val);
10513 else
10514 printf ("%s\n", attr->table[val]);
10515 return p;
10516 }
10517 }
10518 else
10519 {
10520 if (tag & 1)
10521 type = 1; /* String. */
10522 else
10523 type = 2; /* uleb128. */
10524 printf (" Tag_unknown_%d: ", tag);
10525 }
10526
10527 if (type == 1)
10528 {
10529 printf ("\"%s\"\n", p);
10530 p += strlen ((char *) p) + 1;
10531 }
10532 else
10533 {
10534 val = read_uleb128 (p, &len);
10535 p += len;
10536 printf ("%d (0x%x)\n", val, val);
10537 }
10538
10539 return p;
10540 }
10541
10542 static unsigned char *
10543 display_gnu_attribute (unsigned char * p,
10544 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10545 {
10546 int tag;
10547 unsigned int len;
10548 int val;
10549 int type;
10550
10551 tag = read_uleb128 (p, &len);
10552 p += len;
10553
10554 /* Tag_compatibility is the only generic GNU attribute defined at
10555 present. */
10556 if (tag == 32)
10557 {
10558 val = read_uleb128 (p, &len);
10559 p += len;
10560 printf (_("flag = %d, vendor = %s\n"), val, p);
10561 p += strlen ((char *) p) + 1;
10562 return p;
10563 }
10564
10565 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10566 return display_proc_gnu_attribute (p, tag);
10567
10568 if (tag & 1)
10569 type = 1; /* String. */
10570 else
10571 type = 2; /* uleb128. */
10572 printf (" Tag_unknown_%d: ", tag);
10573
10574 if (type == 1)
10575 {
10576 printf ("\"%s\"\n", p);
10577 p += strlen ((char *) p) + 1;
10578 }
10579 else
10580 {
10581 val = read_uleb128 (p, &len);
10582 p += len;
10583 printf ("%d (0x%x)\n", val, val);
10584 }
10585
10586 return p;
10587 }
10588
10589 static unsigned char *
10590 display_power_gnu_attribute (unsigned char * p, int tag)
10591 {
10592 int type;
10593 unsigned int len;
10594 int val;
10595
10596 if (tag == Tag_GNU_Power_ABI_FP)
10597 {
10598 val = read_uleb128 (p, &len);
10599 p += len;
10600 printf (" Tag_GNU_Power_ABI_FP: ");
10601
10602 switch (val)
10603 {
10604 case 0:
10605 printf (_("Hard or soft float\n"));
10606 break;
10607 case 1:
10608 printf (_("Hard float\n"));
10609 break;
10610 case 2:
10611 printf (_("Soft float\n"));
10612 break;
10613 case 3:
10614 printf (_("Single-precision hard float\n"));
10615 break;
10616 default:
10617 printf ("??? (%d)\n", val);
10618 break;
10619 }
10620 return p;
10621 }
10622
10623 if (tag == Tag_GNU_Power_ABI_Vector)
10624 {
10625 val = read_uleb128 (p, &len);
10626 p += len;
10627 printf (" Tag_GNU_Power_ABI_Vector: ");
10628 switch (val)
10629 {
10630 case 0:
10631 printf (_("Any\n"));
10632 break;
10633 case 1:
10634 printf (_("Generic\n"));
10635 break;
10636 case 2:
10637 printf ("AltiVec\n");
10638 break;
10639 case 3:
10640 printf ("SPE\n");
10641 break;
10642 default:
10643 printf ("??? (%d)\n", val);
10644 break;
10645 }
10646 return p;
10647 }
10648
10649 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10650 {
10651 val = read_uleb128 (p, &len);
10652 p += len;
10653 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10654 switch (val)
10655 {
10656 case 0:
10657 printf (_("Any\n"));
10658 break;
10659 case 1:
10660 printf ("r3/r4\n");
10661 break;
10662 case 2:
10663 printf (_("Memory\n"));
10664 break;
10665 default:
10666 printf ("??? (%d)\n", val);
10667 break;
10668 }
10669 return p;
10670 }
10671
10672 if (tag & 1)
10673 type = 1; /* String. */
10674 else
10675 type = 2; /* uleb128. */
10676 printf (" Tag_unknown_%d: ", tag);
10677
10678 if (type == 1)
10679 {
10680 printf ("\"%s\"\n", p);
10681 p += strlen ((char *) p) + 1;
10682 }
10683 else
10684 {
10685 val = read_uleb128 (p, &len);
10686 p += len;
10687 printf ("%d (0x%x)\n", val, val);
10688 }
10689
10690 return p;
10691 }
10692
10693 static unsigned char *
10694 display_mips_gnu_attribute (unsigned char * p, int tag)
10695 {
10696 int type;
10697 unsigned int len;
10698 int val;
10699
10700 if (tag == Tag_GNU_MIPS_ABI_FP)
10701 {
10702 val = read_uleb128 (p, &len);
10703 p += len;
10704 printf (" Tag_GNU_MIPS_ABI_FP: ");
10705
10706 switch (val)
10707 {
10708 case 0:
10709 printf (_("Hard or soft float\n"));
10710 break;
10711 case 1:
10712 printf (_("Hard float (double precision)\n"));
10713 break;
10714 case 2:
10715 printf (_("Hard float (single precision)\n"));
10716 break;
10717 case 3:
10718 printf (_("Soft float\n"));
10719 break;
10720 case 4:
10721 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10722 break;
10723 default:
10724 printf ("??? (%d)\n", val);
10725 break;
10726 }
10727 return p;
10728 }
10729
10730 if (tag & 1)
10731 type = 1; /* String. */
10732 else
10733 type = 2; /* uleb128. */
10734 printf (" Tag_unknown_%d: ", tag);
10735
10736 if (type == 1)
10737 {
10738 printf ("\"%s\"\n", p);
10739 p += strlen ((char *) p) + 1;
10740 }
10741 else
10742 {
10743 val = read_uleb128 (p, &len);
10744 p += len;
10745 printf ("%d (0x%x)\n", val, val);
10746 }
10747
10748 return p;
10749 }
10750
10751 static unsigned char *
10752 display_tic6x_attribute (unsigned char * p)
10753 {
10754 int tag;
10755 unsigned int len;
10756 int val;
10757
10758 tag = read_uleb128 (p, &len);
10759 p += len;
10760
10761 switch (tag)
10762 {
10763 case Tag_C6XABI_Tag_CPU_arch:
10764 val = read_uleb128 (p, &len);
10765 p += len;
10766 printf (" Tag_C6XABI_Tag_CPU_arch: ");
10767
10768 switch (val)
10769 {
10770 case C6XABI_Tag_CPU_arch_none:
10771 printf (_("None\n"));
10772 break;
10773 case C6XABI_Tag_CPU_arch_C62X:
10774 printf ("C62x\n");
10775 break;
10776 case C6XABI_Tag_CPU_arch_C67X:
10777 printf ("C67x\n");
10778 break;
10779 case C6XABI_Tag_CPU_arch_C67XP:
10780 printf ("C67x+\n");
10781 break;
10782 case C6XABI_Tag_CPU_arch_C64X:
10783 printf ("C64x\n");
10784 break;
10785 case C6XABI_Tag_CPU_arch_C64XP:
10786 printf ("C64x+\n");
10787 break;
10788 case C6XABI_Tag_CPU_arch_C674X:
10789 printf ("C674x\n");
10790 break;
10791 default:
10792 printf ("??? (%d)\n", val);
10793 break;
10794 }
10795 return p;
10796
10797 case 32:
10798 /* Tag_compatibility - treated as generic by binutils for now
10799 although not currently specified for C6X. */
10800 val = read_uleb128 (p, &len);
10801 p += len;
10802 printf (_("flag = %d, vendor = %s\n"), val, p);
10803 p += strlen ((char *) p) + 1;
10804 return p;
10805 }
10806
10807 printf (" Tag_unknown_%d: ", tag);
10808
10809 /* No general documentation of handling unknown attributes, treat as
10810 ULEB128 for now. */
10811 val = read_uleb128 (p, &len);
10812 p += len;
10813 printf ("%d (0x%x)\n", val, val);
10814
10815 return p;
10816 }
10817
10818 static int
10819 process_attributes (FILE * file,
10820 const char * public_name,
10821 unsigned int proc_type,
10822 unsigned char * (* display_pub_attribute) (unsigned char *),
10823 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10824 {
10825 Elf_Internal_Shdr * sect;
10826 unsigned char * contents;
10827 unsigned char * p;
10828 unsigned char * end;
10829 bfd_vma section_len;
10830 bfd_vma len;
10831 unsigned i;
10832
10833 /* Find the section header so that we get the size. */
10834 for (i = 0, sect = section_headers;
10835 i < elf_header.e_shnum;
10836 i++, sect++)
10837 {
10838 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
10839 continue;
10840
10841 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10842 sect->sh_size, _("attributes"));
10843 if (contents == NULL)
10844 continue;
10845
10846 p = contents;
10847 if (*p == 'A')
10848 {
10849 len = sect->sh_size - 1;
10850 p++;
10851
10852 while (len > 0)
10853 {
10854 int namelen;
10855 bfd_boolean public_section;
10856 bfd_boolean gnu_section;
10857
10858 section_len = byte_get (p, 4);
10859 p += 4;
10860
10861 if (section_len > len)
10862 {
10863 printf (_("ERROR: Bad section length (%d > %d)\n"),
10864 (int) section_len, (int) len);
10865 section_len = len;
10866 }
10867
10868 len -= section_len;
10869 printf (_("Attribute Section: %s\n"), p);
10870
10871 if (public_name && streq ((char *) p, public_name))
10872 public_section = TRUE;
10873 else
10874 public_section = FALSE;
10875
10876 if (streq ((char *) p, "gnu"))
10877 gnu_section = TRUE;
10878 else
10879 gnu_section = FALSE;
10880
10881 namelen = strlen ((char *) p) + 1;
10882 p += namelen;
10883 section_len -= namelen + 4;
10884
10885 while (section_len > 0)
10886 {
10887 int tag = *(p++);
10888 int val;
10889 bfd_vma size;
10890
10891 size = byte_get (p, 4);
10892 if (size > section_len)
10893 {
10894 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10895 (int) size, (int) section_len);
10896 size = section_len;
10897 }
10898
10899 section_len -= size;
10900 end = p + size - 1;
10901 p += 4;
10902
10903 switch (tag)
10904 {
10905 case 1:
10906 printf (_("File Attributes\n"));
10907 break;
10908 case 2:
10909 printf (_("Section Attributes:"));
10910 goto do_numlist;
10911 case 3:
10912 printf (_("Symbol Attributes:"));
10913 do_numlist:
10914 for (;;)
10915 {
10916 unsigned int j;
10917
10918 val = read_uleb128 (p, &j);
10919 p += j;
10920 if (val == 0)
10921 break;
10922 printf (" %d", val);
10923 }
10924 printf ("\n");
10925 break;
10926 default:
10927 printf (_("Unknown tag: %d\n"), tag);
10928 public_section = FALSE;
10929 break;
10930 }
10931
10932 if (public_section)
10933 {
10934 while (p < end)
10935 p = display_pub_attribute (p);
10936 }
10937 else if (gnu_section)
10938 {
10939 while (p < end)
10940 p = display_gnu_attribute (p,
10941 display_proc_gnu_attribute);
10942 }
10943 else
10944 {
10945 /* ??? Do something sensible, like dump hex. */
10946 printf (_(" Unknown section contexts\n"));
10947 p = end;
10948 }
10949 }
10950 }
10951 }
10952 else
10953 printf (_("Unknown format '%c'\n"), *p);
10954
10955 free (contents);
10956 }
10957 return 1;
10958 }
10959
10960 static int
10961 process_arm_specific (FILE * file)
10962 {
10963 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
10964 display_arm_attribute, NULL);
10965 }
10966
10967 static int
10968 process_power_specific (FILE * file)
10969 {
10970 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
10971 display_power_gnu_attribute);
10972 }
10973
10974 static int
10975 process_tic6x_specific (FILE * file)
10976 {
10977 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
10978 display_tic6x_attribute, NULL);
10979 }
10980
10981 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10982 Print the Address, Access and Initial fields of an entry at VMA ADDR
10983 and return the VMA of the next entry. */
10984
10985 static bfd_vma
10986 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
10987 {
10988 printf (" ");
10989 print_vma (addr, LONG_HEX);
10990 printf (" ");
10991 if (addr < pltgot + 0xfff0)
10992 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
10993 else
10994 printf ("%10s", "");
10995 printf (" ");
10996 if (data == NULL)
10997 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
10998 else
10999 {
11000 bfd_vma entry;
11001
11002 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11003 print_vma (entry, LONG_HEX);
11004 }
11005 return addr + (is_32bit_elf ? 4 : 8);
11006 }
11007
11008 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11009 PLTGOT. Print the Address and Initial fields of an entry at VMA
11010 ADDR and return the VMA of the next entry. */
11011
11012 static bfd_vma
11013 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11014 {
11015 printf (" ");
11016 print_vma (addr, LONG_HEX);
11017 printf (" ");
11018 if (data == NULL)
11019 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11020 else
11021 {
11022 bfd_vma entry;
11023
11024 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11025 print_vma (entry, LONG_HEX);
11026 }
11027 return addr + (is_32bit_elf ? 4 : 8);
11028 }
11029
11030 static int
11031 process_mips_specific (FILE * file)
11032 {
11033 Elf_Internal_Dyn * entry;
11034 size_t liblist_offset = 0;
11035 size_t liblistno = 0;
11036 size_t conflictsno = 0;
11037 size_t options_offset = 0;
11038 size_t conflicts_offset = 0;
11039 size_t pltrelsz = 0;
11040 size_t pltrel = 0;
11041 bfd_vma pltgot = 0;
11042 bfd_vma mips_pltgot = 0;
11043 bfd_vma jmprel = 0;
11044 bfd_vma local_gotno = 0;
11045 bfd_vma gotsym = 0;
11046 bfd_vma symtabno = 0;
11047
11048 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11049 display_mips_gnu_attribute);
11050
11051 /* We have a lot of special sections. Thanks SGI! */
11052 if (dynamic_section == NULL)
11053 /* No information available. */
11054 return 0;
11055
11056 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11057 switch (entry->d_tag)
11058 {
11059 case DT_MIPS_LIBLIST:
11060 liblist_offset
11061 = offset_from_vma (file, entry->d_un.d_val,
11062 liblistno * sizeof (Elf32_External_Lib));
11063 break;
11064 case DT_MIPS_LIBLISTNO:
11065 liblistno = entry->d_un.d_val;
11066 break;
11067 case DT_MIPS_OPTIONS:
11068 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11069 break;
11070 case DT_MIPS_CONFLICT:
11071 conflicts_offset
11072 = offset_from_vma (file, entry->d_un.d_val,
11073 conflictsno * sizeof (Elf32_External_Conflict));
11074 break;
11075 case DT_MIPS_CONFLICTNO:
11076 conflictsno = entry->d_un.d_val;
11077 break;
11078 case DT_PLTGOT:
11079 pltgot = entry->d_un.d_ptr;
11080 break;
11081 case DT_MIPS_LOCAL_GOTNO:
11082 local_gotno = entry->d_un.d_val;
11083 break;
11084 case DT_MIPS_GOTSYM:
11085 gotsym = entry->d_un.d_val;
11086 break;
11087 case DT_MIPS_SYMTABNO:
11088 symtabno = entry->d_un.d_val;
11089 break;
11090 case DT_MIPS_PLTGOT:
11091 mips_pltgot = entry->d_un.d_ptr;
11092 break;
11093 case DT_PLTREL:
11094 pltrel = entry->d_un.d_val;
11095 break;
11096 case DT_PLTRELSZ:
11097 pltrelsz = entry->d_un.d_val;
11098 break;
11099 case DT_JMPREL:
11100 jmprel = entry->d_un.d_ptr;
11101 break;
11102 default:
11103 break;
11104 }
11105
11106 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11107 {
11108 Elf32_External_Lib * elib;
11109 size_t cnt;
11110
11111 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11112 liblistno,
11113 sizeof (Elf32_External_Lib),
11114 _("liblist"));
11115 if (elib)
11116 {
11117 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11118 (unsigned long) liblistno);
11119 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11120 stdout);
11121
11122 for (cnt = 0; cnt < liblistno; ++cnt)
11123 {
11124 Elf32_Lib liblist;
11125 time_t atime;
11126 char timebuf[20];
11127 struct tm * tmp;
11128
11129 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11130 atime = BYTE_GET (elib[cnt].l_time_stamp);
11131 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11132 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11133 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11134
11135 tmp = gmtime (&atime);
11136 snprintf (timebuf, sizeof (timebuf),
11137 "%04u-%02u-%02uT%02u:%02u:%02u",
11138 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11139 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11140
11141 printf ("%3lu: ", (unsigned long) cnt);
11142 if (VALID_DYNAMIC_NAME (liblist.l_name))
11143 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11144 else
11145 printf (_("<corrupt: %9ld>"), liblist.l_name);
11146 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11147 liblist.l_version);
11148
11149 if (liblist.l_flags == 0)
11150 puts (_(" NONE"));
11151 else
11152 {
11153 static const struct
11154 {
11155 const char * name;
11156 int bit;
11157 }
11158 l_flags_vals[] =
11159 {
11160 { " EXACT_MATCH", LL_EXACT_MATCH },
11161 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11162 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11163 { " EXPORTS", LL_EXPORTS },
11164 { " DELAY_LOAD", LL_DELAY_LOAD },
11165 { " DELTA", LL_DELTA }
11166 };
11167 int flags = liblist.l_flags;
11168 size_t fcnt;
11169
11170 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11171 if ((flags & l_flags_vals[fcnt].bit) != 0)
11172 {
11173 fputs (l_flags_vals[fcnt].name, stdout);
11174 flags ^= l_flags_vals[fcnt].bit;
11175 }
11176 if (flags != 0)
11177 printf (" %#x", (unsigned int) flags);
11178
11179 puts ("");
11180 }
11181 }
11182
11183 free (elib);
11184 }
11185 }
11186
11187 if (options_offset != 0)
11188 {
11189 Elf_External_Options * eopt;
11190 Elf_Internal_Shdr * sect = section_headers;
11191 Elf_Internal_Options * iopt;
11192 Elf_Internal_Options * option;
11193 size_t offset;
11194 int cnt;
11195
11196 /* Find the section header so that we get the size. */
11197 while (sect->sh_type != SHT_MIPS_OPTIONS)
11198 ++sect;
11199
11200 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11201 sect->sh_size, _("options"));
11202 if (eopt)
11203 {
11204 iopt = (Elf_Internal_Options *)
11205 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11206 if (iopt == NULL)
11207 {
11208 error (_("Out of memory\n"));
11209 return 0;
11210 }
11211
11212 offset = cnt = 0;
11213 option = iopt;
11214
11215 while (offset < sect->sh_size)
11216 {
11217 Elf_External_Options * eoption;
11218
11219 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11220
11221 option->kind = BYTE_GET (eoption->kind);
11222 option->size = BYTE_GET (eoption->size);
11223 option->section = BYTE_GET (eoption->section);
11224 option->info = BYTE_GET (eoption->info);
11225
11226 offset += option->size;
11227
11228 ++option;
11229 ++cnt;
11230 }
11231
11232 printf (_("\nSection '%s' contains %d entries:\n"),
11233 SECTION_NAME (sect), cnt);
11234
11235 option = iopt;
11236
11237 while (cnt-- > 0)
11238 {
11239 size_t len;
11240
11241 switch (option->kind)
11242 {
11243 case ODK_NULL:
11244 /* This shouldn't happen. */
11245 printf (" NULL %d %lx", option->section, option->info);
11246 break;
11247 case ODK_REGINFO:
11248 printf (" REGINFO ");
11249 if (elf_header.e_machine == EM_MIPS)
11250 {
11251 /* 32bit form. */
11252 Elf32_External_RegInfo * ereg;
11253 Elf32_RegInfo reginfo;
11254
11255 ereg = (Elf32_External_RegInfo *) (option + 1);
11256 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11257 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11258 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11259 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11260 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11261 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11262
11263 printf ("GPR %08lx GP 0x%lx\n",
11264 reginfo.ri_gprmask,
11265 (unsigned long) reginfo.ri_gp_value);
11266 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11267 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11268 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11269 }
11270 else
11271 {
11272 /* 64 bit form. */
11273 Elf64_External_RegInfo * ereg;
11274 Elf64_Internal_RegInfo reginfo;
11275
11276 ereg = (Elf64_External_RegInfo *) (option + 1);
11277 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11278 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11279 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11280 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11281 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11282 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11283
11284 printf ("GPR %08lx GP 0x",
11285 reginfo.ri_gprmask);
11286 printf_vma (reginfo.ri_gp_value);
11287 printf ("\n");
11288
11289 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11290 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11291 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11292 }
11293 ++option;
11294 continue;
11295 case ODK_EXCEPTIONS:
11296 fputs (" EXCEPTIONS fpe_min(", stdout);
11297 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11298 fputs (") fpe_max(", stdout);
11299 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11300 fputs (")", stdout);
11301
11302 if (option->info & OEX_PAGE0)
11303 fputs (" PAGE0", stdout);
11304 if (option->info & OEX_SMM)
11305 fputs (" SMM", stdout);
11306 if (option->info & OEX_FPDBUG)
11307 fputs (" FPDBUG", stdout);
11308 if (option->info & OEX_DISMISS)
11309 fputs (" DISMISS", stdout);
11310 break;
11311 case ODK_PAD:
11312 fputs (" PAD ", stdout);
11313 if (option->info & OPAD_PREFIX)
11314 fputs (" PREFIX", stdout);
11315 if (option->info & OPAD_POSTFIX)
11316 fputs (" POSTFIX", stdout);
11317 if (option->info & OPAD_SYMBOL)
11318 fputs (" SYMBOL", stdout);
11319 break;
11320 case ODK_HWPATCH:
11321 fputs (" HWPATCH ", stdout);
11322 if (option->info & OHW_R4KEOP)
11323 fputs (" R4KEOP", stdout);
11324 if (option->info & OHW_R8KPFETCH)
11325 fputs (" R8KPFETCH", stdout);
11326 if (option->info & OHW_R5KEOP)
11327 fputs (" R5KEOP", stdout);
11328 if (option->info & OHW_R5KCVTL)
11329 fputs (" R5KCVTL", stdout);
11330 break;
11331 case ODK_FILL:
11332 fputs (" FILL ", stdout);
11333 /* XXX Print content of info word? */
11334 break;
11335 case ODK_TAGS:
11336 fputs (" TAGS ", stdout);
11337 /* XXX Print content of info word? */
11338 break;
11339 case ODK_HWAND:
11340 fputs (" HWAND ", stdout);
11341 if (option->info & OHWA0_R4KEOP_CHECKED)
11342 fputs (" R4KEOP_CHECKED", stdout);
11343 if (option->info & OHWA0_R4KEOP_CLEAN)
11344 fputs (" R4KEOP_CLEAN", stdout);
11345 break;
11346 case ODK_HWOR:
11347 fputs (" HWOR ", stdout);
11348 if (option->info & OHWA0_R4KEOP_CHECKED)
11349 fputs (" R4KEOP_CHECKED", stdout);
11350 if (option->info & OHWA0_R4KEOP_CLEAN)
11351 fputs (" R4KEOP_CLEAN", stdout);
11352 break;
11353 case ODK_GP_GROUP:
11354 printf (" GP_GROUP %#06lx self-contained %#06lx",
11355 option->info & OGP_GROUP,
11356 (option->info & OGP_SELF) >> 16);
11357 break;
11358 case ODK_IDENT:
11359 printf (" IDENT %#06lx self-contained %#06lx",
11360 option->info & OGP_GROUP,
11361 (option->info & OGP_SELF) >> 16);
11362 break;
11363 default:
11364 /* This shouldn't happen. */
11365 printf (" %3d ??? %d %lx",
11366 option->kind, option->section, option->info);
11367 break;
11368 }
11369
11370 len = sizeof (* eopt);
11371 while (len < option->size)
11372 if (((char *) option)[len] >= ' '
11373 && ((char *) option)[len] < 0x7f)
11374 printf ("%c", ((char *) option)[len++]);
11375 else
11376 printf ("\\%03o", ((char *) option)[len++]);
11377
11378 fputs ("\n", stdout);
11379 ++option;
11380 }
11381
11382 free (eopt);
11383 }
11384 }
11385
11386 if (conflicts_offset != 0 && conflictsno != 0)
11387 {
11388 Elf32_Conflict * iconf;
11389 size_t cnt;
11390
11391 if (dynamic_symbols == NULL)
11392 {
11393 error (_("conflict list found without a dynamic symbol table\n"));
11394 return 0;
11395 }
11396
11397 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11398 if (iconf == NULL)
11399 {
11400 error (_("Out of memory\n"));
11401 return 0;
11402 }
11403
11404 if (is_32bit_elf)
11405 {
11406 Elf32_External_Conflict * econf32;
11407
11408 econf32 = (Elf32_External_Conflict *)
11409 get_data (NULL, file, conflicts_offset, conflictsno,
11410 sizeof (* econf32), _("conflict"));
11411 if (!econf32)
11412 return 0;
11413
11414 for (cnt = 0; cnt < conflictsno; ++cnt)
11415 iconf[cnt] = BYTE_GET (econf32[cnt]);
11416
11417 free (econf32);
11418 }
11419 else
11420 {
11421 Elf64_External_Conflict * econf64;
11422
11423 econf64 = (Elf64_External_Conflict *)
11424 get_data (NULL, file, conflicts_offset, conflictsno,
11425 sizeof (* econf64), _("conflict"));
11426 if (!econf64)
11427 return 0;
11428
11429 for (cnt = 0; cnt < conflictsno; ++cnt)
11430 iconf[cnt] = BYTE_GET (econf64[cnt]);
11431
11432 free (econf64);
11433 }
11434
11435 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11436 (unsigned long) conflictsno);
11437 puts (_(" Num: Index Value Name"));
11438
11439 for (cnt = 0; cnt < conflictsno; ++cnt)
11440 {
11441 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11442
11443 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11444 print_vma (psym->st_value, FULL_HEX);
11445 putchar (' ');
11446 if (VALID_DYNAMIC_NAME (psym->st_name))
11447 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11448 else
11449 printf (_("<corrupt: %14ld>"), psym->st_name);
11450 putchar ('\n');
11451 }
11452
11453 free (iconf);
11454 }
11455
11456 if (pltgot != 0 && local_gotno != 0)
11457 {
11458 bfd_vma ent, local_end, global_end;
11459 size_t i, offset;
11460 unsigned char * data;
11461 int addr_size;
11462
11463 ent = pltgot;
11464 addr_size = (is_32bit_elf ? 4 : 8);
11465 local_end = pltgot + local_gotno * addr_size;
11466 global_end = local_end + (symtabno - gotsym) * addr_size;
11467
11468 offset = offset_from_vma (file, pltgot, global_end - pltgot);
11469 data = (unsigned char *) get_data (NULL, file, offset,
11470 global_end - pltgot, 1, _("GOT"));
11471 printf (_("\nPrimary GOT:\n"));
11472 printf (_(" Canonical gp value: "));
11473 print_vma (pltgot + 0x7ff0, LONG_HEX);
11474 printf ("\n\n");
11475
11476 printf (_(" Reserved entries:\n"));
11477 printf (_(" %*s %10s %*s Purpose\n"),
11478 addr_size * 2, _("Address"), _("Access"),
11479 addr_size * 2, _("Initial"));
11480 ent = print_mips_got_entry (data, pltgot, ent);
11481 printf (_(" Lazy resolver\n"));
11482 if (data
11483 && (byte_get (data + ent - pltgot, addr_size)
11484 >> (addr_size * 8 - 1)) != 0)
11485 {
11486 ent = print_mips_got_entry (data, pltgot, ent);
11487 printf (_(" Module pointer (GNU extension)\n"));
11488 }
11489 printf ("\n");
11490
11491 if (ent < local_end)
11492 {
11493 printf (_(" Local entries:\n"));
11494 printf (_(" %*s %10s %*s\n"),
11495 addr_size * 2, _("Address"), _("Access"),
11496 addr_size * 2, _("Initial"));
11497 while (ent < local_end)
11498 {
11499 ent = print_mips_got_entry (data, pltgot, ent);
11500 printf ("\n");
11501 }
11502 printf ("\n");
11503 }
11504
11505 if (gotsym < symtabno)
11506 {
11507 int sym_width;
11508
11509 printf (_(" Global entries:\n"));
11510 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
11511 addr_size * 2, _("Address"), _("Access"),
11512 addr_size * 2, _("Initial"),
11513 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11514 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11515 for (i = gotsym; i < symtabno; i++)
11516 {
11517 Elf_Internal_Sym * psym;
11518
11519 psym = dynamic_symbols + i;
11520 ent = print_mips_got_entry (data, pltgot, ent);
11521 printf (" ");
11522 print_vma (psym->st_value, LONG_HEX);
11523 printf (" %-7s %3s ",
11524 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11525 get_symbol_index_type (psym->st_shndx));
11526 if (VALID_DYNAMIC_NAME (psym->st_name))
11527 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11528 else
11529 printf (_("<corrupt: %14ld>"), psym->st_name);
11530 printf ("\n");
11531 }
11532 printf ("\n");
11533 }
11534
11535 if (data)
11536 free (data);
11537 }
11538
11539 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11540 {
11541 bfd_vma ent, end;
11542 size_t offset, rel_offset;
11543 unsigned long count, i;
11544 unsigned char * data;
11545 int addr_size, sym_width;
11546 Elf_Internal_Rela * rels;
11547
11548 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11549 if (pltrel == DT_RELA)
11550 {
11551 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11552 return 0;
11553 }
11554 else
11555 {
11556 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11557 return 0;
11558 }
11559
11560 ent = mips_pltgot;
11561 addr_size = (is_32bit_elf ? 4 : 8);
11562 end = mips_pltgot + (2 + count) * addr_size;
11563
11564 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11565 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11566 1, _("PLT GOT"));
11567 printf (_("\nPLT GOT:\n\n"));
11568 printf (_(" Reserved entries:\n"));
11569 printf (_(" %*s %*s Purpose\n"),
11570 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11571 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11572 printf (_(" PLT lazy resolver\n"));
11573 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11574 printf (_(" Module pointer\n"));
11575 printf ("\n");
11576
11577 printf (_(" Entries:\n"));
11578 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11579 addr_size * 2, _("Address"),
11580 addr_size * 2, _("Initial"),
11581 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11582 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11583 for (i = 0; i < count; i++)
11584 {
11585 Elf_Internal_Sym * psym;
11586
11587 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11588 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11589 printf (" ");
11590 print_vma (psym->st_value, LONG_HEX);
11591 printf (" %-7s %3s ",
11592 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11593 get_symbol_index_type (psym->st_shndx));
11594 if (VALID_DYNAMIC_NAME (psym->st_name))
11595 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11596 else
11597 printf (_("<corrupt: %14ld>"), psym->st_name);
11598 printf ("\n");
11599 }
11600 printf ("\n");
11601
11602 if (data)
11603 free (data);
11604 free (rels);
11605 }
11606
11607 return 1;
11608 }
11609
11610 static int
11611 process_gnu_liblist (FILE * file)
11612 {
11613 Elf_Internal_Shdr * section;
11614 Elf_Internal_Shdr * string_sec;
11615 Elf32_External_Lib * elib;
11616 char * strtab;
11617 size_t strtab_size;
11618 size_t cnt;
11619 unsigned i;
11620
11621 if (! do_arch)
11622 return 0;
11623
11624 for (i = 0, section = section_headers;
11625 i < elf_header.e_shnum;
11626 i++, section++)
11627 {
11628 switch (section->sh_type)
11629 {
11630 case SHT_GNU_LIBLIST:
11631 if (section->sh_link >= elf_header.e_shnum)
11632 break;
11633
11634 elib = (Elf32_External_Lib *)
11635 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11636 _("liblist"));
11637
11638 if (elib == NULL)
11639 break;
11640 string_sec = section_headers + section->sh_link;
11641
11642 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11643 string_sec->sh_size,
11644 _("liblist string table"));
11645 strtab_size = string_sec->sh_size;
11646
11647 if (strtab == NULL
11648 || section->sh_entsize != sizeof (Elf32_External_Lib))
11649 {
11650 free (elib);
11651 break;
11652 }
11653
11654 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11655 SECTION_NAME (section),
11656 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11657
11658 puts (_(" Library Time Stamp Checksum Version Flags"));
11659
11660 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11661 ++cnt)
11662 {
11663 Elf32_Lib liblist;
11664 time_t atime;
11665 char timebuf[20];
11666 struct tm * tmp;
11667
11668 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11669 atime = BYTE_GET (elib[cnt].l_time_stamp);
11670 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11671 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11672 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11673
11674 tmp = gmtime (&atime);
11675 snprintf (timebuf, sizeof (timebuf),
11676 "%04u-%02u-%02uT%02u:%02u:%02u",
11677 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11678 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11679
11680 printf ("%3lu: ", (unsigned long) cnt);
11681 if (do_wide)
11682 printf ("%-20s", liblist.l_name < strtab_size
11683 ? strtab + liblist.l_name : _("<corrupt>"));
11684 else
11685 printf ("%-20.20s", liblist.l_name < strtab_size
11686 ? strtab + liblist.l_name : _("<corrupt>"));
11687 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11688 liblist.l_version, liblist.l_flags);
11689 }
11690
11691 free (elib);
11692 }
11693 }
11694
11695 return 1;
11696 }
11697
11698 static const char *
11699 get_note_type (unsigned e_type)
11700 {
11701 static char buff[64];
11702
11703 if (elf_header.e_type == ET_CORE)
11704 switch (e_type)
11705 {
11706 case NT_AUXV:
11707 return _("NT_AUXV (auxiliary vector)");
11708 case NT_PRSTATUS:
11709 return _("NT_PRSTATUS (prstatus structure)");
11710 case NT_FPREGSET:
11711 return _("NT_FPREGSET (floating point registers)");
11712 case NT_PRPSINFO:
11713 return _("NT_PRPSINFO (prpsinfo structure)");
11714 case NT_TASKSTRUCT:
11715 return _("NT_TASKSTRUCT (task structure)");
11716 case NT_PRXFPREG:
11717 return _("NT_PRXFPREG (user_xfpregs structure)");
11718 case NT_PPC_VMX:
11719 return _("NT_PPC_VMX (ppc Altivec registers)");
11720 case NT_PPC_VSX:
11721 return _("NT_PPC_VSX (ppc VSX registers)");
11722 case NT_X86_XSTATE:
11723 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11724 case NT_S390_HIGH_GPRS:
11725 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11726 case NT_S390_TIMER:
11727 return _("NT_S390_TIMER (s390 timer register)");
11728 case NT_S390_TODCMP:
11729 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11730 case NT_S390_TODPREG:
11731 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11732 case NT_S390_CTRS:
11733 return _("NT_S390_CTRS (s390 control registers)");
11734 case NT_S390_PREFIX:
11735 return _("NT_S390_PREFIX (s390 prefix register)");
11736 case NT_PSTATUS:
11737 return _("NT_PSTATUS (pstatus structure)");
11738 case NT_FPREGS:
11739 return _("NT_FPREGS (floating point registers)");
11740 case NT_PSINFO:
11741 return _("NT_PSINFO (psinfo structure)");
11742 case NT_LWPSTATUS:
11743 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11744 case NT_LWPSINFO:
11745 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11746 case NT_WIN32PSTATUS:
11747 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11748 default:
11749 break;
11750 }
11751 else
11752 switch (e_type)
11753 {
11754 case NT_VERSION:
11755 return _("NT_VERSION (version)");
11756 case NT_ARCH:
11757 return _("NT_ARCH (architecture)");
11758 default:
11759 break;
11760 }
11761
11762 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11763 return buff;
11764 }
11765
11766 static const char *
11767 get_gnu_elf_note_type (unsigned e_type)
11768 {
11769 static char buff[64];
11770
11771 switch (e_type)
11772 {
11773 case NT_GNU_ABI_TAG:
11774 return _("NT_GNU_ABI_TAG (ABI version tag)");
11775 case NT_GNU_HWCAP:
11776 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11777 case NT_GNU_BUILD_ID:
11778 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11779 case NT_GNU_GOLD_VERSION:
11780 return _("NT_GNU_GOLD_VERSION (gold version)");
11781 default:
11782 break;
11783 }
11784
11785 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11786 return buff;
11787 }
11788
11789 static const char *
11790 get_netbsd_elfcore_note_type (unsigned e_type)
11791 {
11792 static char buff[64];
11793
11794 if (e_type == NT_NETBSDCORE_PROCINFO)
11795 {
11796 /* NetBSD core "procinfo" structure. */
11797 return _("NetBSD procinfo structure");
11798 }
11799
11800 /* As of Jan 2002 there are no other machine-independent notes
11801 defined for NetBSD core files. If the note type is less
11802 than the start of the machine-dependent note types, we don't
11803 understand it. */
11804
11805 if (e_type < NT_NETBSDCORE_FIRSTMACH)
11806 {
11807 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11808 return buff;
11809 }
11810
11811 switch (elf_header.e_machine)
11812 {
11813 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11814 and PT_GETFPREGS == mach+2. */
11815
11816 case EM_OLD_ALPHA:
11817 case EM_ALPHA:
11818 case EM_SPARC:
11819 case EM_SPARC32PLUS:
11820 case EM_SPARCV9:
11821 switch (e_type)
11822 {
11823 case NT_NETBSDCORE_FIRSTMACH + 0:
11824 return _("PT_GETREGS (reg structure)");
11825 case NT_NETBSDCORE_FIRSTMACH + 2:
11826 return _("PT_GETFPREGS (fpreg structure)");
11827 default:
11828 break;
11829 }
11830 break;
11831
11832 /* On all other arch's, PT_GETREGS == mach+1 and
11833 PT_GETFPREGS == mach+3. */
11834 default:
11835 switch (e_type)
11836 {
11837 case NT_NETBSDCORE_FIRSTMACH + 1:
11838 return _("PT_GETREGS (reg structure)");
11839 case NT_NETBSDCORE_FIRSTMACH + 3:
11840 return _("PT_GETFPREGS (fpreg structure)");
11841 default:
11842 break;
11843 }
11844 }
11845
11846 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11847 e_type - NT_NETBSDCORE_FIRSTMACH);
11848 return buff;
11849 }
11850
11851 /* Note that by the ELF standard, the name field is already null byte
11852 terminated, and namesz includes the terminating null byte.
11853 I.E. the value of namesz for the name "FSF" is 4.
11854
11855 If the value of namesz is zero, there is no name present. */
11856 static int
11857 process_note (Elf_Internal_Note * pnote)
11858 {
11859 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11860 const char * nt;
11861
11862 if (pnote->namesz == 0)
11863 /* If there is no note name, then use the default set of
11864 note type strings. */
11865 nt = get_note_type (pnote->type);
11866
11867 else if (const_strneq (pnote->namedata, "GNU"))
11868 /* GNU-specific object file notes. */
11869 nt = get_gnu_elf_note_type (pnote->type);
11870
11871 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
11872 /* NetBSD-specific core file notes. */
11873 nt = get_netbsd_elfcore_note_type (pnote->type);
11874
11875 else if (strneq (pnote->namedata, "SPU/", 4))
11876 {
11877 /* SPU-specific core file notes. */
11878 nt = pnote->namedata + 4;
11879 name = "SPU";
11880 }
11881
11882 else
11883 /* Don't recognize this note name; just use the default set of
11884 note type strings. */
11885 nt = get_note_type (pnote->type);
11886
11887 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
11888 return 1;
11889 }
11890
11891
11892 static int
11893 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
11894 {
11895 Elf_External_Note * pnotes;
11896 Elf_External_Note * external;
11897 int res = 1;
11898
11899 if (length <= 0)
11900 return 0;
11901
11902 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
11903 _("notes"));
11904 if (pnotes == NULL)
11905 return 0;
11906
11907 external = pnotes;
11908
11909 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11910 (unsigned long) offset, (unsigned long) length);
11911 printf (_(" Owner\t\tData size\tDescription\n"));
11912
11913 while (external < (Elf_External_Note *) ((char *) pnotes + length))
11914 {
11915 Elf_External_Note * next;
11916 Elf_Internal_Note inote;
11917 char * temp = NULL;
11918
11919 inote.type = BYTE_GET (external->type);
11920 inote.namesz = BYTE_GET (external->namesz);
11921 inote.namedata = external->name;
11922 inote.descsz = BYTE_GET (external->descsz);
11923 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
11924 inote.descpos = offset + (inote.descdata - (char *) pnotes);
11925
11926 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
11927
11928 if ( ((char *) next > ((char *) pnotes) + length)
11929 || ((char *) next < (char *) pnotes))
11930 {
11931 warn (_("corrupt note found at offset %lx into core notes\n"),
11932 (unsigned long) ((char *) external - (char *) pnotes));
11933 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11934 inote.type, inote.namesz, inote.descsz);
11935 break;
11936 }
11937
11938 external = next;
11939
11940 /* Prevent out-of-bounds indexing. */
11941 if (inote.namedata + inote.namesz >= (char *) pnotes + length
11942 || inote.namedata + inote.namesz < inote.namedata)
11943 {
11944 warn (_("corrupt note found at offset %lx into core notes\n"),
11945 (unsigned long) ((char *) external - (char *) pnotes));
11946 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11947 inote.type, inote.namesz, inote.descsz);
11948 break;
11949 }
11950
11951 /* Verify that name is null terminated. It appears that at least
11952 one version of Linux (RedHat 6.0) generates corefiles that don't
11953 comply with the ELF spec by failing to include the null byte in
11954 namesz. */
11955 if (inote.namedata[inote.namesz] != '\0')
11956 {
11957 temp = (char *) malloc (inote.namesz + 1);
11958
11959 if (temp == NULL)
11960 {
11961 error (_("Out of memory\n"));
11962 res = 0;
11963 break;
11964 }
11965
11966 strncpy (temp, inote.namedata, inote.namesz);
11967 temp[inote.namesz] = 0;
11968
11969 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11970 inote.namedata = temp;
11971 }
11972
11973 res &= process_note (& inote);
11974
11975 if (temp != NULL)
11976 {
11977 free (temp);
11978 temp = NULL;
11979 }
11980 }
11981
11982 free (pnotes);
11983
11984 return res;
11985 }
11986
11987 static int
11988 process_corefile_note_segments (FILE * file)
11989 {
11990 Elf_Internal_Phdr * segment;
11991 unsigned int i;
11992 int res = 1;
11993
11994 if (! get_program_headers (file))
11995 return 0;
11996
11997 for (i = 0, segment = program_headers;
11998 i < elf_header.e_phnum;
11999 i++, segment++)
12000 {
12001 if (segment->p_type == PT_NOTE)
12002 res &= process_corefile_note_segment (file,
12003 (bfd_vma) segment->p_offset,
12004 (bfd_vma) segment->p_filesz);
12005 }
12006
12007 return res;
12008 }
12009
12010 static int
12011 process_note_sections (FILE * file)
12012 {
12013 Elf_Internal_Shdr * section;
12014 unsigned long i;
12015 int res = 1;
12016
12017 for (i = 0, section = section_headers;
12018 i < elf_header.e_shnum;
12019 i++, section++)
12020 if (section->sh_type == SHT_NOTE)
12021 res &= process_corefile_note_segment (file,
12022 (bfd_vma) section->sh_offset,
12023 (bfd_vma) section->sh_size);
12024
12025 return res;
12026 }
12027
12028 static int
12029 process_notes (FILE * file)
12030 {
12031 /* If we have not been asked to display the notes then do nothing. */
12032 if (! do_notes)
12033 return 1;
12034
12035 if (elf_header.e_type != ET_CORE)
12036 return process_note_sections (file);
12037
12038 /* No program headers means no NOTE segment. */
12039 if (elf_header.e_phnum > 0)
12040 return process_corefile_note_segments (file);
12041
12042 printf (_("No note segments present in the core file.\n"));
12043 return 1;
12044 }
12045
12046 static int
12047 process_arch_specific (FILE * file)
12048 {
12049 if (! do_arch)
12050 return 1;
12051
12052 switch (elf_header.e_machine)
12053 {
12054 case EM_ARM:
12055 return process_arm_specific (file);
12056 case EM_MIPS:
12057 case EM_MIPS_RS3_LE:
12058 return process_mips_specific (file);
12059 break;
12060 case EM_PPC:
12061 return process_power_specific (file);
12062 break;
12063 case EM_TI_C6000:
12064 return process_tic6x_specific (file);
12065 break;
12066 default:
12067 break;
12068 }
12069 return 1;
12070 }
12071
12072 static int
12073 get_file_header (FILE * file)
12074 {
12075 /* Read in the identity array. */
12076 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12077 return 0;
12078
12079 /* Determine how to read the rest of the header. */
12080 switch (elf_header.e_ident[EI_DATA])
12081 {
12082 default: /* fall through */
12083 case ELFDATANONE: /* fall through */
12084 case ELFDATA2LSB:
12085 byte_get = byte_get_little_endian;
12086 byte_put = byte_put_little_endian;
12087 break;
12088 case ELFDATA2MSB:
12089 byte_get = byte_get_big_endian;
12090 byte_put = byte_put_big_endian;
12091 break;
12092 }
12093
12094 /* For now we only support 32 bit and 64 bit ELF files. */
12095 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12096
12097 /* Read in the rest of the header. */
12098 if (is_32bit_elf)
12099 {
12100 Elf32_External_Ehdr ehdr32;
12101
12102 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12103 return 0;
12104
12105 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12106 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12107 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12108 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12109 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12110 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12111 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12112 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12113 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12114 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12115 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12116 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12117 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12118 }
12119 else
12120 {
12121 Elf64_External_Ehdr ehdr64;
12122
12123 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12124 we will not be able to cope with the 64bit data found in
12125 64 ELF files. Detect this now and abort before we start
12126 overwriting things. */
12127 if (sizeof (bfd_vma) < 8)
12128 {
12129 error (_("This instance of readelf has been built without support for a\n\
12130 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12131 return 0;
12132 }
12133
12134 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12135 return 0;
12136
12137 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12138 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12139 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12140 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12141 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12142 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12143 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12144 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12145 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12146 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12147 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12148 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12149 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12150 }
12151
12152 if (elf_header.e_shoff)
12153 {
12154 /* There may be some extensions in the first section header. Don't
12155 bomb if we can't read it. */
12156 if (is_32bit_elf)
12157 get_32bit_section_headers (file, 1);
12158 else
12159 get_64bit_section_headers (file, 1);
12160 }
12161
12162 return 1;
12163 }
12164
12165 /* Process one ELF object file according to the command line options.
12166 This file may actually be stored in an archive. The file is
12167 positioned at the start of the ELF object. */
12168
12169 static int
12170 process_object (char * file_name, FILE * file)
12171 {
12172 unsigned int i;
12173
12174 if (! get_file_header (file))
12175 {
12176 error (_("%s: Failed to read file header\n"), file_name);
12177 return 1;
12178 }
12179
12180 /* Initialise per file variables. */
12181 for (i = ARRAY_SIZE (version_info); i--;)
12182 version_info[i] = 0;
12183
12184 for (i = ARRAY_SIZE (dynamic_info); i--;)
12185 dynamic_info[i] = 0;
12186
12187 /* Process the file. */
12188 if (show_name)
12189 printf (_("\nFile: %s\n"), file_name);
12190
12191 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12192 Note we do this even if cmdline_dump_sects is empty because we
12193 must make sure that the dump_sets array is zeroed out before each
12194 object file is processed. */
12195 if (num_dump_sects > num_cmdline_dump_sects)
12196 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12197
12198 if (num_cmdline_dump_sects > 0)
12199 {
12200 if (num_dump_sects == 0)
12201 /* A sneaky way of allocating the dump_sects array. */
12202 request_dump_bynumber (num_cmdline_dump_sects, 0);
12203
12204 assert (num_dump_sects >= num_cmdline_dump_sects);
12205 memcpy (dump_sects, cmdline_dump_sects,
12206 num_cmdline_dump_sects * sizeof (* dump_sects));
12207 }
12208
12209 if (! process_file_header ())
12210 return 1;
12211
12212 if (! process_section_headers (file))
12213 {
12214 /* Without loaded section headers we cannot process lots of
12215 things. */
12216 do_unwind = do_version = do_dump = do_arch = 0;
12217
12218 if (! do_using_dynamic)
12219 do_syms = do_dyn_syms = do_reloc = 0;
12220 }
12221
12222 if (! process_section_groups (file))
12223 {
12224 /* Without loaded section groups we cannot process unwind. */
12225 do_unwind = 0;
12226 }
12227
12228 if (process_program_headers (file))
12229 process_dynamic_section (file);
12230
12231 process_relocs (file);
12232
12233 process_unwind (file);
12234
12235 process_symbol_table (file);
12236
12237 process_syminfo (file);
12238
12239 process_version_sections (file);
12240
12241 process_section_contents (file);
12242
12243 process_notes (file);
12244
12245 process_gnu_liblist (file);
12246
12247 process_arch_specific (file);
12248
12249 if (program_headers)
12250 {
12251 free (program_headers);
12252 program_headers = NULL;
12253 }
12254
12255 if (section_headers)
12256 {
12257 free (section_headers);
12258 section_headers = NULL;
12259 }
12260
12261 if (string_table)
12262 {
12263 free (string_table);
12264 string_table = NULL;
12265 string_table_length = 0;
12266 }
12267
12268 if (dynamic_strings)
12269 {
12270 free (dynamic_strings);
12271 dynamic_strings = NULL;
12272 dynamic_strings_length = 0;
12273 }
12274
12275 if (dynamic_symbols)
12276 {
12277 free (dynamic_symbols);
12278 dynamic_symbols = NULL;
12279 num_dynamic_syms = 0;
12280 }
12281
12282 if (dynamic_syminfo)
12283 {
12284 free (dynamic_syminfo);
12285 dynamic_syminfo = NULL;
12286 }
12287
12288 if (section_headers_groups)
12289 {
12290 free (section_headers_groups);
12291 section_headers_groups = NULL;
12292 }
12293
12294 if (section_groups)
12295 {
12296 struct group_list * g;
12297 struct group_list * next;
12298
12299 for (i = 0; i < group_count; i++)
12300 {
12301 for (g = section_groups [i].root; g != NULL; g = next)
12302 {
12303 next = g->next;
12304 free (g);
12305 }
12306 }
12307
12308 free (section_groups);
12309 section_groups = NULL;
12310 }
12311
12312 free_debug_memory ();
12313
12314 return 0;
12315 }
12316
12317 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12318 to the path name of the thin archive itself if necessary. Always returns
12319 a pointer to malloc'ed memory. */
12320
12321 static char *
12322 adjust_relative_path (char * file_name, char * name, int name_len)
12323 {
12324 char * member_file_name;
12325 const char * base_name = lbasename (file_name);
12326
12327 /* This is a proxy entry for a thin archive member.
12328 If the extended name table contains an absolute path
12329 name, or if the archive is in the current directory,
12330 use the path name as given. Otherwise, we need to
12331 find the member relative to the directory where the
12332 archive is located. */
12333 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
12334 {
12335 member_file_name = (char *) malloc (name_len + 1);
12336 if (member_file_name == NULL)
12337 {
12338 error (_("Out of memory\n"));
12339 return NULL;
12340 }
12341 memcpy (member_file_name, name, name_len);
12342 member_file_name[name_len] = '\0';
12343 }
12344 else
12345 {
12346 /* Concatenate the path components of the archive file name
12347 to the relative path name from the extended name table. */
12348 size_t prefix_len = base_name - file_name;
12349 member_file_name = (char *) malloc (prefix_len + name_len + 1);
12350 if (member_file_name == NULL)
12351 {
12352 error (_("Out of memory\n"));
12353 return NULL;
12354 }
12355 memcpy (member_file_name, file_name, prefix_len);
12356 memcpy (member_file_name + prefix_len, name, name_len);
12357 member_file_name[prefix_len + name_len] = '\0';
12358 }
12359 return member_file_name;
12360 }
12361
12362 /* Structure to hold information about an archive file. */
12363
12364 struct archive_info
12365 {
12366 char * file_name; /* Archive file name. */
12367 FILE * file; /* Open file descriptor. */
12368 unsigned long index_num; /* Number of symbols in table. */
12369 unsigned long * index_array; /* The array of member offsets. */
12370 char * sym_table; /* The symbol table. */
12371 unsigned long sym_size; /* Size of the symbol table. */
12372 char * longnames; /* The long file names table. */
12373 unsigned long longnames_size; /* Size of the long file names table. */
12374 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
12375 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
12376 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
12377 struct ar_hdr arhdr; /* Current archive header. */
12378 };
12379
12380 /* Read the symbol table and long-name table from an archive. */
12381
12382 static int
12383 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
12384 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
12385 {
12386 size_t got;
12387 unsigned long size;
12388
12389 arch->file_name = strdup (file_name);
12390 arch->file = file;
12391 arch->index_num = 0;
12392 arch->index_array = NULL;
12393 arch->sym_table = NULL;
12394 arch->sym_size = 0;
12395 arch->longnames = NULL;
12396 arch->longnames_size = 0;
12397 arch->nested_member_origin = 0;
12398 arch->is_thin_archive = is_thin_archive;
12399 arch->next_arhdr_offset = SARMAG;
12400
12401 /* Read the first archive member header. */
12402 if (fseek (file, SARMAG, SEEK_SET) != 0)
12403 {
12404 error (_("%s: failed to seek to first archive header\n"), file_name);
12405 return 1;
12406 }
12407 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
12408 if (got != sizeof arch->arhdr)
12409 {
12410 if (got == 0)
12411 return 0;
12412
12413 error (_("%s: failed to read archive header\n"), file_name);
12414 return 1;
12415 }
12416
12417 /* See if this is the archive symbol table. */
12418 if (const_strneq (arch->arhdr.ar_name, "/ ")
12419 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
12420 {
12421 size = strtoul (arch->arhdr.ar_size, NULL, 10);
12422 size = size + (size & 1);
12423
12424 arch->next_arhdr_offset += sizeof arch->arhdr + size;
12425
12426 if (read_symbols)
12427 {
12428 unsigned long i;
12429 /* A buffer used to hold numbers read in from an archive index.
12430 These are always 4 bytes long and stored in big-endian format. */
12431 #define SIZEOF_AR_INDEX_NUMBERS 4
12432 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
12433 unsigned char * index_buffer;
12434
12435 /* Check the size of the archive index. */
12436 if (size < SIZEOF_AR_INDEX_NUMBERS)
12437 {
12438 error (_("%s: the archive index is empty\n"), file_name);
12439 return 1;
12440 }
12441
12442 /* Read the numer of entries in the archive index. */
12443 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
12444 if (got != sizeof (integer_buffer))
12445 {
12446 error (_("%s: failed to read archive index\n"), file_name);
12447 return 1;
12448 }
12449 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
12450 size -= SIZEOF_AR_INDEX_NUMBERS;
12451
12452 /* Read in the archive index. */
12453 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
12454 {
12455 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12456 file_name, arch->index_num);
12457 return 1;
12458 }
12459 index_buffer = (unsigned char *)
12460 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
12461 if (index_buffer == NULL)
12462 {
12463 error (_("Out of memory whilst trying to read archive symbol index\n"));
12464 return 1;
12465 }
12466 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
12467 if (got != arch->index_num)
12468 {
12469 free (index_buffer);
12470 error (_("%s: failed to read archive index\n"), file_name);
12471 return 1;
12472 }
12473 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
12474
12475 /* Convert the index numbers into the host's numeric format. */
12476 arch->index_array = (long unsigned int *)
12477 malloc (arch->index_num * sizeof (* arch->index_array));
12478 if (arch->index_array == NULL)
12479 {
12480 free (index_buffer);
12481 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12482 return 1;
12483 }
12484
12485 for (i = 0; i < arch->index_num; i++)
12486 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
12487 SIZEOF_AR_INDEX_NUMBERS);
12488 free (index_buffer);
12489
12490 /* The remaining space in the header is taken up by the symbol table. */
12491 if (size < 1)
12492 {
12493 error (_("%s: the archive has an index but no symbols\n"), file_name);
12494 return 1;
12495 }
12496 arch->sym_table = (char *) malloc (size);
12497 arch->sym_size = size;
12498 if (arch->sym_table == NULL)
12499 {
12500 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12501 return 1;
12502 }
12503 got = fread (arch->sym_table, 1, size, file);
12504 if (got != size)
12505 {
12506 error (_("%s: failed to read archive index symbol table\n"), file_name);
12507 return 1;
12508 }
12509 }
12510 else
12511 {
12512 if (fseek (file, size, SEEK_CUR) != 0)
12513 {
12514 error (_("%s: failed to skip archive symbol table\n"), file_name);
12515 return 1;
12516 }
12517 }
12518
12519 /* Read the next archive header. */
12520 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
12521 if (got != sizeof arch->arhdr)
12522 {
12523 if (got == 0)
12524 return 0;
12525 error (_("%s: failed to read archive header following archive index\n"), file_name);
12526 return 1;
12527 }
12528 }
12529 else if (read_symbols)
12530 printf (_("%s has no archive index\n"), file_name);
12531
12532 if (const_strneq (arch->arhdr.ar_name, "// "))
12533 {
12534 /* This is the archive string table holding long member names. */
12535 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
12536 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
12537
12538 arch->longnames = (char *) malloc (arch->longnames_size);
12539 if (arch->longnames == NULL)
12540 {
12541 error (_("Out of memory reading long symbol names in archive\n"));
12542 return 1;
12543 }
12544
12545 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
12546 {
12547 free (arch->longnames);
12548 arch->longnames = NULL;
12549 error (_("%s: failed to read long symbol name string table\n"), file_name);
12550 return 1;
12551 }
12552
12553 if ((arch->longnames_size & 1) != 0)
12554 getc (file);
12555 }
12556
12557 return 0;
12558 }
12559
12560 /* Release the memory used for the archive information. */
12561
12562 static void
12563 release_archive (struct archive_info * arch)
12564 {
12565 if (arch->file_name != NULL)
12566 free (arch->file_name);
12567 if (arch->index_array != NULL)
12568 free (arch->index_array);
12569 if (arch->sym_table != NULL)
12570 free (arch->sym_table);
12571 if (arch->longnames != NULL)
12572 free (arch->longnames);
12573 }
12574
12575 /* Open and setup a nested archive, if not already open. */
12576
12577 static int
12578 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
12579 {
12580 FILE * member_file;
12581
12582 /* Have we already setup this archive? */
12583 if (nested_arch->file_name != NULL
12584 && streq (nested_arch->file_name, member_file_name))
12585 return 0;
12586
12587 /* Close previous file and discard cached information. */
12588 if (nested_arch->file != NULL)
12589 fclose (nested_arch->file);
12590 release_archive (nested_arch);
12591
12592 member_file = fopen (member_file_name, "rb");
12593 if (member_file == NULL)
12594 return 1;
12595 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
12596 }
12597
12598 static char *
12599 get_archive_member_name_at (struct archive_info * arch,
12600 unsigned long offset,
12601 struct archive_info * nested_arch);
12602
12603 /* Get the name of an archive member from the current archive header.
12604 For simple names, this will modify the ar_name field of the current
12605 archive header. For long names, it will return a pointer to the
12606 longnames table. For nested archives, it will open the nested archive
12607 and get the name recursively. NESTED_ARCH is a single-entry cache so
12608 we don't keep rereading the same information from a nested archive. */
12609
12610 static char *
12611 get_archive_member_name (struct archive_info * arch,
12612 struct archive_info * nested_arch)
12613 {
12614 unsigned long j, k;
12615
12616 if (arch->arhdr.ar_name[0] == '/')
12617 {
12618 /* We have a long name. */
12619 char * endp;
12620 char * member_file_name;
12621 char * member_name;
12622
12623 arch->nested_member_origin = 0;
12624 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
12625 if (arch->is_thin_archive && endp != NULL && * endp == ':')
12626 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
12627
12628 while ((j < arch->longnames_size)
12629 && (arch->longnames[j] != '\n')
12630 && (arch->longnames[j] != '\0'))
12631 j++;
12632 if (arch->longnames[j-1] == '/')
12633 j--;
12634 arch->longnames[j] = '\0';
12635
12636 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
12637 return arch->longnames + k;
12638
12639 /* This is a proxy for a member of a nested archive.
12640 Find the name of the member in that archive. */
12641 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
12642 if (member_file_name != NULL
12643 && setup_nested_archive (nested_arch, member_file_name) == 0
12644 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
12645 {
12646 free (member_file_name);
12647 return member_name;
12648 }
12649 free (member_file_name);
12650
12651 /* Last resort: just return the name of the nested archive. */
12652 return arch->longnames + k;
12653 }
12654
12655 /* We have a normal (short) name. */
12656 j = 0;
12657 while ((arch->arhdr.ar_name[j] != '/')
12658 && (j < sizeof (arch->arhdr.ar_name) - 1))
12659 j++;
12660 arch->arhdr.ar_name[j] = '\0';
12661 return arch->arhdr.ar_name;
12662 }
12663
12664 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12665
12666 static char *
12667 get_archive_member_name_at (struct archive_info * arch,
12668 unsigned long offset,
12669 struct archive_info * nested_arch)
12670 {
12671 size_t got;
12672
12673 if (fseek (arch->file, offset, SEEK_SET) != 0)
12674 {
12675 error (_("%s: failed to seek to next file name\n"), arch->file_name);
12676 return NULL;
12677 }
12678 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
12679 if (got != sizeof arch->arhdr)
12680 {
12681 error (_("%s: failed to read archive header\n"), arch->file_name);
12682 return NULL;
12683 }
12684 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
12685 {
12686 error (_("%s: did not find a valid archive header\n"), arch->file_name);
12687 return NULL;
12688 }
12689
12690 return get_archive_member_name (arch, nested_arch);
12691 }
12692
12693 /* Construct a string showing the name of the archive member, qualified
12694 with the name of the containing archive file. For thin archives, we
12695 use square brackets to denote the indirection. For nested archives,
12696 we show the qualified name of the external member inside the square
12697 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12698
12699 static char *
12700 make_qualified_name (struct archive_info * arch,
12701 struct archive_info * nested_arch,
12702 char * member_name)
12703 {
12704 size_t len;
12705 char * name;
12706
12707 len = strlen (arch->file_name) + strlen (member_name) + 3;
12708 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12709 len += strlen (nested_arch->file_name) + 2;
12710
12711 name = (char *) malloc (len);
12712 if (name == NULL)
12713 {
12714 error (_("Out of memory\n"));
12715 return NULL;
12716 }
12717
12718 if (arch->is_thin_archive && arch->nested_member_origin != 0)
12719 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
12720 else if (arch->is_thin_archive)
12721 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
12722 else
12723 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
12724
12725 return name;
12726 }
12727
12728 /* Process an ELF archive.
12729 On entry the file is positioned just after the ARMAG string. */
12730
12731 static int
12732 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12733 {
12734 struct archive_info arch;
12735 struct archive_info nested_arch;
12736 size_t got;
12737 int ret;
12738
12739 show_name = 1;
12740
12741 /* The ARCH structure is used to hold information about this archive. */
12742 arch.file_name = NULL;
12743 arch.file = NULL;
12744 arch.index_array = NULL;
12745 arch.sym_table = NULL;
12746 arch.longnames = NULL;
12747
12748 /* The NESTED_ARCH structure is used as a single-item cache of information
12749 about a nested archive (when members of a thin archive reside within
12750 another regular archive file). */
12751 nested_arch.file_name = NULL;
12752 nested_arch.file = NULL;
12753 nested_arch.index_array = NULL;
12754 nested_arch.sym_table = NULL;
12755 nested_arch.longnames = NULL;
12756
12757 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12758 {
12759 ret = 1;
12760 goto out;
12761 }
12762
12763 if (do_archive_index)
12764 {
12765 if (arch.sym_table == NULL)
12766 error (_("%s: unable to dump the index as none was found\n"), file_name);
12767 else
12768 {
12769 unsigned int i, l;
12770 unsigned long current_pos;
12771
12772 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12773 file_name, arch.index_num, arch.sym_size);
12774 current_pos = ftell (file);
12775
12776 for (i = l = 0; i < arch.index_num; i++)
12777 {
12778 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12779 {
12780 char * member_name;
12781
12782 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12783
12784 if (member_name != NULL)
12785 {
12786 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12787
12788 if (qualified_name != NULL)
12789 {
12790 printf (_("Binary %s contains:\n"), qualified_name);
12791 free (qualified_name);
12792 }
12793 }
12794 }
12795
12796 if (l >= arch.sym_size)
12797 {
12798 error (_("%s: end of the symbol table reached before the end of the index\n"),
12799 file_name);
12800 break;
12801 }
12802 printf ("\t%s\n", arch.sym_table + l);
12803 l += strlen (arch.sym_table + l) + 1;
12804 }
12805
12806 if (l & 01)
12807 ++l;
12808 if (l < arch.sym_size)
12809 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12810 file_name);
12811
12812 if (fseek (file, current_pos, SEEK_SET) != 0)
12813 {
12814 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12815 ret = 1;
12816 goto out;
12817 }
12818 }
12819
12820 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12821 && !do_segments && !do_header && !do_dump && !do_version
12822 && !do_histogram && !do_debugging && !do_arch && !do_notes
12823 && !do_section_groups && !do_dyn_syms)
12824 {
12825 ret = 0; /* Archive index only. */
12826 goto out;
12827 }
12828 }
12829
12830 ret = 0;
12831
12832 while (1)
12833 {
12834 char * name;
12835 size_t namelen;
12836 char * qualified_name;
12837
12838 /* Read the next archive header. */
12839 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12840 {
12841 error (_("%s: failed to seek to next archive header\n"), file_name);
12842 return 1;
12843 }
12844 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12845 if (got != sizeof arch.arhdr)
12846 {
12847 if (got == 0)
12848 break;
12849 error (_("%s: failed to read archive header\n"), file_name);
12850 ret = 1;
12851 break;
12852 }
12853 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12854 {
12855 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12856 ret = 1;
12857 break;
12858 }
12859
12860 arch.next_arhdr_offset += sizeof arch.arhdr;
12861
12862 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12863 if (archive_file_size & 01)
12864 ++archive_file_size;
12865
12866 name = get_archive_member_name (&arch, &nested_arch);
12867 if (name == NULL)
12868 {
12869 error (_("%s: bad archive file name\n"), file_name);
12870 ret = 1;
12871 break;
12872 }
12873 namelen = strlen (name);
12874
12875 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12876 if (qualified_name == NULL)
12877 {
12878 error (_("%s: bad archive file name\n"), file_name);
12879 ret = 1;
12880 break;
12881 }
12882
12883 if (is_thin_archive && arch.nested_member_origin == 0)
12884 {
12885 /* This is a proxy for an external member of a thin archive. */
12886 FILE * member_file;
12887 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12888 if (member_file_name == NULL)
12889 {
12890 ret = 1;
12891 break;
12892 }
12893
12894 member_file = fopen (member_file_name, "rb");
12895 if (member_file == NULL)
12896 {
12897 error (_("Input file '%s' is not readable.\n"), member_file_name);
12898 free (member_file_name);
12899 ret = 1;
12900 break;
12901 }
12902
12903 archive_file_offset = arch.nested_member_origin;
12904
12905 ret |= process_object (qualified_name, member_file);
12906
12907 fclose (member_file);
12908 free (member_file_name);
12909 }
12910 else if (is_thin_archive)
12911 {
12912 /* This is a proxy for a member of a nested archive. */
12913 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12914
12915 /* The nested archive file will have been opened and setup by
12916 get_archive_member_name. */
12917 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12918 {
12919 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12920 ret = 1;
12921 break;
12922 }
12923
12924 ret |= process_object (qualified_name, nested_arch.file);
12925 }
12926 else
12927 {
12928 archive_file_offset = arch.next_arhdr_offset;
12929 arch.next_arhdr_offset += archive_file_size;
12930
12931 ret |= process_object (qualified_name, file);
12932 }
12933
12934 free (qualified_name);
12935 }
12936
12937 out:
12938 if (nested_arch.file != NULL)
12939 fclose (nested_arch.file);
12940 release_archive (&nested_arch);
12941 release_archive (&arch);
12942
12943 return ret;
12944 }
12945
12946 static int
12947 process_file (char * file_name)
12948 {
12949 FILE * file;
12950 struct stat statbuf;
12951 char armag[SARMAG];
12952 int ret;
12953
12954 if (stat (file_name, &statbuf) < 0)
12955 {
12956 if (errno == ENOENT)
12957 error (_("'%s': No such file\n"), file_name);
12958 else
12959 error (_("Could not locate '%s'. System error message: %s\n"),
12960 file_name, strerror (errno));
12961 return 1;
12962 }
12963
12964 if (! S_ISREG (statbuf.st_mode))
12965 {
12966 error (_("'%s' is not an ordinary file\n"), file_name);
12967 return 1;
12968 }
12969
12970 file = fopen (file_name, "rb");
12971 if (file == NULL)
12972 {
12973 error (_("Input file '%s' is not readable.\n"), file_name);
12974 return 1;
12975 }
12976
12977 if (fread (armag, SARMAG, 1, file) != 1)
12978 {
12979 error (_("%s: Failed to read file's magic number\n"), file_name);
12980 fclose (file);
12981 return 1;
12982 }
12983
12984 if (memcmp (armag, ARMAG, SARMAG) == 0)
12985 ret = process_archive (file_name, file, FALSE);
12986 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12987 ret = process_archive (file_name, file, TRUE);
12988 else
12989 {
12990 if (do_archive_index)
12991 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12992 file_name);
12993
12994 rewind (file);
12995 archive_file_size = archive_file_offset = 0;
12996 ret = process_object (file_name, file);
12997 }
12998
12999 fclose (file);
13000
13001 return ret;
13002 }
13003
13004 #ifdef SUPPORT_DISASSEMBLY
13005 /* Needed by the i386 disassembler. For extra credit, someone could
13006 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13007 symbols. */
13008
13009 void
13010 print_address (unsigned int addr, FILE * outfile)
13011 {
13012 fprintf (outfile,"0x%8.8x", addr);
13013 }
13014
13015 /* Needed by the i386 disassembler. */
13016 void
13017 db_task_printsym (unsigned int addr)
13018 {
13019 print_address (addr, stderr);
13020 }
13021 #endif
13022
13023 int
13024 main (int argc, char ** argv)
13025 {
13026 int err;
13027
13028 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13029 setlocale (LC_MESSAGES, "");
13030 #endif
13031 #if defined (HAVE_SETLOCALE)
13032 setlocale (LC_CTYPE, "");
13033 #endif
13034 bindtextdomain (PACKAGE, LOCALEDIR);
13035 textdomain (PACKAGE);
13036
13037 expandargv (&argc, &argv);
13038
13039 parse_args (argc, argv);
13040
13041 if (num_dump_sects > 0)
13042 {
13043 /* Make a copy of the dump_sects array. */
13044 cmdline_dump_sects = (dump_type *)
13045 malloc (num_dump_sects * sizeof (* dump_sects));
13046 if (cmdline_dump_sects == NULL)
13047 error (_("Out of memory allocating dump request table.\n"));
13048 else
13049 {
13050 memcpy (cmdline_dump_sects, dump_sects,
13051 num_dump_sects * sizeof (* dump_sects));
13052 num_cmdline_dump_sects = num_dump_sects;
13053 }
13054 }
13055
13056 if (optind < (argc - 1))
13057 show_name = 1;
13058
13059 err = 0;
13060 while (optind < argc)
13061 err |= process_file (argv[optind++]);
13062
13063 if (dump_sects != NULL)
13064 free (dump_sects);
13065 if (cmdline_dump_sects != NULL)
13066 free (cmdline_dump_sects);
13067
13068 return err;
13069 }
git-cvsimport of binutils cvsroot