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