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