projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
(dump_relocations): EM_ARM uses rela relocs.
[binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 02111-1307, USA. */
23 \f
24
25 #include <assert.h>
26 #include <sys/stat.h>
27 #include <stdio.h>
28 #include <time.h>
29
30 #include "bfd.h"
31
32 #include "elf/common.h"
33 #include "elf/external.h"
34 #include "elf/internal.h"
35
36 /* The following headers use the elf/reloc-macros.h file to
37 automatically generate relocation recognition functions
38 such as elf_mips_reloc_type() */
39
40 #define RELOC_MACROS_GEN_FUNC
41
42 #include "elf/i386.h"
43 #include "elf/v850.h"
44 #include "elf/ppc.h"
45 #include "elf/mips.h"
46 #include "elf/alpha.h"
47 #include "elf/arm.h"
48 #include "elf/m68k.h"
49 #include "elf/sparc.h"
50 #include "elf/m32r.h"
51 #include "elf/d10v.h"
52 #include "elf/d30v.h"
53 #include "elf/sh.h"
54 #include "elf/mn10200.h"
55 #include "elf/mn10300.h"
56 #include "elf/hppa.h"
57 #include "elf/arc.h"
58
59 #include "bucomm.h"
60 #include "getopt.h"
61
62 #ifdef ANSI_PROTOTYPES
63 #include <stdarg.h>
64 #else
65 #include <varargs.h>
66 #endif
67
68 char * program_name = "readelf";
69 unsigned int dynamic_addr;
70 unsigned int dynamic_size;
71 unsigned int rela_addr;
72 unsigned int rela_size;
73 char * dynamic_strings;
74 char * string_table;
75 Elf_Internal_Sym * dynamic_symbols;
76 char program_interpreter [64];
77 int dynamic_info[DT_JMPREL + 1];
78 int version_info[16];
79 int loadaddr = 0;
80 Elf_Internal_Ehdr elf_header;
81 Elf_Internal_Shdr * section_headers;
82 Elf_Internal_Dyn * dynamic_segment;
83 int show_name;
84 int do_dynamic;
85 int do_syms;
86 int do_reloc;
87 int do_sections;
88 int do_segments;
89 int do_using_dynamic;
90 int do_header;
91 int do_dump;
92 int do_version;
93
94 static unsigned long int (* byte_get) PARAMS ((unsigned char *, int));
95
96 #define NUM_DUMP_SECTS 100
97 char dump_sects [NUM_DUMP_SECTS];
98
99 #define HEX_DUMP 1
100 #define DISASS_DUMP 2
101
102 /* Forward declarations for dumb compilers. */
103 static const char * get_mips_dynamic_type PARAMS ((unsigned long type));
104 static const char * get_dynamic_type PARAMS ((unsigned long type));
105 static int dump_relocations
106 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, char *));
107 static char * get_file_type PARAMS ((unsigned e_type));
108 static char * get_machine_name PARAMS ((unsigned e_machine));
109 static char * get_machine_data PARAMS ((unsigned e_data));
110 static char * get_machine_flags PARAMS ((unsigned, unsigned e_machine));
111 static const char * get_mips_segment_type PARAMS ((unsigned long type));
112 static const char * get_segment_type PARAMS ((unsigned long p_type));
113 static const char * get_mips_section_type_name PARAMS ((unsigned int sh_type));
114 static const char * get_section_type_name PARAMS ((unsigned int sh_type));
115 static char * get_symbol_binding PARAMS ((unsigned int binding));
116 static char * get_symbol_type PARAMS ((unsigned int type));
117 static void usage PARAMS ((void));
118 static void parse_args PARAMS ((int argc, char ** argv));
119 static int process_file_header PARAMS ((void));
120 static int process_program_headers PARAMS ((FILE *));
121 static int process_section_headers PARAMS ((FILE *));
122 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *entry));
123 static int process_dynamic_segment PARAMS ((FILE *));
124 static int process_symbol_table PARAMS ((FILE *));
125 static int process_section_contents PARAMS ((FILE *));
126 static void process_file PARAMS ((char * file_name));
127 static int process_relocs PARAMS ((FILE *));
128 static int process_version_sections PARAMS ((FILE *));
129 static char * get_ver_flags PARAMS ((unsigned int flags));
130 static char * get_symbol_index_type PARAMS ((unsigned int type));
131 static int get_section_headers PARAMS ((FILE * file));
132 static int get_file_header PARAMS ((FILE * file));
133 static Elf_Internal_Sym * get_elf_symbols
134 PARAMS ((FILE * file, unsigned long offset, unsigned long number));
135 static int * get_dynamic_data PARAMS ((FILE * file, unsigned int number));
136
137 typedef int Elf32_Word;
138
139 #define SECTION_NAME(X) (string_table + (X)->sh_name)
140
141 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
142
143 #define BYTE_GET(field) byte_get (field, sizeof (field))
144
145 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
146
147 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
148 if (fseek (file, offset, SEEK_SET)) \
149 { \
150 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
151 return 0; \
152 } \
153 \
154 var = (type) malloc (size); \
155 \
156 if (var == NULL) \
157 { \
158 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
159 return 0; \
160 } \
161 \
162 if (fread (var, size, 1, file) != 1) \
163 { \
164 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
165 free (var); \
166 var = NULL; \
167 return 0; \
168 }
169
170
171 #define GET_DATA(offset, var, reason) \
172 if (fseek (file, offset, SEEK_SET)) \
173 { \
174 error (_("Unable to seek to %x for %s\n"), offset, reason); \
175 return 0; \
176 } \
177 else if (fread (& var, sizeof (var), 1, file) != 1) \
178 { \
179 error (_("Unable to read data at %x for %s\n"), offset, reason); \
180 return 0; \
181 }
182
183 #ifdef ANSI_PROTOTYPES
184 static void
185 error (const char * message, ...)
186 {
187 va_list args;
188
189 fprintf (stderr, _("%s: Error: "), program_name);
190 va_start (args, message);
191 vfprintf (stderr, message, args);
192 va_end (args);
193 return;
194 }
195
196 static void
197 warn (const char * message, ...)
198 {
199 va_list args;
200
201 fprintf (stderr, _("%s: Warning: "), program_name);
202 va_start (args, message);
203 vfprintf (stderr, message, args);
204 va_end (args);
205 return;
206 }
207 #else
208 static void
209 error (va_alist)
210 va_dcl
211 {
212 char * message;
213 va_list args;
214
215 fprintf (stderr, _("%s: Error: "), program_name);
216 va_start (args);
217 message = va_arg (args, char *);
218 vfprintf (stderr, message, args);
219 va_end (args);
220 return;
221 }
222
223 static void
224 warn (va_alist)
225 va_dcl
226 {
227 char * message;
228 va_list args;
229
230 fprintf (stderr, _("%s: Warning: "), program_name);
231 va_start (args);
232 message = va_arg (args, char *);
233 vfprintf (stderr, message, args);
234 va_end (args);
235 return;
236 }
237 #endif
238
239 static unsigned long int
240 byte_get_little_endian (field, size)
241 unsigned char * field;
242 int size;
243 {
244 switch (size)
245 {
246 case 1:
247 return * field;
248
249 case 2:
250 return ((unsigned int) (field [0]))
251 | (((unsigned int) (field [1])) << 8);
252
253 case 4:
254 return ((unsigned long) (field [0]))
255 | (((unsigned long) (field [1])) << 8)
256 | (((unsigned long) (field [2])) << 16)
257 | (((unsigned long) (field [3])) << 24);
258
259 default:
260 error (_("Unhandled data length: %d\n"), size);
261 abort();
262 }
263 }
264
265 static unsigned long int
266 byte_get_big_endian (field, size)
267 unsigned char * field;
268 int size;
269 {
270 switch (size)
271 {
272 case 1:
273 return * field;
274
275 case 2:
276 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
277
278 case 4:
279 return ((unsigned long) (field [3]))
280 | (((unsigned long) (field [2])) << 8)
281 | (((unsigned long) (field [1])) << 16)
282 | (((unsigned long) (field [0])) << 24);
283
284 default:
285 error (_("Unhandled data length: %d\n"), size);
286 abort();
287 }
288 }
289
290
291 /* Display the contents of the relocation data
292 found at the specified offset. */
293 static int
294 dump_relocations (file, rel_offset, rel_size, symtab, strtab)
295 FILE * file;
296 unsigned long rel_offset;
297 unsigned long rel_size;
298 Elf_Internal_Sym * symtab;
299 char * strtab;
300 {
301 unsigned int i;
302 int is_rela;
303 Elf_Internal_Rel * rels;
304 Elf_Internal_Rela * relas;
305
306
307 /* Compute number of relocations and read them in. */
308 switch (elf_header.e_machine)
309 {
310 case EM_386:
311 case EM_486:
312 case EM_CYGNUS_M32R:
313 case EM_CYGNUS_D10V:
314 case EM_MIPS:
315 case EM_MIPS_RS4_BE:
316 {
317 Elf32_External_Rel * erels;
318
319 GET_DATA_ALLOC (rel_offset, rel_size, erels,
320 Elf32_External_Rel *, "relocs");
321
322 rel_size = rel_size / sizeof (Elf32_External_Rel);
323
324 rels = (Elf_Internal_Rel *) malloc (rel_size *
325 sizeof (Elf_Internal_Rel));
326
327 for (i = 0; i < rel_size; i++)
328 {
329 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
330 rels[i].r_info = BYTE_GET (erels[i].r_info);
331 }
332
333 free (erels);
334
335 is_rela = 0;
336 relas = (Elf_Internal_Rela *) rels;
337 }
338 break;
339
340 case EM_ARM:
341 case EM_68K:
342 case EM_SPARC:
343 case EM_PPC:
344 case EM_CYGNUS_V850:
345 case EM_CYGNUS_D30V:
346 case EM_CYGNUS_MN10200:
347 case EM_CYGNUS_MN10300:
348 case EM_SH:
349 case EM_ALPHA:
350 {
351 Elf32_External_Rela * erelas;
352
353 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
354 Elf32_External_Rela *, "relocs");
355
356 rel_size = rel_size / sizeof (Elf32_External_Rela);
357
358 relas = (Elf_Internal_Rela *) malloc (rel_size *
359 sizeof (Elf_Internal_Rela));
360
361 for (i = 0; i < rel_size; i++)
362 {
363 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
364 relas[i].r_info = BYTE_GET (erelas[i].r_info);
365 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
366 }
367
368 free (erelas);
369
370 is_rela = 1;
371 rels = (Elf_Internal_Rel *) relas;
372 }
373 break;
374
375 default:
376 warn (_("Don't know about relocations on this machine architecture\n"));
377 return 0;
378 }
379
380 if (is_rela)
381 printf
382 (_(" Offset Value Type Symbol's Value Symbol's Name Addend\n"));
383 else
384 printf
385 (_(" Offset Value Type Symbol's Value Symbol's Name\n"));
386
387 for (i = 0; i < rel_size; i++)
388 {
389 const char * rtype;
390 unsigned long offset;
391 unsigned long info;
392 int symtab_index;
393
394 if (is_rela)
395 {
396 offset = relas [i].r_offset;
397 info = relas [i].r_info;
398 }
399 else
400 {
401 offset = rels [i].r_offset;
402 info = rels [i].r_info;
403 }
404
405 printf (" %8.8lx %5.5lx ", offset, info);
406
407 switch (elf_header.e_machine)
408 {
409 default:
410 rtype = NULL;
411 break;
412
413 case EM_CYGNUS_M32R:
414 rtype = elf_m32r_reloc_type (ELF32_R_TYPE (info));
415 break;
416
417 case EM_386:
418 case EM_486:
419 rtype = elf_i386_reloc_type (ELF32_R_TYPE (info));
420 break;
421
422 case EM_68K:
423 rtype = elf_m68k_reloc_type (ELF32_R_TYPE (info));
424 break;
425
426 case EM_SPARC:
427 rtype = elf_sparc_reloc_type (ELF32_R_TYPE (info));
428 break;
429
430 case EM_CYGNUS_V850:
431 rtype = v850_reloc_type (ELF32_R_TYPE (info));
432 break;
433
434 case EM_CYGNUS_D10V:
435 rtype = elf_d10v_reloc_type (ELF32_R_TYPE (info));
436 break;
437
438 case EM_CYGNUS_D30V:
439 rtype = elf_d30v_reloc_type (ELF32_R_TYPE (info));
440 break;
441
442 case EM_SH:
443 rtype = elf_sh_reloc_type (ELF32_R_TYPE (info));
444 break;
445
446 case EM_CYGNUS_MN10300:
447 rtype = elf_mn10300_reloc_type (ELF32_R_TYPE (info));
448 break;
449
450 case EM_CYGNUS_MN10200:
451 rtype = elf_mn10200_reloc_type (ELF32_R_TYPE (info));
452 break;
453
454 case EM_PPC:
455 rtype = elf_ppc_reloc_type (ELF32_R_TYPE (info));
456 break;
457
458 case EM_MIPS:
459 case EM_MIPS_RS4_BE:
460 rtype = elf_mips_reloc_type (ELF32_R_TYPE (info));
461 break;
462
463 case EM_ALPHA:
464 rtype = elf_alpha_reloc_type (ELF32_R_TYPE (info));
465 break;
466
467 case EM_ARM:
468 rtype = elf_arm_reloc_type (ELF32_R_TYPE (info));
469 break;
470
471 case EM_CYGNUS_ARC:
472 rtype = elf_arc_reloc_type (ELF32_R_TYPE (info));
473 break;
474
475 case EM_PARISC:
476 rtype = elf32_hppa_reloc_type (ELF32_R_TYPE (info));
477 break;
478 }
479
480 if (rtype == NULL)
481 printf (_("unrecognised: %-7x"), ELF32_R_TYPE (info));
482 else
483 printf ("%-21.21s", rtype);
484
485 symtab_index = ELF32_R_SYM (info);
486
487 if (symtab_index && symtab != NULL)
488 {
489 Elf_Internal_Sym * psym;
490
491 psym = symtab + symtab_index;
492
493 printf (" %08lx ", (unsigned long) psym->st_value);
494
495 if (psym->st_name == 0)
496 printf ("%-25.25s",
497 SECTION_NAME (section_headers + psym->st_shndx));
498 else if (strtab == NULL)
499 printf (_("<string table index %3d>"), psym->st_name);
500 else
501 printf ("%-25.25s", strtab + psym->st_name);
502
503 if (is_rela)
504 printf (" + %lx", (unsigned long) relas [i].r_addend);
505 }
506
507 putchar ('\n');
508 }
509
510 free (relas);
511
512 return 1;
513 }
514
515 static const char *
516 get_mips_dynamic_type (type)
517 unsigned long type;
518 {
519 switch (type)
520 {
521 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
522 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
523 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
524 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
525 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
526 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
527 case DT_MIPS_MSYM: return "MIPS_MSYM";
528 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
529 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
530 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
531 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
532 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
533 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
534 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
535 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
536 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
537 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
538 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
539 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
540 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
541 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
542 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
543 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
544 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
545 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
546 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
547 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
548 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
549 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
550 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
551 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
552 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
553 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
554 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
555 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
556 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
557 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
558 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
559 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
560 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
561 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
562 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
563 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
564 default:
565 return NULL;
566 }
567 }
568
569 static const char *
570 get_dynamic_type (type)
571 unsigned long type;
572 {
573 static char buff [32];
574
575 switch (type)
576 {
577 case DT_NULL: return "NULL";
578 case DT_NEEDED: return "NEEDED";
579 case DT_PLTRELSZ: return "PLTRELSZ";
580 case DT_PLTGOT: return "PLTGOT";
581 case DT_HASH: return "HASH";
582 case DT_STRTAB: return "STRTAB";
583 case DT_SYMTAB: return "SYMTAB";
584 case DT_RELA: return "RELA";
585 case DT_RELASZ: return "RELASZ";
586 case DT_RELAENT: return "RELAENT";
587 case DT_STRSZ: return "STRSZ";
588 case DT_SYMENT: return "SYMENT";
589 case DT_INIT: return "INIT";
590 case DT_FINI: return "FINI";
591 case DT_SONAME: return "SONAME";
592 case DT_RPATH: return "RPATH";
593 case DT_SYMBOLIC: return "SYMBOLIC";
594 case DT_REL: return "REL";
595 case DT_RELSZ: return "RELSZ";
596 case DT_RELENT: return "RELENT";
597 case DT_PLTREL: return "PLTREL";
598 case DT_DEBUG: return "DEBUG";
599 case DT_TEXTREL: return "TEXTREL";
600 case DT_JMPREL: return "JMPREL";
601 case DT_VERDEF: return "VERDEF";
602 case DT_VERDEFNUM: return "VERDEFNUM";
603 case DT_VERNEED: return "VERNEED";
604 case DT_VERNEEDNUM: return "VERNEEDNUM";
605 case DT_VERSYM: return "VERSYN";
606 case DT_AUXILIARY: return "AUXILARY";
607 case DT_FILTER: return "FILTER";
608 case DT_POSFLAG_1: return "POSFLAG_1";
609 case DT_SYMINSZ: return "SYMINSZ";
610 case DT_SYMINENT: return "SYMINENT";
611 case DT_SYMINFO: return "SYMINFO";
612 case DT_RELACOUNT: return "RELACOUNT";
613 case DT_RELCOUNT: return "RELCOUNT";
614 case DT_FLAGS_1: return "FLAGS_1";
615 case DT_USED: return "USED";
616
617 default:
618 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
619 {
620 const char *result = NULL;
621 switch (elf_header.e_machine)
622 {
623 case EM_MIPS:
624 case EM_MIPS_RS4_BE:
625 result = get_mips_dynamic_type (type);
626 }
627
628 if (result == NULL)
629 {
630 sprintf (buff, _("Processor Specific"), type);
631 result = buff;
632 }
633 return result;
634 }
635 else
636 sprintf (buff, _("<unknown>: %x"), type);
637 return buff;
638 }
639 }
640
641 static char *
642 get_file_type (e_type)
643 unsigned e_type;
644 {
645 static char buff [32];
646
647 switch (e_type)
648 {
649 case ET_NONE: return _("NONE (None)");
650 case ET_REL: return _("REL (Relocatable file)");
651 case ET_EXEC: return _("EXEC (Executable file)");
652 case ET_DYN: return _("DYN (Shared object file)");
653 case ET_CORE: return _("CORE (Core file)");
654
655 default:
656 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
657 sprintf (buff, _("Processor Specific: (%x)"), e_type);
658 else
659 sprintf (buff, _("<unknown>: %x"), e_type);
660 return buff;
661 }
662 }
663
664 static char *
665 get_machine_name (e_machine)
666 unsigned e_machine;
667 {
668 static char buff [32];
669
670 switch (e_machine)
671 {
672 case EM_NONE: return _("None");
673 case EM_M32: return "WE32100";
674 case EM_SPARC: return "Sparc";
675 case EM_386: return "Intel 80386";
676 case EM_68K: return "MC68000";
677 case EM_88K: return "MC88000";
678 case EM_486: return "Intel 80486";
679 case EM_860: return "Intel 80860";
680 case EM_MIPS: return "MIPS R3000 big-endian";
681 case EM_S370: return "Amdahl";
682 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
683 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
684 case EM_PARISC: return "HPPA";
685 case EM_PPC_OLD: return "Power PC (old)";
686 case EM_SPARC32PLUS: return "Sparc v8+" ;
687 case EM_960: return "Intel 90860";
688 case EM_PPC: return "PowerPC";
689 case EM_V800: return "NEC V800";
690 case EM_FR20: return "Fujitsu FR20";
691 case EM_RH32: return "TRW RH32";
692 case EM_MMA: return "Fujitsu MMA";
693 case EM_ARM: return "ARM";
694 case EM_OLD_ALPHA: return "Digital Alpha (old)";
695 case EM_SH: return "Hitachi SH";
696 case EM_SPARCV9: return "Sparc v9";
697 case EM_ALPHA: return "Alpha";
698 case EM_CYGNUS_D10V: return "d10v";
699 case EM_CYGNUS_D30V: return "d30v";
700 case EM_CYGNUS_ARC: return "Arc";
701 case EM_CYGNUS_M32R: return "M32r";
702 case EM_CYGNUS_V850: return "v850";
703 case EM_CYGNUS_MN10300: return "mn10300";
704 case EM_CYGNUS_MN10200: return "mn10200";
705
706 default:
707 sprintf (buff, _("<unknown>: %x"), e_machine);
708 return buff;
709 }
710 }
711
712 static char *
713 get_machine_flags (e_flags, e_machine)
714 unsigned e_flags;
715 unsigned e_machine;
716 {
717 static char buf [1024];
718
719 buf[0] = '\0';
720 if (e_flags)
721 {
722 switch (e_machine)
723 {
724 default:
725 break;
726
727 case EM_PPC:
728 if (e_flags & EF_PPC_EMB)
729 strcat (buf, ", emb");
730
731 if (e_flags & EF_PPC_RELOCATABLE)
732 strcat (buf, ", relocatable");
733
734 if (e_flags & EF_PPC_RELOCATABLE_LIB)
735 strcat (buf, ", relocatable-lib");
736 break;
737
738 case EM_CYGNUS_M32R:
739 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
740 strcat (buf, ", m32r");
741
742 /* start-sanitize-m32rx */
743 #ifdef E_M32RX_ARCH
744 if ((e_flags & EF_M32R_ARCH) == E_M32RX_ARCH)
745 strcat (buf, ", m32rx");
746 #endif
747 /* end-sanitize-m32rx */
748 break;
749
750 case EM_MIPS:
751 case EM_MIPS_RS4_BE:
752 if (e_flags & EF_MIPS_NOREORDER)
753 strcat (buf, ", noreorder");
754
755 if (e_flags & EF_MIPS_PIC)
756 strcat (buf, ", pic");
757
758 if (e_flags & EF_MIPS_CPIC)
759 strcat (buf, ", cpic");
760
761 if (e_flags & EF_MIPS_ABI2)
762 strcat (buf, ", abi2");
763
764 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
765 strcat (buf, ", mips1");
766
767 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
768 strcat (buf, ", mips2");
769
770 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
771 strcat (buf, ", mips3");
772
773 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
774 strcat (buf, ", mips4");
775 break;
776 }
777 }
778
779 return buf;
780 }
781
782 static char *
783 get_machine_data (e_data)
784 unsigned e_data;
785 {
786 static char buff [32];
787
788 switch (e_data)
789 {
790 case ELFDATA2LSB: return _("ELFDATA2LSB (little endian)");
791 case ELFDATA2MSB: return _("ELFDATA2MSB (big endian)");
792 default:
793 sprintf (buff, _("<unknown>: %x"), e_data);
794 return buff;
795 }
796 }
797
798 static const char *
799 get_mips_segment_type (type)
800 unsigned long type;
801 {
802 switch (type)
803 {
804 case PT_MIPS_REGINFO:
805 return "REGINFO";
806 case PT_MIPS_RTPROC:
807 return "RTPROC";
808 case PT_MIPS_OPTIONS:
809 return "OPTIONS";
810 default:
811 break;
812 }
813
814 return NULL;
815 }
816
817 static const char *
818 get_segment_type (p_type)
819 unsigned long p_type;
820 {
821 static char buff [32];
822
823 switch (p_type)
824 {
825 case PT_NULL: return "NULL";
826 case PT_LOAD: return "LOAD";
827 case PT_DYNAMIC: return "DYNAMIC";
828 case PT_INTERP: return "INTERP";
829 case PT_NOTE: return "NOTE";
830 case PT_SHLIB: return "SHLIB";
831 case PT_PHDR: return "PHDR";
832
833 default:
834 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
835 {
836 const char *result;
837 switch (elf_header.e_machine)
838 {
839 case EM_MIPS:
840 case EM_MIPS_RS4_BE:
841 result = get_mips_segment_type (p_type);
842 break;
843 default:
844 result = NULL;
845 break;
846 }
847 if (result == NULL)
848 {
849 sprintf (buff, "LOPROC+%d", p_type - PT_LOPROC);
850 result = buff;
851 }
852 return result;
853 }
854 else
855 {
856 sprintf (buff, _("<unknown>: %x"), p_type);
857 return buff;
858 }
859 }
860 }
861
862 static const char *
863 get_mips_section_type_name (sh_type)
864 unsigned int sh_type;
865 {
866 switch (sh_type)
867 {
868 case SHT_MIPS_LIBLIST:
869 return "MIPS_LIBLIST";
870 case SHT_MIPS_MSYM:
871 return "MIPS_MSYM";
872 case SHT_MIPS_CONFLICT:
873 return "MIPS_CONFLICT";
874 case SHT_MIPS_GPTAB:
875 return "MIPS_GPTAB";
876 case SHT_MIPS_UCODE:
877 return "MIPS_UCODE";
878 case SHT_MIPS_DEBUG:
879 return "MIPS_DEBUG";
880 case SHT_MIPS_REGINFO:
881 return "MIPS_REGINFO";
882 case SHT_MIPS_PACKAGE:
883 return "MIPS_PACKAGE";
884 case SHT_MIPS_PACKSYM:
885 return "MIPS_PACKSYM";
886 case SHT_MIPS_RELD:
887 return "MIPS_RELD";
888 case SHT_MIPS_IFACE:
889 return "MIPS_IFACE";
890 case SHT_MIPS_CONTENT:
891 return "MIPS_CONTENT";
892 case SHT_MIPS_OPTIONS:
893 return "MIPS_OPTIONS";
894 case SHT_MIPS_SHDR:
895 return "MIPS_SHDR";
896 case SHT_MIPS_FDESC:
897 return "MIPS_FDESC";
898 case SHT_MIPS_EXTSYM:
899 return "MIPS_EXTSYM";
900 case SHT_MIPS_DENSE:
901 return "MIPS_DENSE";
902 case SHT_MIPS_PDESC:
903 return "MIPS_PDESC";
904 case SHT_MIPS_LOCSYM:
905 return "MIPS_LOCSYM";
906 case SHT_MIPS_AUXSYM:
907 return "MIPS_AUXSYM";
908 case SHT_MIPS_OPTSYM:
909 return "MIPS_OPTSYM";
910 case SHT_MIPS_LOCSTR:
911 return "MIPS_LOCSTR";
912 case SHT_MIPS_LINE:
913 return "MIPS_LINE";
914 case SHT_MIPS_RFDESC:
915 return "MIPS_RFDESC";
916 case SHT_MIPS_DELTASYM:
917 return "MIPS_DELTASYM";
918 case SHT_MIPS_DELTAINST:
919 return "MIPS_DELTAINST";
920 case SHT_MIPS_DELTACLASS:
921 return "MIPS_DELTACLASS";
922 case SHT_MIPS_DWARF:
923 return "MIPS_DWARF";
924 case SHT_MIPS_DELTADECL:
925 return "MIPS_DELTADECL";
926 case SHT_MIPS_SYMBOL_LIB:
927 return "MIPS_SYMBOL_LIB";
928 case SHT_MIPS_EVENTS:
929 return "MIPS_EVENTS";
930 case SHT_MIPS_TRANSLATE:
931 return "MIPS_TRANSLATE";
932 case SHT_MIPS_PIXIE:
933 return "MIPS_PIXIE";
934 case SHT_MIPS_XLATE:
935 return "MIPS_XLATE";
936 case SHT_MIPS_XLATE_DEBUG:
937 return "MIPS_XLATE_DEBUG";
938 case SHT_MIPS_WHIRL:
939 return "MIPS_WHIRL";
940 case SHT_MIPS_EH_REGION:
941 return "MIPS_EH_REGION";
942 case SHT_MIPS_XLATE_OLD:
943 return "MIPS_XLATE_OLD";
944 case SHT_MIPS_PDR_EXCEPTION:
945 return "MIPS_PDR_EXCEPTION";
946 default:
947 break;
948 }
949 return NULL;
950 }
951
952 static const char *
953 get_section_type_name (sh_type)
954 unsigned int sh_type;
955 {
956 static char buff [32];
957
958 switch (sh_type)
959 {
960 case SHT_NULL: return "NULL";
961 case SHT_PROGBITS: return "PROGBITS";
962 case SHT_SYMTAB: return "SYMTAB";
963 case SHT_STRTAB: return "STRTAB";
964 case SHT_RELA: return "RELA";
965 case SHT_HASH: return "HASH";
966 case SHT_DYNAMIC: return "DYNAMIC";
967 case SHT_NOTE: return "NOTE";
968 case SHT_NOBITS: return "NOBITS";
969 case SHT_REL: return "REL";
970 case SHT_SHLIB: return "SHLIB";
971 case SHT_DYNSYM: return "DYNSYM";
972 case SHT_GNU_verdef: return "VERDEF";
973 case SHT_GNU_verneed: return "VERNEED";
974 case SHT_GNU_versym: return "VERSYM";
975 case 0x6ffffff0: return "VERSYM";
976 case 0x6ffffffc: return "VERDEF";
977 case 0x7ffffffd: return "AUXILIARY";
978 case 0x7fffffff: return "FILTER";
979
980 default:
981 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
982 {
983 const char *result;
984
985 switch (elf_header.e_machine)
986 {
987 case EM_MIPS:
988 case EM_MIPS_RS4_BE:
989 result = get_mips_section_type_name (sh_type);
990 break;
991 default:
992 result = NULL;
993 break;
994 }
995
996 if (result == NULL)
997 {
998 sprintf (buff, _("SHT_LOPROC+%d"), sh_type - SHT_LOPROC);
999 result = buff;
1000 }
1001 return result;
1002 }
1003 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1004 sprintf (buff, _("SHT_LOUSER+%d"), sh_type - SHT_LOUSER);
1005 else
1006 sprintf (buff, _("<unknown>: %x"), sh_type);
1007 return buff;
1008 }
1009 }
1010
1011 struct option options [] =
1012 {
1013 {"all", no_argument, 0, 'a'},
1014 {"file-header", no_argument, 0, 'h'},
1015 {"program-headers", no_argument, 0, 'l'},
1016 {"headers", no_argument, 0, 'e'},
1017 {"segments", no_argument, 0, 'l'},
1018 {"sections", no_argument, 0, 'S'},
1019 {"section-headers", no_argument, 0, 'S'},
1020 {"symbols", no_argument, 0, 's'},
1021 {"relocs", no_argument, 0, 'r'},
1022 {"dynamic", no_argument, 0, 'd'},
1023 {"version-info", no_argument, 0, 'V'},
1024 {"use-dynamic", no_argument, 0, 'D'},
1025
1026 {"hex-dump", required_argument, 0, 'x'},
1027 #ifdef SUPPORT_DISASSEMBLY
1028 {"instruction-dump", required_argument, 0, 'i'},
1029 #endif
1030
1031 {"version", no_argument, 0, 'v'},
1032 {"help", no_argument, 0, 'H'},
1033
1034 {0, no_argument, 0, 0}
1035 };
1036
1037 static void
1038 usage ()
1039 {
1040 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1041 fprintf (stdout, _(" Options are:\n"));
1042 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V\n"));
1043 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1044 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1045 fprintf (stdout, _(" Display the program headers\n"));
1046 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1047 fprintf (stdout, _(" Display the sections' header\n"));
1048 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1049 fprintf (stdout, _(" -s or --symbols Display the symbol table\n"));
1050 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1051 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1052 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1053 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1054 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1055 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1056 #ifdef SUPPORT_DISASSEMBLY
1057 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1058 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1059 #endif
1060 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1061 fprintf (stdout, _(" -H or --help Display this information\n"));
1062 fprintf (stdout, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1063
1064 exit (0);
1065 }
1066
1067 static void
1068 parse_args (argc, argv)
1069 int argc;
1070 char ** argv;
1071 {
1072 int c;
1073
1074 if (argc < 2)
1075 usage ();
1076
1077 while ((c = getopt_long
1078 (argc, argv, "ersahldSDx:i:vV", options, NULL)) != EOF)
1079 {
1080 char * cp;
1081 int section;
1082
1083 switch (c)
1084 {
1085 case 'H':
1086 usage ();
1087 break;
1088
1089 case 'a':
1090 do_syms ++;
1091 do_reloc ++;
1092 do_dynamic ++;
1093 do_header ++;
1094 do_sections ++;
1095 do_segments ++;
1096 do_version ++;
1097 break;
1098 case 'e':
1099 do_header ++;
1100 do_sections ++;
1101 do_segments ++;
1102 break;
1103 case 'D':
1104 do_using_dynamic ++;
1105 break;
1106 case 'r':
1107 do_reloc ++;
1108 break;
1109 case 'h':
1110 do_header ++;
1111 break;
1112 case 'l':
1113 do_segments ++;
1114 break;
1115 case 's':
1116 do_syms ++;
1117 break;
1118 case 'S':
1119 do_sections ++;
1120 break;
1121 case 'd':
1122 do_dynamic ++;
1123 break;
1124 case 'x':
1125 do_dump ++;
1126 section = strtoul (optarg, & cp, 0);
1127 if (! * cp && section >= 0 && section < NUM_DUMP_SECTS)
1128 {
1129 dump_sects [section] |= HEX_DUMP;
1130 break;
1131 }
1132 goto oops;
1133 #ifdef SUPPORT_DISASSEMBLY
1134 case 'i':
1135 do_dump ++;
1136 section = strtoul (optarg, & cp, 0);
1137 if (! * cp && section >= 0 && section < NUM_DUMP_SECTS)
1138 {
1139 dump_sects [section] |= DISASS_DUMP;
1140 break;
1141 }
1142 goto oops;
1143 #endif
1144 case 'v':
1145 print_version (program_name);
1146 break;
1147 case 'V':
1148 do_version ++;
1149 break;
1150 default:
1151 oops:
1152 /* xgettext:c-format */
1153 error (_("Invalid option '-%c'\n"), c);
1154 /* Drop through. */
1155 case '?':
1156 usage ();
1157 }
1158 }
1159
1160 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
1161 && !do_segments && !do_header && !do_dump && !do_version)
1162 usage ();
1163 else if (argc < 3)
1164 {
1165 warn (_("Nothing to do.\n"));
1166 usage();
1167 }
1168 }
1169
1170 /* Decode the data held in 'elf_header'. */
1171 static int
1172 process_file_header ()
1173 {
1174 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
1175 || elf_header.e_ident [EI_MAG1] != ELFMAG1
1176 || elf_header.e_ident [EI_MAG2] != ELFMAG2
1177 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
1178 {
1179 error
1180 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1181 return 0;
1182 }
1183
1184 if (elf_header.e_ident [EI_CLASS] != ELFCLASS32)
1185 {
1186 error (_("Not a 32 bit ELF file\n"));
1187 return 0;
1188 }
1189
1190 if (do_header)
1191 {
1192 int i;
1193
1194 printf (_("ELF Header:\n"));
1195 printf (_(" Magic: "));
1196 for (i = 0; i < EI_NIDENT; i ++)
1197 printf ("%2.2x ", elf_header.e_ident [i]);
1198 printf ("\n");
1199 printf (_(" Type: %s\n"),
1200 get_file_type (elf_header.e_type));
1201 printf (_(" Machine: %s\n"),
1202 get_machine_name (elf_header.e_machine));
1203 printf (_(" Version: 0x%lx\n"),
1204 (unsigned long) elf_header.e_version);
1205 printf (_(" Data: %s\n"),
1206 get_machine_data (elf_header.e_ident [EI_DATA]));
1207 printf (_(" Entry point address: 0x%lx\n"),
1208 (unsigned long) elf_header.e_entry);
1209 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1210 (long) elf_header.e_phoff);
1211 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1212 (long) elf_header.e_shoff);
1213 printf (_(" Flags: 0x%lx%s\n"),
1214 (unsigned long) elf_header.e_flags,
1215 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
1216 printf (_(" Size of this header: %ld (bytes)\n"),
1217 (long) elf_header.e_ehsize);
1218 printf (_(" Size of program headers: %ld (bytes)\n"),
1219 (long) elf_header.e_phentsize);
1220 printf (_(" Number of program headers: %ld\n"),
1221 (long) elf_header.e_phnum);
1222 printf (_(" Size of section headers: %ld (bytes)\n"),
1223 (long) elf_header.e_shentsize);
1224 printf (_(" Number of section headers: %ld\n"),
1225 (long) elf_header.e_shnum);
1226 printf (_(" Section header string table index: %ld\n"),
1227 (long) elf_header.e_shstrndx);
1228 }
1229
1230 return 1;
1231 }
1232
1233
1234 static int
1235 process_program_headers (file)
1236 FILE * file;
1237 {
1238 Elf32_External_Phdr * phdrs;
1239 Elf32_Internal_Phdr * program_headers;
1240 Elf32_Internal_Phdr * segment;
1241 unsigned int i;
1242
1243 if (elf_header.e_phnum == 0)
1244 {
1245 if (do_segments)
1246 printf (_("\nThere are no program headers in this file.\n"));
1247 return 1;
1248 }
1249
1250 if (do_segments && !do_header)
1251 {
1252 printf (_("\nElf file is %s\n"), get_file_type (elf_header.e_type));
1253 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header.e_entry);
1254 printf (_("There are %d program headers, starting at offset %lx:\n"),
1255 elf_header.e_phnum, (unsigned long) elf_header.e_phoff);
1256 }
1257
1258 GET_DATA_ALLOC (elf_header.e_phoff,
1259 elf_header.e_phentsize * elf_header.e_phnum,
1260 phdrs, Elf32_External_Phdr *, "program headers");
1261
1262 program_headers = (Elf32_Internal_Phdr *) malloc
1263 (elf_header.e_phnum * sizeof (Elf32_Internal_Phdr));
1264
1265 if (program_headers == NULL)
1266 {
1267 error (_("Out of memory\n"));
1268 return 0;
1269 }
1270
1271 for (i = 0, segment = program_headers;
1272 i < elf_header.e_phnum;
1273 i ++, segment ++)
1274 {
1275 segment->p_type = BYTE_GET (phdrs[i].p_type);
1276 segment->p_offset = BYTE_GET (phdrs[i].p_offset);
1277 segment->p_vaddr = BYTE_GET (phdrs[i].p_vaddr);
1278 segment->p_paddr = BYTE_GET (phdrs[i].p_paddr);
1279 segment->p_filesz = BYTE_GET (phdrs[i].p_filesz);
1280 segment->p_memsz = BYTE_GET (phdrs[i].p_memsz);
1281 segment->p_flags = BYTE_GET (phdrs[i].p_flags);
1282 segment->p_align = BYTE_GET (phdrs[i].p_align);
1283 }
1284
1285 free (phdrs);
1286
1287 if (do_segments)
1288 {
1289 printf
1290 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
1291 printf
1292 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1293 }
1294
1295 loadaddr = -1;
1296 dynamic_addr = 0;
1297
1298 for (i = 0, segment = program_headers;
1299 i < elf_header.e_phnum;
1300 i ++, segment ++)
1301 {
1302 if (do_segments)
1303 {
1304 printf (" %-11.11s ", get_segment_type (segment->p_type));
1305 printf ("0x%5.5lx ", (unsigned long) segment->p_offset);
1306 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
1307 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
1308 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
1309 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
1310 printf ("%c%c%c ",
1311 (segment->p_flags & PF_R ? 'R' : ' '),
1312 (segment->p_flags & PF_W ? 'W' : ' '),
1313 (segment->p_flags & PF_X ? 'E' : ' '));
1314 printf ("%#lx", (unsigned long) segment->p_align);
1315 }
1316
1317 switch (segment->p_type)
1318 {
1319 case PT_LOAD:
1320 if (loadaddr == -1)
1321 loadaddr = (segment->p_vaddr & 0xfffff000)
1322 - (segment->p_offset & 0xfffff000);
1323 break;
1324
1325 case PT_DYNAMIC:
1326 if (dynamic_addr)
1327 error (_("more than one dynamic segment\n"));
1328
1329 dynamic_addr = segment->p_offset;
1330 dynamic_size = segment->p_filesz;
1331 break;
1332
1333 case PT_INTERP:
1334 if (fseek (file, segment->p_offset, SEEK_SET))
1335 error (_("Unable to find program interpreter name\n"));
1336 else
1337 {
1338 program_interpreter[0] = 0;
1339 fscanf (file, "%63s", program_interpreter);
1340
1341 if (do_segments)
1342 printf (_("\n [Requesting program interpreter: %s]"),
1343 program_interpreter);
1344 }
1345 break;
1346 }
1347
1348 if (do_segments)
1349 putc ('\n', stdout);
1350 }
1351
1352 if (loadaddr == -1)
1353 {
1354 /* Very strange. */
1355 loadaddr = 0;
1356 }
1357
1358 if (do_segments && section_headers != NULL)
1359 {
1360 printf (_("\n Section to Segment mapping:\n"));
1361 printf (_(" Segment Sections...\n"));
1362
1363 assert (string_table != NULL);
1364
1365 for (i = 0; i < elf_header.e_phnum; i++)
1366 {
1367 int j;
1368 Elf32_Internal_Shdr * section;
1369
1370 segment = program_headers + i;
1371 section = section_headers;
1372
1373 printf (" %2.2d ", i);
1374
1375 for (j = 0; j < elf_header.e_shnum; j++, section ++)
1376 {
1377 if (section->sh_size > 0
1378 /* Compare allocated sections by VMA, unallocated
1379 sections by file offset. */
1380 && (section->sh_flags & SHF_ALLOC
1381 ? (section->sh_addr >= segment->p_vaddr
1382 && section->sh_addr + section->sh_size
1383 <= segment->p_vaddr + segment->p_memsz)
1384 : (section->sh_offset >= segment->p_offset
1385 && (section->sh_offset + section->sh_size
1386 <= segment->p_offset + segment->p_filesz))))
1387 printf ("%s ", SECTION_NAME (section));
1388 }
1389
1390 putc ('\n',stdout);
1391 }
1392 }
1393
1394 free (program_headers);
1395
1396 return 1;
1397 }
1398
1399
1400 static int
1401 get_section_headers (file)
1402 FILE * file;
1403 {
1404 Elf32_External_Shdr * shdrs;
1405 Elf32_Internal_Shdr * internal;
1406 unsigned int i;
1407
1408 GET_DATA_ALLOC (elf_header.e_shoff,
1409 elf_header.e_shentsize * elf_header.e_shnum,
1410 shdrs, Elf32_External_Shdr *, "section headers");
1411
1412 section_headers = (Elf32_Internal_Shdr *) malloc
1413 (elf_header.e_shnum * sizeof (Elf32_Internal_Shdr));
1414
1415 if (section_headers == NULL)
1416 {
1417 error (_("Out of memory\n"));
1418 return 0;
1419 }
1420
1421 for (i = 0, internal = section_headers;
1422 i < elf_header.e_shnum;
1423 i ++, internal ++)
1424 {
1425 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
1426 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
1427 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
1428 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
1429 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
1430 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
1431 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
1432 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
1433 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
1434 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
1435 }
1436
1437 free (shdrs);
1438
1439 return 1;
1440 }
1441
1442 static Elf_Internal_Sym *
1443 get_elf_symbols (file, offset, number)
1444 FILE * file;
1445 unsigned long offset;
1446 unsigned long number;
1447 {
1448 Elf32_External_Sym * esyms;
1449 Elf_Internal_Sym * isyms;
1450 Elf_Internal_Sym * psym;
1451 unsigned int j;
1452
1453 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
1454 esyms, Elf32_External_Sym *, "symbols");
1455
1456 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
1457
1458 if (isyms == NULL)
1459 {
1460 error (_("Out of memory\n"));
1461 free (esyms);
1462
1463 return NULL;
1464 }
1465
1466 for (j = 0, psym = isyms;
1467 j < number;
1468 j ++, psym ++)
1469 {
1470 psym->st_name = BYTE_GET (esyms[j].st_name);
1471 psym->st_value = BYTE_GET (esyms[j].st_value);
1472 psym->st_size = BYTE_GET (esyms[j].st_size);
1473 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
1474 psym->st_info = BYTE_GET (esyms[j].st_info);
1475 psym->st_other = BYTE_GET (esyms[j].st_other);
1476 }
1477
1478 free (esyms);
1479
1480 return isyms;
1481 }
1482
1483 static int
1484 process_section_headers (file)
1485 FILE * file;
1486 {
1487 Elf32_Internal_Shdr * section;
1488 int i;
1489
1490 section_headers = NULL;
1491
1492 if (elf_header.e_shnum == 0)
1493 {
1494 if (do_sections)
1495 printf (_("\nThere are no sections in this file.\n"));
1496
1497 return 1;
1498 }
1499
1500 if (do_sections && !do_header)
1501 printf (_("There are %d section headers, starting at offset %x:\n"),
1502 elf_header.e_shnum, elf_header.e_shoff);
1503
1504 if (! get_section_headers (file))
1505 return 0;
1506
1507 /* Read in the string table, so that we have names to display. */
1508 section = section_headers + elf_header.e_shstrndx;
1509
1510 if (section->sh_size != 0)
1511 {
1512 unsigned long string_table_offset;
1513
1514 string_table_offset = section->sh_offset;
1515
1516 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
1517 string_table, char *, "string table");
1518 }
1519
1520 /* Scan the sections for the dynamic symbol table
1521 and dynamic string table. */
1522 dynamic_symbols = NULL;
1523 dynamic_strings = NULL;
1524 for (i = 0, section = section_headers;
1525 i < elf_header.e_shnum;
1526 i ++, section ++)
1527 {
1528 if (section->sh_type == SHT_DYNSYM)
1529 {
1530 if (dynamic_symbols != NULL)
1531 {
1532 error (_("File contains multiple dynamic symbol tables\n"));
1533 continue;
1534 }
1535
1536 dynamic_symbols = get_elf_symbols
1537 (file, section->sh_offset, section->sh_size / section->sh_entsize);
1538 }
1539 else if (section->sh_type == SHT_STRTAB
1540 && strcmp (SECTION_NAME (section), ".dynstr") == 0)
1541 {
1542 if (dynamic_strings != NULL)
1543 {
1544 error (_("File contains multiple dynamic string tables\n"));
1545 continue;
1546 }
1547
1548 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
1549 dynamic_strings, char *, "dynamic strings");
1550 }
1551 }
1552
1553 if (! do_sections)
1554 return 1;
1555
1556 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
1557 printf
1558 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1559
1560 for (i = 0, section = section_headers;
1561 i < elf_header.e_shnum;
1562 i ++, section ++)
1563 {
1564 printf (" [%2d] %-17.17s %-15.15s ",
1565 i,
1566 SECTION_NAME (section),
1567 get_section_type_name (section->sh_type));
1568
1569 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1570 (unsigned long) section->sh_addr,
1571 (unsigned long) section->sh_offset,
1572 (unsigned long) section->sh_size,
1573 (unsigned long) section->sh_entsize);
1574
1575 printf (" %c%c%c %2ld %3lx %ld \n",
1576 (section->sh_flags & SHF_WRITE ? 'W' : ' '),
1577 (section->sh_flags & SHF_ALLOC ? 'A' : ' '),
1578 (section->sh_flags & SHF_EXECINSTR ? 'X' : ' '),
1579 (unsigned long) section->sh_link,
1580 (unsigned long) section->sh_info,
1581 (unsigned long) section->sh_addralign);
1582 }
1583
1584 return 1;
1585 }
1586
1587 /* Process the reloc section. */
1588 static int
1589 process_relocs (file)
1590 FILE * file;
1591 {
1592 unsigned long rel_size;
1593 unsigned long rel_offset;
1594
1595
1596 if (!do_reloc)
1597 return 1;
1598
1599 if (do_using_dynamic)
1600 {
1601 rel_size = 0;
1602 rel_offset = 0;
1603
1604 if (dynamic_info[DT_REL])
1605 {
1606 rel_offset = dynamic_info[DT_REL];
1607 rel_size = dynamic_info[DT_RELSZ];
1608 }
1609 else if (dynamic_info [DT_RELA])
1610 {
1611 rel_offset = dynamic_info[DT_RELA];
1612 rel_size = dynamic_info[DT_RELASZ];
1613 }
1614 else if (dynamic_info[DT_JMPREL])
1615 {
1616 rel_offset = dynamic_info[DT_JMPREL];
1617 rel_size = dynamic_info[DT_PLTRELSZ];
1618 }
1619
1620 if (rel_size)
1621 {
1622 printf
1623 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
1624 rel_offset, rel_size);
1625
1626 dump_relocations (file, rel_offset - loadaddr, rel_size,
1627 dynamic_symbols, dynamic_strings);
1628 }
1629 else
1630 printf (_("\nThere are no dynamic relocations in this file.\n"));
1631 }
1632 else
1633 {
1634 Elf32_Internal_Shdr * section;
1635 unsigned long i;
1636 int found = 0;
1637
1638 for (i = 0, section = section_headers;
1639 i < elf_header.e_shnum;
1640 i++, section ++)
1641 {
1642 if ( section->sh_type != SHT_RELA
1643 && section->sh_type != SHT_REL)
1644 continue;
1645
1646 rel_offset = section->sh_offset;
1647 rel_size = section->sh_size;
1648
1649 if (rel_size)
1650 {
1651 Elf32_Internal_Shdr * strsec;
1652 Elf32_Internal_Shdr * symsec;
1653 Elf_Internal_Sym * symtab;
1654 char * strtab;
1655
1656 printf (_("\nRelocation section "));
1657
1658 if (string_table == NULL)
1659 printf ("%d", section->sh_name);
1660 else
1661 printf ("'%s'", SECTION_NAME (section));
1662
1663 printf (_(" at offset 0x%x contains %d entries:\n"),
1664 rel_offset, rel_size / section->sh_entsize);
1665
1666 symsec = section_headers + section->sh_link;
1667
1668 symtab = get_elf_symbols (file, symsec->sh_offset,
1669 symsec->sh_size / symsec->sh_entsize);
1670
1671 if (symtab == NULL)
1672 continue;
1673
1674 strsec = section_headers + symsec->sh_link;
1675
1676 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
1677 char *, "string table");
1678
1679 dump_relocations (file, rel_offset, rel_size, symtab, strtab);
1680
1681 free (strtab);
1682 free (symtab);
1683
1684 found = 1;
1685 }
1686 }
1687
1688 if (! found)
1689 printf (_("\nThere are no relocations in this file.\n"));
1690 }
1691
1692 return 1;
1693 }
1694
1695
1696 static void
1697 dynamic_segment_mips_val (entry)
1698 Elf_Internal_Dyn *entry;
1699 {
1700 switch (entry->d_tag)
1701 {
1702 case DT_MIPS_LOCAL_GOTNO:
1703 case DT_MIPS_CONFLICTNO:
1704 case DT_MIPS_LIBLISTNO:
1705 case DT_MIPS_SYMTABNO:
1706 case DT_MIPS_UNREFEXTNO:
1707 case DT_MIPS_HIPAGENO:
1708 case DT_MIPS_DELTA_CLASS_NO:
1709 case DT_MIPS_DELTA_INSTANCE_NO:
1710 case DT_MIPS_DELTA_RELOC_NO:
1711 case DT_MIPS_DELTA_SYM_NO:
1712 case DT_MIPS_DELTA_CLASSSYM_NO:
1713 if (do_dynamic)
1714 printf ("%#ld\n", (long) entry->d_un.d_ptr);
1715 break;
1716 default:
1717 if (do_dynamic)
1718 printf ("%#lx\n", (long) entry->d_un.d_ptr);
1719 }
1720 }
1721
1722 /* Parse the dynamic segment */
1723 static int
1724 process_dynamic_segment (file)
1725 FILE * file;
1726 {
1727 Elf_Internal_Dyn * entry;
1728 Elf32_External_Dyn * edyn;
1729 unsigned int i;
1730
1731 if (dynamic_size == 0)
1732 {
1733 if (do_dynamic)
1734 printf (_("\nThere is no dynamic segment in this file.\n"));
1735
1736 return 1;
1737 }
1738
1739 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
1740 edyn, Elf32_External_Dyn *, "dynamic segment");
1741
1742 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
1743 how large .dynamic is now. We can do this even before the byte
1744 swapping since the DT_NULL tag is recognizable. */
1745 dynamic_size = 0;
1746 while (*(Elf32_Word *) edyn[dynamic_size++].d_tag != DT_NULL)
1747 ;
1748
1749 dynamic_segment = (Elf_Internal_Dyn *)
1750 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
1751
1752 if (dynamic_segment == NULL)
1753 {
1754 error (_("Out of memory\n"));
1755 free (edyn);
1756 return 0;
1757 }
1758
1759 for (i = 0, entry = dynamic_segment;
1760 i < dynamic_size;
1761 i ++, entry ++)
1762 {
1763 entry->d_tag = BYTE_GET (edyn [i].d_tag);
1764 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
1765 }
1766
1767 free (edyn);
1768
1769 /* Find the appropriate symbol table. */
1770 if (dynamic_symbols == NULL)
1771 {
1772 for (i = 0, entry = dynamic_segment;
1773 i < dynamic_size;
1774 ++i, ++ entry)
1775 {
1776 unsigned long offset;
1777 long num_syms;
1778
1779 if (entry->d_tag != DT_SYMTAB)
1780 continue;
1781
1782 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
1783
1784 /* Since we do not know how big the symbol table is,
1785 we default to reading in the entire file (!) and
1786 processing that. This is overkill, I know, but it
1787 should work. */
1788
1789 offset = entry->d_un.d_val - loadaddr;
1790
1791 if (fseek (file, 0, SEEK_END))
1792 error (_("Unable to seek to end of file!"));
1793
1794 num_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
1795
1796 if (num_syms < 1)
1797 {
1798 error (_("Unable to determine the number of symbols to load\n"));
1799 continue;
1800 }
1801
1802 dynamic_symbols = get_elf_symbols (file, offset, num_syms);
1803 }
1804 }
1805
1806 /* Similarly find a string table. */
1807 if (dynamic_strings == NULL)
1808 {
1809 for (i = 0, entry = dynamic_segment;
1810 i < dynamic_size;
1811 ++i, ++ entry)
1812 {
1813 unsigned long offset;
1814 long str_tab_len;
1815
1816 if (entry->d_tag != DT_STRTAB)
1817 continue;
1818
1819 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
1820
1821 /* Since we do not know how big the string table is,
1822 we default to reading in the entire file (!) and
1823 processing that. This is overkill, I know, but it
1824 should work. */
1825
1826 offset = entry->d_un.d_val - loadaddr;
1827 if (fseek (file, 0, SEEK_END))
1828 error (_("Unable to seek to end of file\n"));
1829 str_tab_len = ftell (file) - offset;
1830
1831 if (str_tab_len < 1)
1832 {
1833 error
1834 (_("Unable to determine the length of the dynamic string table\n"));
1835 continue;
1836 }
1837
1838 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
1839 "dynamic string table");
1840
1841 break;
1842 }
1843 }
1844
1845 if (do_dynamic && dynamic_addr)
1846 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
1847 dynamic_addr, dynamic_size);
1848 if (do_dynamic)
1849 printf (_(" Tag Type Name/Value\n"));
1850
1851 for (i = 0, entry = dynamic_segment;
1852 i < dynamic_size;
1853 i++, entry ++)
1854 {
1855 if (do_dynamic)
1856 printf (_(" 0x%-8.8lx (%s)%*s"),
1857 (unsigned long) entry->d_tag,
1858 get_dynamic_type (entry->d_tag),
1859 27 - strlen (get_dynamic_type (entry->d_tag)),
1860 " ");
1861
1862 switch (entry->d_tag)
1863 {
1864 case DT_AUXILIARY:
1865 case DT_FILTER:
1866 if (do_dynamic)
1867 {
1868 if (entry->d_tag == DT_AUXILIARY)
1869 printf (_("Auxiliary library"));
1870 else
1871 printf (_("Filter library"));
1872
1873 if (dynamic_strings)
1874 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
1875 else
1876 printf (": %#lx\n", (long) entry->d_un.d_val);
1877 }
1878 break;
1879
1880 case DT_POSFLAG_1:
1881 if (do_dynamic)
1882 {
1883 printf (_("Flags:"));
1884 if (entry->d_un.d_val == 0)
1885 printf (_(" None\n"));
1886 else
1887 {
1888 if (entry->d_un.d_val & DF_P1_LAZYLOAD)
1889 printf (" LAZYLOAD");
1890 if (entry->d_un.d_val & DF_P1_LAZYLOAD)
1891 printf (" GROUPPERM");
1892 puts ("");
1893 }
1894 }
1895 break;
1896
1897 case DT_FLAGS_1:
1898 if (do_dynamic)
1899 {
1900 printf (_("Flags:"));
1901 if (entry->d_un.d_val == 0)
1902 printf (_(" None\n"));
1903 else
1904 {
1905 if (entry->d_un.d_val & DF_1_NOW)
1906 printf (" NOW");
1907 if (entry->d_un.d_val & DF_1_GLOBAL)
1908 printf (" GLOBAL");
1909 if (entry->d_un.d_val & DF_1_GROUP)
1910 printf (" GROUP");
1911 if (entry->d_un.d_val & DF_1_NODELETE)
1912 printf (" NODELETE");
1913 if (entry->d_un.d_val & DF_1_LOADFLTR)
1914 printf (" LOADFLTR");
1915 if (entry->d_un.d_val & DF_1_INITFIRST)
1916 printf (" INITFIRST");
1917 if (entry->d_un.d_val & DF_1_NOOPEN)
1918 printf (" NOOPEN");
1919 if (entry->d_un.d_val & DF_1_ORIGIN)
1920 printf (" ORIGIN");
1921 if (entry->d_un.d_val & DF_1_DIRECT)
1922 printf (" DIRECT");
1923 if (entry->d_un.d_val & DF_1_TRANS)
1924 printf (" TRANS");
1925 if (entry->d_un.d_val & DF_1_INTERPOSE)
1926 printf (" INTERPOSE");
1927 puts ("");
1928 }
1929 }
1930 break;
1931
1932 case DT_NULL :
1933 case DT_NEEDED :
1934 case DT_PLTRELSZ:
1935 case DT_PLTGOT :
1936 case DT_HASH :
1937 case DT_STRTAB :
1938 case DT_SYMTAB :
1939 case DT_RELA :
1940 case DT_INIT :
1941 case DT_FINI :
1942 case DT_SONAME :
1943 case DT_RPATH :
1944 case DT_SYMBOLIC:
1945 case DT_REL :
1946 case DT_PLTREL :
1947 case DT_DEBUG :
1948 case DT_TEXTREL :
1949 case DT_JMPREL :
1950 dynamic_info[entry->d_tag] = entry->d_un.d_val;
1951
1952 if (do_dynamic)
1953 {
1954 char * name;
1955
1956 if (dynamic_strings == NULL)
1957 name = NULL;
1958 else
1959 name = dynamic_strings + entry->d_un.d_val;
1960
1961 if (name)
1962 {
1963 switch (entry->d_tag)
1964 {
1965 case DT_NEEDED:
1966 printf (_("Shared library: [%s]"), name);
1967
1968 if (strcmp (name, program_interpreter))
1969 printf ("\n");
1970 else
1971 printf (_(" program interpreter\n"));
1972 break;
1973
1974 case DT_SONAME:
1975 printf (_("Library soname: [%s]\n"), name);
1976 break;
1977
1978 case DT_RPATH:
1979 printf (_("Library rpath: [%s]\n"), name);
1980 break;
1981
1982 default:
1983 printf ("%#lx\n", (long) entry->d_un.d_val);
1984 }
1985 }
1986 else
1987 printf ("%#lx\n", (long) entry->d_un.d_val);
1988 }
1989 break;
1990
1991 case DT_RELASZ :
1992 case DT_RELAENT :
1993 case DT_STRSZ :
1994 case DT_SYMENT :
1995 case DT_RELSZ :
1996 case DT_RELENT :
1997 case DT_VERDEFNUM:
1998 case DT_VERNEEDNUM:
1999 case DT_RELACOUNT:
2000 case DT_RELCOUNT:
2001 printf ("%ld\n", entry->d_un.d_val);
2002 break;
2003
2004 case DT_SYMINSZ :
2005 case DT_SYMINENT:
2006 case DT_SYMINFO :
2007 case DT_USED:
2008 if (do_dynamic)
2009 {
2010 char * name;
2011
2012 if (dynamic_strings == NULL)
2013 name = NULL;
2014 else
2015 name = dynamic_strings + entry->d_un.d_val;
2016
2017
2018
2019 if (name)
2020 {
2021 switch (entry->d_tag)
2022 {
2023 case DT_USED:
2024 printf (_("Not needed object: [%s]\n"), name);
2025 break;
2026
2027 default:
2028 printf ("%#lx\n", (long) entry->d_un.d_val);
2029 }
2030 }
2031 else
2032 printf ("%#lx\n", (long) entry->d_un.d_val);
2033 }
2034 break;
2035
2036 default:
2037 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
2038 {
2039 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
2040 entry->d_un.d_val;
2041
2042 if (do_dynamic)
2043 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2044 }
2045 else
2046 switch (elf_header.e_machine)
2047 {
2048 case EM_MIPS:
2049 case EM_MIPS_RS4_BE:
2050 dynamic_segment_mips_val (entry);
2051 break;
2052 default:
2053 if (do_dynamic)
2054 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2055 }
2056 break;
2057 }
2058 }
2059
2060 return 1;
2061 }
2062
2063 static char *
2064 get_ver_flags (flags)
2065 unsigned int flags;
2066 {
2067 static char buff [32];
2068
2069 buff[0] = 0;
2070
2071 if (flags == 0)
2072 return _("none");
2073
2074 if (flags & VER_FLG_BASE)
2075 strcat (buff, "BASE ");
2076
2077 if (flags & VER_FLG_WEAK)
2078 {
2079 if (flags & VER_FLG_BASE)
2080 strcat (buff, "| ");
2081
2082 strcat (buff, "WEAK ");
2083 }
2084
2085 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
2086 strcat (buff, "| <unknown>");
2087
2088 return buff;
2089 }
2090
2091 /* Display the contents of the version sections. */
2092 static int
2093 process_version_sections (file)
2094 FILE * file;
2095 {
2096 Elf32_Internal_Shdr * section;
2097 unsigned i;
2098 int found = 0;
2099
2100 if (! do_version)
2101 return 1;
2102
2103 for (i = 0, section = section_headers;
2104 i < elf_header.e_shnum;
2105 i++, section ++)
2106 {
2107 switch (section->sh_type)
2108 {
2109 case SHT_GNU_verdef:
2110 {
2111 Elf_External_Verdef * edefs;
2112 unsigned int idx;
2113 unsigned int cnt;
2114
2115 found = 1;
2116
2117 printf
2118 (_("\nVersion definition section '%s' contains %d entries:\n"),
2119 SECTION_NAME (section), section->sh_info);
2120
2121 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2122 section->sh_addr, section->sh_offset, section->sh_link,
2123 SECTION_NAME (section_headers + section->sh_link));
2124
2125 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2126 edefs, Elf_External_Verdef *,
2127 "version definition section");
2128
2129 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
2130 {
2131 char * vstart;
2132 Elf_External_Verdef * edef;
2133 Elf_Internal_Verdef ent;
2134 Elf_External_Verdaux * eaux;
2135 Elf_Internal_Verdaux aux;
2136 int j;
2137 int isum;
2138
2139 vstart = ((char *) edefs) + idx;
2140
2141 edef = (Elf_External_Verdef *) vstart;
2142
2143 ent.vd_version = BYTE_GET (edef->vd_version);
2144 ent.vd_flags = BYTE_GET (edef->vd_flags);
2145 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
2146 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
2147 ent.vd_hash = BYTE_GET (edef->vd_hash);
2148 ent.vd_aux = BYTE_GET (edef->vd_aux);
2149 ent.vd_next = BYTE_GET (edef->vd_next);
2150
2151 printf (_(" %#06x: Rev: %d Flags: %s"),
2152 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
2153
2154 printf (_(" Index: %ld Cnt: %ld "), ent.vd_ndx, ent.vd_cnt);
2155
2156 vstart += ent.vd_aux;
2157
2158 eaux = (Elf_External_Verdaux *) vstart;
2159
2160 aux.vda_name = BYTE_GET (eaux->vda_name);
2161 aux.vda_next = BYTE_GET (eaux->vda_next);
2162
2163 if (dynamic_strings)
2164 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
2165 else
2166 printf (_("Name index: %ld\n"), aux.vda_name);
2167
2168 isum = idx + ent.vd_aux;
2169
2170 for (j = 1; j < ent.vd_cnt; j ++)
2171 {
2172 isum += aux.vda_next;
2173 vstart += aux.vda_next;
2174
2175 eaux = (Elf_External_Verdaux *) vstart;
2176
2177 aux.vda_name = BYTE_GET (eaux->vda_name);
2178 aux.vda_next = BYTE_GET (eaux->vda_next);
2179
2180 if (dynamic_strings)
2181 printf (_(" %#06x: Parent %d: %s\n"),
2182 isum, j, dynamic_strings + aux.vda_name);
2183 else
2184 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2185 isum, j, aux.vda_name);
2186 }
2187
2188 idx += ent.vd_next;
2189 }
2190
2191 free (edefs);
2192 }
2193 break;
2194
2195 case SHT_GNU_verneed:
2196 {
2197 Elf_External_Verneed * eneed;
2198 unsigned int idx;
2199 unsigned int cnt;
2200
2201 found = 1;
2202
2203 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2204 SECTION_NAME (section), section->sh_info);
2205
2206 printf
2207 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2208 section->sh_addr, section->sh_offset, section->sh_link,
2209 SECTION_NAME (section_headers + section->sh_link));
2210
2211 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2212 eneed, Elf_External_Verneed *,
2213 "version need section");
2214
2215 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
2216 {
2217 Elf_External_Verneed * entry;
2218 Elf_Internal_Verneed ent;
2219 int j;
2220 int isum;
2221 char * vstart;
2222
2223 vstart = ((char *) eneed) + idx;
2224
2225 entry = (Elf_External_Verneed *) vstart;
2226
2227 ent.vn_version = BYTE_GET (entry->vn_version);
2228 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
2229 ent.vn_file = BYTE_GET (entry->vn_file);
2230 ent.vn_aux = BYTE_GET (entry->vn_aux);
2231 ent.vn_next = BYTE_GET (entry->vn_next);
2232
2233 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
2234
2235 if (dynamic_strings)
2236 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
2237 else
2238 printf (_(" File: %lx"), ent.vn_file);
2239
2240 printf (_(" Cnt: %d\n"), ent.vn_cnt);
2241
2242 vstart += ent.vn_aux;
2243
2244 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
2245 {
2246 Elf_External_Vernaux * eaux;
2247 Elf_Internal_Vernaux aux;
2248
2249 eaux = (Elf_External_Vernaux *) vstart;
2250
2251 aux.vna_hash = BYTE_GET (eaux->vna_hash);
2252 aux.vna_flags = BYTE_GET (eaux->vna_flags);
2253 aux.vna_other = BYTE_GET (eaux->vna_other);
2254 aux.vna_name = BYTE_GET (eaux->vna_name);
2255 aux.vna_next = BYTE_GET (eaux->vna_next);
2256
2257 if (dynamic_strings)
2258 printf (_(" %#06x: Name: %s"),
2259 isum, dynamic_strings + aux.vna_name);
2260 else
2261 printf (_(" %#06x: Name index: %lx"),
2262 isum, aux.vna_name);
2263
2264 printf (_(" Flags: %s Version: %d\n"),
2265 get_ver_flags (aux.vna_flags), aux.vna_other);
2266
2267 isum += aux.vna_next;
2268 vstart += aux.vna_next;
2269 }
2270
2271 idx += ent.vn_next;
2272 }
2273
2274 free (eneed);
2275 }
2276 break;
2277
2278 case SHT_GNU_versym:
2279 {
2280 Elf32_Internal_Shdr * link_section;
2281 int total;
2282 int cnt;
2283 unsigned char * edata;
2284 unsigned short * data;
2285 char * strtab;
2286 Elf_Internal_Sym * symbols;
2287 Elf32_Internal_Shdr * string_sec;
2288
2289 link_section = section_headers + section->sh_link;
2290 total = section->sh_size / section->sh_entsize;
2291
2292 found = 1;
2293
2294 symbols = get_elf_symbols
2295 (file, link_section->sh_offset,
2296 link_section->sh_size / link_section->sh_entsize);
2297
2298 string_sec = section_headers + link_section->sh_link;
2299
2300 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
2301 strtab, char *, "version string table");
2302
2303 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2304 SECTION_NAME (section), total);
2305
2306 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2307 section->sh_addr, section->sh_offset, section->sh_link,
2308 SECTION_NAME (link_section));
2309
2310 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
2311 - loadaddr,
2312 total * sizeof (short), edata,
2313 char *, "version symbol data");
2314
2315 data = (unsigned short *) malloc (total * sizeof (short));
2316
2317 for (cnt = total; cnt --;)
2318 data [cnt] = byte_get (edata + cnt * sizeof (short), sizeof (short));
2319
2320 free (edata);
2321
2322 for (cnt = 0; cnt < total; cnt += 4)
2323 {
2324 int j, nn;
2325
2326 printf (" %03x:", cnt);
2327
2328 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
2329 switch (data [cnt + j])
2330 {
2331 case 0:
2332 fputs (_(" 0 (*local*) "), stdout);
2333 break;
2334
2335 case 1:
2336 fputs (_(" 1 (*global*) "), stdout);
2337 break;
2338
2339 default:
2340 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
2341 data [cnt + j] & 0x8000 ? 'h' : ' ');
2342
2343 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
2344 && section_headers[symbols [cnt + j].st_shndx].sh_type
2345 == SHT_NOBITS)
2346 {
2347 /* We must test both. */
2348 Elf_Internal_Verneed ivn;
2349 unsigned long offset;
2350
2351 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
2352 - loadaddr;
2353
2354 do
2355 {
2356 Elf_External_Verneed evn;
2357 Elf_External_Vernaux evna;
2358 Elf_Internal_Vernaux ivna;
2359 unsigned long vna_off;
2360
2361 GET_DATA (offset, evn, "version need");
2362
2363 ivn.vn_aux = BYTE_GET (evn.vn_aux);
2364 ivn.vn_next = BYTE_GET (evn.vn_next);
2365
2366 vna_off = offset + ivn.vn_aux;
2367
2368 do
2369 {
2370 GET_DATA (vna_off, evna,
2371 "version need aux (1)");
2372
2373 ivna.vna_next = BYTE_GET (evna.vna_next);
2374 ivna.vna_other = BYTE_GET (evna.vna_other);
2375
2376 vna_off += ivna.vna_next;
2377 }
2378 while (ivna.vna_other != data [cnt + j]
2379 && ivna.vna_next != 0);
2380
2381 if (ivna.vna_other == data [cnt + j])
2382 {
2383 ivna.vna_name = BYTE_GET (evna.vna_name);
2384
2385 nn += printf ("(%s%-*s",
2386 strtab + ivna.vna_name,
2387 12 - strlen (strtab
2388 + ivna.vna_name),
2389 ")");
2390 break;
2391 }
2392 else if (ivn.vn_next == 0)
2393 {
2394 if (data [cnt + j] != 0x8001)
2395 {
2396 Elf_Internal_Verdef ivd;
2397 Elf_External_Verdef evd;
2398
2399 offset = version_info
2400 [DT_VERSIONTAGIDX (DT_VERDEF)]
2401 - loadaddr;
2402
2403 do
2404 {
2405 GET_DATA (offset, evd,
2406 "version definition");
2407
2408 ivd.vd_next = BYTE_GET (evd.vd_next);
2409 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
2410
2411 offset += ivd.vd_next;
2412 }
2413 while (ivd.vd_ndx
2414 != (data [cnt + j] & 0x7fff)
2415 && ivd.vd_next != 0);
2416
2417 if (ivd.vd_ndx
2418 == (data [cnt + j] & 0x7fff))
2419 {
2420 Elf_External_Verdaux evda;
2421 Elf_Internal_Verdaux ivda;
2422
2423 ivd.vd_aux = BYTE_GET (evd.vd_aux);
2424
2425 GET_DATA (offset + ivd.vd_aux, evda,
2426 "version definition aux");
2427
2428 ivda.vda_name =
2429 BYTE_GET (evda.vda_name);
2430
2431 nn +=
2432 printf ("(%s%-*s",
2433 strtab + ivda.vda_name,
2434 12
2435 - strlen (strtab
2436 + ivda.vda_name),
2437 ")");
2438 }
2439 }
2440
2441 break;
2442 }
2443 else
2444 offset += ivn.vn_next;
2445 }
2446 while (ivn.vn_next);
2447 }
2448 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
2449 {
2450 Elf_Internal_Verneed ivn;
2451 unsigned long offset;
2452
2453 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
2454 - loadaddr;
2455
2456 do
2457 {
2458 Elf_Internal_Vernaux ivna;
2459 Elf_External_Verneed evn;
2460 Elf_External_Vernaux evna;
2461 unsigned long a_off;
2462
2463 GET_DATA (offset, evn, "version need");
2464
2465 ivn.vn_aux = BYTE_GET (evn.vn_aux);
2466 ivn.vn_next = BYTE_GET (evn.vn_next);
2467
2468 a_off = offset + ivn.vn_aux;
2469
2470 do
2471 {
2472 GET_DATA (a_off, evna,
2473 "version need aux (2)");
2474
2475 ivna.vna_next = BYTE_GET (evna.vna_next);
2476 ivna.vna_other = BYTE_GET (evna.vna_other);
2477
2478 a_off += ivna.vna_next;
2479 }
2480 while (ivna.vna_other != data [cnt + j]
2481 && ivna.vna_next != 0);
2482
2483 if (ivna.vna_other == data [cnt + j])
2484 {
2485 ivna.vna_name = BYTE_GET (evna.vna_name);
2486
2487 nn += printf ("(%s%-*s",
2488 strtab + ivna.vna_name,
2489 12 - strlen (strtab
2490 + ivna.vna_name),
2491 ")");
2492 break;
2493 }
2494
2495 offset += ivn.vn_next;
2496 }
2497 while (ivn.vn_next);
2498 }
2499 else if (data [cnt + j] != 0x8001)
2500 {
2501 Elf_Internal_Verdef ivd;
2502 Elf_External_Verdef evd;
2503 unsigned long offset;
2504
2505 offset = version_info
2506 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
2507
2508 do
2509 {
2510 GET_DATA (offset, evd, "version def");
2511
2512 ivd.vd_next = BYTE_GET (evd.vd_next);
2513 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
2514
2515 offset += ivd.vd_next;
2516 }
2517 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
2518 && ivd.vd_next != 0);
2519
2520 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
2521 {
2522 Elf_External_Verdaux evda;
2523 Elf_Internal_Verdaux ivda;
2524
2525 ivd.vd_aux = BYTE_GET (evd.vd_aux);
2526
2527 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
2528 evda, "version def aux");
2529
2530 ivda.vda_name = BYTE_GET (evda.vda_name);
2531
2532 nn += printf ("(%s%-*s",
2533 strtab + ivda.vda_name,
2534 12 - strlen (strtab
2535 + ivda.vda_name),
2536 ")");
2537 }
2538 }
2539
2540 if (nn < 18)
2541 printf ("%*c", 18 - nn, ' ');
2542 }
2543
2544 putchar ('\n');
2545 }
2546
2547 free (data);
2548 free (strtab);
2549 free (symbols);
2550 }
2551 break;
2552
2553 default:
2554 break;
2555 }
2556 }
2557
2558 if (! found)
2559 printf (_("\nNo version information found in this file.\n"));
2560
2561 return 1;
2562 }
2563
2564 static char *
2565 get_symbol_binding (binding)
2566 unsigned int binding;
2567 {
2568 static char buff [32];
2569
2570 switch (binding)
2571 {
2572 case STB_LOCAL: return _("LOCAL");
2573 case STB_GLOBAL: return _("GLOBAL");
2574 case STB_WEAK: return _("WEAK");
2575 default:
2576 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
2577 sprintf (buff, _("<processor specific>: %d"), binding);
2578 else
2579 sprintf (buff, _("<unknown>: %d"), binding);
2580 return buff;
2581 }
2582 }
2583
2584 static char *
2585 get_symbol_type (type)
2586 unsigned int type;
2587 {
2588 static char buff [32];
2589
2590 switch (type)
2591 {
2592 case STT_NOTYPE: return _("NOTYPE");
2593 case STT_OBJECT: return _("OBJECT");
2594 case STT_FUNC: return _("FUNC");
2595 case STT_SECTION: return _("SECTION");
2596 case STT_FILE: return _("FILE");
2597 default:
2598 if (type >= STT_LOPROC && type <= STT_HIPROC)
2599 sprintf (buff, _("<processor specific>: %d"), type);
2600 else
2601 sprintf (buff, _("<unknown>: %d"), type);
2602 return buff;
2603 }
2604 }
2605
2606 static char *
2607 get_symbol_index_type (type)
2608 unsigned int type;
2609 {
2610 switch (type)
2611 {
2612 case SHN_UNDEF: return "UND";
2613 case SHN_ABS: return "ABS";
2614 case SHN_COMMON: return "COM";
2615 default:
2616 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
2617 return "PRC";
2618 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
2619 return "RSV";
2620 else
2621 {
2622 static char buff [32];
2623
2624 sprintf (buff, "%3d", type);
2625 return buff;
2626 }
2627 }
2628 }
2629
2630
2631 static int *
2632 get_dynamic_data (file, number)
2633 FILE * file;
2634 unsigned int number;
2635 {
2636 char * e_data;
2637 int * i_data;
2638
2639 e_data = (char *) malloc (number * 4);
2640
2641 if (e_data == NULL)
2642 {
2643 error (_("Out of memory\n"));
2644 return NULL;
2645 }
2646
2647 if (fread (e_data, 4, number, file) != number)
2648 {
2649 error (_("Unable to read in dynamic data\n"));
2650 return NULL;
2651 }
2652
2653 i_data = (int *) malloc (number * sizeof (* i_data));
2654
2655 if (i_data == NULL)
2656 {
2657 error (_("Out of memory\n"));
2658 free (e_data);
2659 return NULL;
2660 }
2661
2662 while (number--)
2663 i_data [number] = byte_get (e_data + number * 4, 4);
2664
2665 free (e_data);
2666
2667 return i_data;
2668 }
2669
2670 /* Dump the symbol table */
2671 static int
2672 process_symbol_table (file)
2673 FILE * file;
2674 {
2675 Elf32_Internal_Shdr * section;
2676
2677 if (! do_syms)
2678 return 1;
2679
2680 if (dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
2681 {
2682 char nb [4];
2683 char nc [4];
2684 int nbuckets;
2685 int nchains;
2686 int * buckets;
2687 int * chains;
2688 int hn;
2689 int si;
2690
2691 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
2692 {
2693 error (_("Unable to seek to start of dynamic information"));
2694 return 0;
2695 }
2696
2697 if (fread (& nb, sizeof (nb), 1, file) != 1)
2698 {
2699 error (_("Failed to read in number of buckets\n"));
2700 return 0;
2701 }
2702
2703 if (fread (& nc, sizeof (nc), 1, file) != 1)
2704 {
2705 error (_("Failed to read in number of chains\n"));
2706 return 0;
2707 }
2708
2709 nbuckets = byte_get (nb, 4);
2710 nchains = byte_get (nc, 4);
2711
2712 buckets = get_dynamic_data (file, nbuckets);
2713 chains = get_dynamic_data (file, nchains);
2714
2715 if (buckets == NULL || chains == NULL)
2716 return 0;
2717
2718 printf (_("\nSymbol table for image:\n"));
2719 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
2720
2721 for (hn = 0; hn < nbuckets; hn++)
2722 {
2723 if (! buckets [hn])
2724 continue;
2725
2726 for (si = buckets [hn]; si; si = chains [si])
2727 {
2728 Elf_Internal_Sym * psym;
2729
2730 psym = dynamic_symbols + si;
2731
2732 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
2733 si, hn,
2734 (unsigned long) psym->st_value,
2735 (unsigned long) psym->st_size,
2736 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
2737 get_symbol_binding (ELF_ST_BIND (psym->st_info)),
2738 psym->st_other);
2739
2740 printf ("%3.3s", get_symbol_index_type (psym->st_shndx));
2741
2742 printf (" %s\n", dynamic_strings + psym->st_name);
2743 }
2744 }
2745
2746 free (buckets);
2747 free (chains);
2748 }
2749 else if (!do_using_dynamic)
2750 {
2751 unsigned int i;
2752
2753 for (i = 0, section = section_headers;
2754 i < elf_header.e_shnum;
2755 i++, section++)
2756 {
2757 unsigned int si;
2758 char * strtab;
2759 Elf_Internal_Sym * symtab;
2760 Elf_Internal_Sym * psym;
2761
2762
2763 if ( section->sh_type != SHT_SYMTAB
2764 && section->sh_type != SHT_DYNSYM)
2765 continue;
2766
2767 printf (_("\nSymbol table '%s' contains %d entries:\n"),
2768 SECTION_NAME (section),
2769 section->sh_size / section->sh_entsize);
2770 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
2771 stdout);
2772
2773 symtab = get_elf_symbols (file, section->sh_offset,
2774 section->sh_size / section->sh_entsize);
2775 if (symtab == NULL)
2776 continue;
2777
2778 if (section->sh_link == elf_header.e_shstrndx)
2779 strtab = string_table;
2780 else
2781 {
2782 Elf32_Internal_Shdr * string_sec;
2783
2784 string_sec = section_headers + section->sh_link;
2785
2786 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
2787 strtab, char *, "string table");
2788 }
2789
2790 for (si = 0, psym = symtab;
2791 si < section->sh_size / section->sh_entsize;
2792 si ++, psym ++)
2793 {
2794 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
2795 si,
2796 (unsigned long) psym->st_value,
2797 (unsigned long) psym->st_size,
2798 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
2799 get_symbol_binding (ELF_ST_BIND (psym->st_info)),
2800 psym->st_other);
2801
2802 if (psym->st_shndx == 0)
2803 fputs (" UND", stdout);
2804 else if ((psym->st_shndx & 0xffff) == 0xfff1)
2805 fputs (" ABS", stdout);
2806 else if ((psym->st_shndx & 0xffff) == 0xfff2)
2807 fputs (" COM", stdout);
2808 else
2809 printf ("%4x", psym->st_shndx);
2810
2811 printf (" %s", strtab + psym->st_name);
2812
2813 if (section->sh_type == SHT_DYNSYM &&
2814 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
2815 {
2816 unsigned char data[2];
2817 unsigned short vers_data;
2818 unsigned long offset;
2819 int is_nobits;
2820 int check_def;
2821
2822 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
2823 - loadaddr;
2824
2825 GET_DATA (offset + si * sizeof (vers_data), data,
2826 "version data");
2827
2828 vers_data = byte_get (data, 2);
2829
2830 is_nobits = psym->st_shndx < SHN_LORESERVE ?
2831 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
2832 : 0;
2833
2834 check_def = (psym->st_shndx != SHN_UNDEF);
2835
2836 if ((vers_data & 0x8000) || vers_data > 1)
2837 {
2838 if (is_nobits || ! check_def)
2839 {
2840 Elf_External_Verneed evn;
2841 Elf_Internal_Verneed ivn;
2842 Elf_Internal_Vernaux ivna;
2843
2844 /* We must test both. */
2845 offset = version_info
2846 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
2847
2848 GET_DATA (offset, evn, "version need");
2849
2850 ivn.vn_aux = BYTE_GET (evn.vn_aux);
2851 ivn.vn_next = BYTE_GET (evn.vn_next);
2852
2853 do
2854 {
2855 unsigned long vna_off;
2856
2857 vna_off = offset + ivn.vn_aux;
2858
2859 do
2860 {
2861 Elf_External_Vernaux evna;
2862
2863 GET_DATA (vna_off, evna,
2864 "version need aux (3)");
2865
2866 ivna.vna_other = BYTE_GET (evna.vna_other);
2867 ivna.vna_next = BYTE_GET (evna.vna_next);
2868 ivna.vna_name = BYTE_GET (evna.vna_name);
2869
2870 vna_off += ivna.vna_next;
2871 }
2872 while (ivna.vna_other != vers_data
2873 && ivna.vna_next != 0);
2874
2875 if (ivna.vna_other == vers_data)
2876 break;
2877
2878 offset += ivn.vn_next;
2879 }
2880 while (ivn.vn_next != 0);
2881
2882 if (ivna.vna_other == vers_data)
2883 {
2884 printf ("@%s (%d)",
2885 strtab + ivna.vna_name, ivna.vna_other);
2886 check_def = 0;
2887 }
2888 else if (! is_nobits)
2889 error (_("bad dynamic symbol"));
2890 else
2891 check_def = 1;
2892 }
2893
2894 if (check_def)
2895 {
2896 if (vers_data != 0x8001)
2897 {
2898 Elf_Internal_Verdef ivd;
2899 Elf_Internal_Verdaux ivda;
2900 Elf_External_Verdaux evda;
2901 unsigned long offset;
2902
2903 offset =
2904 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
2905 - loadaddr;
2906
2907 do
2908 {
2909 Elf_External_Verdef evd;
2910
2911 GET_DATA (offset, evd, "version def");
2912
2913 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
2914 ivd.vd_aux = BYTE_GET (evd.vd_aux);
2915 ivd.vd_next = BYTE_GET (evd.vd_next);
2916
2917 offset += ivd.vd_next;
2918 }
2919 while (ivd.vd_ndx != (vers_data & 0x7fff)
2920 && ivd.vd_next != 0);
2921
2922 offset -= ivd.vd_next;
2923 offset += ivd.vd_aux;
2924
2925 GET_DATA (offset, evda, "version def aux");
2926
2927 ivda.vda_name = BYTE_GET (evda.vda_name);
2928
2929 if (psym->st_name != ivda.vda_name)
2930 printf ((vers_data & 0x8000)
2931 ? "@%s" : "@@%s",
2932 strtab + ivda.vda_name);
2933 }
2934 }
2935 }
2936 }
2937
2938 putchar ('\n');
2939 }
2940
2941 free (symtab);
2942 if (strtab != string_table)
2943 free (strtab);
2944 }
2945 }
2946 else
2947 printf
2948 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
2949
2950 return 1;
2951 }
2952
2953 static int
2954 process_section_contents (file)
2955 FILE * file;
2956 {
2957 Elf32_Internal_Shdr * section;
2958 unsigned int i;
2959
2960 if (! do_dump)
2961 return 1;
2962
2963 for (i = 0, section = section_headers;
2964 i < elf_header.e_shnum;
2965 i ++, section ++)
2966 {
2967 #ifdef SUPPORT_DISASSEMBLY
2968 /* See if we need an assembly dump of this section */
2969
2970 if ((i < NUM_DUMP_SECTS) && (dump_sects[i] & DISASS_DUMP))
2971 {
2972 printf (_("\nAssembly dump of section %s\n"),
2973 SECTION_NAME (section));
2974
2975 /* XXX -- to be done --- XXX */
2976 }
2977 #endif
2978 /* See if we need a hex dump of this section. */
2979 if ((i < NUM_DUMP_SECTS) && (dump_sects[i] & HEX_DUMP))
2980 {
2981 int bytes;
2982 int addr;
2983 unsigned char * data;
2984 char * start;
2985
2986 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
2987
2988 bytes = section->sh_size;
2989 addr = section->sh_addr;
2990
2991 GET_DATA_ALLOC (section->sh_offset, bytes, start, char *,
2992 "section data");
2993
2994 data = start;
2995
2996 while (bytes)
2997 {
2998 int j;
2999 int k;
3000 int lbytes;
3001
3002 lbytes = (bytes > 16 ? 16 : bytes);
3003
3004 printf (" 0x%8.8x ", addr);
3005
3006 switch (elf_header.e_ident [EI_DATA])
3007 {
3008 case ELFDATA2LSB:
3009 for (j = 15; j >= 0; j --)
3010 {
3011 if (j < lbytes)
3012 printf ("%2.2x", data [j]);
3013 else
3014 printf (" ");
3015
3016 if (!(j & 0x3))
3017 printf (" ");
3018 }
3019 break;
3020
3021 case ELFDATA2MSB:
3022 for (j = 0; j < 16; j++)
3023 {
3024 if (j < lbytes)
3025 printf ("%2.2x", data [j]);
3026 else
3027 printf (" ");
3028
3029 if ((j & 3) == 3)
3030 printf (" ");
3031 }
3032 break;
3033 }
3034
3035 for (j = 0; j < lbytes; j++)
3036 {
3037 k = data [j];
3038 if (k >= ' ' && k < 0x80)
3039 printf ("%c", k);
3040 else
3041 printf (".");
3042 }
3043
3044 putchar ('\n');
3045
3046 data += lbytes;
3047 addr += lbytes;
3048 bytes -= lbytes;
3049 }
3050
3051 free (start);
3052 }
3053 }
3054
3055 return 1;
3056 }
3057
3058 static void
3059 process_mips_fpe_exception (mask)
3060 int mask;
3061 {
3062 if (mask)
3063 {
3064 int first = 1;
3065 if (mask & OEX_FPU_INEX)
3066 fputs ("INEX", stdout), first = 0;
3067 if (mask & OEX_FPU_UFLO)
3068 printf ("%sUFLO", first ? "" : "|"), first = 0;
3069 if (mask & OEX_FPU_OFLO)
3070 printf ("%sOFLO", first ? "" : "|"), first = 0;
3071 if (mask & OEX_FPU_DIV0)
3072 printf ("%sDIV0", first ? "" : "|"), first = 0;
3073 if (mask & OEX_FPU_INVAL)
3074 printf ("%sINVAL", first ? "" : "|");
3075 }
3076 else
3077 fputs ("0", stdout);
3078 }
3079
3080 static int
3081 process_mips_specific (file)
3082 FILE *file;
3083 {
3084 Elf_Internal_Dyn * entry;
3085 size_t liblist_offset = 0;
3086 size_t liblistno = 0;
3087 size_t options_offset = 0;
3088
3089 /* We have a lot of special sections. Thanks SGI! */
3090 if (dynamic_segment == NULL)
3091 /* No information available. */
3092 return 0;
3093
3094 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
3095 switch (entry->d_tag)
3096 {
3097 case DT_MIPS_LIBLIST:
3098 liblist_offset = entry->d_un.d_val - loadaddr;
3099 break;
3100 case DT_MIPS_LIBLISTNO:
3101 liblistno = entry->d_un.d_val;
3102 break;
3103 case DT_MIPS_OPTIONS:
3104 options_offset = entry->d_un.d_val - loadaddr;
3105 break;
3106 default:
3107 break;
3108 }
3109
3110 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
3111 {
3112 Elf32_External_Lib *elib;
3113 size_t cnt;
3114
3115 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
3116 elib, Elf32_External_Lib *, "liblist");
3117
3118 printf ("\nSection '.liblist' contains %d entries:\n", liblistno);
3119 fputs (" Library Time Stamp Checksum Version Flags\n",
3120 stdout);
3121
3122 for (cnt = 0; cnt < liblistno; ++cnt)
3123 {
3124 Elf32_Lib liblist;
3125 time_t time;
3126 char timebuf[17];
3127
3128 liblist.l_name = BYTE_GET (elib[cnt].l_name);
3129 time = BYTE_GET (elib[cnt].l_time_stamp);
3130 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
3131 liblist.l_version = BYTE_GET (elib[cnt].l_version);
3132 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
3133
3134 strftime (timebuf, 17, "%Y-%m-%dT%H:%M", gmtime (&time));
3135
3136 printf ("%3d: %-20s %s %#10lx %-7ld %#lx\n", cnt,
3137 dynamic_strings + liblist.l_name, timebuf,
3138 liblist.l_checksum, liblist.l_version, liblist.l_flags);
3139 }
3140
3141 free (elib);
3142 }
3143
3144 if (options_offset != 0)
3145 {
3146 Elf_External_Options *eopt;
3147 Elf_Internal_Shdr *sect = section_headers;
3148 Elf_Internal_Options *iopt;
3149 Elf_Internal_Options *option;
3150 size_t offset;
3151 int cnt;
3152
3153 /* Find the section header so that we get the size. */
3154 while (sect->sh_type != SHT_MIPS_OPTIONS)
3155 ++sect;
3156
3157 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
3158 Elf_External_Options *, "options");
3159
3160 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
3161 * sizeof (*iopt));
3162 if (iopt == NULL)
3163 {
3164 error (_("Out of memory"));
3165 return 0;
3166 }
3167
3168 offset = cnt = 0;
3169 option = iopt;
3170 while (offset < sect->sh_size)
3171 {
3172 Elf_External_Options *eoption;
3173
3174 eoption = (Elf_External_Options *) ((char *) eopt + offset);
3175
3176 option->kind = BYTE_GET (eoption->kind);
3177 option->size = BYTE_GET (eoption->size);
3178 option->section = BYTE_GET (eoption->section);
3179 option->info = BYTE_GET (eoption->info);
3180
3181 offset += option->size;
3182 ++option;
3183 ++cnt;
3184 }
3185
3186 printf (_("\nSection '%s' contains %d entries:\n"),
3187 string_table + sect->sh_name, cnt);
3188
3189 option = iopt;
3190 while (cnt-- > 0)
3191 {
3192 size_t len;
3193
3194 switch (option->kind)
3195 {
3196 case ODK_NULL:
3197 /* This shouldn't happen. */
3198 printf (" NULL %d %x", option->section, option->info);
3199 break;
3200 case ODK_REGINFO:
3201 printf (" REGINFO ");
3202 if (elf_header.e_machine == EM_MIPS)
3203 {
3204 /* 32bit form. */
3205 Elf32_External_RegInfo *ereg;
3206 Elf32_RegInfo reginfo;
3207
3208 ereg = (Elf32_External_RegInfo *) (option + 1);
3209 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
3210 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
3211 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
3212 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
3213 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
3214 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
3215
3216 printf ("GPR %08lx GP %ld\n",
3217 reginfo.ri_gprmask, reginfo.ri_gp_value);
3218 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3219 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
3220 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
3221 }
3222 else
3223 {
3224 /* 64 bit form. */
3225 Elf64_External_RegInfo *ereg;
3226 Elf64_Internal_RegInfo reginfo;
3227
3228 ereg = (Elf64_External_RegInfo *) (option + 1);
3229 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
3230 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
3231 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
3232 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
3233 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
3234 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
3235
3236 printf ("GPR %08lx GP %ld\n",
3237 reginfo.ri_gprmask, reginfo.ri_gp_value);
3238 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3239 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
3240 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
3241 }
3242 ++option;
3243 continue;
3244 case ODK_EXCEPTIONS:
3245 fputs (" EXCEPTIONS fpe_min(", stdout);
3246 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
3247 fputs (") fpe_max(", stdout);
3248 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
3249 fputs (")", stdout);
3250
3251 if (option->info & OEX_PAGE0)
3252 fputs (" PAGE0", stdout);
3253 if (option->info & OEX_SMM)
3254 fputs (" SMM", stdout);
3255 if (option->info & OEX_FPDBUG)
3256 fputs (" FPDBUG", stdout);
3257 if (option->info & OEX_DISMISS)
3258 fputs (" DISMISS", stdout);
3259 break;
3260 case ODK_PAD:
3261 fputs (" PAD ", stdout);
3262 if (option->info & OPAD_PREFIX)
3263 fputs (" PREFIX", stdout);
3264 if (option->info & OPAD_POSTFIX)
3265 fputs (" POSTFIX", stdout);
3266 if (option->info & OPAD_SYMBOL)
3267 fputs (" SYMBOL", stdout);
3268 break;
3269 case ODK_HWPATCH:
3270 fputs (" HWPATCH ", stdout);
3271 if (option->info & OHW_R4KEOP)
3272 fputs (" R4KEOP", stdout);
3273 if (option->info & OHW_R8KPFETCH)
3274 fputs (" R8KPFETCH", stdout);
3275 if (option->info & OHW_R5KEOP)
3276 fputs (" R5KEOP", stdout);
3277 if (option->info & OHW_R5KCVTL)
3278 fputs (" R5KCVTL", stdout);
3279 break;
3280 case ODK_FILL:
3281 fputs (" FILL ", stdout);
3282 /* XXX Print content of info word? */
3283 break;
3284 case ODK_TAGS:
3285 fputs (" TAGS ", stdout);
3286 /* XXX Print content of info word? */
3287 break;
3288 case ODK_HWAND:
3289 fputs (" HWAND ", stdout);
3290 if (option->info & OHWA0_R4KEOP_CHECKED)
3291 fputs (" R4KEOP_CHECKED", stdout);
3292 if (option->info & OHWA0_R4KEOP_CLEAN)
3293 fputs (" R4KEOP_CLEAN", stdout);
3294 break;
3295 case ODK_HWOR:
3296 fputs (" HWOR ", stdout);
3297 if (option->info & OHWA0_R4KEOP_CHECKED)
3298 fputs (" R4KEOP_CHECKED", stdout);
3299 if (option->info & OHWA0_R4KEOP_CLEAN)
3300 fputs (" R4KEOP_CLEAN", stdout);
3301 break;
3302 case ODK_GP_GROUP:
3303 printf (" GP_GROUP %#06x self-contained %#06x",
3304 option->info & OGP_GROUP,
3305 (option->info & OGP_SELF) >> 16);
3306 break;
3307 case ODK_IDENT:
3308 printf (" IDENT %#06x self-contained %#06x",
3309 option->info & OGP_GROUP,
3310 (option->info & OGP_SELF) >> 16);
3311 break;
3312 default:
3313 /* This shouldn't happen. */
3314 printf (" %3d ??? %d %x",
3315 option->kind, option->section, option->info);
3316 break;
3317 }
3318
3319 len = sizeof (*eopt);
3320 while (len < option->size)
3321 if (((char *) option)[len] >= ' '
3322 && ((char *) option)[len] < 0x7f)
3323 printf ("%c", ((char *) option)[len++]);
3324 else
3325 printf ("\\%03o", ((char *) option)[len++]);
3326
3327 fputs ("\n", stdout);
3328 ++option;
3329 }
3330
3331 free (eopt);
3332 }
3333
3334 return 1;
3335 }
3336
3337 static int
3338 process_arch_specific (file)
3339 FILE *file;
3340 {
3341 switch (elf_header.e_machine)
3342 {
3343 case EM_MIPS:
3344 case EM_MIPS_RS4_BE:
3345 return process_mips_specific (file);
3346 break;
3347 default:
3348 break;
3349 }
3350 return 1;
3351 }
3352
3353 static int
3354 get_file_header (file)
3355 FILE * file;
3356 {
3357 Elf32_External_Ehdr ehdr;
3358
3359 if (fread (& ehdr, sizeof (ehdr), 1, file) != 1)
3360 return 0;
3361
3362 memcpy (elf_header.e_ident, ehdr.e_ident, EI_NIDENT);
3363
3364 if (elf_header.e_ident [EI_DATA] == ELFDATA2LSB)
3365 byte_get = byte_get_little_endian;
3366 else
3367 byte_get = byte_get_big_endian;
3368
3369 elf_header.e_entry = BYTE_GET (ehdr.e_entry);
3370 elf_header.e_phoff = BYTE_GET (ehdr.e_phoff);
3371 elf_header.e_shoff = BYTE_GET (ehdr.e_shoff);
3372 elf_header.e_version = BYTE_GET (ehdr.e_version);
3373 elf_header.e_flags = BYTE_GET (ehdr.e_flags);
3374 elf_header.e_type = BYTE_GET (ehdr.e_type);
3375 elf_header.e_machine = BYTE_GET (ehdr.e_machine);
3376 elf_header.e_ehsize = BYTE_GET (ehdr.e_ehsize);
3377 elf_header.e_phentsize = BYTE_GET (ehdr.e_phentsize);
3378 elf_header.e_phnum = BYTE_GET (ehdr.e_phnum);
3379 elf_header.e_shentsize = BYTE_GET (ehdr.e_shentsize);
3380 elf_header.e_shnum = BYTE_GET (ehdr.e_shnum);
3381 elf_header.e_shstrndx = BYTE_GET (ehdr.e_shstrndx);
3382
3383 return 1;
3384 }
3385
3386 static void
3387 process_file (file_name)
3388 char * file_name;
3389 {
3390 FILE * file;
3391 struct stat statbuf;
3392 unsigned int i;
3393
3394 if (stat (file_name, & statbuf) < 0)
3395 {
3396 error (_("Cannot stat input file %s.\n"), file_name);
3397 return;
3398 }
3399
3400 file = fopen (file_name, "rb");
3401 if (file == NULL)
3402 {
3403 error (_("Input file %s not found.\n"), file_name);
3404 return;
3405 }
3406
3407 if (! get_file_header (file))
3408 {
3409 error (_("%s: Failed to read file header\n"), file_name);
3410 fclose (file);
3411 return;
3412 }
3413
3414 /* Initialise per file variables. */
3415 for (i = NUM_ELEM (version_info); i--;)
3416 version_info[i] = 0;
3417
3418 for (i = NUM_ELEM (dynamic_info); i--;)
3419 dynamic_info[i] = 0;
3420
3421 /* Process the file. */
3422 if (show_name)
3423 printf (_("\nFile: %s\n"), file_name);
3424
3425 if (! process_file_header ())
3426 {
3427 fclose (file);
3428 return;
3429 }
3430
3431 process_section_headers (file);
3432
3433 process_program_headers (file);
3434
3435 process_dynamic_segment (file);
3436
3437 process_relocs (file);
3438
3439 process_symbol_table (file);
3440
3441 process_version_sections (file);
3442
3443 process_section_contents (file);
3444
3445 process_arch_specific (file);
3446
3447 fclose (file);
3448
3449 if (section_headers)
3450 {
3451 free (section_headers);
3452 section_headers = NULL;
3453 }
3454
3455 if (string_table)
3456 {
3457 free (string_table);
3458 string_table = NULL;
3459 }
3460
3461 if (dynamic_strings)
3462 {
3463 free (dynamic_strings);
3464 dynamic_strings = NULL;
3465 }
3466
3467 if (dynamic_symbols)
3468 {
3469 free (dynamic_symbols);
3470 dynamic_symbols = NULL;
3471 }
3472 }
3473
3474 #ifdef SUPPORT_DISASSEMBLY
3475 /* Needed by the i386 disassembler. For extra credit, someone could
3476 fix this so that we insert symbolic addresses here, esp for GOT/PLT
3477 symbols */
3478
3479 void
3480 print_address (unsigned int addr, FILE * outfile)
3481 {
3482 fprintf (outfile,"0x%8.8x", addr);
3483 }
3484
3485 /* Needed by the i386 disassembler. */
3486 void
3487 db_task_printsym (unsigned int addr)
3488 {
3489 print_address (addr, stderr);
3490 }
3491 #endif
3492
3493 int
3494 main (argc, argv)
3495 int argc;
3496 char ** argv;
3497 {
3498 parse_args (argc, argv);
3499
3500 if (optind < (argc - 1))
3501 show_name = 1;
3502
3503 while (optind < argc)
3504 process_file (argv [optind ++]);
3505
3506 return 0;
3507 }