1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
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.
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.
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
31 #include "elf/common.h"
32 #include "elf/alpha.h"
35 /* start-sanitize-d30v */
37 /* end-sanitize-d30v */
42 #include "elf/mn10200.h"
43 #include "elf/mn10300.h"
46 #include "elf/sparc.h"
48 #include "elf/external.h"
49 #include "elf/internal.h"
54 #ifdef ANSI_PROTOTYPES
60 char * program_name
= "readelf";
61 unsigned int dynamic_addr
;
62 unsigned int dynamic_size
;
63 unsigned int rela_addr
;
64 unsigned int rela_size
;
65 char * dynamic_strings
;
67 Elf_Internal_Sym
* dynamic_symbols
;
68 char program_interpreter
[64];
69 int dynamic_info
[DT_JMPREL
+ 1];
70 int version_info
[16];
72 Elf_Internal_Ehdr elf_header
;
73 Elf_Internal_Shdr
* section_headers
;
74 Elf_Internal_Dyn
* dynamic_segment
;
86 static unsigned long int (* byte_get
) PARAMS ((unsigned char *, int));
88 #define NUM_DUMP_SECTS 100
89 char dump_sects
[NUM_DUMP_SECTS
];
94 /* Forward declarations for dumb compilers. */
95 static const char * get_mips_dynamic_type
PARAMS ((unsigned long type
));
96 static const char * get_dynamic_type
PARAMS ((unsigned long type
));
97 static const char * get_i386_rel_type
PARAMS ((unsigned long rtype
));
98 static const char * get_m68k_rel_type
PARAMS ((unsigned long rtype
));
99 static const char * get_sparc_rel_type
PARAMS ((unsigned long rtype
));
100 static const char * get_m32r_rel_type
PARAMS ((unsigned long rtype
));
101 static const char * get_v850_rel_type
PARAMS ((unsigned long rtype
));
102 static const char * get_d10v_rel_type
PARAMS ((unsigned long rtype
));
103 /* start-sanitize-d30v */
104 static const char * get_d30v_rel_type
PARAMS ((unsigned long rtype
));
105 /* end-sanitize-d30v */
106 static const char * get_sh_rel_type
PARAMS ((unsigned long rtype
));
107 static const char * get_mn10300_rel_type
PARAMS ((unsigned long rtype
));
108 static const char * get_mn10200_rel_type
PARAMS ((unsigned long rtype
));
109 static const char * get_ppc_rel_type
PARAMS ((unsigned long rtype
));
110 static const char * get_mips_rel_type
PARAMS ((unsigned long rtype
));
111 static const char * get_alpha_rel_type
PARAMS ((unsigned long rtype
));
112 static const char * get_arm_rel_type
PARAMS ((unsigned long rtype
));
113 static int dump_relocations
114 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, char *));
115 static char * get_file_type
PARAMS ((unsigned e_type
));
116 static char * get_machine_name
PARAMS ((unsigned e_machine
));
117 static char * get_machine_data
PARAMS ((unsigned e_data
));
118 static char * get_machine_flags
PARAMS ((unsigned, unsigned e_machine
));
119 static const char * get_mips_segment_type
PARAMS ((unsigned long type
));
120 static const char * get_segment_type
PARAMS ((unsigned long p_type
));
121 static const char * get_mips_section_type_name
PARAMS ((unsigned int sh_type
));
122 static const char * get_section_type_name
PARAMS ((unsigned int sh_type
));
123 static char * get_symbol_binding
PARAMS ((unsigned int binding
));
124 static char * get_symbol_type
PARAMS ((unsigned int type
));
125 static void usage
PARAMS ((void));
126 static void parse_args
PARAMS ((int argc
, char ** argv
));
127 static int process_file_header
PARAMS ((void));
128 static int process_program_headers
PARAMS ((FILE *));
129 static int process_section_headers
PARAMS ((FILE *));
130 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*entry
));
131 static int process_dynamic_segment
PARAMS ((FILE *));
132 static int process_symbol_table
PARAMS ((FILE *));
133 static int process_section_contents
PARAMS ((FILE *));
134 static void process_file
PARAMS ((char * file_name
));
135 static int process_relocs
PARAMS ((FILE *));
136 static int process_version_sections
PARAMS ((FILE *));
137 static char * get_ver_flags
PARAMS ((unsigned int flags
));
138 static char * get_symbol_index_type
PARAMS ((unsigned int type
));
139 static int get_section_headers
PARAMS ((FILE * file
));
140 static int get_file_header
PARAMS ((FILE * file
));
141 static Elf_Internal_Sym
* get_elf_symbols
142 PARAMS ((FILE * file
, unsigned long offset
, unsigned long number
));
143 static int * get_dynamic_data
PARAMS ((FILE * file
, unsigned int number
));
145 typedef int Elf32_Word
;
147 #define SECTION_NAME(X) (string_table + (X)->sh_name)
149 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
151 #define BYTE_GET(field) byte_get (field, sizeof (field))
153 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
155 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
156 if (fseek (file, offset, SEEK_SET)) \
158 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
162 var = (type) malloc (size); \
166 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
170 if (fread (var, size, 1, file) != 1) \
172 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
179 #define GET_DATA(offset, var, reason) \
180 if (fseek (file, offset, SEEK_SET)) \
182 error (_("Unable to seek to %x for %s\n"), offset, reason); \
185 else if (fread (& var, sizeof (var), 1, file) != 1) \
187 error (_("Unable to read data at %x for %s\n"), offset, reason); \
191 #ifdef ANSI_PROTOTYPES
193 error (const char * message
, ...)
197 fprintf (stderr
, _("%s: Error: "), program_name
);
198 va_start (args
, message
);
199 vfprintf (stderr
, message
, args
);
205 warn (const char * message
, ...)
209 fprintf (stderr
, _("%s: Warning: "), program_name
);
210 va_start (args
, message
);
211 vfprintf (stderr
, message
, args
);
223 fprintf (stderr
, _("%s: Error: "), program_name
);
225 message
= va_arg (args
, char *);
226 vfprintf (stderr
, message
, args
);
238 fprintf (stderr
, _("%s: Warning: "), program_name
);
240 message
= va_arg (args
, char *);
241 vfprintf (stderr
, message
, args
);
247 static unsigned long int
248 byte_get_little_endian (field
, size
)
249 unsigned char * field
;
258 return ((unsigned int) (field
[0]))
259 | (((unsigned int) (field
[1])) << 8);
262 return ((unsigned long) (field
[0]))
263 | (((unsigned long) (field
[1])) << 8)
264 | (((unsigned long) (field
[2])) << 16)
265 | (((unsigned long) (field
[3])) << 24);
268 error (_("Unhandled data length: %d\n"), size
);
273 static unsigned long int
274 byte_get_big_endian (field
, size
)
275 unsigned char * field
;
284 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
287 return ((unsigned long) (field
[3]))
288 | (((unsigned long) (field
[2])) << 8)
289 | (((unsigned long) (field
[1])) << 16)
290 | (((unsigned long) (field
[0])) << 24);
293 error (_("Unhandled data length: %d\n"), size
);
299 get_i386_rel_type (rtype
)
304 case R_386_NONE
: return "R_386_NONE";
305 case R_386_32
: return "R_386_32";
306 case R_386_PC32
: return "R_386_PC32";
307 case R_386_GOT32
: return "R_386_GOT32";
308 case R_386_PLT32
: return "R_386_PLT32";
309 case R_386_COPY
: return "R_386_COPY";
310 case R_386_GLOB_DAT
: return "R_386_GLOB_DAT";
311 case R_386_JMP_SLOT
: return "R_386_JMP_SLOT";
312 case R_386_RELATIVE
: return "R_386_RELATIVE";
313 case R_386_GOTOFF
: return "R_386_GOTOFF";
314 case R_386_GOTPC
: return "R_386_GOTPC";
315 case R_386_16
: return "R_386_16";
316 case R_386_PC16
: return "R_386_PC16";
317 case R_386_PC8
: return "R_386_PC8";
318 default: return _("*INVALID*");
323 get_m68k_rel_type (rtype
)
328 case R_68K_NONE
: return "R_68K_NONE";
329 case R_68K_32
: return "R_68K_32";
330 case R_68K_16
: return "R_68K_16";
331 case R_68K_8
: return "R_68K_8";
332 case R_68K_PC32
: return "R_68K_PC32";
333 case R_68K_PC16
: return "R_68K_PC16";
334 case R_68K_PC8
: return "R_68K_PC8";
335 case R_68K_GOT32
: return "R_68K_GOT32";
336 case R_68K_GOT16
: return "R_68K_GOT16";
337 case R_68K_GOT8
: return "R_68K_GOT8";
338 case R_68K_GOT32O
: return "R_68K_GOT32O";
339 case R_68K_GOT16O
: return "R_68K_GOT16O";
340 case R_68K_GOT8O
: return "R_68K_GOT8O";
341 case R_68K_PLT32
: return "R_68K_PLT32";
342 case R_68K_PLT16
: return "R_68K_PLT16";
343 case R_68K_PLT8
: return "R_68K_PLT8";
344 case R_68K_PLT32O
: return "R_68K_PLT32O";
345 case R_68K_PLT16O
: return "R_68K_PLT16O";
346 case R_68K_PLT8O
: return "R_68K_PLT8O";
347 case R_68K_COPY
: return "R_68K_COPY";
348 case R_68K_GLOB_DAT
: return "R_68K_GLOB_DAT";
349 case R_68K_JMP_SLOT
: return "R_68K_JMP_SLOT";
350 case R_68K_RELATIVE
: return "R_68K_RELATIVE";
351 default: return _("*INVALID*");
357 get_sparc_rel_type (rtype
)
362 case R_SPARC_NONE
: return "R_SPARC_NONE";
363 case R_SPARC_8
: return "R_SPARC_8";
364 case R_SPARC_16
: return "R_SPARC_16";
365 case R_SPARC_32
: return "R_SPARC_32";
366 case R_SPARC_DISP8
: return "R_SPARC_DISP8";
367 case R_SPARC_DISP16
: return "R_SPARC_DISP16";
368 case R_SPARC_DISP32
: return "R_SPARC_DISP32";
369 case R_SPARC_WDISP30
: return "R_SPARC_WDISP30";
370 case R_SPARC_WDISP22
: return "R_SPARC_WDISP22";
371 case R_SPARC_HI22
: return "R_SPARC_HI22";
372 case R_SPARC_22
: return "R_SPARC_22";
373 case R_SPARC_13
: return "R_SPARC_13";
374 case R_SPARC_LO10
: return "R_SPARC_LO10";
375 case R_SPARC_GOT10
: return "R_SPARC_GOT10";
376 case R_SPARC_GOT13
: return "R_SPARC_GOT13";
377 case R_SPARC_GOT22
: return "R_SPARC_GOT22";
378 case R_SPARC_PC10
: return "R_SPARC_PC10";
379 case R_SPARC_PC22
: return "R_SPARC_PC22";
380 case R_SPARC_WPLT30
: return "R_SPARC_WPLT30";
381 case R_SPARC_COPY
: return "R_SPARC_COPY";
382 case R_SPARC_GLOB_DAT
: return "R_SPARC_GLOB_DAT";
383 case R_SPARC_JMP_SLOT
: return "R_SPARC_JMP_SLOT";
384 case R_SPARC_RELATIVE
: return "R_SPARC_RELATIVE";
385 case R_SPARC_UA32
: return "R_SPARC_UA32";
386 case R_SPARC_10
: return "R_SPARC_10";
387 case R_SPARC_11
: return "R_SPARC_11";
388 case R_SPARC_64
: return "R_SPARC_64";
389 case R_SPARC_OLO10
: return "R_SPARC_OLO10";
390 case R_SPARC_HH22
: return "R_SPARC_HH22";
391 case R_SPARC_HM10
: return "R_SPARC_HM10";
392 case R_SPARC_LM22
: return "R_SPARC_LM22";
393 case R_SPARC_PC_HH22
: return "R_SPARC_PC_HH22";
394 case R_SPARC_PC_HM10
: return "R_SPARC_PC_HM10";
395 case R_SPARC_PC_LM22
: return "R_SPARC_PC_LM22";
396 case R_SPARC_WDISP16
: return "R_SPARC_WDISP16";
397 case R_SPARC_WDISP19
: return "R_SPARC_WDISP19";
398 case R_SPARC_UNUSED_42
: return "R_SPARC_UNUSED_42";
399 case R_SPARC_7
: return "R_SPARC_7";
400 case R_SPARC_5
: return "R_SPARC_5";
401 case R_SPARC_6
: return "R_SPARC_6";
402 case R_SPARC_DISP64
: return "R_SPARC_DISP64";
403 case R_SPARC_PLT64
: return "R_SPARC_PLT64";
404 case R_SPARC_HIX22
: return "R_SPARC_HIX22";
405 case R_SPARC_LOX10
: return "R_SPARC_LOX10";
406 case R_SPARC_H44
: return "R_SPARC_H44";
407 case R_SPARC_M44
: return "R_SPARC_M44";
408 case R_SPARC_L44
: return "R_SPARC_L44";
409 case R_SPARC_REGISTER
: return "R_SPARC_REGISTER";
410 case R_SPARC_UA64
: return "R_SPARC_UA64";
411 case R_SPARC_UA16
: return "R_SPARC_UA16";
412 default: return _("*INVALID*");
418 get_m32r_rel_type (rtype
)
423 case R_M32R_NONE
: return "R_M32R_NONE";
424 case R_M32R_16
: return "R_M32R_16";
425 case R_M32R_32
: return "R_M32R_32";
426 case R_M32R_24
: return "R_M32R_24";
427 case R_M32R_10_PCREL
: return "R_M32R_10_PCREL";
428 case R_M32R_18_PCREL
: return "R_M32R_18_PCREL";
429 case R_M32R_26_PCREL
: return "R_M32R_26_PCREL";
430 case R_M32R_HI16_ULO
: return "R_M32R_HI16_ULO";
431 case R_M32R_HI16_SLO
: return "R_M32R_HI16_SLO";
432 case R_M32R_LO16
: return "R_M32R_LO16";
433 case R_M32R_SDA16
: return "R_M32R_SDA16";
434 default: return _("*INVALID*");
440 get_v850_rel_type (rtype
)
445 case R_V850_NONE
: return "R_V850_NONE";
446 case R_V850_9_PCREL
: return "R_V850_9_PCREL";
447 case R_V850_22_PCREL
: return "R_V850_22_PCREL";
448 case R_V850_HI16_S
: return "R_V850_HI16_S";
449 case R_V850_HI16
: return "R_V850_HI16";
450 case R_V850_LO16
: return "R_V850_LO16";
451 case R_V850_32
: return "R_V850_32";
452 case R_V850_16
: return "R_V850_16";
453 case R_V850_8
: return "R_V850_8";
454 case R_V850_SDA_16_16_OFFSET
: return "R_V850_SDA_16_16_OFFSET";
455 case R_V850_SDA_15_16_OFFSET
: return "R_V850_SDA_15_16_OFFSET";
456 case R_V850_ZDA_16_16_OFFSET
: return "R_V850_ZDA_16_16_OFFSET";
457 case R_V850_ZDA_15_16_OFFSET
: return "R_V850_ZDA_15_16_OFFSET";
458 case R_V850_TDA_6_8_OFFSET
: return "R_V850_TDA_6_8_OFFSET";
459 case R_V850_TDA_7_8_OFFSET
: return "R_V850_TDA_7_8_OFFSET";
460 case R_V850_TDA_7_7_OFFSET
: return "R_V850_TDA_7_7_OFFSET";
461 case R_V850_TDA_16_16_OFFSET
: return "R_V850_TDA_16_16_OFFSET";
462 /* start-sanitize-v850e */
463 case R_V850_TDA_4_5_OFFSET
: return "R_V850_TDA_4_5_OFFSET";
464 case R_V850_TDA_4_4_OFFSET
: return "R_V850_TDA_4_4_OFFSET";
465 case R_V850_SDA_16_16_SPLIT_OFFSET
: return "R_V850_SDA_16_16_SPLIT_OFFSET";
466 case R_V850_ZDA_16_16_SPLIT_OFFSET
: return "R_V850_ZDA_16_16_SPLIT_OFFSET";
467 case R_V850_CALLT_6_7_OFFSET
: return "R_V850_CALLT_6_7_OFFSET";
468 case R_V850_CALLT_16_16_OFFSET
: return "R_V850_CALLT_16_16_OFFSET";
469 /* end-sanitize-v850e */
470 default: return _("*INVALID*");
476 get_d10v_rel_type (rtype
)
481 case R_D10V_NONE
: return "R_D10V_NONE";
482 case R_D10V_10_PCREL_R
: return "R_D10V_10_PCREL_R";
483 case R_D10V_10_PCREL_L
: return "R_D10V_10_PCREL_L";
484 case R_D10V_16
: return "R_D10V_16";
485 case R_D10V_18
: return "R_D10V_18";
486 case R_D10V_18_PCREL
: return "R_D10V_18_PCREL";
487 case R_D10V_32
: return "R_D10V_32";
488 default: return _("*INVALID*");
492 /* start-sanitize-d30v */
494 get_d30v_rel_type (rtype
)
499 case R_D30V_NONE
: return "R_D30V_NONE";
500 case R_D30V_6
: return "R_D30V_6";
501 case R_D30V_9_PCREL
: return "R_D30V_9_PCREL";
502 case R_D30V_9_PCREL_R
: return "R_D30V_9_PCREL_R";
503 case R_D30V_15
: return "R_D30V_15";
504 case R_D30V_15_PCREL
: return "R_D30V_15_PCREL";
505 case R_D30V_15_PCREL_R
: return "R_D30V_15_PCREL_R";
506 case R_D30V_21
: return "R_D30V_21";
507 case R_D30V_21_PCREL
: return "R_D30V_21_PCREL";
508 case R_D30V_21_PCREL_R
: return "R_D30V_21_PCREL_R";
509 case R_D30V_32
: return "R_D30V_32";
510 case R_D30V_32_PCREL
: return "R_D30V_32_PCREL";
511 case R_D30V_32_NORMAL
: return "R_D30V_32_NORMAL";
512 default: return _("*INVALID*");
516 /* end-sanitize-d30v */
518 get_sh_rel_type (rtype
)
523 case R_SH_NONE
: return "R_SH_NONE";
524 case R_SH_DIR32
: return "R_SH_DIR32";
525 case R_SH_REL32
: return "R_SH_REL32";
526 case R_SH_DIR8WPN
: return "R_SH_DIR8WPN";
527 case R_SH_IND12W
: return "R_SH_IND12W";
528 case R_SH_DIR8WPL
: return "R_SH_DIR8WPL";
529 case R_SH_DIR8WPZ
: return "R_SH_DIR8WPZ";
530 case R_SH_DIR8BP
: return "R_SH_DIR8BP";
531 case R_SH_DIR8W
: return "R_SH_DIR8W";
532 case R_SH_DIR8L
: return "R_SH_DIR8L";
533 case R_SH_SWITCH16
: return "R_SH_SWITCH16";
534 case R_SH_SWITCH32
: return "R_SH_SWITCH32";
535 case R_SH_USES
: return "R_SH_USES";
536 case R_SH_COUNT
: return "R_SH_COUNT";
537 case R_SH_ALIGN
: return "R_SH_ALIGN";
538 case R_SH_CODE
: return "R_SH_CODE";
539 case R_SH_DATA
: return "R_SH_DATA";
540 case R_SH_LABEL
: return "R_SH_LABEL";
541 default: return _("*INVALID*");
547 get_mn10300_rel_type (rtype
)
552 case R_MN10300_NONE
: return "R_MN10300_NONE";
553 case R_MN10300_32
: return "R_MN10300_32";
554 case R_MN10300_16
: return "R_MN10300_16";
555 case R_MN10300_8
: return "R_MN10300_8";
556 case R_MN10300_PCREL32
: return "R_MN10300_PCREL32";
557 case R_MN10300_PCREL16
: return "R_MN10300_PCREL16";
558 case R_MN10300_PCREL8
: return "R_MN10300_PCREL8";
559 default: return _("*INVALID*");
565 get_mn10200_rel_type (rtype
)
570 case R_MN10200_NONE
: return "R_MN10200_NONE";
571 case R_MN10200_32
: return "R_MN10200_32";
572 case R_MN10200_16
: return "R_MN10200_16";
573 case R_MN10200_8
: return "R_MN10200_8";
574 case R_MN10200_24
: return "R_MN10200_24";
575 case R_MN10200_PCREL8
: return "R_MN10200_PCREL8";
576 case R_MN10200_PCREL16
: return "R_MN10200_PCREL16";
577 case R_MN10200_PCREL24
: return "R_MN10200_PCREL24";
578 default: return _("*INVALID*");
584 get_ppc_rel_type (rtype
)
589 case R_PPC_NONE
: return "R_PPC_NONE";
590 case R_PPC_ADDR32
: return "R_PPC_ADDR32";
591 case R_PPC_ADDR24
: return "R_PPC_ADDR24";
592 case R_PPC_ADDR16
: return "R_PPC_ADDR16";
593 case R_PPC_ADDR16_LO
: return "R_PPC_ADDR16_LO";
594 case R_PPC_ADDR16_HI
: return "R_PPC_ADDR16_HI";
595 case R_PPC_ADDR16_HA
: return "R_PPC_ADDR16_HA";
596 case R_PPC_ADDR14
: return "R_PPC_ADDR14";
597 case R_PPC_ADDR14_BRTAKEN
: return "R_PPC_ADDR14_BRTAKEN";
598 case R_PPC_ADDR14_BRNTAKEN
: return "R_PPC_ADDR14_BRNTAKEN";
599 case R_PPC_REL24
: return "R_PPC_REL24";
600 case R_PPC_REL14
: return "R_PPC_REL14";
601 case R_PPC_REL14_BRTAKEN
: return "R_PPC_REL14_BRTAKEN";
602 case R_PPC_REL14_BRNTAKEN
: return "R_PPC_REL14_BRNTAKEN";
603 case R_PPC_GOT16
: return "R_PPC_GOT16";
604 case R_PPC_GOT16_LO
: return "R_PPC_GOT16_LO";
605 case R_PPC_GOT16_HI
: return "R_PPC_GOT16_HI";
606 case R_PPC_GOT16_HA
: return "R_PPC_GOT16_HA";
607 case R_PPC_PLTREL24
: return "R_PPC_PLTREL24";
608 case R_PPC_COPY
: return "R_PPC_COPY";
609 case R_PPC_GLOB_DAT
: return "R_PPC_GLOB_DAT";
610 case R_PPC_JMP_SLOT
: return "R_PPC_JMP_SLOT";
611 case R_PPC_RELATIVE
: return "R_PPC_RELATIVE";
612 case R_PPC_LOCAL24PC
: return "R_PPC_LOCAL24PC";
613 case R_PPC_UADDR32
: return "R_PPC_UADDR32";
614 case R_PPC_UADDR16
: return "R_PPC_UADDR16";
615 case R_PPC_REL32
: return "R_PPC_REL32";
616 case R_PPC_PLT32
: return "R_PPC_PLT32";
617 case R_PPC_PLTREL32
: return "R_PPC_PLTREL32";
618 case R_PPC_PLT16_LO
: return "R_PPC_PLT16_LO";
619 case R_PPC_PLT16_HI
: return "R_PPC_PLT16_HI";
620 case R_PPC_PLT16_HA
: return "R_PPC_PLT16_HA";
621 case R_PPC_SDAREL16
: return "R_PPC_SDAREL16";
622 case R_PPC_SECTOFF
: return "R_PPC_SECTOFF";
623 case R_PPC_SECTOFF_LO
: return "R_PPC_SECTOFF_LO";
624 case R_PPC_SECTOFF_HI
: return "R_PPC_SECTOFF_HI";
625 case R_PPC_SECTOFF_HA
: return "R_PPC_SECTOFF_HA";
626 case R_PPC_EMB_NADDR32
: return "R_PPC_EMB_NADDR32";
627 case R_PPC_EMB_NADDR16
: return "R_PPC_EMB_NADDR16";
628 case R_PPC_EMB_NADDR16_LO
: return "R_PPC_EMB_NADDR16_LO";
629 case R_PPC_EMB_NADDR16_HI
: return "R_PPC_EMB_NADDR16_HI";
630 case R_PPC_EMB_NADDR16_HA
: return "R_PPC_EMB_NADDR16_HA";
631 case R_PPC_EMB_SDAI16
: return "R_PPC_EMB_SDAI16";
632 case R_PPC_EMB_SDA2I16
: return "R_PPC_EMB_SDA2I16";
633 case R_PPC_EMB_SDA2REL
: return "R_PPC_EMB_SDA2REL";
634 case R_PPC_EMB_SDA21
: return "R_PPC_EMB_SDA21";
635 case R_PPC_EMB_MRKREF
: return "R_PPC_EMB_MRKREF";
636 case R_PPC_EMB_RELSEC16
: return "R_PPC_EMB_RELSEC16";
637 case R_PPC_EMB_RELST_LO
: return "R_PPC_EMB_RELST_LO";
638 case R_PPC_EMB_RELST_HI
: return "R_PPC_EMB_RELST_HI";
639 case R_PPC_EMB_RELST_HA
: return "R_PPC_EMB_RELST_HA";
640 case R_PPC_EMB_BIT_FLD
: return "R_PPC_EMB_BIT_FLD";
641 case R_PPC_EMB_RELSDA
: return "R_PPC_EMB_RELSDA";
642 case R_PPC_TOC16
: return "R_PPC_TOC16";
643 default: return _("*INVALID*");
649 get_mips_rel_type (rtype
)
654 case R_MIPS_NONE
: return "R_MIPS_NONE";
655 case R_MIPS_16
: return "R_MIPS_16";
656 case R_MIPS_32
: return "R_MIPS_32";
657 case R_MIPS_REL32
: return "R_MIPS_REL32";
658 case R_MIPS_26
: return "R_MIPS_26";
659 case R_MIPS_HI16
: return "R_MIPS_HI16";
660 case R_MIPS_LO16
: return "R_MIPS_LO16";
661 case R_MIPS_GPREL16
: return "R_MIPS_GPREL16";
662 case R_MIPS_LITERAL
: return "R_MIPS_LITERAL";
663 case R_MIPS_GOT16
: return "R_MIPS_GOT16";
664 case R_MIPS_PC16
: return "R_MIPS_PC16";
665 case R_MIPS_CALL16
: return "R_MIPS_CALL16";
666 case R_MIPS_GPREL32
: return "R_MIPS_GPREL32";
667 default: return _("*INVALID*");
673 get_alpha_rel_type (rtype
)
678 case R_ALPHA_NONE
: return "R_ALPHA_NONE";
679 case R_ALPHA_REFLONG
: return "R_ALPHA_REFLONG";
680 case R_ALPHA_REFQUAD
: return "R_ALPHA_REFQUAD";
681 case R_ALPHA_GPREL32
: return "R_ALPHA_GPREL32";
682 case R_ALPHA_LITERAL
: return "R_ALPHA_LITERAL";
683 case R_ALPHA_LITUSE
: return "R_ALPHA_LITUSE";
684 case R_ALPHA_GPDISP
: return "R_ALPHA_GPDISP";
685 case R_ALPHA_BRADDR
: return "R_ALPHA_BRADDR";
686 case R_ALPHA_HINT
: return "R_ALPHA_HINT";
687 case R_ALPHA_SREL16
: return "R_ALPHA_SREL16";
688 case R_ALPHA_SREL32
: return "R_ALPHA_SREL32";
689 case R_ALPHA_SREL64
: return "R_ALPHA_SREL64";
690 case R_ALPHA_OP_PUSH
: return "R_ALPHA_OP_PUSH";
691 case R_ALPHA_OP_STORE
: return "R_ALPHA_OP_STORE";
692 case R_ALPHA_OP_PSUB
: return "R_ALPHA_OP_PSUB";
693 case R_ALPHA_OP_PRSHIFT
: return "R_ALPHA_OP_PRSHIFT";
694 case R_ALPHA_GPVALUE
: return "R_ALPHA_GPVALUE";
695 case R_ALPHA_GPRELHIGH
: return "R_ALPHA_GPRELHIGH";
696 case R_ALPHA_GPRELLOW
: return "R_ALPHA_GPRELLOW";
697 case R_ALPHA_IMMED_GP_16
: return "R_ALPHA_IMMED_GP_16";
698 case R_ALPHA_IMMED_GP_HI32
: return "R_ALPHA_IMMED_GP_HI32";
699 case R_ALPHA_IMMED_SCN_HI32
: return "R_ALPHA_IMMED_SCN_HI32";
700 case R_ALPHA_IMMED_BR_HI32
: return "R_ALPHA_IMMED_BR_HI32";
701 case R_ALPHA_IMMED_LO32
: return "R_ALPHA_IMMED_LO32";
702 case R_ALPHA_COPY
: return "R_ALPHA_COPY";
703 case R_ALPHA_GLOB_DAT
: return "R_ALPHA_GLOB_DAT";
704 case R_ALPHA_JMP_SLOT
: return "R_ALPHA_JMP_SLOT";
705 case R_ALPHA_RELATIVE
: return "R_ALPHA_RELATIVE";
706 default: return _("*INVALID*");
712 get_arm_rel_type (rtype
)
717 case R_ARM_NONE
: return "R_ARM_NONE";
718 case R_ARM_PC24
: return "R_ARM_PC24";
719 case R_ARM_ABS32
: return "R_ARM_ABS32";
720 case R_ARM_REL32
: return "R_ARM_REL32";
721 case R_ARM_COPY
: return "R_ARM_COPY";
722 case R_ARM_GLOB_DAT
: return "R_ARM_GLOB_DAT";
723 case R_ARM_JUMP_SLOT
: return "R_ARM_JUMP_SLOT";
724 case R_ARM_RELATIVE
: return "R_ARM_RELATIVE";
725 case R_ARM_GOTOFF
: return "R_ARM_GOTOFF";
726 case R_ARM_GOTPC
: return "R_ARM_GOTPC";
727 case R_ARM_GOT32
: return "R_ARM_GOT32";
728 case R_ARM_PLT32
: return "R_ARM_PLT32";
729 default: return _("*INVALID*");
734 /* Display the contents of the relocation data
735 found at the specified offset. */
737 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
)
739 unsigned long rel_offset
;
740 unsigned long rel_size
;
741 Elf_Internal_Sym
* symtab
;
746 Elf_Internal_Rel
* rels
;
747 Elf_Internal_Rela
* relas
;
750 /* Compute number of relocations and read them in. */
751 switch (elf_header
.e_machine
)
761 Elf32_External_Rel
* erels
;
763 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
764 Elf32_External_Rel
*, "relocs");
766 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
768 rels
= (Elf_Internal_Rel
*) malloc (rel_size
*
769 sizeof (Elf_Internal_Rel
));
771 for (i
= 0; i
< rel_size
; i
++)
773 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
774 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
780 relas
= (Elf_Internal_Rela
*) rels
;
788 /* start-sanitize-d30v */
790 /* end-sanitize-d30v */
791 case EM_CYGNUS_MN10200
:
792 case EM_CYGNUS_MN10300
:
796 Elf32_External_Rela
* erelas
;
798 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
799 Elf32_External_Rela
*, "relocs");
801 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
803 relas
= (Elf_Internal_Rela
*) malloc (rel_size
*
804 sizeof (Elf_Internal_Rela
));
806 for (i
= 0; i
< rel_size
; i
++)
808 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
809 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
810 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
816 rels
= (Elf_Internal_Rel
*) relas
;
821 warn (_("Don't know about relocations on this machine architecture\n"));
827 (_(" Offset Value Type Symbol's Value Symbol's Name Addend\n"));
830 (_(" Offset Value Type Symbol's Value Symbol's Name\n"));
832 for (i
= 0; i
< rel_size
; i
++)
835 unsigned long offset
;
841 offset
= relas
[i
].r_offset
;
842 info
= relas
[i
].r_info
;
846 offset
= rels
[i
].r_offset
;
847 info
= rels
[i
].r_info
;
850 printf (" %8.8lx %5.5lx ", offset
, info
);
852 switch (elf_header
.e_machine
)
859 rtype
= get_m32r_rel_type (ELF32_R_TYPE (info
));
864 rtype
= get_i386_rel_type (ELF32_R_TYPE (info
));
868 rtype
= get_m68k_rel_type (ELF32_R_TYPE (info
));
872 rtype
= get_sparc_rel_type (ELF32_R_TYPE (info
));
876 rtype
= get_v850_rel_type (ELF32_R_TYPE (info
));
880 rtype
= get_d10v_rel_type (ELF32_R_TYPE (info
));
883 /* start-sanitize-d30v */
885 rtype
= get_d30v_rel_type (ELF32_R_TYPE (info
));
888 /* end-sanitize-d30v */
890 rtype
= get_sh_rel_type (ELF32_R_TYPE (info
));
893 case EM_CYGNUS_MN10300
:
894 rtype
= get_mn10300_rel_type (ELF32_R_TYPE (info
));
897 case EM_CYGNUS_MN10200
:
898 rtype
= get_mn10200_rel_type (ELF32_R_TYPE (info
));
902 rtype
= get_ppc_rel_type (ELF32_R_TYPE (info
));
907 rtype
= get_mips_rel_type (ELF32_R_TYPE (info
));
911 rtype
= get_alpha_rel_type (ELF32_R_TYPE (info
));
915 rtype
= get_arm_rel_type (ELF32_R_TYPE (info
));
919 printf ("%-21.21s", rtype
);
921 symtab_index
= ELF32_R_SYM (info
);
923 if (symtab_index
&& symtab
!= NULL
)
925 Elf_Internal_Sym
* psym
;
927 psym
= symtab
+ symtab_index
;
929 printf (" %08lx ", (unsigned long) psym
->st_value
);
931 if (psym
->st_name
== 0)
933 SECTION_NAME (section_headers
+ psym
->st_shndx
));
934 else if (strtab
== NULL
)
935 printf (_("<string table index %3d>"), psym
->st_name
);
937 printf ("%-25.25s", strtab
+ psym
->st_name
);
940 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
952 get_mips_dynamic_type (type
)
957 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
958 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
959 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
960 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
961 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
962 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
963 case DT_MIPS_MSYM
: return "MIPS_MSYM";
964 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
965 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
966 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
967 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
968 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
969 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
970 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
971 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
972 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
973 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
974 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
975 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
976 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
977 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
978 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
979 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
980 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
981 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
982 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
983 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
984 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
985 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
986 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
987 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
988 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
989 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
990 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
991 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
992 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
993 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
994 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
995 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
996 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
997 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
998 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
999 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1006 get_dynamic_type (type
)
1009 static char buff
[32];
1013 case DT_NULL
: return _("NULL");
1014 case DT_NEEDED
: return _("NEEDED");
1015 case DT_PLTRELSZ
: return _("PLTRELSZ");
1016 case DT_PLTGOT
: return _("PLTGOT");
1017 case DT_HASH
: return _("HASH");
1018 case DT_STRTAB
: return _("STRTAB");
1019 case DT_SYMTAB
: return _("SYMTAB");
1020 case DT_RELA
: return _("RELA");
1021 case DT_RELASZ
: return _("RELASZ");
1022 case DT_RELAENT
: return _("RELAENT");
1023 case DT_STRSZ
: return _("STRSZ");
1024 case DT_SYMENT
: return _("SYMENT");
1025 case DT_INIT
: return _("INIT");
1026 case DT_FINI
: return _("FINI");
1027 case DT_SONAME
: return _("SONAME");
1028 case DT_RPATH
: return _("RPATH");
1029 case DT_SYMBOLIC
: return _("SYMBOLIC");
1030 case DT_REL
: return _("REL");
1031 case DT_RELSZ
: return _("RELSZ");
1032 case DT_RELENT
: return _("RELENT");
1033 case DT_PLTREL
: return _("PLTREL");
1034 case DT_DEBUG
: return _("DEBUG");
1035 case DT_TEXTREL
: return _("TEXTREL");
1036 case DT_JMPREL
: return _("JMPREL");
1037 case DT_VERDEF
: return _("VERDEF");
1038 case DT_VERDEFNUM
: return _("VERDEFNUM");
1039 case DT_VERNEED
: return _("VERNEED");
1040 case DT_VERNEEDNUM
: return _("VERNEEDNUM");
1041 case DT_VERSYM
: return _("VERSYN");
1042 case DT_AUXILIARY
: return _("AUXILARY");
1043 case DT_FILTER
: return _("FILTER");
1046 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1048 const char *result
= NULL
;
1049 switch (elf_header
.e_machine
)
1052 case EM_MIPS_RS4_BE
:
1053 result
= get_mips_dynamic_type (type
);
1059 sprintf (buff
, _("Processor Specific: (%x)"), type
);
1065 sprintf (buff
, _("<unknown>: %x"), type
);
1071 get_file_type (e_type
)
1074 static char buff
[32];
1078 case ET_NONE
: return _("NONE (None)");
1079 case ET_REL
: return _("REL (Relocatable file)");
1080 case ET_EXEC
: return _("EXEC (Executable file)");
1081 case ET_DYN
: return _("DYN (Shared object file)");
1082 case ET_CORE
: return _("CORE (Core file)");
1085 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1086 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1088 sprintf (buff
, _("<unknown>: %x"), e_type
);
1094 get_machine_name (e_machine
)
1097 static char buff
[32];
1101 case EM_NONE
: return _("None");
1102 case EM_M32
: return "WE32100";
1103 case EM_SPARC
: return "Sparc";
1104 case EM_386
: return "Intel 80386";
1105 case EM_68K
: return "MC68000";
1106 case EM_88K
: return "MC88000";
1107 case EM_486
: return "Intel 80486";
1108 case EM_860
: return "Intel 80860";
1109 case EM_MIPS
: return "MIPS R3000 big-endian";
1110 case EM_S370
: return "Amdahl";
1111 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1112 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1113 case EM_PARISC
: return "HPPA";
1114 case EM_PPC_OLD
: return "Power PC (old)";
1115 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1116 case EM_960
: return "Intel 90860";
1117 case EM_PPC
: return "PowerPC";
1118 case EM_V800
: return "NEC V800";
1119 case EM_FR20
: return "Fujitsu FR20";
1120 case EM_RH32
: return "TRW RH32";
1121 case EM_MMA
: return "Fujitsu MMA";
1122 case EM_ARM
: return "ARM";
1123 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1124 case EM_SH
: return "Hitachi SH";
1125 case EM_SPARCV9
: return "Sparc v9";
1126 case EM_ALPHA
: return "Alpha";
1127 case EM_CYGNUS_D10V
: return "d10v";
1128 /* start-sanitize-d30v */
1129 case EM_CYGNUS_D30V
: return "d30v";
1130 /* end-sanitize-d30v */
1131 case EM_CYGNUS_M32R
: return "M32r";
1132 case EM_CYGNUS_V850
: return "v850";
1133 case EM_CYGNUS_MN10300
: return "mn10300";
1134 case EM_CYGNUS_MN10200
: return "mn10200";
1137 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1143 get_machine_flags (e_flags
, e_machine
)
1147 static char buf
[1024];
1158 if (e_flags
& EF_PPC_EMB
)
1159 strcat (buf
, ", emb");
1161 if (e_flags
& EF_PPC_RELOCATABLE
)
1162 strcat (buf
, ", relocatable");
1164 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1165 strcat (buf
, ", relocatable-lib");
1168 case EM_CYGNUS_M32R
:
1169 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1170 strcat (buf
, ", m32r");
1172 /* start-sanitize-m32rx */
1174 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
1175 strcat (buf
, ", m32rx");
1177 /* end-sanitize-m32rx */
1181 case EM_MIPS_RS4_BE
:
1182 if (e_flags
& EF_MIPS_NOREORDER
)
1183 strcat (buf
, ", noreorder");
1185 if (e_flags
& EF_MIPS_PIC
)
1186 strcat (buf
, ", pic");
1188 if (e_flags
& EF_MIPS_CPIC
)
1189 strcat (buf
, ", cpic");
1191 if (e_flags
& EF_MIPS_ABI2
)
1192 strcat (buf
, ", abi2");
1194 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1195 strcat (buf
, ", mips1");
1197 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1198 strcat (buf
, ", mips2");
1200 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1201 strcat (buf
, ", mips3");
1203 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1204 strcat (buf
, ", mips4");
1213 get_machine_data (e_data
)
1216 static char buff
[32];
1220 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
1221 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
1223 sprintf (buff
, _("<unknown>: %x"), e_data
);
1229 get_mips_segment_type (type
)
1234 case PT_MIPS_REGINFO
:
1236 case PT_MIPS_RTPROC
:
1238 case PT_MIPS_OPTIONS
:
1248 get_segment_type (p_type
)
1249 unsigned long p_type
;
1251 static char buff
[32];
1255 case PT_NULL
: return "NULL";
1256 case PT_LOAD
: return "LOAD";
1257 case PT_DYNAMIC
: return "DYNAMIC";
1258 case PT_INTERP
: return "INTERP";
1259 case PT_NOTE
: return "NOTE";
1260 case PT_SHLIB
: return "SHLIB";
1261 case PT_PHDR
: return "PHDR";
1264 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1267 switch (elf_header
.e_machine
)
1270 case EM_MIPS_RS4_BE
:
1271 result
= get_mips_segment_type (p_type
);
1279 sprintf (buff
, "LOPROC+%d", p_type
- PT_LOPROC
);
1286 sprintf (buff
, _("<unknown>: %x"), p_type
);
1293 get_mips_section_type_name (sh_type
)
1294 unsigned int sh_type
;
1298 case SHT_MIPS_LIBLIST
:
1299 return "MIPS_LIBLIST";
1302 case SHT_MIPS_CONFLICT
:
1303 return "MIPS_CONFLICT";
1304 case SHT_MIPS_GPTAB
:
1305 return "MIPS_GPTAB";
1306 case SHT_MIPS_UCODE
:
1307 return "MIPS_UCODE";
1308 case SHT_MIPS_DEBUG
:
1309 return "MIPS_DEBUG";
1310 case SHT_MIPS_REGINFO
:
1311 return "MIPS_REGINFO";
1312 case SHT_MIPS_PACKAGE
:
1313 return "MIPS_PACKAGE";
1314 case SHT_MIPS_PACKSYM
:
1315 return "MIPS_PACKSYM";
1318 case SHT_MIPS_IFACE
:
1319 return "MIPS_IFACE";
1320 case SHT_MIPS_CONTENT
:
1321 return "MIPS_CONTENT";
1322 case SHT_MIPS_OPTIONS
:
1323 return "MIPS_OPTIONS";
1326 case SHT_MIPS_FDESC
:
1327 return "MIPS_FDESC";
1328 case SHT_MIPS_EXTSYM
:
1329 return "MIPS_EXTSYM";
1330 case SHT_MIPS_DENSE
:
1331 return "MIPS_DENSE";
1332 case SHT_MIPS_PDESC
:
1333 return "MIPS_PDESC";
1334 case SHT_MIPS_LOCSYM
:
1335 return "MIPS_LOCSYM";
1336 case SHT_MIPS_AUXSYM
:
1337 return "MIPS_AUXSYM";
1338 case SHT_MIPS_OPTSYM
:
1339 return "MIPS_OPTSYM";
1340 case SHT_MIPS_LOCSTR
:
1341 return "MIPS_LOCSTR";
1344 case SHT_MIPS_RFDESC
:
1345 return "MIPS_RFDESC";
1346 case SHT_MIPS_DELTASYM
:
1347 return "MIPS_DELTASYM";
1348 case SHT_MIPS_DELTAINST
:
1349 return "MIPS_DELTAINST";
1350 case SHT_MIPS_DELTACLASS
:
1351 return "MIPS_DELTACLASS";
1352 case SHT_MIPS_DWARF
:
1353 return "MIPS_DWARF";
1354 case SHT_MIPS_DELTADECL
:
1355 return "MIPS_DELTADECL";
1356 case SHT_MIPS_SYMBOL_LIB
:
1357 return "MIPS_SYMBOL_LIB";
1358 case SHT_MIPS_EVENTS
:
1359 return "MIPS_EVENTS";
1360 case SHT_MIPS_TRANSLATE
:
1361 return "MIPS_TRANSLATE";
1362 case SHT_MIPS_PIXIE
:
1363 return "MIPS_PIXIE";
1364 case SHT_MIPS_XLATE
:
1365 return "MIPS_XLATE";
1366 case SHT_MIPS_XLATE_DEBUG
:
1367 return "MIPS_XLATE_DEBUG";
1368 case SHT_MIPS_WHIRL
:
1369 return "MIPS_WHIRL";
1370 case SHT_MIPS_EH_REGION
:
1371 return "MIPS_EH_REGION";
1372 case SHT_MIPS_XLATE_OLD
:
1373 return "MIPS_XLATE_OLD";
1374 case SHT_MIPS_PDR_EXCEPTION
:
1375 return "MIPS_PDR_EXCEPTION";
1383 get_section_type_name (sh_type
)
1384 unsigned int sh_type
;
1386 static char buff
[32];
1390 case SHT_NULL
: return "NULL";
1391 case SHT_PROGBITS
: return "PROGBITS";
1392 case SHT_SYMTAB
: return "SYMTAB";
1393 case SHT_STRTAB
: return "STRTAB";
1394 case SHT_RELA
: return "RELA";
1395 case SHT_HASH
: return "HASH";
1396 case SHT_DYNAMIC
: return "DYNAMIC";
1397 case SHT_NOTE
: return "NOTE";
1398 case SHT_NOBITS
: return "NOBITS";
1399 case SHT_REL
: return "REL";
1400 case SHT_SHLIB
: return "SHLIB";
1401 case SHT_DYNSYM
: return "DYNSYM";
1402 case SHT_GNU_verdef
: return "VERDEF";
1403 case SHT_GNU_verneed
: return "VERNEED";
1404 case SHT_GNU_versym
: return "VERSYM";
1405 case 0x6ffffff0: return "VERSYM";
1406 case 0x6ffffffc: return "VERDEF";
1407 case 0x7ffffffd: return "AUXILIARY";
1408 case 0x7fffffff: return "FILTER";
1411 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1415 switch (elf_header
.e_machine
)
1418 case EM_MIPS_RS4_BE
:
1419 result
= get_mips_section_type_name (sh_type
);
1428 sprintf (buff
, _("SHT_LOPROC+%d"), sh_type
- SHT_LOPROC
);
1433 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1434 sprintf (buff
, _("SHT_LOUSER+%d"), sh_type
- SHT_LOUSER
);
1436 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1441 struct option options
[] =
1443 {"all", no_argument
, 0, 'a'},
1444 {"file-header", no_argument
, 0, 'h'},
1445 {"program-headers", no_argument
, 0, 'l'},
1446 {"headers", no_argument
, 0, 'e'},
1447 {"segments", no_argument
, 0, 'l'},
1448 {"sections", no_argument
, 0, 'S'},
1449 {"section-headers", no_argument
, 0, 'S'},
1450 {"symbols", no_argument
, 0, 's'},
1451 {"relocs", no_argument
, 0, 'r'},
1452 {"dynamic", no_argument
, 0, 'd'},
1453 {"version-info", no_argument
, 0, 'V'},
1454 {"use-dynamic", no_argument
, 0, 'D'},
1456 {"hex-dump", required_argument
, 0, 'x'},
1457 #ifdef SUPPORT_DISASSEMBLY
1458 {"instruction-dump", required_argument
, 0, 'i'},
1461 {"version", no_argument
, 0, 'v'},
1462 {"help", no_argument
, 0, 'H'},
1464 {0, no_argument
, 0, 0}
1470 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1471 fprintf (stdout
, _(" Options are:\n"));
1472 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V\n"));
1473 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1474 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1475 fprintf (stdout
, _(" Display the program headers\n"));
1476 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1477 fprintf (stdout
, _(" Display the sections' header\n"));
1478 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1479 fprintf (stdout
, _(" -s or --symbols Display the symbol table\n"));
1480 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1481 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1482 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1483 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1484 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1485 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1486 #ifdef SUPPORT_DISASSEMBLY
1487 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1488 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1490 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1491 fprintf (stdout
, _(" -H or --help Display this information\n"));
1492 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1498 parse_args (argc
, argv
)
1507 while ((c
= getopt_long
1508 (argc
, argv
, "ersahldSDx:i:vV", options
, NULL
)) != EOF
)
1534 do_using_dynamic
++;
1556 section
= strtoul (optarg
, & cp
, 0);
1557 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1559 dump_sects
[section
] |= HEX_DUMP
;
1563 #ifdef SUPPORT_DISASSEMBLY
1566 section
= strtoul (optarg
, & cp
, 0);
1567 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1569 dump_sects
[section
] |= DISASS_DUMP
;
1575 print_version (program_name
);
1582 /* xgettext:c-format */
1583 error (_("Invalid option '-%c'\n"), c
);
1590 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1591 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
)
1595 warn (_("Nothing to do.\n"));
1600 /* Decode the data held in 'elf_header'. */
1602 process_file_header ()
1604 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1605 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1606 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1607 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1610 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1614 if (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS32
)
1616 error (_("Not a 32 bit ELF file\n"));
1624 printf (_("ELF Header:\n"));
1625 printf (_(" Magic: "));
1626 for (i
= 0; i
< EI_NIDENT
; i
++)
1627 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1629 printf (_(" Type: %s\n"),
1630 get_file_type (elf_header
.e_type
));
1631 printf (_(" Machine: %s\n"),
1632 get_machine_name (elf_header
.e_machine
));
1633 printf (_(" Version: 0x%lx\n"),
1634 (unsigned long) elf_header
.e_version
);
1635 printf (_(" Data: %s\n"),
1636 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1637 printf (_(" Entry point address: 0x%lx\n"),
1638 (unsigned long) elf_header
.e_entry
);
1639 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1640 (long) elf_header
.e_phoff
);
1641 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1642 (long) elf_header
.e_shoff
);
1643 printf (_(" Flags: 0x%lx%s\n"),
1644 (unsigned long) elf_header
.e_flags
,
1645 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1646 printf (_(" Size of this header: %ld (bytes)\n"),
1647 (long) elf_header
.e_ehsize
);
1648 printf (_(" Size of program headers: %ld (bytes)\n"),
1649 (long) elf_header
.e_phentsize
);
1650 printf (_(" Number of program headers: %ld\n"),
1651 (long) elf_header
.e_phnum
);
1652 printf (_(" Size of section headers: %ld (bytes)\n"),
1653 (long) elf_header
.e_shentsize
);
1654 printf (_(" Number of section headers: %ld\n"),
1655 (long) elf_header
.e_shnum
);
1656 printf (_(" Section header string table index: %ld\n"),
1657 (long) elf_header
.e_shstrndx
);
1665 process_program_headers (file
)
1668 Elf32_External_Phdr
* phdrs
;
1669 Elf32_Internal_Phdr
* program_headers
;
1670 Elf32_Internal_Phdr
* segment
;
1673 if (elf_header
.e_phnum
== 0)
1676 printf (_("\nThere are no program headers in this file.\n"));
1680 if (do_segments
&& !do_header
)
1682 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1683 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1684 printf (_("There are %d program headers, starting at offset %lx:\n"),
1685 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1688 GET_DATA_ALLOC (elf_header
.e_phoff
,
1689 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1690 phdrs
, Elf32_External_Phdr
*, "program headers");
1692 program_headers
= (Elf32_Internal_Phdr
*) malloc
1693 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1695 if (program_headers
== NULL
)
1697 error (_("Out of memory\n"));
1701 for (i
= 0, segment
= program_headers
;
1702 i
< elf_header
.e_phnum
;
1705 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1706 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1707 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1708 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1709 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1710 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1711 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1712 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1720 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1722 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1728 for (i
= 0, segment
= program_headers
;
1729 i
< elf_header
.e_phnum
;
1734 printf (" %-11.11s ", get_segment_type (segment
->p_type
));
1735 printf ("0x%5.5lx ", (unsigned long) segment
->p_offset
);
1736 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1737 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1738 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1739 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1741 (segment
->p_flags
& PF_R
? 'R' : ' '),
1742 (segment
->p_flags
& PF_W
? 'W' : ' '),
1743 (segment
->p_flags
& PF_X
? 'E' : ' '));
1744 printf ("%#lx", (unsigned long) segment
->p_align
);
1747 switch (segment
->p_type
)
1751 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1752 - (segment
->p_offset
& 0xfffff000);
1757 error (_("more than one dynamic segment\n"));
1759 dynamic_addr
= segment
->p_offset
;
1760 dynamic_size
= segment
->p_filesz
;
1764 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1765 error (_("Unable to find program interpreter name\n"));
1768 program_interpreter
[0] = 0;
1769 fscanf (file
, "%63s", program_interpreter
);
1772 printf (_("\n [Requesting program interpreter: %s]"),
1773 program_interpreter
);
1779 putc ('\n', stdout
);
1788 if (do_segments
&& section_headers
!= NULL
)
1790 printf (_("\n Section to Segment mapping:\n"));
1791 printf (_(" Segment Sections...\n"));
1793 assert (string_table
!= NULL
);
1795 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1798 Elf32_Internal_Shdr
* section
;
1800 segment
= program_headers
+ i
;
1801 section
= section_headers
;
1803 printf (" %2.2d ", i
);
1805 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1807 if (section
->sh_size
> 0
1808 /* Compare allocated sections by VMA, unallocated
1809 sections by file offset. */
1810 && (section
->sh_flags
& SHF_ALLOC
1811 ? (section
->sh_addr
>= segment
->p_vaddr
1812 && section
->sh_addr
+ section
->sh_size
1813 <= segment
->p_vaddr
+ segment
->p_memsz
)
1814 : (section
->sh_offset
>= segment
->p_offset
1815 && (section
->sh_offset
+ section
->sh_size
1816 <= segment
->p_offset
+ segment
->p_filesz
))))
1817 printf ("%s ", SECTION_NAME (section
));
1824 free (program_headers
);
1831 get_section_headers (file
)
1834 Elf32_External_Shdr
* shdrs
;
1835 Elf32_Internal_Shdr
* internal
;
1838 GET_DATA_ALLOC (elf_header
.e_shoff
,
1839 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1840 shdrs
, Elf32_External_Shdr
*, "section headers");
1842 section_headers
= (Elf32_Internal_Shdr
*) malloc
1843 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1845 if (section_headers
== NULL
)
1847 error (_("Out of memory\n"));
1851 for (i
= 0, internal
= section_headers
;
1852 i
< elf_header
.e_shnum
;
1855 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1856 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1857 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1858 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1859 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1860 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1861 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1862 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1863 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1864 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1872 static Elf_Internal_Sym
*
1873 get_elf_symbols (file
, offset
, number
)
1875 unsigned long offset
;
1876 unsigned long number
;
1878 Elf32_External_Sym
* esyms
;
1879 Elf_Internal_Sym
* isyms
;
1880 Elf_Internal_Sym
* psym
;
1883 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1884 esyms
, Elf32_External_Sym
*, "symbols");
1886 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1890 error (_("Out of memory\n"));
1896 for (j
= 0, psym
= isyms
;
1900 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1901 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1902 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1903 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1904 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1905 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1914 process_section_headers (file
)
1917 Elf32_Internal_Shdr
* section
;
1920 section_headers
= NULL
;
1922 if (elf_header
.e_shnum
== 0)
1925 printf (_("\nThere are no sections in this file.\n"));
1930 if (do_sections
&& !do_header
)
1931 printf (_("There are %d section headers, starting at offset %x:\n"),
1932 elf_header
.e_shnum
, elf_header
.e_shoff
);
1934 if (! get_section_headers (file
))
1937 /* Read in the string table, so that we have names to display. */
1938 section
= section_headers
+ elf_header
.e_shstrndx
;
1940 if (section
->sh_size
!= 0)
1942 unsigned long string_table_offset
;
1944 string_table_offset
= section
->sh_offset
;
1946 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1947 string_table
, char *, "string table");
1950 /* Scan the sections for the dynamic symbol table
1951 and dynamic string table. */
1952 dynamic_symbols
= NULL
;
1953 dynamic_strings
= NULL
;
1954 for (i
= 0, section
= section_headers
;
1955 i
< elf_header
.e_shnum
;
1958 if (section
->sh_type
== SHT_DYNSYM
)
1960 if (dynamic_symbols
!= NULL
)
1962 error (_("File contains multiple dynamic symbol tables\n"));
1966 dynamic_symbols
= get_elf_symbols
1967 (file
, section
->sh_offset
, section
->sh_size
/ section
->sh_entsize
);
1969 else if (section
->sh_type
== SHT_STRTAB
1970 && strcmp (SECTION_NAME (section
), ".dynstr") == 0)
1972 if (dynamic_strings
!= NULL
)
1974 error (_("File contains multiple dynamic string tables\n"));
1978 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1979 dynamic_strings
, char *, "dynamic strings");
1986 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1988 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1990 for (i
= 0, section
= section_headers
;
1991 i
< elf_header
.e_shnum
;
1994 printf (" [%2d] %-17.17s %-15.15s ",
1996 SECTION_NAME (section
),
1997 get_section_type_name (section
->sh_type
));
1999 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
2000 (unsigned long) section
->sh_addr
,
2001 (unsigned long) section
->sh_offset
,
2002 (unsigned long) section
->sh_size
,
2003 (unsigned long) section
->sh_entsize
);
2005 printf (" %c%c%c %2ld %3lx %ld \n",
2006 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
2007 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
2008 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
2009 (unsigned long) section
->sh_link
,
2010 (unsigned long) section
->sh_info
,
2011 (unsigned long) section
->sh_addralign
);
2017 /* Process the reloc section. */
2019 process_relocs (file
)
2022 unsigned long rel_size
;
2023 unsigned long rel_offset
;
2029 if (do_using_dynamic
)
2034 if (dynamic_info
[DT_REL
])
2036 rel_offset
= dynamic_info
[DT_REL
];
2037 rel_size
= dynamic_info
[DT_RELSZ
];
2039 else if (dynamic_info
[DT_RELA
])
2041 rel_offset
= dynamic_info
[DT_RELA
];
2042 rel_size
= dynamic_info
[DT_RELASZ
];
2044 else if (dynamic_info
[DT_JMPREL
])
2046 rel_offset
= dynamic_info
[DT_JMPREL
];
2047 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2053 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
2054 rel_offset
, rel_size
);
2056 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2057 dynamic_symbols
, dynamic_strings
);
2060 printf (_("\nThere are no dynamic relocations in this file.\n"));
2064 Elf32_Internal_Shdr
* section
;
2068 assert (string_table
!= NULL
);
2070 for (i
= 0, section
= section_headers
;
2071 i
< elf_header
.e_shnum
;
2074 if ( section
->sh_type
!= SHT_RELA
2075 && section
->sh_type
!= SHT_REL
)
2078 rel_offset
= section
->sh_offset
;
2079 rel_size
= section
->sh_size
;
2083 Elf32_Internal_Shdr
* strsec
;
2084 Elf32_Internal_Shdr
* symsec
;
2085 Elf_Internal_Sym
* symtab
;
2089 (_("\nRelocation section '%s' at offset 0x%x contains %d entries:\n"),
2090 SECTION_NAME (section
), rel_offset
,
2091 rel_size
/ section
->sh_entsize
);
2093 symsec
= section_headers
+ section
->sh_link
;
2095 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
2096 symsec
->sh_size
/ symsec
->sh_entsize
);
2101 strsec
= section_headers
+ symsec
->sh_link
;
2103 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2104 char *, "string table");
2106 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
);
2116 printf (_("\nThere are no relocations in this file.\n"));
2124 dynamic_segment_mips_val (entry
)
2125 Elf_Internal_Dyn
*entry
;
2127 switch (entry
->d_tag
)
2129 case DT_MIPS_LOCAL_GOTNO
:
2130 case DT_MIPS_CONFLICTNO
:
2131 case DT_MIPS_LIBLISTNO
:
2132 case DT_MIPS_SYMTABNO
:
2133 case DT_MIPS_UNREFEXTNO
:
2134 case DT_MIPS_HIPAGENO
:
2135 case DT_MIPS_DELTA_CLASS_NO
:
2136 case DT_MIPS_DELTA_INSTANCE_NO
:
2137 case DT_MIPS_DELTA_RELOC_NO
:
2138 case DT_MIPS_DELTA_SYM_NO
:
2139 case DT_MIPS_DELTA_CLASSSYM_NO
:
2141 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
2145 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2149 /* Parse the dynamic segment */
2151 process_dynamic_segment (file
)
2154 Elf_Internal_Dyn
* entry
;
2155 Elf32_External_Dyn
* edyn
;
2158 if (dynamic_size
== 0)
2161 printf (_("\nThere is no dynamic segment in this file.\n"));
2166 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2167 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2169 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2170 how large .dynamic is now. We can do this even before the byte
2171 swapping since the DT_NULL tag is recognizable. */
2173 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2176 dynamic_segment
= (Elf_Internal_Dyn
*)
2177 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2179 if (dynamic_segment
== NULL
)
2181 error (_("Out of memory\n"));
2186 for (i
= 0, entry
= dynamic_segment
;
2190 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2191 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2196 /* Find the appropriate symbol table. */
2197 if (dynamic_symbols
== NULL
)
2199 for (i
= 0, entry
= dynamic_segment
;
2203 unsigned long offset
;
2206 if (entry
->d_tag
!= DT_SYMTAB
)
2209 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
2211 /* Since we do not know how big the symbol table is,
2212 we default to reading in the entire file (!) and
2213 processing that. This is overkill, I know, but it
2216 offset
= entry
->d_un
.d_val
- loadaddr
;
2218 if (fseek (file
, 0, SEEK_END
))
2219 error (_("Unable to seek to end of file!"));
2221 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
2225 error (_("Unable to determine the number of symbols to load\n"));
2229 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
2233 /* Similarly find a string table. */
2234 if (dynamic_strings
== NULL
)
2236 for (i
= 0, entry
= dynamic_segment
;
2240 unsigned long offset
;
2243 if (entry
->d_tag
!= DT_STRTAB
)
2246 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
2248 /* Since we do not know how big the string table is,
2249 we default to reading in the entire file (!) and
2250 processing that. This is overkill, I know, but it
2253 offset
= entry
->d_un
.d_val
- loadaddr
;
2254 if (fseek (file
, 0, SEEK_END
))
2255 error (_("Unable to seek to end of file\n"));
2256 str_tab_len
= ftell (file
) - offset
;
2258 if (str_tab_len
< 1)
2261 (_("Unable to determine the length of the dynamic string table\n"));
2265 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
2266 "dynamic string table");
2272 if (do_dynamic
&& dynamic_addr
)
2273 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
2274 dynamic_addr
, dynamic_size
);
2276 printf (_(" Tag Type Name/Value\n"));
2278 for (i
= 0, entry
= dynamic_segment
;
2283 printf (_(" 0x%-8.8lx (%s)%*s"),
2284 (unsigned long) entry
->d_tag
,
2285 get_dynamic_type (entry
->d_tag
),
2286 27 - strlen (get_dynamic_type (entry
->d_tag
)),
2289 switch (entry
->d_tag
)
2295 if (entry
->d_tag
== DT_AUXILIARY
)
2296 printf (_("Auxiliary library"));
2298 printf (_("Filter library"));
2300 if (dynamic_strings
)
2301 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
2303 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2331 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2337 if (dynamic_strings
== NULL
)
2340 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2344 switch (entry
->d_tag
)
2347 printf (_("Shared library: [%s]"), name
);
2349 if (strcmp (name
, program_interpreter
))
2352 printf (_(" program interpreter\n"));
2356 printf (_("Library soname: [%s]\n"), name
);
2360 printf (_("Library rpath: [%s]\n"), name
);
2364 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2368 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2373 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2375 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2379 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2382 switch (elf_header
.e_machine
)
2385 case EM_MIPS_RS4_BE
:
2386 dynamic_segment_mips_val (entry
);
2390 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2400 get_ver_flags (flags
)
2403 static char buff
[32];
2410 if (flags
& VER_FLG_BASE
)
2411 strcat (buff
, "BASE ");
2413 if (flags
& VER_FLG_WEAK
)
2415 if (flags
& VER_FLG_BASE
)
2416 strcat (buff
, "| ");
2418 strcat (buff
, "WEAK ");
2421 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2422 strcat (buff
, "| <unknown>");
2427 /* Display the contents of the version sections. */
2429 process_version_sections (file
)
2432 Elf32_Internal_Shdr
* section
;
2439 for (i
= 0, section
= section_headers
;
2440 i
< elf_header
.e_shnum
;
2443 switch (section
->sh_type
)
2445 case SHT_GNU_verdef
:
2447 Elf_External_Verdef
* edefs
;
2454 (_("\nVersion definition section '%s' contains %d entries:\n"),
2455 SECTION_NAME (section
), section
->sh_info
);
2457 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2458 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2459 SECTION_NAME (section_headers
+ section
->sh_link
));
2461 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2462 edefs
, Elf_External_Verdef
*,
2463 "version definition section");
2465 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2468 Elf_External_Verdef
* edef
;
2469 Elf_Internal_Verdef ent
;
2470 Elf_External_Verdaux
* eaux
;
2471 Elf_Internal_Verdaux aux
;
2475 vstart
= ((char *) edefs
) + idx
;
2477 edef
= (Elf_External_Verdef
*) vstart
;
2479 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2480 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2481 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2482 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2483 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2484 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2485 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2487 printf (_(" %#06x: Rev: %d Flags: %s"),
2488 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2490 printf (_(" Index: %ld Cnt: %ld "), ent
.vd_ndx
, ent
.vd_cnt
);
2492 vstart
+= ent
.vd_aux
;
2494 eaux
= (Elf_External_Verdaux
*) vstart
;
2496 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2497 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2499 if (dynamic_strings
)
2500 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2502 printf (_("Name index: %ld\n"), aux
.vda_name
);
2504 isum
= idx
+ ent
.vd_aux
;
2506 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2508 isum
+= aux
.vda_next
;
2509 vstart
+= aux
.vda_next
;
2511 eaux
= (Elf_External_Verdaux
*) vstart
;
2513 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2514 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2516 if (dynamic_strings
)
2517 printf (_(" %#06x: Parent %d: %s\n"),
2518 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2520 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2521 isum
, j
, aux
.vda_name
);
2531 case SHT_GNU_verneed
:
2533 Elf_External_Verneed
* eneed
;
2539 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2540 SECTION_NAME (section
), section
->sh_info
);
2543 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2544 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2545 SECTION_NAME (section_headers
+ section
->sh_link
));
2547 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2548 eneed
, Elf_External_Verneed
*,
2549 "version need section");
2551 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2553 Elf_External_Verneed
* entry
;
2554 Elf_Internal_Verneed ent
;
2559 vstart
= ((char *) eneed
) + idx
;
2561 entry
= (Elf_External_Verneed
*) vstart
;
2563 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2564 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2565 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2566 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2567 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2569 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2571 if (dynamic_strings
)
2572 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2574 printf (_(" File: %lx"), ent
.vn_file
);
2576 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2578 vstart
+= ent
.vn_aux
;
2580 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2582 Elf_External_Vernaux
* eaux
;
2583 Elf_Internal_Vernaux aux
;
2585 eaux
= (Elf_External_Vernaux
*) vstart
;
2587 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2588 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2589 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2590 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2591 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2593 if (dynamic_strings
)
2594 printf (_(" %#06x: Name: %s"),
2595 isum
, dynamic_strings
+ aux
.vna_name
);
2597 printf (_(" %#06x: Name index: %lx"),
2598 isum
, aux
.vna_name
);
2600 printf (_(" Flags: %s Version: %d\n"),
2601 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2603 isum
+= aux
.vna_next
;
2604 vstart
+= aux
.vna_next
;
2614 case SHT_GNU_versym
:
2616 Elf32_Internal_Shdr
* link_section
;
2619 unsigned char * edata
;
2620 unsigned short * data
;
2622 Elf_Internal_Sym
* symbols
;
2623 Elf32_Internal_Shdr
* string_sec
;
2625 link_section
= section_headers
+ section
->sh_link
;
2626 total
= section
->sh_size
/ section
->sh_entsize
;
2630 symbols
= get_elf_symbols
2631 (file
, link_section
->sh_offset
,
2632 link_section
->sh_size
/ link_section
->sh_entsize
);
2634 string_sec
= section_headers
+ link_section
->sh_link
;
2636 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2637 strtab
, char *, "version string table");
2639 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2640 SECTION_NAME (section
), total
);
2642 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2643 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2644 SECTION_NAME (link_section
));
2646 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2648 total
* sizeof (short), edata
,
2649 char *, "version symbol data");
2651 data
= (unsigned short *) malloc (total
* sizeof (short));
2653 for (cnt
= total
; cnt
--;)
2654 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short), sizeof (short));
2658 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2662 printf (" %03x:", cnt
);
2664 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2665 switch (data
[cnt
+ j
])
2668 fputs (_(" 0 (*local*) "), stdout
);
2672 fputs (_(" 1 (*global*) "), stdout
);
2676 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2677 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2679 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2680 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2683 /* We must test both. */
2684 Elf_Internal_Verneed ivn
;
2685 unsigned long offset
;
2687 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2692 Elf_External_Verneed evn
;
2693 Elf_External_Vernaux evna
;
2694 Elf_Internal_Vernaux ivna
;
2695 unsigned long vna_off
;
2697 GET_DATA (offset
, evn
, "version need");
2699 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2700 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2702 vna_off
= offset
+ ivn
.vn_aux
;
2706 GET_DATA (vna_off
, evna
,
2707 "version need aux (1)");
2709 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2710 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2712 vna_off
+= ivna
.vna_next
;
2714 while (ivna
.vna_other
!= data
[cnt
+ j
]
2715 && ivna
.vna_next
!= 0);
2717 if (ivna
.vna_other
== data
[cnt
+ j
])
2719 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2721 nn
+= printf ("(%s%-*s",
2722 strtab
+ ivna
.vna_name
,
2728 else if (ivn
.vn_next
== 0)
2730 if (data
[cnt
+ j
] != 0x8001)
2732 Elf_Internal_Verdef ivd
;
2733 Elf_External_Verdef evd
;
2735 offset
= version_info
2736 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2741 GET_DATA (offset
, evd
,
2742 "version definition");
2744 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2745 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2747 offset
+= ivd
.vd_next
;
2750 != (data
[cnt
+ j
] & 0x7fff)
2751 && ivd
.vd_next
!= 0);
2754 == (data
[cnt
+ j
] & 0x7fff))
2756 Elf_External_Verdaux evda
;
2757 Elf_Internal_Verdaux ivda
;
2759 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2761 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2762 "version definition aux");
2765 BYTE_GET (evda
.vda_name
);
2769 strtab
+ ivda
.vda_name
,
2780 offset
+= ivn
.vn_next
;
2782 while (ivn
.vn_next
);
2784 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2786 Elf_Internal_Verneed ivn
;
2787 unsigned long offset
;
2789 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2794 Elf_Internal_Vernaux ivna
;
2795 Elf_External_Verneed evn
;
2796 Elf_External_Vernaux evna
;
2797 unsigned long a_off
;
2799 GET_DATA (offset
, evn
, "version need");
2801 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2802 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2804 a_off
= offset
+ ivn
.vn_aux
;
2808 GET_DATA (a_off
, evna
,
2809 "version need aux (2)");
2811 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2812 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2814 a_off
+= ivna
.vna_next
;
2816 while (ivna
.vna_other
!= data
[cnt
+ j
]
2817 && ivna
.vna_next
!= 0);
2819 if (ivna
.vna_other
== data
[cnt
+ j
])
2821 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2823 nn
+= printf ("(%s%-*s",
2824 strtab
+ ivna
.vna_name
,
2831 offset
+= ivn
.vn_next
;
2833 while (ivn
.vn_next
);
2835 else if (data
[cnt
+ j
] != 0x8001)
2837 Elf_Internal_Verdef ivd
;
2838 Elf_External_Verdef evd
;
2839 unsigned long offset
;
2841 offset
= version_info
2842 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2846 GET_DATA (offset
, evd
, "version def");
2848 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2849 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2851 offset
+= ivd
.vd_next
;
2853 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2854 && ivd
.vd_next
!= 0);
2856 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2858 Elf_External_Verdaux evda
;
2859 Elf_Internal_Verdaux ivda
;
2861 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2863 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2864 evda
, "version def aux");
2866 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2868 nn
+= printf ("(%s%-*s",
2869 strtab
+ ivda
.vda_name
,
2877 printf ("%*c", 18 - nn
, ' ');
2895 printf (_("\nNo version information found in this file.\n"));
2901 get_symbol_binding (binding
)
2902 unsigned int binding
;
2904 static char buff
[32];
2908 case STB_LOCAL
: return _("LOCAL");
2909 case STB_GLOBAL
: return _("GLOBAL");
2910 case STB_WEAK
: return _("WEAK");
2912 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
2913 sprintf (buff
, _("<processor specific>: %d"), binding
);
2915 sprintf (buff
, _("<unknown>: %d"), binding
);
2921 get_symbol_type (type
)
2924 static char buff
[32];
2928 case STT_NOTYPE
: return _("NOTYPE");
2929 case STT_OBJECT
: return _("OBJECT");
2930 case STT_FUNC
: return _("FUNC");
2931 case STT_SECTION
: return _("SECTION");
2932 case STT_FILE
: return _("FILE");
2934 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
2935 sprintf (buff
, _("<processor specific>: %d"), type
);
2937 sprintf (buff
, _("<unknown>: %d"), type
);
2943 get_symbol_index_type (type
)
2948 case SHN_UNDEF
: return "UND";
2949 case SHN_ABS
: return "ABS";
2950 case SHN_COMMON
: return "COM";
2952 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
2954 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
2958 static char buff
[32];
2960 sprintf (buff
, "%3d", type
);
2968 get_dynamic_data (file
, number
)
2970 unsigned int number
;
2975 e_data
= (char *) malloc (number
* 4);
2979 error (_("Out of memory\n"));
2983 if (fread (e_data
, 4, number
, file
) != number
)
2985 error (_("Unable to read in dynamic data\n"));
2989 i_data
= (int *) malloc (number
* sizeof (* i_data
));
2993 error (_("Out of memory\n"));
2999 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
3006 /* Dump the symbol table */
3008 process_symbol_table (file
)
3011 Elf32_Internal_Shdr
* section
;
3016 if (dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
3027 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
3029 error (_("Unable to seek to start of dynamic information"));
3033 if (fread (& nb
, sizeof (nb
), 1, file
) != 1)
3035 error (_("Failed to read in number of buckets\n"));
3039 if (fread (& nc
, sizeof (nc
), 1, file
) != 1)
3041 error (_("Failed to read in number of chains\n"));
3045 nbuckets
= byte_get (nb
, 4);
3046 nchains
= byte_get (nc
, 4);
3048 buckets
= get_dynamic_data (file
, nbuckets
);
3049 chains
= get_dynamic_data (file
, nchains
);
3051 if (buckets
== NULL
|| chains
== NULL
)
3054 printf (_("\nSymbol table for image:\n"));
3055 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
3057 for (hn
= 0; hn
< nbuckets
; hn
++)
3062 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
3064 Elf_Internal_Sym
* psym
;
3066 psym
= dynamic_symbols
+ si
;
3068 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
3070 (unsigned long) psym
->st_value
,
3071 (unsigned long) psym
->st_size
,
3072 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3073 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3076 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
3078 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
3085 else if (!do_using_dynamic
)
3089 for (i
= 0, section
= section_headers
;
3090 i
< elf_header
.e_shnum
;
3095 Elf_Internal_Sym
* symtab
;
3096 Elf_Internal_Sym
* psym
;
3099 if ( section
->sh_type
!= SHT_SYMTAB
3100 && section
->sh_type
!= SHT_DYNSYM
)
3103 printf (_("\nSymbol table '%s' contains %d entries:\n"),
3104 SECTION_NAME (section
),
3105 section
->sh_size
/ section
->sh_entsize
);
3106 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
3109 symtab
= get_elf_symbols (file
, section
->sh_offset
,
3110 section
->sh_size
/ section
->sh_entsize
);
3114 if (section
->sh_link
== elf_header
.e_shstrndx
)
3115 strtab
= string_table
;
3118 Elf32_Internal_Shdr
* string_sec
;
3120 string_sec
= section_headers
+ section
->sh_link
;
3122 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3123 strtab
, char *, "string table");
3126 for (si
= 0, psym
= symtab
;
3127 si
< section
->sh_size
/ section
->sh_entsize
;
3130 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
3132 (unsigned long) psym
->st_value
,
3133 (unsigned long) psym
->st_size
,
3134 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3135 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3138 if (psym
->st_shndx
== 0)
3139 fputs (" UND", stdout
);
3140 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
3141 fputs (" ABS", stdout
);
3142 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
3143 fputs (" COM", stdout
);
3145 printf ("%4x", psym
->st_shndx
);
3147 printf (" %s", strtab
+ psym
->st_name
);
3149 if (section
->sh_type
== SHT_DYNSYM
&&
3150 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
3152 unsigned char data
[2];
3153 unsigned short vers_data
;
3154 unsigned long offset
;
3158 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3161 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
3164 vers_data
= byte_get (data
, 2);
3166 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
3167 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
3170 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
3172 if ((vers_data
& 0x8000) || vers_data
> 1)
3174 if (is_nobits
|| ! check_def
)
3176 Elf_External_Verneed evn
;
3177 Elf_Internal_Verneed ivn
;
3178 Elf_Internal_Vernaux ivna
;
3180 /* We must test both. */
3181 offset
= version_info
3182 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
3184 GET_DATA (offset
, evn
, "version need");
3186 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3187 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3191 unsigned long vna_off
;
3193 vna_off
= offset
+ ivn
.vn_aux
;
3197 Elf_External_Vernaux evna
;
3199 GET_DATA (vna_off
, evna
,
3200 "version need aux (3)");
3202 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3203 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3204 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3206 vna_off
+= ivna
.vna_next
;
3208 while (ivna
.vna_other
!= vers_data
3209 && ivna
.vna_next
!= 0);
3211 if (ivna
.vna_other
== vers_data
)
3214 offset
+= ivn
.vn_next
;
3216 while (ivn
.vn_next
!= 0);
3218 if (ivna
.vna_other
== vers_data
)
3221 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
3224 else if (! is_nobits
)
3225 error (_("bad dynamic symbol"));
3232 if (vers_data
!= 0x8001)
3234 Elf_Internal_Verdef ivd
;
3235 Elf_Internal_Verdaux ivda
;
3236 Elf_External_Verdaux evda
;
3237 unsigned long offset
;
3240 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
3245 Elf_External_Verdef evd
;
3247 GET_DATA (offset
, evd
, "version def");
3249 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3250 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3251 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3253 offset
+= ivd
.vd_next
;
3255 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
3256 && ivd
.vd_next
!= 0);
3258 offset
-= ivd
.vd_next
;
3259 offset
+= ivd
.vd_aux
;
3261 GET_DATA (offset
, evda
, "version def aux");
3263 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3265 if (psym
->st_name
!= ivda
.vda_name
)
3266 printf ((vers_data
& 0x8000)
3268 strtab
+ ivda
.vda_name
);
3278 if (strtab
!= string_table
)
3284 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
3290 process_section_contents (file
)
3293 Elf32_Internal_Shdr
* section
;
3299 for (i
= 0, section
= section_headers
;
3300 i
< elf_header
.e_shnum
;
3303 #ifdef SUPPORT_DISASSEMBLY
3304 /* See if we need an assembly dump of this section */
3306 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & DISASS_DUMP
))
3308 printf (_("\nAssembly dump of section %s\n"),
3309 SECTION_NAME (section
));
3311 /* XXX -- to be done --- XXX */
3314 /* See if we need a hex dump of this section. */
3315 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & HEX_DUMP
))
3319 unsigned char * data
;
3322 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
3324 bytes
= section
->sh_size
;
3325 addr
= section
->sh_addr
;
3327 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, char *,
3338 lbytes
= (bytes
> 16 ? 16 : bytes
);
3340 printf (" 0x%8.8x ", addr
);
3342 switch (elf_header
.e_ident
[EI_DATA
])
3345 for (j
= 15; j
>= 0; j
--)
3348 printf ("%2.2x", data
[j
]);
3358 for (j
= 0; j
< 16; j
++)
3361 printf ("%2.2x", data
[j
]);
3371 for (j
= 0; j
< lbytes
; j
++)
3374 if (k
>= ' ' && k
< 0x80)
3395 process_mips_fpe_exception (mask
)
3401 if (mask
& OEX_FPU_INEX
)
3402 fputs ("INEX", stdout
), first
= 0;
3403 if (mask
& OEX_FPU_UFLO
)
3404 printf ("%sUFLO", first
? "" : "|"), first
= 0;
3405 if (mask
& OEX_FPU_OFLO
)
3406 printf ("%sOFLO", first
? "" : "|"), first
= 0;
3407 if (mask
& OEX_FPU_DIV0
)
3408 printf ("%sDIV0", first
? "" : "|"), first
= 0;
3409 if (mask
& OEX_FPU_INVAL
)
3410 printf ("%sINVAL", first
? "" : "|");
3413 fputs ("0", stdout
);
3417 process_mips_specific (file
)
3420 Elf_Internal_Dyn
* entry
;
3421 size_t liblist_offset
= 0;
3422 size_t liblistno
= 0;
3423 size_t options_offset
= 0;
3425 /* We have a lot of special sections. Thanks SGI! */
3426 if (dynamic_segment
== NULL
)
3427 /* No information available. */
3430 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
3431 switch (entry
->d_tag
)
3433 case DT_MIPS_LIBLIST
:
3434 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
3436 case DT_MIPS_LIBLISTNO
:
3437 liblistno
= entry
->d_un
.d_val
;
3439 case DT_MIPS_OPTIONS
:
3440 options_offset
= entry
->d_un
.d_val
- loadaddr
;
3446 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
3448 Elf32_External_Lib
*elib
;
3451 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
3452 elib
, Elf32_External_Lib
*, "liblist");
3454 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
3455 fputs (" Library Time Stamp Checksum Version Flags\n",
3458 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
3464 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
3465 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
3466 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
3467 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
3468 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
3470 strftime (timebuf
, 17, "%Y-%m-%dT%H:%M", gmtime (&time
));
3472 printf ("%3d: %-20s %s %#10lx %-7ld %#lx\n", cnt
,
3473 dynamic_strings
+ liblist
.l_name
, timebuf
,
3474 liblist
.l_checksum
, liblist
.l_version
, liblist
.l_flags
);
3480 if (options_offset
!= 0)
3482 Elf_External_Options
*eopt
;
3483 Elf_Internal_Shdr
*sect
= section_headers
;
3484 Elf_Internal_Options
*iopt
;
3485 Elf_Internal_Options
*option
;
3489 /* Find the section header so that we get the size. */
3490 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
3493 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
3494 Elf_External_Options
*, "options");
3496 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
3500 error (_("Out of memory"));
3506 while (offset
< sect
->sh_size
)
3508 Elf_External_Options
*eoption
;
3510 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
3512 option
->kind
= BYTE_GET (eoption
->kind
);
3513 option
->size
= BYTE_GET (eoption
->size
);
3514 option
->section
= BYTE_GET (eoption
->section
);
3515 option
->info
= BYTE_GET (eoption
->info
);
3517 offset
+= option
->size
;
3522 printf (_("\nSection '%s' contains %d entries:\n"),
3523 string_table
+ sect
->sh_name
, cnt
);
3530 switch (option
->kind
)
3533 /* This shouldn't happen. */
3534 printf (" NULL %d %x", option
->section
, option
->info
);
3537 printf (" REGINFO ");
3538 if (elf_header
.e_machine
== EM_MIPS
)
3541 Elf32_External_RegInfo
*ereg
;
3542 Elf32_RegInfo reginfo
;
3544 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
3545 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3546 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3547 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3548 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3549 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3550 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3552 printf ("GPR %08lx GP %ld\n",
3553 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3554 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3555 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3556 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3561 Elf64_External_RegInfo
*ereg
;
3562 Elf64_Internal_RegInfo reginfo
;
3564 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
3565 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3566 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3567 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3568 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3569 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3570 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3572 printf ("GPR %08lx GP %ld\n",
3573 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3574 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3575 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3576 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3580 case ODK_EXCEPTIONS
:
3581 fputs (" EXCEPTIONS fpe_min(", stdout
);
3582 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
3583 fputs (") fpe_max(", stdout
);
3584 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
3585 fputs (")", stdout
);
3587 if (option
->info
& OEX_PAGE0
)
3588 fputs (" PAGE0", stdout
);
3589 if (option
->info
& OEX_SMM
)
3590 fputs (" SMM", stdout
);
3591 if (option
->info
& OEX_FPDBUG
)
3592 fputs (" FPDBUG", stdout
);
3593 if (option
->info
& OEX_DISMISS
)
3594 fputs (" DISMISS", stdout
);
3597 fputs (" PAD ", stdout
);
3598 if (option
->info
& OPAD_PREFIX
)
3599 fputs (" PREFIX", stdout
);
3600 if (option
->info
& OPAD_POSTFIX
)
3601 fputs (" POSTFIX", stdout
);
3602 if (option
->info
& OPAD_SYMBOL
)
3603 fputs (" SYMBOL", stdout
);
3606 fputs (" HWPATCH ", stdout
);
3607 if (option
->info
& OHW_R4KEOP
)
3608 fputs (" R4KEOP", stdout
);
3609 if (option
->info
& OHW_R8KPFETCH
)
3610 fputs (" R8KPFETCH", stdout
);
3611 if (option
->info
& OHW_R5KEOP
)
3612 fputs (" R5KEOP", stdout
);
3613 if (option
->info
& OHW_R5KCVTL
)
3614 fputs (" R5KCVTL", stdout
);
3617 fputs (" FILL ", stdout
);
3618 /* XXX Print content of info word? */
3621 fputs (" TAGS ", stdout
);
3622 /* XXX Print content of info word? */
3625 fputs (" HWAND ", stdout
);
3626 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3627 fputs (" R4KEOP_CHECKED", stdout
);
3628 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3629 fputs (" R4KEOP_CLEAN", stdout
);
3632 fputs (" HWOR ", stdout
);
3633 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3634 fputs (" R4KEOP_CHECKED", stdout
);
3635 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3636 fputs (" R4KEOP_CLEAN", stdout
);
3639 printf (" GP_GROUP %#06x self-contained %#06x",
3640 option
->info
& OGP_GROUP
,
3641 (option
->info
& OGP_SELF
) >> 16);
3644 printf (" IDENT %#06x self-contained %#06x",
3645 option
->info
& OGP_GROUP
,
3646 (option
->info
& OGP_SELF
) >> 16);
3649 /* This shouldn't happen. */
3650 printf (" %3d ??? %d %x",
3651 option
->kind
, option
->section
, option
->info
);
3655 len
= sizeof (*eopt
);
3656 while (len
< option
->size
)
3657 if (((char *) option
)[len
] >= ' '
3658 && ((char *) option
)[len
] < 0x7f)
3659 printf ("%c", ((char *) option
)[len
++]);
3661 printf ("\\%03o", ((char *) option
)[len
++]);
3663 fputs ("\n", stdout
);
3674 process_arch_specific (file
)
3677 switch (elf_header
.e_machine
)
3680 case EM_MIPS_RS4_BE
:
3681 return process_mips_specific (file
);
3690 get_file_header (file
)
3693 Elf32_External_Ehdr ehdr
;
3695 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
3698 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
3700 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
3701 byte_get
= byte_get_little_endian
;
3703 byte_get
= byte_get_big_endian
;
3705 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
3706 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
3707 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
3708 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
3709 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
3710 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
3711 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
3712 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
3713 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
3714 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
3715 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
3716 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
3717 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
3723 process_file (file_name
)
3727 struct stat statbuf
;
3730 if (stat (file_name
, & statbuf
) < 0)
3732 error (_("Cannot stat input file %s.\n"), file_name
);
3736 file
= fopen (file_name
, "rb");
3739 error (_("Input file %s not found.\n"), file_name
);
3743 if (! get_file_header (file
))
3745 error (_("%s: Failed to read file header\n"), file_name
);
3750 /* Initialise per file variables. */
3751 for (i
= NUM_ELEM (version_info
); i
--;)
3752 version_info
[i
] = 0;
3754 for (i
= NUM_ELEM (dynamic_info
); i
--;)
3755 dynamic_info
[i
] = 0;
3758 /* Process the file. */
3760 printf (_("\nFile: %s\n"), file_name
);
3762 if (! process_file_header ())
3768 process_section_headers (file
);
3770 process_program_headers (file
);
3772 process_dynamic_segment (file
);
3774 process_relocs (file
);
3776 process_symbol_table (file
);
3778 process_version_sections (file
);
3780 process_section_contents (file
);
3782 process_arch_specific (file
);
3786 if (section_headers
)
3788 free (section_headers
);
3789 section_headers
= NULL
;
3794 free (string_table
);
3795 string_table
= NULL
;
3798 if (dynamic_strings
)
3800 free (dynamic_strings
);
3801 dynamic_strings
= NULL
;
3804 if (dynamic_symbols
)
3806 free (dynamic_symbols
);
3807 dynamic_symbols
= NULL
;
3811 #ifdef SUPPORT_DISASSEMBLY
3812 /* Needed by the i386 disassembler. For extra credit, someone could
3813 fix this so that we insert symbolic addresses here, esp for GOT/PLT
3817 print_address (unsigned int addr
, FILE * outfile
)
3819 fprintf (outfile
,"0x%8.8x", addr
);
3822 /* Needed by the i386 disassembler. */
3824 db_task_printsym (unsigned int addr
)
3826 print_address (addr
, stderr
);
3835 parse_args (argc
, argv
);
3837 if (optind
< (argc
- 1))
3840 while (optind
< argc
)
3841 process_file (argv
[optind
++]);