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