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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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 NULL
;
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
));
920 printf ("unrecognised: %-7x", ELF32_R_TYPE (info
));
922 printf ("%-21.21s", rtype
);
924 symtab_index
= ELF32_R_SYM (info
);
926 if (symtab_index
&& symtab
!= NULL
)
928 Elf_Internal_Sym
* psym
;
930 psym
= symtab
+ symtab_index
;
932 printf (" %08lx ", (unsigned long) psym
->st_value
);
934 if (psym
->st_name
== 0)
936 SECTION_NAME (section_headers
+ psym
->st_shndx
));
937 else if (strtab
== NULL
)
938 printf (_("<string table index %3d>"), psym
->st_name
);
940 printf ("%-25.25s", strtab
+ psym
->st_name
);
943 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
955 get_mips_dynamic_type (type
)
960 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
961 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
962 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
963 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
964 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
965 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
966 case DT_MIPS_MSYM
: return "MIPS_MSYM";
967 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
968 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
969 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
970 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
971 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
972 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
973 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
974 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
975 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
976 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
977 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
978 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
979 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
980 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
981 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
982 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
983 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
984 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
985 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
986 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
987 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
988 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
989 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
990 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
991 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
992 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
993 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
994 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
995 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
996 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
997 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
998 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
999 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1000 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1001 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1002 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1009 get_dynamic_type (type
)
1012 static char buff
[32];
1016 case DT_NULL
: return _("NULL");
1017 case DT_NEEDED
: return _("NEEDED");
1018 case DT_PLTRELSZ
: return _("PLTRELSZ");
1019 case DT_PLTGOT
: return _("PLTGOT");
1020 case DT_HASH
: return _("HASH");
1021 case DT_STRTAB
: return _("STRTAB");
1022 case DT_SYMTAB
: return _("SYMTAB");
1023 case DT_RELA
: return _("RELA");
1024 case DT_RELASZ
: return _("RELASZ");
1025 case DT_RELAENT
: return _("RELAENT");
1026 case DT_STRSZ
: return _("STRSZ");
1027 case DT_SYMENT
: return _("SYMENT");
1028 case DT_INIT
: return _("INIT");
1029 case DT_FINI
: return _("FINI");
1030 case DT_SONAME
: return _("SONAME");
1031 case DT_RPATH
: return _("RPATH");
1032 case DT_SYMBOLIC
: return _("SYMBOLIC");
1033 case DT_REL
: return _("REL");
1034 case DT_RELSZ
: return _("RELSZ");
1035 case DT_RELENT
: return _("RELENT");
1036 case DT_PLTREL
: return _("PLTREL");
1037 case DT_DEBUG
: return _("DEBUG");
1038 case DT_TEXTREL
: return _("TEXTREL");
1039 case DT_JMPREL
: return _("JMPREL");
1040 case DT_VERDEF
: return _("VERDEF");
1041 case DT_VERDEFNUM
: return _("VERDEFNUM");
1042 case DT_VERNEED
: return _("VERNEED");
1043 case DT_VERNEEDNUM
: return _("VERNEEDNUM");
1044 case DT_VERSYM
: return _("VERSYN");
1045 case DT_AUXILIARY
: return _("AUXILARY");
1046 case DT_FILTER
: return _("FILTER");
1049 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1051 const char *result
= NULL
;
1052 switch (elf_header
.e_machine
)
1055 case EM_MIPS_RS4_BE
:
1056 result
= get_mips_dynamic_type (type
);
1062 sprintf (buff
, _("Processor Specific: (%x)"), type
);
1068 sprintf (buff
, _("<unknown>: %x"), type
);
1074 get_file_type (e_type
)
1077 static char buff
[32];
1081 case ET_NONE
: return _("NONE (None)");
1082 case ET_REL
: return _("REL (Relocatable file)");
1083 case ET_EXEC
: return _("EXEC (Executable file)");
1084 case ET_DYN
: return _("DYN (Shared object file)");
1085 case ET_CORE
: return _("CORE (Core file)");
1088 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1089 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1091 sprintf (buff
, _("<unknown>: %x"), e_type
);
1097 get_machine_name (e_machine
)
1100 static char buff
[32];
1104 case EM_NONE
: return _("None");
1105 case EM_M32
: return "WE32100";
1106 case EM_SPARC
: return "Sparc";
1107 case EM_386
: return "Intel 80386";
1108 case EM_68K
: return "MC68000";
1109 case EM_88K
: return "MC88000";
1110 case EM_486
: return "Intel 80486";
1111 case EM_860
: return "Intel 80860";
1112 case EM_MIPS
: return "MIPS R3000 big-endian";
1113 case EM_S370
: return "Amdahl";
1114 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1115 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1116 case EM_PARISC
: return "HPPA";
1117 case EM_PPC_OLD
: return "Power PC (old)";
1118 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1119 case EM_960
: return "Intel 90860";
1120 case EM_PPC
: return "PowerPC";
1121 case EM_V800
: return "NEC V800";
1122 case EM_FR20
: return "Fujitsu FR20";
1123 case EM_RH32
: return "TRW RH32";
1124 case EM_MMA
: return "Fujitsu MMA";
1125 case EM_ARM
: return "ARM";
1126 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1127 case EM_SH
: return "Hitachi SH";
1128 case EM_SPARCV9
: return "Sparc v9";
1129 case EM_ALPHA
: return "Alpha";
1130 case EM_CYGNUS_D10V
: return "d10v";
1131 /* start-sanitize-d30v */
1132 case EM_CYGNUS_D30V
: return "d30v";
1133 /* end-sanitize-d30v */
1134 case EM_CYGNUS_M32R
: return "M32r";
1135 case EM_CYGNUS_V850
: return "v850";
1136 case EM_CYGNUS_MN10300
: return "mn10300";
1137 case EM_CYGNUS_MN10200
: return "mn10200";
1140 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1146 get_machine_flags (e_flags
, e_machine
)
1150 static char buf
[1024];
1161 if (e_flags
& EF_PPC_EMB
)
1162 strcat (buf
, ", emb");
1164 if (e_flags
& EF_PPC_RELOCATABLE
)
1165 strcat (buf
, ", relocatable");
1167 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1168 strcat (buf
, ", relocatable-lib");
1171 case EM_CYGNUS_M32R
:
1172 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1173 strcat (buf
, ", m32r");
1175 /* start-sanitize-m32rx */
1177 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
1178 strcat (buf
, ", m32rx");
1180 /* end-sanitize-m32rx */
1184 case EM_MIPS_RS4_BE
:
1185 if (e_flags
& EF_MIPS_NOREORDER
)
1186 strcat (buf
, ", noreorder");
1188 if (e_flags
& EF_MIPS_PIC
)
1189 strcat (buf
, ", pic");
1191 if (e_flags
& EF_MIPS_CPIC
)
1192 strcat (buf
, ", cpic");
1194 if (e_flags
& EF_MIPS_ABI2
)
1195 strcat (buf
, ", abi2");
1197 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1198 strcat (buf
, ", mips1");
1200 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1201 strcat (buf
, ", mips2");
1203 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1204 strcat (buf
, ", mips3");
1206 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1207 strcat (buf
, ", mips4");
1216 get_machine_data (e_data
)
1219 static char buff
[32];
1223 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
1224 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
1226 sprintf (buff
, _("<unknown>: %x"), e_data
);
1232 get_mips_segment_type (type
)
1237 case PT_MIPS_REGINFO
:
1239 case PT_MIPS_RTPROC
:
1241 case PT_MIPS_OPTIONS
:
1251 get_segment_type (p_type
)
1252 unsigned long p_type
;
1254 static char buff
[32];
1258 case PT_NULL
: return "NULL";
1259 case PT_LOAD
: return "LOAD";
1260 case PT_DYNAMIC
: return "DYNAMIC";
1261 case PT_INTERP
: return "INTERP";
1262 case PT_NOTE
: return "NOTE";
1263 case PT_SHLIB
: return "SHLIB";
1264 case PT_PHDR
: return "PHDR";
1267 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1270 switch (elf_header
.e_machine
)
1273 case EM_MIPS_RS4_BE
:
1274 result
= get_mips_segment_type (p_type
);
1282 sprintf (buff
, "LOPROC+%d", p_type
- PT_LOPROC
);
1289 sprintf (buff
, _("<unknown>: %x"), p_type
);
1296 get_mips_section_type_name (sh_type
)
1297 unsigned int sh_type
;
1301 case SHT_MIPS_LIBLIST
:
1302 return "MIPS_LIBLIST";
1305 case SHT_MIPS_CONFLICT
:
1306 return "MIPS_CONFLICT";
1307 case SHT_MIPS_GPTAB
:
1308 return "MIPS_GPTAB";
1309 case SHT_MIPS_UCODE
:
1310 return "MIPS_UCODE";
1311 case SHT_MIPS_DEBUG
:
1312 return "MIPS_DEBUG";
1313 case SHT_MIPS_REGINFO
:
1314 return "MIPS_REGINFO";
1315 case SHT_MIPS_PACKAGE
:
1316 return "MIPS_PACKAGE";
1317 case SHT_MIPS_PACKSYM
:
1318 return "MIPS_PACKSYM";
1321 case SHT_MIPS_IFACE
:
1322 return "MIPS_IFACE";
1323 case SHT_MIPS_CONTENT
:
1324 return "MIPS_CONTENT";
1325 case SHT_MIPS_OPTIONS
:
1326 return "MIPS_OPTIONS";
1329 case SHT_MIPS_FDESC
:
1330 return "MIPS_FDESC";
1331 case SHT_MIPS_EXTSYM
:
1332 return "MIPS_EXTSYM";
1333 case SHT_MIPS_DENSE
:
1334 return "MIPS_DENSE";
1335 case SHT_MIPS_PDESC
:
1336 return "MIPS_PDESC";
1337 case SHT_MIPS_LOCSYM
:
1338 return "MIPS_LOCSYM";
1339 case SHT_MIPS_AUXSYM
:
1340 return "MIPS_AUXSYM";
1341 case SHT_MIPS_OPTSYM
:
1342 return "MIPS_OPTSYM";
1343 case SHT_MIPS_LOCSTR
:
1344 return "MIPS_LOCSTR";
1347 case SHT_MIPS_RFDESC
:
1348 return "MIPS_RFDESC";
1349 case SHT_MIPS_DELTASYM
:
1350 return "MIPS_DELTASYM";
1351 case SHT_MIPS_DELTAINST
:
1352 return "MIPS_DELTAINST";
1353 case SHT_MIPS_DELTACLASS
:
1354 return "MIPS_DELTACLASS";
1355 case SHT_MIPS_DWARF
:
1356 return "MIPS_DWARF";
1357 case SHT_MIPS_DELTADECL
:
1358 return "MIPS_DELTADECL";
1359 case SHT_MIPS_SYMBOL_LIB
:
1360 return "MIPS_SYMBOL_LIB";
1361 case SHT_MIPS_EVENTS
:
1362 return "MIPS_EVENTS";
1363 case SHT_MIPS_TRANSLATE
:
1364 return "MIPS_TRANSLATE";
1365 case SHT_MIPS_PIXIE
:
1366 return "MIPS_PIXIE";
1367 case SHT_MIPS_XLATE
:
1368 return "MIPS_XLATE";
1369 case SHT_MIPS_XLATE_DEBUG
:
1370 return "MIPS_XLATE_DEBUG";
1371 case SHT_MIPS_WHIRL
:
1372 return "MIPS_WHIRL";
1373 case SHT_MIPS_EH_REGION
:
1374 return "MIPS_EH_REGION";
1375 case SHT_MIPS_XLATE_OLD
:
1376 return "MIPS_XLATE_OLD";
1377 case SHT_MIPS_PDR_EXCEPTION
:
1378 return "MIPS_PDR_EXCEPTION";
1386 get_section_type_name (sh_type
)
1387 unsigned int sh_type
;
1389 static char buff
[32];
1393 case SHT_NULL
: return "NULL";
1394 case SHT_PROGBITS
: return "PROGBITS";
1395 case SHT_SYMTAB
: return "SYMTAB";
1396 case SHT_STRTAB
: return "STRTAB";
1397 case SHT_RELA
: return "RELA";
1398 case SHT_HASH
: return "HASH";
1399 case SHT_DYNAMIC
: return "DYNAMIC";
1400 case SHT_NOTE
: return "NOTE";
1401 case SHT_NOBITS
: return "NOBITS";
1402 case SHT_REL
: return "REL";
1403 case SHT_SHLIB
: return "SHLIB";
1404 case SHT_DYNSYM
: return "DYNSYM";
1405 case SHT_GNU_verdef
: return "VERDEF";
1406 case SHT_GNU_verneed
: return "VERNEED";
1407 case SHT_GNU_versym
: return "VERSYM";
1408 case 0x6ffffff0: return "VERSYM";
1409 case 0x6ffffffc: return "VERDEF";
1410 case 0x7ffffffd: return "AUXILIARY";
1411 case 0x7fffffff: return "FILTER";
1414 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1418 switch (elf_header
.e_machine
)
1421 case EM_MIPS_RS4_BE
:
1422 result
= get_mips_section_type_name (sh_type
);
1431 sprintf (buff
, _("SHT_LOPROC+%d"), sh_type
- SHT_LOPROC
);
1436 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1437 sprintf (buff
, _("SHT_LOUSER+%d"), sh_type
- SHT_LOUSER
);
1439 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1444 struct option options
[] =
1446 {"all", no_argument
, 0, 'a'},
1447 {"file-header", no_argument
, 0, 'h'},
1448 {"program-headers", no_argument
, 0, 'l'},
1449 {"headers", no_argument
, 0, 'e'},
1450 {"segments", no_argument
, 0, 'l'},
1451 {"sections", no_argument
, 0, 'S'},
1452 {"section-headers", no_argument
, 0, 'S'},
1453 {"symbols", no_argument
, 0, 's'},
1454 {"relocs", no_argument
, 0, 'r'},
1455 {"dynamic", no_argument
, 0, 'd'},
1456 {"version-info", no_argument
, 0, 'V'},
1457 {"use-dynamic", no_argument
, 0, 'D'},
1459 {"hex-dump", required_argument
, 0, 'x'},
1460 #ifdef SUPPORT_DISASSEMBLY
1461 {"instruction-dump", required_argument
, 0, 'i'},
1464 {"version", no_argument
, 0, 'v'},
1465 {"help", no_argument
, 0, 'H'},
1467 {0, no_argument
, 0, 0}
1473 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1474 fprintf (stdout
, _(" Options are:\n"));
1475 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V\n"));
1476 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1477 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1478 fprintf (stdout
, _(" Display the program headers\n"));
1479 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1480 fprintf (stdout
, _(" Display the sections' header\n"));
1481 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1482 fprintf (stdout
, _(" -s or --symbols Display the symbol table\n"));
1483 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1484 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1485 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1486 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1487 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1488 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1489 #ifdef SUPPORT_DISASSEMBLY
1490 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1491 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1493 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1494 fprintf (stdout
, _(" -H or --help Display this information\n"));
1495 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1501 parse_args (argc
, argv
)
1510 while ((c
= getopt_long
1511 (argc
, argv
, "ersahldSDx:i:vV", options
, NULL
)) != EOF
)
1537 do_using_dynamic
++;
1559 section
= strtoul (optarg
, & cp
, 0);
1560 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1562 dump_sects
[section
] |= HEX_DUMP
;
1566 #ifdef SUPPORT_DISASSEMBLY
1569 section
= strtoul (optarg
, & cp
, 0);
1570 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1572 dump_sects
[section
] |= DISASS_DUMP
;
1578 print_version (program_name
);
1585 /* xgettext:c-format */
1586 error (_("Invalid option '-%c'\n"), c
);
1593 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1594 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
)
1598 warn (_("Nothing to do.\n"));
1603 /* Decode the data held in 'elf_header'. */
1605 process_file_header ()
1607 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1608 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1609 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1610 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1613 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1617 if (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS32
)
1619 error (_("Not a 32 bit ELF file\n"));
1627 printf (_("ELF Header:\n"));
1628 printf (_(" Magic: "));
1629 for (i
= 0; i
< EI_NIDENT
; i
++)
1630 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1632 printf (_(" Type: %s\n"),
1633 get_file_type (elf_header
.e_type
));
1634 printf (_(" Machine: %s\n"),
1635 get_machine_name (elf_header
.e_machine
));
1636 printf (_(" Version: 0x%lx\n"),
1637 (unsigned long) elf_header
.e_version
);
1638 printf (_(" Data: %s\n"),
1639 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1640 printf (_(" Entry point address: 0x%lx\n"),
1641 (unsigned long) elf_header
.e_entry
);
1642 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1643 (long) elf_header
.e_phoff
);
1644 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1645 (long) elf_header
.e_shoff
);
1646 printf (_(" Flags: 0x%lx%s\n"),
1647 (unsigned long) elf_header
.e_flags
,
1648 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1649 printf (_(" Size of this header: %ld (bytes)\n"),
1650 (long) elf_header
.e_ehsize
);
1651 printf (_(" Size of program headers: %ld (bytes)\n"),
1652 (long) elf_header
.e_phentsize
);
1653 printf (_(" Number of program headers: %ld\n"),
1654 (long) elf_header
.e_phnum
);
1655 printf (_(" Size of section headers: %ld (bytes)\n"),
1656 (long) elf_header
.e_shentsize
);
1657 printf (_(" Number of section headers: %ld\n"),
1658 (long) elf_header
.e_shnum
);
1659 printf (_(" Section header string table index: %ld\n"),
1660 (long) elf_header
.e_shstrndx
);
1668 process_program_headers (file
)
1671 Elf32_External_Phdr
* phdrs
;
1672 Elf32_Internal_Phdr
* program_headers
;
1673 Elf32_Internal_Phdr
* segment
;
1676 if (elf_header
.e_phnum
== 0)
1679 printf (_("\nThere are no program headers in this file.\n"));
1683 if (do_segments
&& !do_header
)
1685 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1686 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1687 printf (_("There are %d program headers, starting at offset %lx:\n"),
1688 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1691 GET_DATA_ALLOC (elf_header
.e_phoff
,
1692 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1693 phdrs
, Elf32_External_Phdr
*, "program headers");
1695 program_headers
= (Elf32_Internal_Phdr
*) malloc
1696 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1698 if (program_headers
== NULL
)
1700 error (_("Out of memory\n"));
1704 for (i
= 0, segment
= program_headers
;
1705 i
< elf_header
.e_phnum
;
1708 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1709 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1710 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1711 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1712 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1713 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1714 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1715 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1723 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1725 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1731 for (i
= 0, segment
= program_headers
;
1732 i
< elf_header
.e_phnum
;
1737 printf (" %-11.11s ", get_segment_type (segment
->p_type
));
1738 printf ("0x%5.5lx ", (unsigned long) segment
->p_offset
);
1739 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1740 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1741 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1742 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1744 (segment
->p_flags
& PF_R
? 'R' : ' '),
1745 (segment
->p_flags
& PF_W
? 'W' : ' '),
1746 (segment
->p_flags
& PF_X
? 'E' : ' '));
1747 printf ("%#lx", (unsigned long) segment
->p_align
);
1750 switch (segment
->p_type
)
1754 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1755 - (segment
->p_offset
& 0xfffff000);
1760 error (_("more than one dynamic segment\n"));
1762 dynamic_addr
= segment
->p_offset
;
1763 dynamic_size
= segment
->p_filesz
;
1767 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1768 error (_("Unable to find program interpreter name\n"));
1771 program_interpreter
[0] = 0;
1772 fscanf (file
, "%63s", program_interpreter
);
1775 printf (_("\n [Requesting program interpreter: %s]"),
1776 program_interpreter
);
1782 putc ('\n', stdout
);
1791 if (do_segments
&& section_headers
!= NULL
)
1793 printf (_("\n Section to Segment mapping:\n"));
1794 printf (_(" Segment Sections...\n"));
1796 assert (string_table
!= NULL
);
1798 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1801 Elf32_Internal_Shdr
* section
;
1803 segment
= program_headers
+ i
;
1804 section
= section_headers
;
1806 printf (" %2.2d ", i
);
1808 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1810 if (section
->sh_size
> 0
1811 /* Compare allocated sections by VMA, unallocated
1812 sections by file offset. */
1813 && (section
->sh_flags
& SHF_ALLOC
1814 ? (section
->sh_addr
>= segment
->p_vaddr
1815 && section
->sh_addr
+ section
->sh_size
1816 <= segment
->p_vaddr
+ segment
->p_memsz
)
1817 : (section
->sh_offset
>= segment
->p_offset
1818 && (section
->sh_offset
+ section
->sh_size
1819 <= segment
->p_offset
+ segment
->p_filesz
))))
1820 printf ("%s ", SECTION_NAME (section
));
1827 free (program_headers
);
1834 get_section_headers (file
)
1837 Elf32_External_Shdr
* shdrs
;
1838 Elf32_Internal_Shdr
* internal
;
1841 GET_DATA_ALLOC (elf_header
.e_shoff
,
1842 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1843 shdrs
, Elf32_External_Shdr
*, "section headers");
1845 section_headers
= (Elf32_Internal_Shdr
*) malloc
1846 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1848 if (section_headers
== NULL
)
1850 error (_("Out of memory\n"));
1854 for (i
= 0, internal
= section_headers
;
1855 i
< elf_header
.e_shnum
;
1858 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1859 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1860 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1861 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1862 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1863 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1864 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1865 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1866 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1867 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1875 static Elf_Internal_Sym
*
1876 get_elf_symbols (file
, offset
, number
)
1878 unsigned long offset
;
1879 unsigned long number
;
1881 Elf32_External_Sym
* esyms
;
1882 Elf_Internal_Sym
* isyms
;
1883 Elf_Internal_Sym
* psym
;
1886 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1887 esyms
, Elf32_External_Sym
*, "symbols");
1889 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1893 error (_("Out of memory\n"));
1899 for (j
= 0, psym
= isyms
;
1903 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1904 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1905 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1906 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1907 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1908 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1917 process_section_headers (file
)
1920 Elf32_Internal_Shdr
* section
;
1923 section_headers
= NULL
;
1925 if (elf_header
.e_shnum
== 0)
1928 printf (_("\nThere are no sections in this file.\n"));
1933 if (do_sections
&& !do_header
)
1934 printf (_("There are %d section headers, starting at offset %x:\n"),
1935 elf_header
.e_shnum
, elf_header
.e_shoff
);
1937 if (! get_section_headers (file
))
1940 /* Read in the string table, so that we have names to display. */
1941 section
= section_headers
+ elf_header
.e_shstrndx
;
1943 if (section
->sh_size
!= 0)
1945 unsigned long string_table_offset
;
1947 string_table_offset
= section
->sh_offset
;
1949 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1950 string_table
, char *, "string table");
1953 /* Scan the sections for the dynamic symbol table
1954 and dynamic string table. */
1955 dynamic_symbols
= NULL
;
1956 dynamic_strings
= NULL
;
1957 for (i
= 0, section
= section_headers
;
1958 i
< elf_header
.e_shnum
;
1961 if (section
->sh_type
== SHT_DYNSYM
)
1963 if (dynamic_symbols
!= NULL
)
1965 error (_("File contains multiple dynamic symbol tables\n"));
1969 dynamic_symbols
= get_elf_symbols
1970 (file
, section
->sh_offset
, section
->sh_size
/ section
->sh_entsize
);
1972 else if (section
->sh_type
== SHT_STRTAB
1973 && strcmp (SECTION_NAME (section
), ".dynstr") == 0)
1975 if (dynamic_strings
!= NULL
)
1977 error (_("File contains multiple dynamic string tables\n"));
1981 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1982 dynamic_strings
, char *, "dynamic strings");
1989 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1991 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1993 for (i
= 0, section
= section_headers
;
1994 i
< elf_header
.e_shnum
;
1997 printf (" [%2d] %-17.17s %-15.15s ",
1999 SECTION_NAME (section
),
2000 get_section_type_name (section
->sh_type
));
2002 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
2003 (unsigned long) section
->sh_addr
,
2004 (unsigned long) section
->sh_offset
,
2005 (unsigned long) section
->sh_size
,
2006 (unsigned long) section
->sh_entsize
);
2008 printf (" %c%c%c %2ld %3lx %ld \n",
2009 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
2010 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
2011 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
2012 (unsigned long) section
->sh_link
,
2013 (unsigned long) section
->sh_info
,
2014 (unsigned long) section
->sh_addralign
);
2020 /* Process the reloc section. */
2022 process_relocs (file
)
2025 unsigned long rel_size
;
2026 unsigned long rel_offset
;
2032 if (do_using_dynamic
)
2037 if (dynamic_info
[DT_REL
])
2039 rel_offset
= dynamic_info
[DT_REL
];
2040 rel_size
= dynamic_info
[DT_RELSZ
];
2042 else if (dynamic_info
[DT_RELA
])
2044 rel_offset
= dynamic_info
[DT_RELA
];
2045 rel_size
= dynamic_info
[DT_RELASZ
];
2047 else if (dynamic_info
[DT_JMPREL
])
2049 rel_offset
= dynamic_info
[DT_JMPREL
];
2050 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2056 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
2057 rel_offset
, rel_size
);
2059 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2060 dynamic_symbols
, dynamic_strings
);
2063 printf (_("\nThere are no dynamic relocations in this file.\n"));
2067 Elf32_Internal_Shdr
* section
;
2071 assert (string_table
!= NULL
);
2073 for (i
= 0, section
= section_headers
;
2074 i
< elf_header
.e_shnum
;
2077 if ( section
->sh_type
!= SHT_RELA
2078 && section
->sh_type
!= SHT_REL
)
2081 rel_offset
= section
->sh_offset
;
2082 rel_size
= section
->sh_size
;
2086 Elf32_Internal_Shdr
* strsec
;
2087 Elf32_Internal_Shdr
* symsec
;
2088 Elf_Internal_Sym
* symtab
;
2092 (_("\nRelocation section '%s' at offset 0x%x contains %d entries:\n"),
2093 SECTION_NAME (section
), rel_offset
,
2094 rel_size
/ section
->sh_entsize
);
2096 symsec
= section_headers
+ section
->sh_link
;
2098 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
2099 symsec
->sh_size
/ symsec
->sh_entsize
);
2104 strsec
= section_headers
+ symsec
->sh_link
;
2106 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2107 char *, "string table");
2109 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
);
2119 printf (_("\nThere are no relocations in this file.\n"));
2127 dynamic_segment_mips_val (entry
)
2128 Elf_Internal_Dyn
*entry
;
2130 switch (entry
->d_tag
)
2132 case DT_MIPS_LOCAL_GOTNO
:
2133 case DT_MIPS_CONFLICTNO
:
2134 case DT_MIPS_LIBLISTNO
:
2135 case DT_MIPS_SYMTABNO
:
2136 case DT_MIPS_UNREFEXTNO
:
2137 case DT_MIPS_HIPAGENO
:
2138 case DT_MIPS_DELTA_CLASS_NO
:
2139 case DT_MIPS_DELTA_INSTANCE_NO
:
2140 case DT_MIPS_DELTA_RELOC_NO
:
2141 case DT_MIPS_DELTA_SYM_NO
:
2142 case DT_MIPS_DELTA_CLASSSYM_NO
:
2144 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
2148 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2152 /* Parse the dynamic segment */
2154 process_dynamic_segment (file
)
2157 Elf_Internal_Dyn
* entry
;
2158 Elf32_External_Dyn
* edyn
;
2161 if (dynamic_size
== 0)
2164 printf (_("\nThere is no dynamic segment in this file.\n"));
2169 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2170 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2172 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2173 how large .dynamic is now. We can do this even before the byte
2174 swapping since the DT_NULL tag is recognizable. */
2176 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2179 dynamic_segment
= (Elf_Internal_Dyn
*)
2180 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2182 if (dynamic_segment
== NULL
)
2184 error (_("Out of memory\n"));
2189 for (i
= 0, entry
= dynamic_segment
;
2193 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2194 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2199 /* Find the appropriate symbol table. */
2200 if (dynamic_symbols
== NULL
)
2202 for (i
= 0, entry
= dynamic_segment
;
2206 unsigned long offset
;
2209 if (entry
->d_tag
!= DT_SYMTAB
)
2212 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
2214 /* Since we do not know how big the symbol table is,
2215 we default to reading in the entire file (!) and
2216 processing that. This is overkill, I know, but it
2219 offset
= entry
->d_un
.d_val
- loadaddr
;
2221 if (fseek (file
, 0, SEEK_END
))
2222 error (_("Unable to seek to end of file!"));
2224 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
2228 error (_("Unable to determine the number of symbols to load\n"));
2232 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
2236 /* Similarly find a string table. */
2237 if (dynamic_strings
== NULL
)
2239 for (i
= 0, entry
= dynamic_segment
;
2243 unsigned long offset
;
2246 if (entry
->d_tag
!= DT_STRTAB
)
2249 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
2251 /* Since we do not know how big the string table is,
2252 we default to reading in the entire file (!) and
2253 processing that. This is overkill, I know, but it
2256 offset
= entry
->d_un
.d_val
- loadaddr
;
2257 if (fseek (file
, 0, SEEK_END
))
2258 error (_("Unable to seek to end of file\n"));
2259 str_tab_len
= ftell (file
) - offset
;
2261 if (str_tab_len
< 1)
2264 (_("Unable to determine the length of the dynamic string table\n"));
2268 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
2269 "dynamic string table");
2275 if (do_dynamic
&& dynamic_addr
)
2276 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
2277 dynamic_addr
, dynamic_size
);
2279 printf (_(" Tag Type Name/Value\n"));
2281 for (i
= 0, entry
= dynamic_segment
;
2286 printf (_(" 0x%-8.8lx (%s)%*s"),
2287 (unsigned long) entry
->d_tag
,
2288 get_dynamic_type (entry
->d_tag
),
2289 27 - strlen (get_dynamic_type (entry
->d_tag
)),
2292 switch (entry
->d_tag
)
2298 if (entry
->d_tag
== DT_AUXILIARY
)
2299 printf (_("Auxiliary library"));
2301 printf (_("Filter library"));
2303 if (dynamic_strings
)
2304 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
2306 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2334 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2340 if (dynamic_strings
== NULL
)
2343 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2347 switch (entry
->d_tag
)
2350 printf (_("Shared library: [%s]"), name
);
2352 if (strcmp (name
, program_interpreter
))
2355 printf (_(" program interpreter\n"));
2359 printf (_("Library soname: [%s]\n"), name
);
2363 printf (_("Library rpath: [%s]\n"), name
);
2367 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2371 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2376 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2378 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2382 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2385 switch (elf_header
.e_machine
)
2388 case EM_MIPS_RS4_BE
:
2389 dynamic_segment_mips_val (entry
);
2393 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2403 get_ver_flags (flags
)
2406 static char buff
[32];
2413 if (flags
& VER_FLG_BASE
)
2414 strcat (buff
, "BASE ");
2416 if (flags
& VER_FLG_WEAK
)
2418 if (flags
& VER_FLG_BASE
)
2419 strcat (buff
, "| ");
2421 strcat (buff
, "WEAK ");
2424 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2425 strcat (buff
, "| <unknown>");
2430 /* Display the contents of the version sections. */
2432 process_version_sections (file
)
2435 Elf32_Internal_Shdr
* section
;
2442 for (i
= 0, section
= section_headers
;
2443 i
< elf_header
.e_shnum
;
2446 switch (section
->sh_type
)
2448 case SHT_GNU_verdef
:
2450 Elf_External_Verdef
* edefs
;
2457 (_("\nVersion definition section '%s' contains %d entries:\n"),
2458 SECTION_NAME (section
), section
->sh_info
);
2460 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2461 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2462 SECTION_NAME (section_headers
+ section
->sh_link
));
2464 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2465 edefs
, Elf_External_Verdef
*,
2466 "version definition section");
2468 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2471 Elf_External_Verdef
* edef
;
2472 Elf_Internal_Verdef ent
;
2473 Elf_External_Verdaux
* eaux
;
2474 Elf_Internal_Verdaux aux
;
2478 vstart
= ((char *) edefs
) + idx
;
2480 edef
= (Elf_External_Verdef
*) vstart
;
2482 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2483 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2484 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2485 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2486 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2487 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2488 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2490 printf (_(" %#06x: Rev: %d Flags: %s"),
2491 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2493 printf (_(" Index: %ld Cnt: %ld "), ent
.vd_ndx
, ent
.vd_cnt
);
2495 vstart
+= ent
.vd_aux
;
2497 eaux
= (Elf_External_Verdaux
*) vstart
;
2499 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2500 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2502 if (dynamic_strings
)
2503 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2505 printf (_("Name index: %ld\n"), aux
.vda_name
);
2507 isum
= idx
+ ent
.vd_aux
;
2509 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2511 isum
+= aux
.vda_next
;
2512 vstart
+= aux
.vda_next
;
2514 eaux
= (Elf_External_Verdaux
*) vstart
;
2516 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2517 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2519 if (dynamic_strings
)
2520 printf (_(" %#06x: Parent %d: %s\n"),
2521 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2523 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2524 isum
, j
, aux
.vda_name
);
2534 case SHT_GNU_verneed
:
2536 Elf_External_Verneed
* eneed
;
2542 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2543 SECTION_NAME (section
), section
->sh_info
);
2546 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2547 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2548 SECTION_NAME (section_headers
+ section
->sh_link
));
2550 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2551 eneed
, Elf_External_Verneed
*,
2552 "version need section");
2554 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2556 Elf_External_Verneed
* entry
;
2557 Elf_Internal_Verneed ent
;
2562 vstart
= ((char *) eneed
) + idx
;
2564 entry
= (Elf_External_Verneed
*) vstart
;
2566 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2567 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2568 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2569 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2570 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2572 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2574 if (dynamic_strings
)
2575 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2577 printf (_(" File: %lx"), ent
.vn_file
);
2579 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2581 vstart
+= ent
.vn_aux
;
2583 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2585 Elf_External_Vernaux
* eaux
;
2586 Elf_Internal_Vernaux aux
;
2588 eaux
= (Elf_External_Vernaux
*) vstart
;
2590 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2591 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2592 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2593 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2594 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2596 if (dynamic_strings
)
2597 printf (_(" %#06x: Name: %s"),
2598 isum
, dynamic_strings
+ aux
.vna_name
);
2600 printf (_(" %#06x: Name index: %lx"),
2601 isum
, aux
.vna_name
);
2603 printf (_(" Flags: %s Version: %d\n"),
2604 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2606 isum
+= aux
.vna_next
;
2607 vstart
+= aux
.vna_next
;
2617 case SHT_GNU_versym
:
2619 Elf32_Internal_Shdr
* link_section
;
2622 unsigned char * edata
;
2623 unsigned short * data
;
2625 Elf_Internal_Sym
* symbols
;
2626 Elf32_Internal_Shdr
* string_sec
;
2628 link_section
= section_headers
+ section
->sh_link
;
2629 total
= section
->sh_size
/ section
->sh_entsize
;
2633 symbols
= get_elf_symbols
2634 (file
, link_section
->sh_offset
,
2635 link_section
->sh_size
/ link_section
->sh_entsize
);
2637 string_sec
= section_headers
+ link_section
->sh_link
;
2639 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2640 strtab
, char *, "version string table");
2642 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2643 SECTION_NAME (section
), total
);
2645 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2646 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2647 SECTION_NAME (link_section
));
2649 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2651 total
* sizeof (short), edata
,
2652 char *, "version symbol data");
2654 data
= (unsigned short *) malloc (total
* sizeof (short));
2656 for (cnt
= total
; cnt
--;)
2657 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short), sizeof (short));
2661 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2665 printf (" %03x:", cnt
);
2667 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2668 switch (data
[cnt
+ j
])
2671 fputs (_(" 0 (*local*) "), stdout
);
2675 fputs (_(" 1 (*global*) "), stdout
);
2679 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2680 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2682 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2683 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2686 /* We must test both. */
2687 Elf_Internal_Verneed ivn
;
2688 unsigned long offset
;
2690 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2695 Elf_External_Verneed evn
;
2696 Elf_External_Vernaux evna
;
2697 Elf_Internal_Vernaux ivna
;
2698 unsigned long vna_off
;
2700 GET_DATA (offset
, evn
, "version need");
2702 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2703 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2705 vna_off
= offset
+ ivn
.vn_aux
;
2709 GET_DATA (vna_off
, evna
,
2710 "version need aux (1)");
2712 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2713 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2715 vna_off
+= ivna
.vna_next
;
2717 while (ivna
.vna_other
!= data
[cnt
+ j
]
2718 && ivna
.vna_next
!= 0);
2720 if (ivna
.vna_other
== data
[cnt
+ j
])
2722 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2724 nn
+= printf ("(%s%-*s",
2725 strtab
+ ivna
.vna_name
,
2731 else if (ivn
.vn_next
== 0)
2733 if (data
[cnt
+ j
] != 0x8001)
2735 Elf_Internal_Verdef ivd
;
2736 Elf_External_Verdef evd
;
2738 offset
= version_info
2739 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2744 GET_DATA (offset
, evd
,
2745 "version definition");
2747 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2748 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2750 offset
+= ivd
.vd_next
;
2753 != (data
[cnt
+ j
] & 0x7fff)
2754 && ivd
.vd_next
!= 0);
2757 == (data
[cnt
+ j
] & 0x7fff))
2759 Elf_External_Verdaux evda
;
2760 Elf_Internal_Verdaux ivda
;
2762 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2764 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2765 "version definition aux");
2768 BYTE_GET (evda
.vda_name
);
2772 strtab
+ ivda
.vda_name
,
2783 offset
+= ivn
.vn_next
;
2785 while (ivn
.vn_next
);
2787 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2789 Elf_Internal_Verneed ivn
;
2790 unsigned long offset
;
2792 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2797 Elf_Internal_Vernaux ivna
;
2798 Elf_External_Verneed evn
;
2799 Elf_External_Vernaux evna
;
2800 unsigned long a_off
;
2802 GET_DATA (offset
, evn
, "version need");
2804 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2805 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2807 a_off
= offset
+ ivn
.vn_aux
;
2811 GET_DATA (a_off
, evna
,
2812 "version need aux (2)");
2814 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2815 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2817 a_off
+= ivna
.vna_next
;
2819 while (ivna
.vna_other
!= data
[cnt
+ j
]
2820 && ivna
.vna_next
!= 0);
2822 if (ivna
.vna_other
== data
[cnt
+ j
])
2824 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2826 nn
+= printf ("(%s%-*s",
2827 strtab
+ ivna
.vna_name
,
2834 offset
+= ivn
.vn_next
;
2836 while (ivn
.vn_next
);
2838 else if (data
[cnt
+ j
] != 0x8001)
2840 Elf_Internal_Verdef ivd
;
2841 Elf_External_Verdef evd
;
2842 unsigned long offset
;
2844 offset
= version_info
2845 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2849 GET_DATA (offset
, evd
, "version def");
2851 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2852 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2854 offset
+= ivd
.vd_next
;
2856 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2857 && ivd
.vd_next
!= 0);
2859 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2861 Elf_External_Verdaux evda
;
2862 Elf_Internal_Verdaux ivda
;
2864 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2866 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2867 evda
, "version def aux");
2869 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2871 nn
+= printf ("(%s%-*s",
2872 strtab
+ ivda
.vda_name
,
2880 printf ("%*c", 18 - nn
, ' ');
2898 printf (_("\nNo version information found in this file.\n"));
2904 get_symbol_binding (binding
)
2905 unsigned int binding
;
2907 static char buff
[32];
2911 case STB_LOCAL
: return _("LOCAL");
2912 case STB_GLOBAL
: return _("GLOBAL");
2913 case STB_WEAK
: return _("WEAK");
2915 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
2916 sprintf (buff
, _("<processor specific>: %d"), binding
);
2918 sprintf (buff
, _("<unknown>: %d"), binding
);
2924 get_symbol_type (type
)
2927 static char buff
[32];
2931 case STT_NOTYPE
: return _("NOTYPE");
2932 case STT_OBJECT
: return _("OBJECT");
2933 case STT_FUNC
: return _("FUNC");
2934 case STT_SECTION
: return _("SECTION");
2935 case STT_FILE
: return _("FILE");
2937 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
2938 sprintf (buff
, _("<processor specific>: %d"), type
);
2940 sprintf (buff
, _("<unknown>: %d"), type
);
2946 get_symbol_index_type (type
)
2951 case SHN_UNDEF
: return "UND";
2952 case SHN_ABS
: return "ABS";
2953 case SHN_COMMON
: return "COM";
2955 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
2957 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
2961 static char buff
[32];
2963 sprintf (buff
, "%3d", type
);
2971 get_dynamic_data (file
, number
)
2973 unsigned int number
;
2978 e_data
= (char *) malloc (number
* 4);
2982 error (_("Out of memory\n"));
2986 if (fread (e_data
, 4, number
, file
) != number
)
2988 error (_("Unable to read in dynamic data\n"));
2992 i_data
= (int *) malloc (number
* sizeof (* i_data
));
2996 error (_("Out of memory\n"));
3002 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
3009 /* Dump the symbol table */
3011 process_symbol_table (file
)
3014 Elf32_Internal_Shdr
* section
;
3019 if (dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
3030 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
3032 error (_("Unable to seek to start of dynamic information"));
3036 if (fread (& nb
, sizeof (nb
), 1, file
) != 1)
3038 error (_("Failed to read in number of buckets\n"));
3042 if (fread (& nc
, sizeof (nc
), 1, file
) != 1)
3044 error (_("Failed to read in number of chains\n"));
3048 nbuckets
= byte_get (nb
, 4);
3049 nchains
= byte_get (nc
, 4);
3051 buckets
= get_dynamic_data (file
, nbuckets
);
3052 chains
= get_dynamic_data (file
, nchains
);
3054 if (buckets
== NULL
|| chains
== NULL
)
3057 printf (_("\nSymbol table for image:\n"));
3058 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
3060 for (hn
= 0; hn
< nbuckets
; hn
++)
3065 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
3067 Elf_Internal_Sym
* psym
;
3069 psym
= dynamic_symbols
+ si
;
3071 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
3073 (unsigned long) psym
->st_value
,
3074 (unsigned long) psym
->st_size
,
3075 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3076 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3079 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
3081 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
3088 else if (!do_using_dynamic
)
3092 for (i
= 0, section
= section_headers
;
3093 i
< elf_header
.e_shnum
;
3098 Elf_Internal_Sym
* symtab
;
3099 Elf_Internal_Sym
* psym
;
3102 if ( section
->sh_type
!= SHT_SYMTAB
3103 && section
->sh_type
!= SHT_DYNSYM
)
3106 printf (_("\nSymbol table '%s' contains %d entries:\n"),
3107 SECTION_NAME (section
),
3108 section
->sh_size
/ section
->sh_entsize
);
3109 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
3112 symtab
= get_elf_symbols (file
, section
->sh_offset
,
3113 section
->sh_size
/ section
->sh_entsize
);
3117 if (section
->sh_link
== elf_header
.e_shstrndx
)
3118 strtab
= string_table
;
3121 Elf32_Internal_Shdr
* string_sec
;
3123 string_sec
= section_headers
+ section
->sh_link
;
3125 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3126 strtab
, char *, "string table");
3129 for (si
= 0, psym
= symtab
;
3130 si
< section
->sh_size
/ section
->sh_entsize
;
3133 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
3135 (unsigned long) psym
->st_value
,
3136 (unsigned long) psym
->st_size
,
3137 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3138 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3141 if (psym
->st_shndx
== 0)
3142 fputs (" UND", stdout
);
3143 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
3144 fputs (" ABS", stdout
);
3145 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
3146 fputs (" COM", stdout
);
3148 printf ("%4x", psym
->st_shndx
);
3150 printf (" %s", strtab
+ psym
->st_name
);
3152 if (section
->sh_type
== SHT_DYNSYM
&&
3153 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
3155 unsigned char data
[2];
3156 unsigned short vers_data
;
3157 unsigned long offset
;
3161 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3164 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
3167 vers_data
= byte_get (data
, 2);
3169 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
3170 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
3173 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
3175 if ((vers_data
& 0x8000) || vers_data
> 1)
3177 if (is_nobits
|| ! check_def
)
3179 Elf_External_Verneed evn
;
3180 Elf_Internal_Verneed ivn
;
3181 Elf_Internal_Vernaux ivna
;
3183 /* We must test both. */
3184 offset
= version_info
3185 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
3187 GET_DATA (offset
, evn
, "version need");
3189 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3190 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3194 unsigned long vna_off
;
3196 vna_off
= offset
+ ivn
.vn_aux
;
3200 Elf_External_Vernaux evna
;
3202 GET_DATA (vna_off
, evna
,
3203 "version need aux (3)");
3205 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3206 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3207 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3209 vna_off
+= ivna
.vna_next
;
3211 while (ivna
.vna_other
!= vers_data
3212 && ivna
.vna_next
!= 0);
3214 if (ivna
.vna_other
== vers_data
)
3217 offset
+= ivn
.vn_next
;
3219 while (ivn
.vn_next
!= 0);
3221 if (ivna
.vna_other
== vers_data
)
3224 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
3227 else if (! is_nobits
)
3228 error (_("bad dynamic symbol"));
3235 if (vers_data
!= 0x8001)
3237 Elf_Internal_Verdef ivd
;
3238 Elf_Internal_Verdaux ivda
;
3239 Elf_External_Verdaux evda
;
3240 unsigned long offset
;
3243 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
3248 Elf_External_Verdef evd
;
3250 GET_DATA (offset
, evd
, "version def");
3252 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3253 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3254 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3256 offset
+= ivd
.vd_next
;
3258 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
3259 && ivd
.vd_next
!= 0);
3261 offset
-= ivd
.vd_next
;
3262 offset
+= ivd
.vd_aux
;
3264 GET_DATA (offset
, evda
, "version def aux");
3266 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3268 if (psym
->st_name
!= ivda
.vda_name
)
3269 printf ((vers_data
& 0x8000)
3271 strtab
+ ivda
.vda_name
);
3281 if (strtab
!= string_table
)
3287 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
3293 process_section_contents (file
)
3296 Elf32_Internal_Shdr
* section
;
3302 for (i
= 0, section
= section_headers
;
3303 i
< elf_header
.e_shnum
;
3306 #ifdef SUPPORT_DISASSEMBLY
3307 /* See if we need an assembly dump of this section */
3309 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & DISASS_DUMP
))
3311 printf (_("\nAssembly dump of section %s\n"),
3312 SECTION_NAME (section
));
3314 /* XXX -- to be done --- XXX */
3317 /* See if we need a hex dump of this section. */
3318 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & HEX_DUMP
))
3322 unsigned char * data
;
3325 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
3327 bytes
= section
->sh_size
;
3328 addr
= section
->sh_addr
;
3330 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, char *,
3341 lbytes
= (bytes
> 16 ? 16 : bytes
);
3343 printf (" 0x%8.8x ", addr
);
3345 switch (elf_header
.e_ident
[EI_DATA
])
3348 for (j
= 15; j
>= 0; j
--)
3351 printf ("%2.2x", data
[j
]);
3361 for (j
= 0; j
< 16; j
++)
3364 printf ("%2.2x", data
[j
]);
3374 for (j
= 0; j
< lbytes
; j
++)
3377 if (k
>= ' ' && k
< 0x80)
3398 process_mips_fpe_exception (mask
)
3404 if (mask
& OEX_FPU_INEX
)
3405 fputs ("INEX", stdout
), first
= 0;
3406 if (mask
& OEX_FPU_UFLO
)
3407 printf ("%sUFLO", first
? "" : "|"), first
= 0;
3408 if (mask
& OEX_FPU_OFLO
)
3409 printf ("%sOFLO", first
? "" : "|"), first
= 0;
3410 if (mask
& OEX_FPU_DIV0
)
3411 printf ("%sDIV0", first
? "" : "|"), first
= 0;
3412 if (mask
& OEX_FPU_INVAL
)
3413 printf ("%sINVAL", first
? "" : "|");
3416 fputs ("0", stdout
);
3420 process_mips_specific (file
)
3423 Elf_Internal_Dyn
* entry
;
3424 size_t liblist_offset
= 0;
3425 size_t liblistno
= 0;
3426 size_t options_offset
= 0;
3428 /* We have a lot of special sections. Thanks SGI! */
3429 if (dynamic_segment
== NULL
)
3430 /* No information available. */
3433 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
3434 switch (entry
->d_tag
)
3436 case DT_MIPS_LIBLIST
:
3437 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
3439 case DT_MIPS_LIBLISTNO
:
3440 liblistno
= entry
->d_un
.d_val
;
3442 case DT_MIPS_OPTIONS
:
3443 options_offset
= entry
->d_un
.d_val
- loadaddr
;
3449 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
3451 Elf32_External_Lib
*elib
;
3454 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
3455 elib
, Elf32_External_Lib
*, "liblist");
3457 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
3458 fputs (" Library Time Stamp Checksum Version Flags\n",
3461 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
3467 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
3468 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
3469 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
3470 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
3471 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
3473 strftime (timebuf
, 17, "%Y-%m-%dT%H:%M", gmtime (&time
));
3475 printf ("%3d: %-20s %s %#10lx %-7ld %#lx\n", cnt
,
3476 dynamic_strings
+ liblist
.l_name
, timebuf
,
3477 liblist
.l_checksum
, liblist
.l_version
, liblist
.l_flags
);
3483 if (options_offset
!= 0)
3485 Elf_External_Options
*eopt
;
3486 Elf_Internal_Shdr
*sect
= section_headers
;
3487 Elf_Internal_Options
*iopt
;
3488 Elf_Internal_Options
*option
;
3492 /* Find the section header so that we get the size. */
3493 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
3496 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
3497 Elf_External_Options
*, "options");
3499 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
3503 error (_("Out of memory"));
3509 while (offset
< sect
->sh_size
)
3511 Elf_External_Options
*eoption
;
3513 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
3515 option
->kind
= BYTE_GET (eoption
->kind
);
3516 option
->size
= BYTE_GET (eoption
->size
);
3517 option
->section
= BYTE_GET (eoption
->section
);
3518 option
->info
= BYTE_GET (eoption
->info
);
3520 offset
+= option
->size
;
3525 printf (_("\nSection '%s' contains %d entries:\n"),
3526 string_table
+ sect
->sh_name
, cnt
);
3533 switch (option
->kind
)
3536 /* This shouldn't happen. */
3537 printf (" NULL %d %x", option
->section
, option
->info
);
3540 printf (" REGINFO ");
3541 if (elf_header
.e_machine
== EM_MIPS
)
3544 Elf32_External_RegInfo
*ereg
;
3545 Elf32_RegInfo reginfo
;
3547 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
3548 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3549 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3550 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3551 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3552 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3553 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3555 printf ("GPR %08lx GP %ld\n",
3556 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3557 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3558 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3559 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3564 Elf64_External_RegInfo
*ereg
;
3565 Elf64_Internal_RegInfo reginfo
;
3567 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
3568 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3569 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3570 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3571 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3572 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3573 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3575 printf ("GPR %08lx GP %ld\n",
3576 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3577 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3578 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3579 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3583 case ODK_EXCEPTIONS
:
3584 fputs (" EXCEPTIONS fpe_min(", stdout
);
3585 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
3586 fputs (") fpe_max(", stdout
);
3587 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
3588 fputs (")", stdout
);
3590 if (option
->info
& OEX_PAGE0
)
3591 fputs (" PAGE0", stdout
);
3592 if (option
->info
& OEX_SMM
)
3593 fputs (" SMM", stdout
);
3594 if (option
->info
& OEX_FPDBUG
)
3595 fputs (" FPDBUG", stdout
);
3596 if (option
->info
& OEX_DISMISS
)
3597 fputs (" DISMISS", stdout
);
3600 fputs (" PAD ", stdout
);
3601 if (option
->info
& OPAD_PREFIX
)
3602 fputs (" PREFIX", stdout
);
3603 if (option
->info
& OPAD_POSTFIX
)
3604 fputs (" POSTFIX", stdout
);
3605 if (option
->info
& OPAD_SYMBOL
)
3606 fputs (" SYMBOL", stdout
);
3609 fputs (" HWPATCH ", stdout
);
3610 if (option
->info
& OHW_R4KEOP
)
3611 fputs (" R4KEOP", stdout
);
3612 if (option
->info
& OHW_R8KPFETCH
)
3613 fputs (" R8KPFETCH", stdout
);
3614 if (option
->info
& OHW_R5KEOP
)
3615 fputs (" R5KEOP", stdout
);
3616 if (option
->info
& OHW_R5KCVTL
)
3617 fputs (" R5KCVTL", stdout
);
3620 fputs (" FILL ", stdout
);
3621 /* XXX Print content of info word? */
3624 fputs (" TAGS ", stdout
);
3625 /* XXX Print content of info word? */
3628 fputs (" HWAND ", stdout
);
3629 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3630 fputs (" R4KEOP_CHECKED", stdout
);
3631 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3632 fputs (" R4KEOP_CLEAN", stdout
);
3635 fputs (" HWOR ", stdout
);
3636 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3637 fputs (" R4KEOP_CHECKED", stdout
);
3638 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3639 fputs (" R4KEOP_CLEAN", stdout
);
3642 printf (" GP_GROUP %#06x self-contained %#06x",
3643 option
->info
& OGP_GROUP
,
3644 (option
->info
& OGP_SELF
) >> 16);
3647 printf (" IDENT %#06x self-contained %#06x",
3648 option
->info
& OGP_GROUP
,
3649 (option
->info
& OGP_SELF
) >> 16);
3652 /* This shouldn't happen. */
3653 printf (" %3d ??? %d %x",
3654 option
->kind
, option
->section
, option
->info
);
3658 len
= sizeof (*eopt
);
3659 while (len
< option
->size
)
3660 if (((char *) option
)[len
] >= ' '
3661 && ((char *) option
)[len
] < 0x7f)
3662 printf ("%c", ((char *) option
)[len
++]);
3664 printf ("\\%03o", ((char *) option
)[len
++]);
3666 fputs ("\n", stdout
);
3677 process_arch_specific (file
)
3680 switch (elf_header
.e_machine
)
3683 case EM_MIPS_RS4_BE
:
3684 return process_mips_specific (file
);
3693 get_file_header (file
)
3696 Elf32_External_Ehdr ehdr
;
3698 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
3701 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
3703 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
3704 byte_get
= byte_get_little_endian
;
3706 byte_get
= byte_get_big_endian
;
3708 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
3709 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
3710 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
3711 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
3712 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
3713 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
3714 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
3715 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
3716 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
3717 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
3718 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
3719 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
3720 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
3726 process_file (file_name
)
3730 struct stat statbuf
;
3733 if (stat (file_name
, & statbuf
) < 0)
3735 error (_("Cannot stat input file %s.\n"), file_name
);
3739 file
= fopen (file_name
, "rb");
3742 error (_("Input file %s not found.\n"), file_name
);
3746 if (! get_file_header (file
))
3748 error (_("%s: Failed to read file header\n"), file_name
);
3753 /* Initialise per file variables. */
3754 for (i
= NUM_ELEM (version_info
); i
--;)
3755 version_info
[i
] = 0;
3757 for (i
= NUM_ELEM (dynamic_info
); i
--;)
3758 dynamic_info
[i
] = 0;
3761 /* Process the file. */
3763 printf (_("\nFile: %s\n"), file_name
);
3765 if (! process_file_header ())
3771 process_section_headers (file
);
3773 process_program_headers (file
);
3775 process_dynamic_segment (file
);
3777 process_relocs (file
);
3779 process_symbol_table (file
);
3781 process_version_sections (file
);
3783 process_section_contents (file
);
3785 process_arch_specific (file
);
3789 if (section_headers
)
3791 free (section_headers
);
3792 section_headers
= NULL
;
3797 free (string_table
);
3798 string_table
= NULL
;
3801 if (dynamic_strings
)
3803 free (dynamic_strings
);
3804 dynamic_strings
= NULL
;
3807 if (dynamic_symbols
)
3809 free (dynamic_symbols
);
3810 dynamic_symbols
= NULL
;
3814 #ifdef SUPPORT_DISASSEMBLY
3815 /* Needed by the i386 disassembler. For extra credit, someone could
3816 fix this so that we insert symbolic addresses here, esp for GOT/PLT
3820 print_address (unsigned int addr
, FILE * outfile
)
3822 fprintf (outfile
,"0x%8.8x", addr
);
3825 /* Needed by the i386 disassembler. */
3827 db_task_printsym (unsigned int addr
)
3829 print_address (addr
, stderr
);
3838 parse_args (argc
, argv
);
3840 if (optind
< (argc
- 1))
3843 while (optind
< argc
)
3844 process_file (argv
[optind
++]);