projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix displaying 64bit ELF files.
[binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 1999 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 02111-1307, USA. */
23 \f
24
25 #include <assert.h>
26 #include <sys/stat.h>
27 #include <stdio.h>
28 #include <time.h>
29
30 #if __GNUC__ >= 2
31 /* Define BFD64 here, even if our default architecture is 32 bit ELF
32 as this will allow us to read in and parse 64bit and 32bit ELF files.
33 Only do this if we belive that the compiler can support a 64 bit
34 data type. For now we only rely on GCC being able to do this. */
35 #define BFD64
36 #endif
37
38 #include "bfd.h"
39
40 #include "elf/common.h"
41 #include "elf/external.h"
42 #include "elf/internal.h"
43 #include "elf/dwarf2.h"
44
45 /* The following headers use the elf/reloc-macros.h file to
46 automatically generate relocation recognition functions
47 such as elf_mips_reloc_type() */
48
49 #define RELOC_MACROS_GEN_FUNC
50
51 #include "elf/i386.h"
52 #include "elf/v850.h"
53 #include "elf/ppc.h"
54 #include "elf/mips.h"
55 #include "elf/alpha.h"
56 #include "elf/arm.h"
57 #include "elf/m68k.h"
58 #include "elf/sparc.h"
59 #include "elf/m32r.h"
60 #include "elf/d10v.h"
61 #include "elf/d30v.h"
62 #include "elf/sh.h"
63 #include "elf/mn10200.h"
64 #include "elf/mn10300.h"
65 #include "elf/hppa.h"
66 #include "elf/arc.h"
67 #include "elf/fr30.h"
68 #include "elf/mcore.h"
69 #include "elf/i960.h"
70 #include "elf/pj.h"
71
72 #include "bucomm.h"
73 #include "getopt.h"
74
75 #ifdef ANSI_PROTOTYPES
76 #include <stdarg.h>
77 #else
78 #include <varargs.h>
79 #endif
80
81 char * program_name = "readelf";
82 unsigned int dynamic_addr;
83 bfd_size_type dynamic_size;
84 unsigned int rela_addr;
85 unsigned int rela_size;
86 char * dynamic_strings;
87 char * string_table;
88 unsigned long num_dynamic_syms;
89 Elf_Internal_Sym * dynamic_symbols;
90 Elf_Internal_Syminfo * dynamic_syminfo;
91 unsigned long dynamic_syminfo_offset;
92 unsigned int dynamic_syminfo_nent;
93 char program_interpreter [64];
94 int dynamic_info[DT_JMPREL + 1];
95 int version_info[16];
96 int loadaddr = 0;
97 Elf_Internal_Ehdr elf_header;
98 Elf_Internal_Shdr * section_headers;
99 Elf_Internal_Dyn * dynamic_segment;
100 int show_name;
101 int do_dynamic;
102 int do_syms;
103 int do_reloc;
104 int do_sections;
105 int do_segments;
106 int do_using_dynamic;
107 int do_header;
108 int do_dump;
109 int do_version;
110 int do_histogram;
111 int do_debugging;
112 int do_debug_info;
113 int do_debug_abbrevs;
114 int do_debug_lines;
115 int do_debug_pubnames;
116 int do_debug_aranges;
117 int do_arch;
118 int do_notes;
119 int is_32bit_elf;
120
121 /* A dynamic array of flags indicating which sections require dumping. */
122 char * dump_sects = NULL;
123 unsigned int num_dump_sects = 0;
124
125 #define HEX_DUMP (1 << 0)
126 #define DISASS_DUMP (1 << 1)
127 #define DEBUG_DUMP (1 << 2)
128
129 /* Forward declarations for dumb compilers. */
130 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
131 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
132 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
133 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
134 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
135 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
136 static const char * get_dynamic_type PARAMS ((unsigned long));
137 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
138 static char * get_file_type PARAMS ((unsigned));
139 static char * get_machine_name PARAMS ((unsigned));
140 static char * get_machine_flags PARAMS ((unsigned, unsigned));
141 static const char * get_mips_segment_type PARAMS ((unsigned long));
142 static const char * get_parisc_segment_type PARAMS ((unsigned long));
143 static const char * get_segment_type PARAMS ((unsigned long));
144 static const char * get_mips_section_type_name PARAMS ((unsigned int));
145 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
146 static const char * get_section_type_name PARAMS ((unsigned int));
147 static char * get_symbol_binding PARAMS ((unsigned int));
148 static char * get_symbol_type PARAMS ((unsigned int));
149 static void usage PARAMS ((void));
150 static void parse_args PARAMS ((int, char **));
151 static int process_file_header PARAMS ((void));
152 static int process_program_headers PARAMS ((FILE *));
153 static int process_section_headers PARAMS ((FILE *));
154 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
155 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
156 static int process_dynamic_segment PARAMS ((FILE *));
157 static int process_symbol_table PARAMS ((FILE *));
158 static int process_section_contents PARAMS ((FILE *));
159 static void process_file PARAMS ((char *));
160 static int process_relocs PARAMS ((FILE *));
161 static int process_version_sections PARAMS ((FILE *));
162 static char * get_ver_flags PARAMS ((unsigned int));
163 static char * get_symbol_index_type PARAMS ((unsigned int));
164 static int get_32bit_section_headers PARAMS ((FILE *));
165 static int get_64bit_section_headers PARAMS ((FILE *));
166 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
167 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
168 static int get_file_header PARAMS ((FILE *));
169 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
170 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
171 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
172 static int get_32bit_dynamic_segment PARAMS ((FILE *));
173 static int get_64bit_dynamic_segment PARAMS ((FILE *));
174 #ifdef SUPPORT_DISASSEMBLY
175 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
176 #endif
177 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
178 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
179 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
180 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
181 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
182 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
183 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
184 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
185 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
186 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
187 static void reset_state_machine PARAMS ((int));
188 static char * get_TAG_name PARAMS ((unsigned long));
189 static char * get_AT_name PARAMS ((unsigned long));
190 static char * get_FORM_name PARAMS ((unsigned long));
191 static void free_abbrevs PARAMS ((void));
192 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
193 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
194 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
195 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
196 static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
197 static void request_dump PARAMS ((unsigned int, char));
198 static const char * get_elf_class PARAMS ((unsigned char));
199 static const char * get_data_encoding PARAMS ((unsigned char));
200 static const char * get_osabi_name PARAMS ((unsigned char));
201 static int guess_is_rela PARAMS ((unsigned long));
202 static char * get_note_type PARAMS ((unsigned int));
203 static int process_note PARAMS ((Elf32_Internal_Note *));
204 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
205 static int process_corefile_note_segments PARAMS ((FILE *));
206 static int process_corefile_contents PARAMS ((FILE *));
207
208 typedef int Elf32_Word;
209
210 #ifndef TRUE
211 #define TRUE 1
212 #define FALSE 0
213 #endif
214 #define UNKNOWN -1
215
216 #define SECTION_NAME(X) (string_table + (X)->sh_name)
217
218 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
219
220 #define BYTE_GET(field) byte_get (field, sizeof (field))
221
222 /* If we can support a 64 bit data type then BFD64 should be defined
223 and sizeof (bfd_vma) == 8. In this case when translating from an
224 external 8 byte field to an internal field, we can assume that the
225 internal field is also 8 bytes wide and so we can extact all the data.
226 If, however, BFD64 is not defined, then we must assume that the
227 internal data structure only has 4 byte wide fields that are the
228 equivalent of the 8 byte wide external counterparts, and so we must
229 truncate the data. */
230 #ifdef BFD64
231 #define BYTE_GET8(field) byte_get (field, -8)
232 #else
233 #define BYTE_GET8(field) byte_get (field, 8)
234 #endif
235
236 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
237
238 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
239 if (fseek (file, offset, SEEK_SET)) \
240 { \
241 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
242 return 0; \
243 } \
244 \
245 var = (type) malloc (size); \
246 \
247 if (var == NULL) \
248 { \
249 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
250 return 0; \
251 } \
252 \
253 if (fread (var, size, 1, file) != 1) \
254 { \
255 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
256 free (var); \
257 var = NULL; \
258 return 0; \
259 }
260
261
262 #define GET_DATA(offset, var, reason) \
263 if (fseek (file, offset, SEEK_SET)) \
264 { \
265 error (_("Unable to seek to %x for %s\n"), offset, reason); \
266 return 0; \
267 } \
268 else if (fread (& var, sizeof (var), 1, file) != 1) \
269 { \
270 error (_("Unable to read data at %x for %s\n"), offset, reason); \
271 return 0; \
272 }
273
274 #define GET_ELF_SYMBOLS(file, offset, size) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
276 : get_64bit_elf_symbols (file, offset, size))
277
278
279 #ifdef ANSI_PROTOTYPES
280 static void
281 error (const char * message, ...)
282 {
283 va_list args;
284
285 fprintf (stderr, _("%s: Error: "), program_name);
286 va_start (args, message);
287 vfprintf (stderr, message, args);
288 va_end (args);
289 return;
290 }
291
292 static void
293 warn (const char * message, ...)
294 {
295 va_list args;
296
297 fprintf (stderr, _("%s: Warning: "), program_name);
298 va_start (args, message);
299 vfprintf (stderr, message, args);
300 va_end (args);
301 return;
302 }
303 #else
304 static void
305 error (va_alist)
306 va_dcl
307 {
308 char * message;
309 va_list args;
310
311 fprintf (stderr, _("%s: Error: "), program_name);
312 va_start (args);
313 message = va_arg (args, char *);
314 vfprintf (stderr, message, args);
315 va_end (args);
316 return;
317 }
318
319 static void
320 warn (va_alist)
321 va_dcl
322 {
323 char * message;
324 va_list args;
325
326 fprintf (stderr, _("%s: Warning: "), program_name);
327 va_start (args);
328 message = va_arg (args, char *);
329 vfprintf (stderr, message, args);
330 va_end (args);
331 return;
332 }
333 #endif
334
335 static bfd_vma
336 byte_get_little_endian (field, size)
337 unsigned char * field;
338 int size;
339 {
340 switch (size)
341 {
342 case 1:
343 return * field;
344
345 case 2:
346 return ((unsigned int) (field [0]))
347 | (((unsigned int) (field [1])) << 8);
348
349 case 8:
350 /* We want to extract data from an 8 byte wide field and
351 place it into a 4 byte wide field. Since this is a little
352 endian source we can juts use the 4 byte extraction code. */
353 /* Fall through. */
354 case 4:
355 return ((unsigned long) (field [0]))
356 | (((unsigned long) (field [1])) << 8)
357 | (((unsigned long) (field [2])) << 16)
358 | (((unsigned long) (field [3])) << 24);
359
360 #ifdef BFD64
361 case -8:
362 /* This is a special case, generated by the BYTE_GET8 macro.
363 It means that we are loading an 8 byte value from a field
364 in an external structure into an 8 byte value in a field
365 in an internal strcuture. */
366 return ((bfd_vma) (field [0]))
367 | (((bfd_vma) (field [1])) << 8)
368 | (((bfd_vma) (field [2])) << 16)
369 | (((bfd_vma) (field [3])) << 24)
370 | (((bfd_vma) (field [4])) << 32)
371 | (((bfd_vma) (field [5])) << 40)
372 | (((bfd_vma) (field [6])) << 48)
373 | (((bfd_vma) (field [7])) << 56);
374 #endif
375 default:
376 error (_("Unhandled data length: %d\n"), size);
377 abort ();
378 }
379 }
380
381 /* Print a VMA value. */
382 typedef enum print_mode
383 {
384 HEX,
385 DEC,
386 DEC_5,
387 UNSIGNED,
388 PREFIX_HEX,
389 FULL_HEX,
390 LONG_HEX
391 }
392 print_mode;
393
394 static void print_vma PARAMS ((bfd_vma, print_mode));
395
396 static void
397 print_vma (vma, mode)
398 bfd_vma vma;
399 print_mode mode;
400 {
401 #ifdef BFD64
402 if (is_32bit_elf)
403 #endif
404 {
405 switch (mode)
406 {
407 case FULL_HEX: printf ("0x"); /* drop through */
408 case LONG_HEX: printf ("%08.8lx", vma); break;
409 case PREFIX_HEX: printf ("0x"); /* drop through */
410 case HEX: printf ("%lx", vma); break;
411 case DEC: printf ("%ld", vma); break;
412 case DEC_5: printf ("%5ld", vma); break;
413 case UNSIGNED: printf ("%lu", vma); break;
414 }
415 }
416 #ifdef BFD64
417 else
418 {
419 switch (mode)
420 {
421 case FULL_HEX:
422 printf ("0x");
423 /* drop through */
424
425 case LONG_HEX:
426 printf_vma (vma);
427 break;
428
429 case PREFIX_HEX:
430 printf ("0x");
431 /* drop through */
432
433 case HEX:
434 #if BFD_HOST_64BIT_LONG
435 printf ("%lx", vma);
436 #else
437 if (_bfd_int64_high (vma))
438 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
439 else
440 printf ("%lx", _bfd_int64_low (vma));
441 #endif
442 break;
443
444 case DEC:
445 if (_bfd_int64_high (vma))
446 /* ugg */
447 printf ("++%ld", _bfd_int64_low (vma));
448 else
449 printf ("%ld", _bfd_int64_low (vma));
450 break;
451
452 case DEC_5:
453 if (_bfd_int64_high (vma))
454 /* ugg */
455 printf ("++%ld", _bfd_int64_low (vma));
456 else
457 printf ("%5ld", _bfd_int64_low (vma));
458 break;
459
460 case UNSIGNED:
461 if (_bfd_int64_high (vma))
462 /* ugg */
463 printf ("++%lu", _bfd_int64_low (vma));
464 else
465 printf ("%lu", _bfd_int64_low (vma));
466 break;
467 }
468 }
469 #endif
470 }
471
472 static bfd_vma
473 byte_get_big_endian (field, size)
474 unsigned char * field;
475 int size;
476 {
477 switch (size)
478 {
479 case 1:
480 return * field;
481
482 case 2:
483 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
484
485 case 4:
486 return ((unsigned long) (field [3]))
487 | (((unsigned long) (field [2])) << 8)
488 | (((unsigned long) (field [1])) << 16)
489 | (((unsigned long) (field [0])) << 24);
490
491 case 8:
492 /* Although we are extracing data from an 8 byte wide field, we
493 are returning only 4 bytes of data. */
494 return ((unsigned long) (field [7]))
495 | (((unsigned long) (field [6])) << 8)
496 | (((unsigned long) (field [5])) << 16)
497 | (((unsigned long) (field [4])) << 24);
498
499 #ifdef BFD64
500 case -8:
501 /* This is a special case, generated by the BYTE_GET8 macro.
502 It means that we are loading an 8 byte value from a field
503 in an external structure into an 8 byte value in a field
504 in an internal strcuture. */
505 return ((bfd_vma) (field [7]))
506 | (((bfd_vma) (field [6])) << 8)
507 | (((bfd_vma) (field [5])) << 16)
508 | (((bfd_vma) (field [4])) << 24)
509 | (((bfd_vma) (field [3])) << 32)
510 | (((bfd_vma) (field [2])) << 40)
511 | (((bfd_vma) (field [1])) << 48)
512 | (((bfd_vma) (field [0])) << 56);
513 #endif
514
515 default:
516 error (_("Unhandled data length: %d\n"), size);
517 abort ();
518 }
519 }
520
521
522 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
523 static int
524 guess_is_rela (e_machine)
525 unsigned long e_machine;
526 {
527 switch (e_machine)
528 {
529 /* Targets that use REL relocations. */
530 case EM_ARM:
531 case EM_386:
532 case EM_486:
533 case EM_960:
534 case EM_CYGNUS_M32R:
535 case EM_CYGNUS_D10V:
536 case EM_MIPS:
537 case EM_MIPS_RS4_BE:
538 return FALSE;
539
540 /* Targets that use RELA relocations. */
541 case EM_68K:
542 case EM_SPARC32PLUS:
543 case EM_SPARCV9:
544 case EM_SPARC:
545 case EM_PPC:
546 case EM_CYGNUS_V850:
547 case EM_CYGNUS_D30V:
548 case EM_CYGNUS_MN10200:
549 case EM_CYGNUS_MN10300:
550 case EM_CYGNUS_FR30:
551 case EM_SH:
552 case EM_ALPHA:
553 case EM_MCORE:
554 return TRUE;
555
556 default:
557 warn (_("Don't know about relocations on this machine architecture\n"));
558 return FALSE;
559 }
560 }
561
562 /* Display the contents of the relocation data found at the specified offset. */
563 static int
564 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
565 FILE * file;
566 unsigned long rel_offset;
567 unsigned long rel_size;
568 Elf_Internal_Sym * symtab;
569 unsigned long nsyms;
570 char * strtab;
571 int is_rela;
572 {
573 unsigned int i;
574 Elf_Internal_Rel * rels;
575 Elf_Internal_Rela * relas;
576
577
578 if (is_rela == UNKNOWN)
579 is_rela = guess_is_rela (elf_header.e_machine);
580
581 if (is_rela)
582 {
583 if (is_32bit_elf)
584 {
585 Elf32_External_Rela * erelas;
586
587 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
588 Elf32_External_Rela *, "relocs");
589
590 rel_size = rel_size / sizeof (Elf32_External_Rela);
591
592 relas = (Elf_Internal_Rela *)
593 malloc (rel_size * sizeof (Elf_Internal_Rela));
594
595 if (relas == NULL)
596 {
597 error(_("out of memory parsing relocs"));
598 return 0;
599 }
600
601 for (i = 0; i < rel_size; i++)
602 {
603 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
604 relas[i].r_info = BYTE_GET (erelas[i].r_info);
605 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
606 }
607
608 free (erelas);
609
610 rels = (Elf_Internal_Rel *) relas;
611 }
612 else
613 {
614 Elf64_External_Rela * erelas;
615
616 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
617 Elf64_External_Rela *, "relocs");
618
619 rel_size = rel_size / sizeof (Elf64_External_Rela);
620
621 relas = (Elf_Internal_Rela *)
622 malloc (rel_size * sizeof (Elf_Internal_Rela));
623
624 if (relas == NULL)
625 {
626 error(_("out of memory parsing relocs"));
627 return 0;
628 }
629
630 for (i = 0; i < rel_size; i++)
631 {
632 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
633 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
634 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
635 }
636
637 free (erelas);
638
639 rels = (Elf_Internal_Rel *) relas;
640 }
641 }
642 else
643 {
644 if (is_32bit_elf)
645 {
646 Elf32_External_Rel * erels;
647
648 GET_DATA_ALLOC (rel_offset, rel_size, erels,
649 Elf32_External_Rel *, "relocs");
650
651 rel_size = rel_size / sizeof (Elf32_External_Rel);
652
653 rels = (Elf_Internal_Rel *)
654 malloc (rel_size * sizeof (Elf_Internal_Rel));
655
656 if (rels == NULL)
657 {
658 error(_("out of memory parsing relocs"));
659 return 0;
660 }
661
662 for (i = 0; i < rel_size; i++)
663 {
664 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
665 rels[i].r_info = BYTE_GET (erels[i].r_info);
666 }
667
668 free (erels);
669
670 relas = (Elf_Internal_Rela *) rels;
671 }
672 else
673 {
674 Elf64_External_Rel * erels;
675
676 GET_DATA_ALLOC (rel_offset, rel_size, erels,
677 Elf64_External_Rel *, "relocs");
678
679 rel_size = rel_size / sizeof (Elf64_External_Rel);
680
681 rels = (Elf_Internal_Rel *)
682 malloc (rel_size * sizeof (Elf_Internal_Rel));
683
684 if (rels == NULL)
685 {
686 error(_("out of memory parsing relocs"));
687 return 0;
688 }
689
690 for (i = 0; i < rel_size; i++)
691 {
692 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
693 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
694 }
695
696 free (erels);
697
698 relas = (Elf_Internal_Rela *) rels;
699 }
700 }
701
702 if (is_rela)
703 printf
704 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
705 else
706 printf
707 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
708
709 for (i = 0; i < rel_size; i++)
710 {
711 const char * rtype;
712 bfd_vma offset;
713 bfd_vma info;
714 bfd_vma symtab_index;
715 bfd_vma type;
716
717 if (is_rela)
718 {
719 offset = relas [i].r_offset;
720 info = relas [i].r_info;
721 }
722 else
723 {
724 offset = rels [i].r_offset;
725 info = rels [i].r_info;
726 }
727
728 if (is_32bit_elf)
729 {
730 type = ELF32_R_TYPE (info);
731 symtab_index = ELF32_R_SYM (info);
732 }
733 else
734 {
735 if (elf_header.e_machine == EM_SPARCV9)
736 type = ELF64_R_TYPE_ID (info);
737 else
738 type = ELF64_R_TYPE (info);
739 /* The #ifdef BFD64 below is to prevent a compile time warning.
740 We know that if we do not have a 64 bit data type that we
741 will never execute this code anyway. */
742 #ifdef BFD64
743 symtab_index = ELF64_R_SYM (info);
744 #endif
745 }
746
747 #ifdef _bfd_int64_low
748 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
749 #else
750 printf (" %8.8lx %5.5lx ", offset, info);
751 #endif
752
753 switch (elf_header.e_machine)
754 {
755 default:
756 rtype = NULL;
757 break;
758
759 case EM_CYGNUS_M32R:
760 rtype = elf_m32r_reloc_type (type);
761 break;
762
763 case EM_386:
764 case EM_486:
765 rtype = elf_i386_reloc_type (type);
766 break;
767
768 case EM_68K:
769 rtype = elf_m68k_reloc_type (type);
770 break;
771
772 case EM_960:
773 rtype = elf_i960_reloc_type (type);
774 break;
775
776 case EM_OLD_SPARCV9:
777 case EM_SPARC32PLUS:
778 case EM_SPARCV9:
779 case EM_SPARC:
780 rtype = elf_sparc_reloc_type (type);
781 break;
782
783 case EM_CYGNUS_V850:
784 rtype = v850_reloc_type (type);
785 break;
786
787 case EM_CYGNUS_D10V:
788 rtype = elf_d10v_reloc_type (type);
789 break;
790
791 case EM_CYGNUS_D30V:
792 rtype = elf_d30v_reloc_type (type);
793 break;
794
795 case EM_SH:
796 rtype = elf_sh_reloc_type (type);
797 break;
798
799 case EM_CYGNUS_MN10300:
800 rtype = elf_mn10300_reloc_type (type);
801 break;
802
803 case EM_CYGNUS_MN10200:
804 rtype = elf_mn10200_reloc_type (type);
805 break;
806
807 case EM_CYGNUS_FR30:
808 rtype = elf_fr30_reloc_type (type);
809 break;
810
811 case EM_MCORE:
812 rtype = elf_mcore_reloc_type (type);
813 break;
814
815 case EM_PPC:
816 rtype = elf_ppc_reloc_type (type);
817 break;
818
819 case EM_MIPS:
820 case EM_MIPS_RS4_BE:
821 rtype = elf_mips_reloc_type (type);
822 break;
823
824 case EM_ALPHA:
825 rtype = elf_alpha_reloc_type (type);
826 break;
827
828 case EM_ARM:
829 rtype = elf_arm_reloc_type (type);
830 break;
831
832 case EM_CYGNUS_ARC:
833 rtype = elf_arc_reloc_type (type);
834 break;
835
836 case EM_PARISC:
837 rtype = elf_hppa_reloc_type (type);
838 break;
839
840 case EM_PJ:
841 rtype = elf_pj_reloc_type (type);
842 break;
843 }
844
845 if (rtype == NULL)
846 #ifdef _bfd_int64_low
847 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
848 #else
849 printf (_("unrecognised: %-7lx"), type);
850 #endif
851 else
852 printf ("%-21.21s", rtype);
853
854 if (symtab_index)
855 {
856 if (symtab != NULL)
857 {
858 if (symtab_index >= nsyms)
859 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
860 else
861 {
862 Elf_Internal_Sym * psym;
863
864 psym = symtab + symtab_index;
865
866 printf (" ");
867 print_vma (psym->st_value, LONG_HEX);
868 printf (" ");
869
870 if (psym->st_name == 0)
871 printf ("%-25.25s",
872 SECTION_NAME (section_headers + psym->st_shndx));
873 else if (strtab == NULL)
874 printf (_("<string table index %3ld>"), psym->st_name);
875 else
876 printf ("%-25.25s", strtab + psym->st_name);
877
878 if (is_rela)
879 printf (" + %lx", (unsigned long) relas [i].r_addend);
880 }
881 }
882 }
883 else if (is_rela)
884 {
885 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
886 print_vma (relas[i].r_addend, LONG_HEX);
887 }
888
889 if (elf_header.e_machine == EM_SPARCV9
890 && !strcmp (rtype, "R_SPARC_OLO10"))
891 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
892
893 putchar ('\n');
894 }
895
896 free (relas);
897
898 return 1;
899 }
900
901 static const char *
902 get_mips_dynamic_type (type)
903 unsigned long type;
904 {
905 switch (type)
906 {
907 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
908 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
909 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
910 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
911 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
912 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
913 case DT_MIPS_MSYM: return "MIPS_MSYM";
914 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
915 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
916 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
917 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
918 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
919 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
920 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
921 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
922 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
923 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
924 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
925 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
926 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
927 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
928 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
929 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
930 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
931 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
932 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
933 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
934 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
935 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
936 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
937 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
938 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
939 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
940 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
941 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
942 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
943 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
944 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
945 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
946 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
947 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
948 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
949 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
950 default:
951 return NULL;
952 }
953 }
954
955 static const char *
956 get_sparc64_dynamic_type (type)
957 unsigned long type;
958 {
959 switch (type)
960 {
961 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
962 default:
963 return NULL;
964 }
965 }
966
967 static const char *
968 get_parisc_dynamic_type (type)
969 unsigned long type;
970 {
971 switch (type)
972 {
973 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
974 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
975 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
976 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
977 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
978 case DT_HP_PREINIT: return "HP_PREINIT";
979 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
980 case DT_HP_NEEDED: return "HP_NEEDED";
981 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
982 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
983 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
984 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
985 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
986 default:
987 return NULL;
988 }
989 }
990
991 static const char *
992 get_dynamic_type (type)
993 unsigned long type;
994 {
995 static char buff [32];
996
997 switch (type)
998 {
999 case DT_NULL: return "NULL";
1000 case DT_NEEDED: return "NEEDED";
1001 case DT_PLTRELSZ: return "PLTRELSZ";
1002 case DT_PLTGOT: return "PLTGOT";
1003 case DT_HASH: return "HASH";
1004 case DT_STRTAB: return "STRTAB";
1005 case DT_SYMTAB: return "SYMTAB";
1006 case DT_RELA: return "RELA";
1007 case DT_RELASZ: return "RELASZ";
1008 case DT_RELAENT: return "RELAENT";
1009 case DT_STRSZ: return "STRSZ";
1010 case DT_SYMENT: return "SYMENT";
1011 case DT_INIT: return "INIT";
1012 case DT_FINI: return "FINI";
1013 case DT_SONAME: return "SONAME";
1014 case DT_RPATH: return "RPATH";
1015 case DT_SYMBOLIC: return "SYMBOLIC";
1016 case DT_REL: return "REL";
1017 case DT_RELSZ: return "RELSZ";
1018 case DT_RELENT: return "RELENT";
1019 case DT_PLTREL: return "PLTREL";
1020 case DT_DEBUG: return "DEBUG";
1021 case DT_TEXTREL: return "TEXTREL";
1022 case DT_JMPREL: return "JMPREL";
1023 case DT_BIND_NOW: return "BIND_NOW";
1024 case DT_INIT_ARRAY: return "INIT_ARRAY";
1025 case DT_FINI_ARRAY: return "FINI_ARRAY";
1026 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1027 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1028
1029 case DT_PLTPADSZ: return "PLTPADSZ";
1030 case DT_MOVEENT: return "MOVEENT";
1031 case DT_MOVESZ: return "MOVESZ";
1032 case DT_FEATURE_1: return "FEATURE_1";
1033 case DT_POSFLAG_1: return "POSFLAG_1";
1034 case DT_SYMINSZ: return "SYMINSZ";
1035 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1036
1037 case DT_ADDRRNGLO: return "ADDRRNGLO";
1038 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1039
1040 case DT_VERSYM: return "VERSYM";
1041
1042 case DT_RELACOUNT: return "RELACOUNT";
1043 case DT_RELCOUNT: return "RELCOUNT";
1044 case DT_FLAGS_1: return "FLAGS_1";
1045 case DT_VERDEF: return "VERDEF";
1046 case DT_VERDEFNUM: return "VERDEFNUM";
1047 case DT_VERNEED: return "VERNEED";
1048 case DT_VERNEEDNUM: return "VERNEEDNUM";
1049
1050 case DT_AUXILIARY: return "AUXILARY";
1051 case DT_USED: return "USED";
1052 case DT_FILTER: return "FILTER";
1053
1054 default:
1055 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1056 {
1057 const char * result;
1058
1059 switch (elf_header.e_machine)
1060 {
1061 case EM_MIPS:
1062 case EM_MIPS_RS4_BE:
1063 result = get_mips_dynamic_type (type);
1064 break;
1065 case EM_SPARCV9:
1066 result = get_sparc64_dynamic_type (type);
1067 break;
1068 default:
1069 result = NULL;
1070 break;
1071 }
1072
1073 if (result != NULL)
1074 return result;
1075
1076 sprintf (buff, _("Processor Specific: %lx"), type);
1077 }
1078 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1079 {
1080 const char * result;
1081
1082 switch (elf_header.e_machine)
1083 {
1084 case EM_PARISC:
1085 result = get_parisc_dynamic_type (type);
1086 break;
1087 default:
1088 result = NULL;
1089 break;
1090 }
1091
1092 if (result != NULL)
1093 return result;
1094
1095 sprintf (buff, _("Operating System specific: %lx"), type);
1096 }
1097 else
1098 sprintf (buff, _("<unknown>: %lx"), type);
1099
1100 return buff;
1101 }
1102 }
1103
1104 static char *
1105 get_file_type (e_type)
1106 unsigned e_type;
1107 {
1108 static char buff [32];
1109
1110 switch (e_type)
1111 {
1112 case ET_NONE: return _("NONE (None)");
1113 case ET_REL: return _("REL (Relocatable file)");
1114 case ET_EXEC: return _("EXEC (Executable file)");
1115 case ET_DYN: return _("DYN (Shared object file)");
1116 case ET_CORE: return _("CORE (Core file)");
1117
1118 default:
1119 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1120 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1121 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1122 sprintf (buff, _("OS Specific: (%x)"), e_type);
1123 else
1124 sprintf (buff, _("<unknown>: %x"), e_type);
1125 return buff;
1126 }
1127 }
1128
1129 static char *
1130 get_machine_name (e_machine)
1131 unsigned e_machine;
1132 {
1133 static char buff [32];
1134
1135 switch (e_machine)
1136 {
1137 case EM_NONE: return _("None");
1138 case EM_M32: return "WE32100";
1139 case EM_SPARC: return "Sparc";
1140 case EM_386: return "Intel 80386";
1141 case EM_68K: return "MC68000";
1142 case EM_88K: return "MC88000";
1143 case EM_486: return "Intel 80486";
1144 case EM_860: return "Intel 80860";
1145 case EM_MIPS: return "MIPS R3000 big-endian";
1146 case EM_S370: return "Amdahl";
1147 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1148 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1149 case EM_PARISC: return "HPPA";
1150 case EM_PPC_OLD: return "Power PC (old)";
1151 case EM_SPARC32PLUS: return "Sparc v8+" ;
1152 case EM_960: return "Intel 90860";
1153 case EM_PPC: return "PowerPC";
1154 case EM_V800: return "NEC V800";
1155 case EM_FR20: return "Fujitsu FR20";
1156 case EM_RH32: return "TRW RH32";
1157 case EM_MCORE: return "MCORE";
1158 case EM_ARM: return "ARM";
1159 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1160 case EM_SH: return "Hitachi SH";
1161 case EM_SPARCV9: return "Sparc v9";
1162 case EM_TRICORE: return "Siemens Tricore";
1163 case EM_ARC: return "Argonaut RISC Core";
1164 case EM_H8_300: return "Hitachi H8/300";
1165 case EM_H8_300H: return "Hitachi H8/300H";
1166 case EM_H8S: return "Hitachi H8S";
1167 case EM_H8_500: return "Hitachi H8/500";
1168 case EM_IA_64: return "Intel Merced";
1169 case EM_MIPS_X: return "Stanford MIPS-X";
1170 case EM_COLDFIRE: return "Motorola Coldfire";
1171 case EM_68HC12: return "Motorola M68HC12";
1172 case EM_ALPHA: return "Alpha";
1173 case EM_CYGNUS_D10V: return "d10v";
1174 case EM_CYGNUS_D30V: return "d30v";
1175 case EM_CYGNUS_ARC: return "Arc";
1176 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1177 case EM_CYGNUS_V850: return "NEC v850";
1178 case EM_CYGNUS_MN10300: return "mn10300";
1179 case EM_CYGNUS_MN10200: return "mn10200";
1180 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1181 case EM_PJ: return "picoJava";
1182 default:
1183 sprintf (buff, _("<unknown>: %x"), e_machine);
1184 return buff;
1185 }
1186 }
1187
1188 static char *
1189 get_machine_flags (e_flags, e_machine)
1190 unsigned e_flags;
1191 unsigned e_machine;
1192 {
1193 static char buf [1024];
1194
1195 buf[0] = '\0';
1196 if (e_flags)
1197 {
1198 switch (e_machine)
1199 {
1200 default:
1201 break;
1202
1203 case EM_68K:
1204 if (e_flags & EF_CPU32)
1205 strcat (buf, ", cpu32");
1206 break;
1207
1208 case EM_PPC:
1209 if (e_flags & EF_PPC_EMB)
1210 strcat (buf, ", emb");
1211
1212 if (e_flags & EF_PPC_RELOCATABLE)
1213 strcat (buf, ", relocatable");
1214
1215 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1216 strcat (buf, ", relocatable-lib");
1217 break;
1218
1219 case EM_CYGNUS_V850:
1220 switch (e_flags & EF_V850_ARCH)
1221 {
1222 case E_V850E_ARCH:
1223 strcat (buf, ", v850e");
1224 break;
1225 case E_V850EA_ARCH:
1226 strcat (buf, ", v850ea");
1227 break;
1228 case E_V850_ARCH:
1229 strcat (buf, ", v850");
1230 break;
1231 default:
1232 strcat (buf, ", unknown v850 architecture variant");
1233 break;
1234 }
1235 break;
1236
1237 case EM_CYGNUS_M32R:
1238 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1239 strcat (buf, ", m32r");
1240
1241 break;
1242
1243 case EM_MIPS:
1244 case EM_MIPS_RS4_BE:
1245 if (e_flags & EF_MIPS_NOREORDER)
1246 strcat (buf, ", noreorder");
1247
1248 if (e_flags & EF_MIPS_PIC)
1249 strcat (buf, ", pic");
1250
1251 if (e_flags & EF_MIPS_CPIC)
1252 strcat (buf, ", cpic");
1253
1254 if (e_flags & EF_MIPS_ABI2)
1255 strcat (buf, ", abi2");
1256
1257 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1258 strcat (buf, ", mips1");
1259
1260 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1261 strcat (buf, ", mips2");
1262
1263 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1264 strcat (buf, ", mips3");
1265
1266 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1267 strcat (buf, ", mips4");
1268 break;
1269
1270 case EM_SPARCV9:
1271 if (e_flags & EF_SPARC_32PLUS)
1272 strcat (buf, ", v8+");
1273
1274 if (e_flags & EF_SPARC_SUN_US1)
1275 strcat (buf, ", ultrasparcI");
1276
1277 if (e_flags & EF_SPARC_SUN_US3)
1278 strcat (buf, ", ultrasparcIII");
1279
1280 if (e_flags & EF_SPARC_HAL_R1)
1281 strcat (buf, ", halr1");
1282
1283 if (e_flags & EF_SPARC_LEDATA)
1284 strcat (buf, ", ledata");
1285
1286 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1287 strcat (buf, ", tso");
1288
1289 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1290 strcat (buf, ", pso");
1291
1292 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1293 strcat (buf, ", rmo");
1294 break;
1295
1296 case EM_PARISC:
1297 switch (e_flags & EF_PARISC_ARCH)
1298 {
1299 case EFA_PARISC_1_0:
1300 strcpy (buf, ", PA-RISC 1.0");
1301 break;
1302 case EFA_PARISC_1_1:
1303 strcpy (buf, ", PA-RISC 1.1");
1304 break;
1305 case EFA_PARISC_2_0:
1306 strcpy (buf, ", PA-RISC 2.0");
1307 break;
1308 default:
1309 break;
1310 }
1311 if (e_flags & EF_PARISC_TRAPNIL)
1312 strcat (buf, ", trapnil");
1313 if (e_flags & EF_PARISC_EXT)
1314 strcat (buf, ", ext");
1315 if (e_flags & EF_PARISC_LSB)
1316 strcat (buf, ", lsb");
1317 if (e_flags & EF_PARISC_WIDE)
1318 strcat (buf, ", wide");
1319 if (e_flags & EF_PARISC_NO_KABP)
1320 strcat (buf, ", no kabp");
1321 if (e_flags & EF_PARISC_LAZYSWAP)
1322 strcat (buf, ", lazyswap");
1323
1324 case EM_PJ:
1325 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1326 strcat (buf, ", new calling convention");
1327
1328 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1329 strcat (buf, ", gnu calling convention");
1330 break;
1331 }
1332 }
1333
1334 return buf;
1335 }
1336
1337 static const char *
1338 get_mips_segment_type (type)
1339 unsigned long type;
1340 {
1341 switch (type)
1342 {
1343 case PT_MIPS_REGINFO:
1344 return "REGINFO";
1345 case PT_MIPS_RTPROC:
1346 return "RTPROC";
1347 case PT_MIPS_OPTIONS:
1348 return "OPTIONS";
1349 default:
1350 break;
1351 }
1352
1353 return NULL;
1354 }
1355
1356 static const char *
1357 get_parisc_segment_type (type)
1358 unsigned long type;
1359 {
1360 switch (type)
1361 {
1362 case PT_HP_TLS: return "HP_TLS";
1363 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1364 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1365 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1366 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1367 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1368 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1369 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1370 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1371 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1372 case PT_HP_PARALLEL: return "HP_PARALLEL";
1373 case PT_HP_FASTBIND: return "HP_FASTBIND";
1374 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1375 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1376 default:
1377 break;
1378 }
1379
1380 return NULL;
1381 }
1382
1383 static const char *
1384 get_segment_type (p_type)
1385 unsigned long p_type;
1386 {
1387 static char buff [32];
1388
1389 switch (p_type)
1390 {
1391 case PT_NULL: return "NULL";
1392 case PT_LOAD: return "LOAD";
1393 case PT_DYNAMIC: return "DYNAMIC";
1394 case PT_INTERP: return "INTERP";
1395 case PT_NOTE: return "NOTE";
1396 case PT_SHLIB: return "SHLIB";
1397 case PT_PHDR: return "PHDR";
1398
1399 default:
1400 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1401 {
1402 const char * result;
1403
1404 switch (elf_header.e_machine)
1405 {
1406 case EM_MIPS:
1407 case EM_MIPS_RS4_BE:
1408 result = get_mips_segment_type (p_type);
1409 break;
1410 case EM_PARISC:
1411 result = get_parisc_segment_type (p_type);
1412 break;
1413 default:
1414 result = NULL;
1415 break;
1416 }
1417
1418 if (result != NULL)
1419 return result;
1420
1421 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1422 }
1423 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1424 {
1425 const char * result;
1426
1427 switch (elf_header.e_machine)
1428 {
1429 case EM_PARISC:
1430 result = get_parisc_segment_type (p_type);
1431 break;
1432 default:
1433 result = NULL;
1434 break;
1435 }
1436
1437 if (result != NULL)
1438 return result;
1439
1440 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1441 }
1442 else
1443 sprintf (buff, _("<unknown>: %lx"), p_type);
1444
1445 return buff;
1446 }
1447 }
1448
1449 static const char *
1450 get_mips_section_type_name (sh_type)
1451 unsigned int sh_type;
1452 {
1453 switch (sh_type)
1454 {
1455 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1456 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1457 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1458 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1459 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1460 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1461 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1462 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1463 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1464 case SHT_MIPS_RELD: return "MIPS_RELD";
1465 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1466 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1467 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1468 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1469 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1470 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1471 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1472 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1473 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1474 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1475 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1476 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1477 case SHT_MIPS_LINE: return "MIPS_LINE";
1478 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1479 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1480 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1481 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1482 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1483 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1484 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1485 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1486 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1487 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1488 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1489 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1490 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1491 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1492 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1493 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1494 default:
1495 break;
1496 }
1497 return NULL;
1498 }
1499
1500 static const char *
1501 get_parisc_section_type_name (sh_type)
1502 unsigned int sh_type;
1503 {
1504 switch (sh_type)
1505 {
1506 case SHT_PARISC_EXT: return "PARISC_EXT";
1507 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1508 case SHT_PARISC_DOC: return "PARISC_DOC";
1509 default:
1510 break;
1511 }
1512 return NULL;
1513 }
1514
1515 static const char *
1516 get_section_type_name (sh_type)
1517 unsigned int sh_type;
1518 {
1519 static char buff [32];
1520
1521 switch (sh_type)
1522 {
1523 case SHT_NULL: return "NULL";
1524 case SHT_PROGBITS: return "PROGBITS";
1525 case SHT_SYMTAB: return "SYMTAB";
1526 case SHT_STRTAB: return "STRTAB";
1527 case SHT_RELA: return "RELA";
1528 case SHT_HASH: return "HASH";
1529 case SHT_DYNAMIC: return "DYNAMIC";
1530 case SHT_NOTE: return "NOTE";
1531 case SHT_NOBITS: return "NOBITS";
1532 case SHT_REL: return "REL";
1533 case SHT_SHLIB: return "SHLIB";
1534 case SHT_DYNSYM: return "DYNSYM";
1535 case SHT_GNU_verdef: return "VERDEF";
1536 case SHT_GNU_verneed: return "VERNEED";
1537 case SHT_GNU_versym: return "VERSYM";
1538 case 0x6ffffff0: return "VERSYM";
1539 case 0x6ffffffc: return "VERDEF";
1540 case 0x7ffffffd: return "AUXILIARY";
1541 case 0x7fffffff: return "FILTER";
1542
1543 default:
1544 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1545 {
1546 const char * result;
1547
1548 switch (elf_header.e_machine)
1549 {
1550 case EM_MIPS:
1551 case EM_MIPS_RS4_BE:
1552 result = get_mips_section_type_name (sh_type);
1553 break;
1554 case EM_PARISC:
1555 result = get_parisc_section_type_name (sh_type);
1556 break;
1557 default:
1558 result = NULL;
1559 break;
1560 }
1561
1562 if (result != NULL)
1563 return result;
1564
1565 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1566 }
1567 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1568 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1569 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1570 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1571 else
1572 sprintf (buff, _("<unknown>: %x"), sh_type);
1573
1574 return buff;
1575 }
1576 }
1577
1578 struct option options [] =
1579 {
1580 {"all", no_argument, 0, 'a'},
1581 {"file-header", no_argument, 0, 'h'},
1582 {"program-headers", no_argument, 0, 'l'},
1583 {"headers", no_argument, 0, 'e'},
1584 {"histogram", no_argument, 0, 'I'},
1585 {"segments", no_argument, 0, 'l'},
1586 {"sections", no_argument, 0, 'S'},
1587 {"section-headers", no_argument, 0, 'S'},
1588 {"symbols", no_argument, 0, 's'},
1589 {"syms", no_argument, 0, 's'},
1590 {"relocs", no_argument, 0, 'r'},
1591 {"notes", no_argument, 0, 'n'},
1592 {"dynamic", no_argument, 0, 'd'},
1593 {"arch-specific", no_argument, 0, 'A'},
1594 {"version-info", no_argument, 0, 'V'},
1595 {"use-dynamic", no_argument, 0, 'D'},
1596 {"hex-dump", required_argument, 0, 'x'},
1597 {"debug-dump", optional_argument, 0, 'w'},
1598 #ifdef SUPPORT_DISASSEMBLY
1599 {"instruction-dump", required_argument, 0, 'i'},
1600 #endif
1601
1602 {"version", no_argument, 0, 'v'},
1603 {"help", no_argument, 0, 'H'},
1604 {0, no_argument, 0, 0}
1605 };
1606
1607 static void
1608 usage ()
1609 {
1610 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1611 fprintf (stdout, _(" Options are:\n"));
1612 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1613 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1614 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1615 fprintf (stdout, _(" Display the program headers\n"));
1616 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1617 fprintf (stdout, _(" Display the sections' header\n"));
1618 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1619 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1620 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1621 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1622 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1623 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1624 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1625 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1626 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1627 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1628 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1629 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1630 #ifdef SUPPORT_DISASSEMBLY
1631 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1632 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1633 #endif
1634 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1635 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1636 fprintf (stdout, _(" -H or --help Display this information\n"));
1637 fprintf (stdout, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1638
1639 exit (0);
1640 }
1641
1642 static void
1643 request_dump (section, type)
1644 unsigned int section;
1645 char type;
1646 {
1647 if (section >= num_dump_sects)
1648 {
1649 char * new_dump_sects;
1650
1651 new_dump_sects = (char *) calloc (section + 1, 1);
1652
1653 if (new_dump_sects == NULL)
1654 error (_("Out of memory allocating dump request table."));
1655 else
1656 {
1657 /* Copy current flag settings. */
1658 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1659
1660 free (dump_sects);
1661
1662 dump_sects = new_dump_sects;
1663 num_dump_sects = section + 1;
1664 }
1665 }
1666
1667 if (dump_sects)
1668 dump_sects [section] |= type;
1669
1670 return;
1671 }
1672
1673 static void
1674 parse_args (argc, argv)
1675 int argc;
1676 char ** argv;
1677 {
1678 int c;
1679
1680 if (argc < 2)
1681 usage ();
1682
1683 while ((c = getopt_long
1684 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1685 {
1686 char * cp;
1687 int section;
1688
1689 switch (c)
1690 {
1691 case 0:
1692 /* Long options. */
1693 break;
1694 case 'H':
1695 usage ();
1696 break;
1697
1698 case 'a':
1699 do_syms ++;
1700 do_reloc ++;
1701 do_dynamic ++;
1702 do_header ++;
1703 do_sections ++;
1704 do_segments ++;
1705 do_version ++;
1706 do_histogram ++;
1707 do_arch ++;
1708 do_notes ++;
1709 break;
1710 case 'e':
1711 do_header ++;
1712 do_sections ++;
1713 do_segments ++;
1714 break;
1715 case 'A':
1716 do_arch ++;
1717 break;
1718 case 'D':
1719 do_using_dynamic ++;
1720 break;
1721 case 'r':
1722 do_reloc ++;
1723 break;
1724 case 'h':
1725 do_header ++;
1726 break;
1727 case 'l':
1728 do_segments ++;
1729 break;
1730 case 's':
1731 do_syms ++;
1732 break;
1733 case 'S':
1734 do_sections ++;
1735 break;
1736 case 'd':
1737 do_dynamic ++;
1738 break;
1739 case 'I':
1740 do_histogram ++;
1741 break;
1742 case 'n':
1743 do_notes ++;
1744 break;
1745 case 'x':
1746 do_dump ++;
1747 section = strtoul (optarg, & cp, 0);
1748 if (! * cp && section >= 0)
1749 {
1750 request_dump (section, HEX_DUMP);
1751 break;
1752 }
1753 goto oops;
1754 case 'w':
1755 do_dump ++;
1756 if (optarg == 0)
1757 do_debugging = 1;
1758 else
1759 {
1760 do_debugging = 0;
1761 switch (optarg[0])
1762 {
1763 case 'i':
1764 case 'I':
1765 do_debug_info = 1;
1766 break;
1767
1768 case 'a':
1769 case 'A':
1770 do_debug_abbrevs = 1;
1771 break;
1772
1773 case 'l':
1774 case 'L':
1775 do_debug_lines = 1;
1776 break;
1777
1778 case 'p':
1779 case 'P':
1780 do_debug_pubnames = 1;
1781 break;
1782
1783 case 'r':
1784 case 'R':
1785 do_debug_aranges = 1;
1786 break;
1787
1788 default:
1789 warn (_("Unrecognised debug option '%s'\n"), optarg);
1790 break;
1791 }
1792 }
1793 break;
1794 #ifdef SUPPORT_DISASSEMBLY
1795 case 'i':
1796 do_dump ++;
1797 section = strtoul (optarg, & cp, 0);
1798 if (! * cp && section >= 0)
1799 {
1800 request_dump (section, DISASS_DUMP);
1801 break;
1802 }
1803 goto oops;
1804 #endif
1805 case 'v':
1806 print_version (program_name);
1807 break;
1808 case 'V':
1809 do_version ++;
1810 break;
1811 default:
1812 oops:
1813 /* xgettext:c-format */
1814 error (_("Invalid option '-%c'\n"), c);
1815 /* Drop through. */
1816 case '?':
1817 usage ();
1818 }
1819 }
1820
1821 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
1822 && !do_segments && !do_header && !do_dump && !do_version
1823 && !do_histogram && !do_debugging && !do_arch && !do_notes)
1824 usage ();
1825 else if (argc < 3)
1826 {
1827 warn (_("Nothing to do.\n"));
1828 usage();
1829 }
1830 }
1831
1832 static const char *
1833 get_elf_class (elf_class)
1834 unsigned char elf_class;
1835 {
1836 static char buff [32];
1837
1838 switch (elf_class)
1839 {
1840 case ELFCLASSNONE: return _("none");
1841 case ELFCLASS32: return _("ELF32");
1842 case ELFCLASS64: return _("ELF64");
1843 default:
1844 sprintf (buff, _("<unknown: %x>"), elf_class);
1845 return buff;
1846 }
1847 }
1848
1849 static const char *
1850 get_data_encoding (encoding)
1851 unsigned char encoding;
1852 {
1853 static char buff [32];
1854
1855 switch (encoding)
1856 {
1857 case ELFDATANONE: return _("none");
1858 case ELFDATA2LSB: return _("2's complement, little endian");
1859 case ELFDATA2MSB: return _("2's complement, big endian");
1860 default:
1861 sprintf (buff, _("<unknown: %x>"), encoding);
1862 return buff;
1863 }
1864 }
1865
1866 static const char *
1867 get_osabi_name (osabi)
1868 unsigned char osabi;
1869 {
1870 static char buff [32];
1871
1872 switch (osabi)
1873 {
1874 case ELFOSABI_SYSV: return _("UNIX - System V");
1875 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
1876 case ELFOSABI_STANDALONE: return _("Standalone App");
1877 default:
1878 sprintf (buff, _("<unknown: %x>"), osabi);
1879 return buff;
1880 }
1881 }
1882
1883 /* Decode the data held in 'elf_header'. */
1884 static int
1885 process_file_header ()
1886 {
1887 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
1888 || elf_header.e_ident [EI_MAG1] != ELFMAG1
1889 || elf_header.e_ident [EI_MAG2] != ELFMAG2
1890 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
1891 {
1892 error
1893 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1894 return 0;
1895 }
1896
1897 if (do_header)
1898 {
1899 int i;
1900
1901 printf (_("ELF Header:\n"));
1902 printf (_(" Magic: "));
1903 for (i = 0; i < EI_NIDENT; i ++)
1904 printf ("%2.2x ", elf_header.e_ident [i]);
1905 printf ("\n");
1906 printf (_(" Class: %s\n"),
1907 get_elf_class (elf_header.e_ident [EI_CLASS]));
1908 printf (_(" Data: %s\n"),
1909 get_data_encoding (elf_header.e_ident [EI_DATA]));
1910 printf (_(" Version: %d %s\n"),
1911 elf_header.e_ident [EI_VERSION],
1912 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
1913 ? "(current)"
1914 : (elf_header.e_ident [EI_VERSION] != EV_NONE
1915 ? "<unknown: %lx>"
1916 : "")));
1917 printf (_(" OS/ABI: %s\n"),
1918 get_osabi_name (elf_header.e_ident [EI_OSABI]));
1919 printf (_(" ABI Version: %d\n"),
1920 elf_header.e_ident [EI_ABIVERSION]);
1921 printf (_(" Type: %s\n"),
1922 get_file_type (elf_header.e_type));
1923 printf (_(" Machine: %s\n"),
1924 get_machine_name (elf_header.e_machine));
1925 printf (_(" Version: 0x%lx\n"),
1926 (unsigned long) elf_header.e_version);
1927
1928 printf (_(" Entry point address: "));
1929 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
1930 printf (_("\n Start of program headers: "));
1931 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
1932 printf (_(" (bytes into file)\n Start of section headers: "));
1933 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
1934 printf (_(" (bytes into file)\n"));
1935
1936 printf (_(" Flags: 0x%lx%s\n"),
1937 (unsigned long) elf_header.e_flags,
1938 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
1939 printf (_(" Size of this header: %ld (bytes)\n"),
1940 (long) elf_header.e_ehsize);
1941 printf (_(" Size of program headers: %ld (bytes)\n"),
1942 (long) elf_header.e_phentsize);
1943 printf (_(" Number of program headers: %ld\n"),
1944 (long) elf_header.e_phnum);
1945 printf (_(" Size of section headers: %ld (bytes)\n"),
1946 (long) elf_header.e_shentsize);
1947 printf (_(" Number of section headers: %ld\n"),
1948 (long) elf_header.e_shnum);
1949 printf (_(" Section header string table index: %ld\n"),
1950 (long) elf_header.e_shstrndx);
1951 }
1952
1953 return 1;
1954 }
1955
1956
1957 static int
1958 get_32bit_program_headers (file, program_headers)
1959 FILE * file;
1960 Elf_Internal_Phdr * program_headers;
1961 {
1962 Elf32_External_Phdr * phdrs;
1963 Elf32_External_Phdr * external;
1964 Elf32_Internal_Phdr * internal;
1965 unsigned int i;
1966
1967 GET_DATA_ALLOC (elf_header.e_phoff,
1968 elf_header.e_phentsize * elf_header.e_phnum,
1969 phdrs, Elf32_External_Phdr *, "program headers");
1970
1971 for (i = 0, internal = program_headers, external = phdrs;
1972 i < elf_header.e_phnum;
1973 i ++, internal ++, external ++)
1974 {
1975 internal->p_type = BYTE_GET (external->p_type);
1976 internal->p_offset = BYTE_GET (external->p_offset);
1977 internal->p_vaddr = BYTE_GET (external->p_vaddr);
1978 internal->p_paddr = BYTE_GET (external->p_paddr);
1979 internal->p_filesz = BYTE_GET (external->p_filesz);
1980 internal->p_memsz = BYTE_GET (external->p_memsz);
1981 internal->p_flags = BYTE_GET (external->p_flags);
1982 internal->p_align = BYTE_GET (external->p_align);
1983 }
1984
1985 free (phdrs);
1986
1987 return 1;
1988 }
1989
1990 static int
1991 get_64bit_program_headers (file, program_headers)
1992 FILE * file;
1993 Elf_Internal_Phdr * program_headers;
1994 {
1995 Elf64_External_Phdr * phdrs;
1996 Elf64_External_Phdr * external;
1997 Elf64_Internal_Phdr * internal;
1998 unsigned int i;
1999
2000 GET_DATA_ALLOC (elf_header.e_phoff,
2001 elf_header.e_phentsize * elf_header.e_phnum,
2002 phdrs, Elf64_External_Phdr *, "program headers");
2003
2004 for (i = 0, internal = program_headers, external = phdrs;
2005 i < elf_header.e_phnum;
2006 i ++, internal ++, external ++)
2007 {
2008 internal->p_type = BYTE_GET (external->p_type);
2009 internal->p_flags = BYTE_GET (external->p_flags);
2010 internal->p_offset = BYTE_GET8 (external->p_offset);
2011 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2012 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2013 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2014 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2015 internal->p_align = BYTE_GET8 (external->p_align);
2016 }
2017
2018 free (phdrs);
2019
2020 return 1;
2021 }
2022
2023 static int
2024 process_program_headers (file)
2025 FILE * file;
2026 {
2027 Elf_Internal_Phdr * program_headers;
2028 Elf_Internal_Phdr * segment;
2029 unsigned int i;
2030
2031 if (elf_header.e_phnum == 0)
2032 {
2033 if (do_segments)
2034 printf (_("\nThere are no program headers in this file.\n"));
2035 return 1;
2036 }
2037
2038 if (do_segments && !do_header)
2039 {
2040 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2041 printf (_("Entry point "));
2042 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2043 printf (_("\nThere are %d program headers, starting at offset "),
2044 elf_header.e_phnum);
2045 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2046 printf ("\n");
2047 }
2048
2049 program_headers = (Elf_Internal_Phdr *) malloc
2050 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2051
2052 if (program_headers == NULL)
2053 {
2054 error (_("Out of memory\n"));
2055 return 0;
2056 }
2057
2058 if (is_32bit_elf)
2059 i = get_32bit_program_headers (file, program_headers);
2060 else
2061 i = get_64bit_program_headers (file, program_headers);
2062
2063 if (i == 0)
2064 {
2065 free (program_headers);
2066 return 0;
2067 }
2068
2069 if (do_segments)
2070 {
2071 printf
2072 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2073
2074 if (is_32bit_elf)
2075 printf
2076 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2077 else
2078 {
2079 printf
2080 (_(" Type Offset VirtAddr PhysAddr\n"));
2081 printf
2082 (_(" FileSiz MemSiz Flags Align\n"));
2083 }
2084 }
2085
2086 loadaddr = -1;
2087 dynamic_addr = 0;
2088 dynamic_size = 0;
2089
2090 for (i = 0, segment = program_headers;
2091 i < elf_header.e_phnum;
2092 i ++, segment ++)
2093 {
2094 if (do_segments)
2095 {
2096 printf (" %-14.14s ", get_segment_type (segment->p_type));
2097
2098 if (is_32bit_elf)
2099 {
2100 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2101 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2102 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2103 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2104 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2105 printf ("%c%c%c ",
2106 (segment->p_flags & PF_R ? 'R' : ' '),
2107 (segment->p_flags & PF_W ? 'W' : ' '),
2108 (segment->p_flags & PF_X ? 'E' : ' '));
2109 printf ("%#lx", (unsigned long) segment->p_align);
2110 }
2111 else
2112 {
2113 print_vma (segment->p_offset, FULL_HEX);
2114 putchar (' ');
2115 print_vma (segment->p_vaddr, FULL_HEX);
2116 putchar (' ');
2117 print_vma (segment->p_paddr, FULL_HEX);
2118 printf ("\n ");
2119 print_vma (segment->p_filesz, FULL_HEX);
2120 putchar (' ');
2121 print_vma (segment->p_memsz, FULL_HEX);
2122 printf (" %c%c%c ",
2123 (segment->p_flags & PF_R ? 'R' : ' '),
2124 (segment->p_flags & PF_W ? 'W' : ' '),
2125 (segment->p_flags & PF_X ? 'E' : ' '));
2126 print_vma (segment->p_align, HEX);
2127 }
2128 }
2129
2130 switch (segment->p_type)
2131 {
2132 case PT_LOAD:
2133 if (loadaddr == -1)
2134 loadaddr = (segment->p_vaddr & 0xfffff000)
2135 - (segment->p_offset & 0xfffff000);
2136 break;
2137
2138 case PT_DYNAMIC:
2139 if (dynamic_addr)
2140 error (_("more than one dynamic segment\n"));
2141
2142 dynamic_addr = segment->p_offset;
2143 dynamic_size = segment->p_filesz;
2144 break;
2145
2146 case PT_INTERP:
2147 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2148 error (_("Unable to find program interpreter name\n"));
2149 else
2150 {
2151 program_interpreter[0] = 0;
2152 fscanf (file, "%63s", program_interpreter);
2153
2154 if (do_segments)
2155 printf (_("\n [Requesting program interpreter: %s]"),
2156 program_interpreter);
2157 }
2158 break;
2159 }
2160
2161 if (do_segments)
2162 putc ('\n', stdout);
2163 }
2164
2165 if (loadaddr == -1)
2166 {
2167 /* Very strange. */
2168 loadaddr = 0;
2169 }
2170
2171 if (do_segments && section_headers != NULL)
2172 {
2173 printf (_("\n Section to Segment mapping:\n"));
2174 printf (_(" Segment Sections...\n"));
2175
2176 assert (string_table != NULL);
2177
2178 for (i = 0; i < elf_header.e_phnum; i++)
2179 {
2180 int j;
2181 Elf_Internal_Shdr * section;
2182
2183 segment = program_headers + i;
2184 section = section_headers;
2185
2186 printf (" %2.2d ", i);
2187
2188 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2189 {
2190 if (section->sh_size > 0
2191 /* Compare allocated sections by VMA, unallocated
2192 sections by file offset. */
2193 && (section->sh_flags & SHF_ALLOC
2194 ? (section->sh_addr >= segment->p_vaddr
2195 && section->sh_addr + section->sh_size
2196 <= segment->p_vaddr + segment->p_memsz)
2197 : ((bfd_vma) section->sh_offset >= segment->p_offset
2198 && (section->sh_offset + section->sh_size
2199 <= segment->p_offset + segment->p_filesz))))
2200 printf ("%s ", SECTION_NAME (section));
2201 }
2202
2203 putc ('\n',stdout);
2204 }
2205 }
2206
2207 free (program_headers);
2208
2209 return 1;
2210 }
2211
2212
2213 static int
2214 get_32bit_section_headers (file)
2215 FILE * file;
2216 {
2217 Elf32_External_Shdr * shdrs;
2218 Elf32_Internal_Shdr * internal;
2219 unsigned int i;
2220
2221 GET_DATA_ALLOC (elf_header.e_shoff,
2222 elf_header.e_shentsize * elf_header.e_shnum,
2223 shdrs, Elf32_External_Shdr *, "section headers");
2224
2225 section_headers = (Elf_Internal_Shdr *) malloc
2226 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2227
2228 if (section_headers == NULL)
2229 {
2230 error (_("Out of memory\n"));
2231 return 0;
2232 }
2233
2234 for (i = 0, internal = section_headers;
2235 i < elf_header.e_shnum;
2236 i ++, internal ++)
2237 {
2238 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2239 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2240 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2241 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2242 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2243 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2244 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2245 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2246 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2247 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2248 }
2249
2250 free (shdrs);
2251
2252 return 1;
2253 }
2254
2255 static int
2256 get_64bit_section_headers (file)
2257 FILE * file;
2258 {
2259 Elf64_External_Shdr * shdrs;
2260 Elf64_Internal_Shdr * internal;
2261 unsigned int i;
2262
2263 GET_DATA_ALLOC (elf_header.e_shoff,
2264 elf_header.e_shentsize * elf_header.e_shnum,
2265 shdrs, Elf64_External_Shdr *, "section headers");
2266
2267 section_headers = (Elf_Internal_Shdr *) malloc
2268 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2269
2270 if (section_headers == NULL)
2271 {
2272 error (_("Out of memory\n"));
2273 return 0;
2274 }
2275
2276 for (i = 0, internal = section_headers;
2277 i < elf_header.e_shnum;
2278 i ++, internal ++)
2279 {
2280 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2281 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2282 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2283 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2284 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2285 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2286 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2287 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2288 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2289 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2290 }
2291
2292 free (shdrs);
2293
2294 return 1;
2295 }
2296
2297 static Elf_Internal_Sym *
2298 get_32bit_elf_symbols (file, offset, number)
2299 FILE * file;
2300 unsigned long offset;
2301 unsigned long number;
2302 {
2303 Elf32_External_Sym * esyms;
2304 Elf_Internal_Sym * isyms;
2305 Elf_Internal_Sym * psym;
2306 unsigned int j;
2307
2308 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2309 esyms, Elf32_External_Sym *, "symbols");
2310
2311 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2312
2313 if (isyms == NULL)
2314 {
2315 error (_("Out of memory\n"));
2316 free (esyms);
2317
2318 return NULL;
2319 }
2320
2321 for (j = 0, psym = isyms;
2322 j < number;
2323 j ++, psym ++)
2324 {
2325 psym->st_name = BYTE_GET (esyms[j].st_name);
2326 psym->st_value = BYTE_GET (esyms[j].st_value);
2327 psym->st_size = BYTE_GET (esyms[j].st_size);
2328 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2329 psym->st_info = BYTE_GET (esyms[j].st_info);
2330 psym->st_other = BYTE_GET (esyms[j].st_other);
2331 }
2332
2333 free (esyms);
2334
2335 return isyms;
2336 }
2337
2338 static Elf_Internal_Sym *
2339 get_64bit_elf_symbols (file, offset, number)
2340 FILE * file;
2341 unsigned long offset;
2342 unsigned long number;
2343 {
2344 Elf64_External_Sym * esyms;
2345 Elf_Internal_Sym * isyms;
2346 Elf_Internal_Sym * psym;
2347 unsigned int j;
2348
2349 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2350 esyms, Elf64_External_Sym *, "symbols");
2351
2352 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2353
2354 if (isyms == NULL)
2355 {
2356 error (_("Out of memory\n"));
2357 free (esyms);
2358
2359 return NULL;
2360 }
2361
2362 for (j = 0, psym = isyms;
2363 j < number;
2364 j ++, psym ++)
2365 {
2366 psym->st_name = BYTE_GET (esyms[j].st_name);
2367 psym->st_info = BYTE_GET (esyms[j].st_info);
2368 psym->st_other = BYTE_GET (esyms[j].st_other);
2369 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2370 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2371 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2372 }
2373
2374 free (esyms);
2375
2376 return isyms;
2377 }
2378
2379 static int
2380 process_section_headers (file)
2381 FILE * file;
2382 {
2383 Elf_Internal_Shdr * section;
2384 int i;
2385
2386 section_headers = NULL;
2387
2388 if (elf_header.e_shnum == 0)
2389 {
2390 if (do_sections)
2391 printf (_("\nThere are no sections in this file.\n"));
2392
2393 return 1;
2394 }
2395
2396 if (do_sections && !do_header)
2397 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2398 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2399
2400 if (is_32bit_elf)
2401 {
2402 if (! get_32bit_section_headers (file))
2403 return 0;
2404 }
2405 else if (! get_64bit_section_headers (file))
2406 return 0;
2407
2408 /* Read in the string table, so that we have names to display. */
2409 section = section_headers + elf_header.e_shstrndx;
2410
2411 if (section->sh_size != 0)
2412 {
2413 unsigned long string_table_offset;
2414
2415 string_table_offset = section->sh_offset;
2416
2417 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2418 string_table, char *, "string table");
2419 }
2420
2421 /* Scan the sections for the dynamic symbol table
2422 and dynamic string table and debug sections. */
2423 dynamic_symbols = NULL;
2424 dynamic_strings = NULL;
2425 dynamic_syminfo = NULL;
2426
2427 for (i = 0, section = section_headers;
2428 i < elf_header.e_shnum;
2429 i ++, section ++)
2430 {
2431 char * name = SECTION_NAME (section);
2432
2433 if (section->sh_type == SHT_DYNSYM)
2434 {
2435 if (dynamic_symbols != NULL)
2436 {
2437 error (_("File contains multiple dynamic symbol tables\n"));
2438 continue;
2439 }
2440
2441 num_dynamic_syms = section->sh_size / section->sh_entsize;
2442 dynamic_symbols =
2443 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2444 }
2445 else if (section->sh_type == SHT_STRTAB
2446 && strcmp (name, ".dynstr") == 0)
2447 {
2448 if (dynamic_strings != NULL)
2449 {
2450 error (_("File contains multiple dynamic string tables\n"));
2451 continue;
2452 }
2453
2454 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2455 dynamic_strings, char *, "dynamic strings");
2456 }
2457 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2458 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2459 && strncmp (name, ".debug_", 7) == 0)
2460 {
2461 name += 7;
2462
2463 if (do_debugging
2464 || (do_debug_info && (strcmp (name, "info") == 0))
2465 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2466 || (do_debug_lines && (strcmp (name, "line") == 0))
2467 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2468 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2469 )
2470 request_dump (i, DEBUG_DUMP);
2471 }
2472 }
2473
2474 if (! do_sections)
2475 return 1;
2476
2477 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2478 if (is_32bit_elf)
2479 printf
2480 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2481 else
2482 {
2483 printf (_(" [Nr] Name Type Address Offset\n"));
2484 printf (_(" Size EntSize Flags Link Info Align\n"));
2485 }
2486
2487 for (i = 0, section = section_headers;
2488 i < elf_header.e_shnum;
2489 i ++, section ++)
2490 {
2491 printf (" [%2d] %-17.17s %-15.15s ",
2492 i,
2493 SECTION_NAME (section),
2494 get_section_type_name (section->sh_type));
2495
2496 if (is_32bit_elf)
2497 {
2498 print_vma (section->sh_addr, LONG_HEX);
2499
2500 printf ( " %6.6lx %6.6lx %2.2lx",
2501 (unsigned long) section->sh_offset,
2502 (unsigned long) section->sh_size,
2503 (unsigned long) section->sh_entsize);
2504
2505 printf (" %c%c%c %2ld %3lx %ld\n",
2506 (section->sh_flags & SHF_WRITE ? 'W' : ' '),
2507 (section->sh_flags & SHF_ALLOC ? 'A' : ' '),
2508 (section->sh_flags & SHF_EXECINSTR ? 'X' : ' '),
2509 (unsigned long) section->sh_link,
2510 (unsigned long) section->sh_info,
2511 (unsigned long) section->sh_addralign);
2512 }
2513 else
2514 {
2515 putchar (' ');
2516 print_vma (section->sh_addr, LONG_HEX);
2517 printf (" %08.8lx", section->sh_offset);
2518 printf ("\n ");
2519 print_vma (section->sh_size, LONG_HEX);
2520 printf (" ");
2521 print_vma (section->sh_entsize, LONG_HEX);
2522
2523 printf (" %c%c%c",
2524 (section->sh_flags & SHF_WRITE ? 'W' : ' '),
2525 (section->sh_flags & SHF_ALLOC ? 'A' : ' '),
2526 (section->sh_flags & SHF_EXECINSTR ? 'X' : ' '));
2527
2528 printf (" %2ld %3lx %ld\n",
2529 (unsigned long) section->sh_link,
2530 (unsigned long) section->sh_info,
2531 (unsigned long) section->sh_addralign);
2532 }
2533 }
2534
2535 return 1;
2536 }
2537
2538 /* Process the reloc section. */
2539 static int
2540 process_relocs (file)
2541 FILE * file;
2542 {
2543 unsigned long rel_size;
2544 unsigned long rel_offset;
2545
2546
2547 if (!do_reloc)
2548 return 1;
2549
2550 if (do_using_dynamic)
2551 {
2552 int is_rela = FALSE;
2553
2554 rel_size = 0;
2555 rel_offset = 0;
2556
2557 if (dynamic_info[DT_REL])
2558 {
2559 rel_offset = dynamic_info[DT_REL];
2560 rel_size = dynamic_info[DT_RELSZ];
2561 is_rela = FALSE;
2562 }
2563 else if (dynamic_info [DT_RELA])
2564 {
2565 rel_offset = dynamic_info[DT_RELA];
2566 rel_size = dynamic_info[DT_RELASZ];
2567 is_rela = TRUE;
2568 }
2569 else if (dynamic_info[DT_JMPREL])
2570 {
2571 rel_offset = dynamic_info[DT_JMPREL];
2572 rel_size = dynamic_info[DT_PLTRELSZ];
2573
2574 switch (dynamic_info[DT_PLTREL])
2575 {
2576 case DT_REL:
2577 is_rela = FALSE;
2578 break;
2579 case DT_RELA:
2580 is_rela = TRUE;
2581 break;
2582 default:
2583 is_rela = UNKNOWN;
2584 break;
2585 }
2586 }
2587
2588 if (rel_size)
2589 {
2590 printf
2591 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2592 rel_offset, rel_size);
2593
2594 dump_relocations (file, rel_offset - loadaddr, rel_size,
2595 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2596 }
2597 else
2598 printf (_("\nThere are no dynamic relocations in this file.\n"));
2599 }
2600 else
2601 {
2602 Elf32_Internal_Shdr * section;
2603 unsigned long i;
2604 int found = 0;
2605
2606 for (i = 0, section = section_headers;
2607 i < elf_header.e_shnum;
2608 i++, section ++)
2609 {
2610 if ( section->sh_type != SHT_RELA
2611 && section->sh_type != SHT_REL)
2612 continue;
2613
2614 rel_offset = section->sh_offset;
2615 rel_size = section->sh_size;
2616
2617 if (rel_size)
2618 {
2619 Elf32_Internal_Shdr * strsec;
2620 Elf32_Internal_Shdr * symsec;
2621 Elf_Internal_Sym * symtab;
2622 char * strtab;
2623 int is_rela;
2624 unsigned long nsyms;
2625
2626 printf (_("\nRelocation section "));
2627
2628 if (string_table == NULL)
2629 printf ("%d", section->sh_name);
2630 else
2631 printf ("'%s'", SECTION_NAME (section));
2632
2633 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2634 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2635
2636 symsec = section_headers + section->sh_link;
2637
2638 nsyms = symsec->sh_size / symsec->sh_entsize;
2639 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2640
2641 if (symtab == NULL)
2642 continue;
2643
2644 strsec = section_headers + symsec->sh_link;
2645
2646 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2647 char *, "string table");
2648
2649 is_rela = section->sh_type == SHT_RELA;
2650
2651 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2652
2653 free (strtab);
2654 free (symtab);
2655
2656 found = 1;
2657 }
2658 }
2659
2660 if (! found)
2661 printf (_("\nThere are no relocations in this file.\n"));
2662 }
2663
2664 return 1;
2665 }
2666
2667
2668 static void
2669 dynamic_segment_mips_val (entry)
2670 Elf_Internal_Dyn * entry;
2671 {
2672 switch (entry->d_tag)
2673 {
2674 case DT_MIPS_FLAGS:
2675 if (entry->d_un.d_val == 0)
2676 printf ("NONE\n");
2677 else
2678 {
2679 static const char * opts[] =
2680 {
2681 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2682 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2683 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2684 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2685 "RLD_ORDER_SAFE"
2686 };
2687 unsigned int cnt;
2688 int first = 1;
2689 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2690 if (entry->d_un.d_val & (1 << cnt))
2691 {
2692 printf ("%s%s", first ? "" : " ", opts[cnt]);
2693 first = 0;
2694 }
2695 puts ("");
2696 }
2697 break;
2698
2699 case DT_MIPS_IVERSION:
2700 if (dynamic_strings != NULL)
2701 printf ("Interface Version: %s\n",
2702 dynamic_strings + entry->d_un.d_val);
2703 else
2704 printf ("%ld\n", (long) entry->d_un.d_ptr);
2705 break;
2706
2707 case DT_MIPS_TIME_STAMP:
2708 {
2709 char timebuf[20];
2710 time_t time = entry->d_un.d_val;
2711 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2712 printf ("Time Stamp: %s\n", timebuf);
2713 }
2714 break;
2715
2716 case DT_MIPS_RLD_VERSION:
2717 case DT_MIPS_LOCAL_GOTNO:
2718 case DT_MIPS_CONFLICTNO:
2719 case DT_MIPS_LIBLISTNO:
2720 case DT_MIPS_SYMTABNO:
2721 case DT_MIPS_UNREFEXTNO:
2722 case DT_MIPS_HIPAGENO:
2723 case DT_MIPS_DELTA_CLASS_NO:
2724 case DT_MIPS_DELTA_INSTANCE_NO:
2725 case DT_MIPS_DELTA_RELOC_NO:
2726 case DT_MIPS_DELTA_SYM_NO:
2727 case DT_MIPS_DELTA_CLASSSYM_NO:
2728 case DT_MIPS_COMPACT_SIZE:
2729 printf ("%ld\n", (long) entry->d_un.d_ptr);
2730 break;
2731
2732 default:
2733 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2734 }
2735 }
2736
2737
2738 static void
2739 dynamic_segment_parisc_val (entry)
2740 Elf_Internal_Dyn * entry;
2741 {
2742 switch (entry->d_tag)
2743 {
2744 case DT_HP_DLD_FLAGS:
2745 {
2746 static struct
2747 {
2748 long int bit;
2749 const char *str;
2750 } flags[] =
2751 {
2752 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2753 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2754 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2755 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2756 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2757 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2758 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2759 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2760 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2761 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2762 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2763 };
2764 int first = 1;
2765 int cnt;
2766 bfd_vma val = entry->d_un.d_val;
2767
2768 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
2769 if (val & flags[cnt].bit)
2770 {
2771 if (! first)
2772 putchar (' ');
2773 fputs (flags[cnt].str, stdout);
2774 first = 0;
2775 val ^= flags[cnt].bit;
2776 }
2777 if (val != 0 || first)
2778 {
2779 if (! first)
2780 putchar (' ');
2781 print_vma (val, HEX);
2782 }
2783 }
2784 break;
2785
2786 default:
2787 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
2788 break;
2789 }
2790 }
2791
2792 static int
2793 get_32bit_dynamic_segment (file)
2794 FILE * file;
2795 {
2796 Elf32_External_Dyn * edyn;
2797 Elf_Internal_Dyn * entry;
2798 bfd_size_type i;
2799
2800 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
2801 edyn, Elf32_External_Dyn *, "dynamic segment");
2802
2803 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2804 how large this .dynamic is now. We can do this even before the byte
2805 swapping since the DT_NULL tag is recognizable. */
2806 dynamic_size = 0;
2807 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
2808 ;
2809
2810 dynamic_segment = (Elf_Internal_Dyn *)
2811 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2812
2813 if (dynamic_segment == NULL)
2814 {
2815 error (_("Out of memory\n"));
2816 free (edyn);
2817 return 0;
2818 }
2819
2820 for (i = 0, entry = dynamic_segment;
2821 i < dynamic_size;
2822 i ++, entry ++)
2823 {
2824 entry->d_tag = BYTE_GET (edyn [i].d_tag);
2825 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
2826 }
2827
2828 free (edyn);
2829
2830 return 1;
2831 }
2832
2833 static int
2834 get_64bit_dynamic_segment (file)
2835 FILE * file;
2836 {
2837 Elf64_External_Dyn * edyn;
2838 Elf_Internal_Dyn * entry;
2839 bfd_size_type i;
2840
2841 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
2842 edyn, Elf64_External_Dyn *, "dynamic segment");
2843
2844 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2845 how large this .dynamic is now. We can do this even before the byte
2846 swapping since the DT_NULL tag is recognizable. */
2847 dynamic_size = 0;
2848 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
2849 ;
2850
2851 dynamic_segment = (Elf_Internal_Dyn *)
2852 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2853
2854 if (dynamic_segment == NULL)
2855 {
2856 error (_("Out of memory\n"));
2857 free (edyn);
2858 return 0;
2859 }
2860
2861 for (i = 0, entry = dynamic_segment;
2862 i < dynamic_size;
2863 i ++, entry ++)
2864 {
2865 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
2866 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
2867 }
2868
2869 free (edyn);
2870
2871 return 1;
2872 }
2873
2874 /* Parse and display the contents of the dynamic segment. */
2875 static int
2876 process_dynamic_segment (file)
2877 FILE * file;
2878 {
2879 Elf_Internal_Dyn * entry;
2880 bfd_size_type i;
2881
2882 if (dynamic_size == 0)
2883 {
2884 if (do_dynamic)
2885 printf (_("\nThere is no dynamic segment in this file.\n"));
2886
2887 return 1;
2888 }
2889
2890 if (is_32bit_elf)
2891 {
2892 if (! get_32bit_dynamic_segment (file))
2893 return 0;
2894 }
2895 else if (! get_64bit_dynamic_segment (file))
2896 return 0;
2897
2898 /* Find the appropriate symbol table. */
2899 if (dynamic_symbols == NULL)
2900 {
2901 for (i = 0, entry = dynamic_segment;
2902 i < dynamic_size;
2903 ++i, ++ entry)
2904 {
2905 unsigned long offset;
2906
2907 if (entry->d_tag != DT_SYMTAB)
2908 continue;
2909
2910 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
2911
2912 /* Since we do not know how big the symbol table is,
2913 we default to reading in the entire file (!) and
2914 processing that. This is overkill, I know, but it
2915 should work. */
2916 offset = entry->d_un.d_val - loadaddr;
2917
2918 if (fseek (file, 0, SEEK_END))
2919 error (_("Unable to seek to end of file!"));
2920
2921 if (is_32bit_elf)
2922 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
2923 else
2924 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
2925
2926 if (num_dynamic_syms < 1)
2927 {
2928 error (_("Unable to determine the number of symbols to load\n"));
2929 continue;
2930 }
2931
2932 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
2933 }
2934 }
2935
2936 /* Similarly find a string table. */
2937 if (dynamic_strings == NULL)
2938 {
2939 for (i = 0, entry = dynamic_segment;
2940 i < dynamic_size;
2941 ++i, ++ entry)
2942 {
2943 unsigned long offset;
2944 long str_tab_len;
2945
2946 if (entry->d_tag != DT_STRTAB)
2947 continue;
2948
2949 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
2950
2951 /* Since we do not know how big the string table is,
2952 we default to reading in the entire file (!) and
2953 processing that. This is overkill, I know, but it
2954 should work. */
2955
2956 offset = entry->d_un.d_val - loadaddr;
2957 if (fseek (file, 0, SEEK_END))
2958 error (_("Unable to seek to end of file\n"));
2959 str_tab_len = ftell (file) - offset;
2960
2961 if (str_tab_len < 1)
2962 {
2963 error
2964 (_("Unable to determine the length of the dynamic string table\n"));
2965 continue;
2966 }
2967
2968 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
2969 "dynamic string table");
2970
2971 break;
2972 }
2973 }
2974
2975 /* And find the syminfo section if available. */
2976 if (dynamic_syminfo == NULL)
2977 {
2978 unsigned int syminsz = 0;
2979
2980 for (i = 0, entry = dynamic_segment;
2981 i < dynamic_size;
2982 ++i, ++ entry)
2983 {
2984 if (entry->d_tag == DT_SYMINENT)
2985 {
2986 /* Note: these braces are necessary to avoid a syntax
2987 error from the SunOS4 C compiler. */
2988 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
2989 }
2990 else if (entry->d_tag == DT_SYMINSZ)
2991 syminsz = entry->d_un.d_val;
2992 else if (entry->d_tag == DT_SYMINFO)
2993 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
2994 }
2995
2996 if (dynamic_syminfo_offset != 0 && syminsz != 0)
2997 {
2998 Elf_External_Syminfo * extsyminfo;
2999 Elf_Internal_Syminfo * syminfo;
3000
3001 /* There is a syminfo section. Read the data. */
3002 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3003 Elf_External_Syminfo *, "symbol information");
3004
3005 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3006 if (dynamic_syminfo == NULL)
3007 {
3008 error (_("Out of memory\n"));
3009 return 0;
3010 }
3011
3012 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3013 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3014 ++i, ++syminfo)
3015 {
3016 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3017 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3018 }
3019
3020 free (extsyminfo);
3021 }
3022 }
3023
3024 if (do_dynamic && dynamic_addr)
3025 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3026 dynamic_addr, (long) dynamic_size);
3027 if (do_dynamic)
3028 printf (_(" Tag Type Name/Value\n"));
3029
3030 for (i = 0, entry = dynamic_segment;
3031 i < dynamic_size;
3032 i++, entry ++)
3033 {
3034 if (do_dynamic)
3035 {
3036 putchar (' ');
3037 print_vma (entry->d_tag, FULL_HEX);
3038 printf (" (%s)%*s",
3039 get_dynamic_type (entry->d_tag),
3040 (is_32bit_elf ? 27 : 19) - strlen (get_dynamic_type (entry->d_tag)),
3041 " ");
3042 }
3043
3044 switch (entry->d_tag)
3045 {
3046 case DT_AUXILIARY:
3047 case DT_FILTER:
3048 if (do_dynamic)
3049 {
3050 if (entry->d_tag == DT_AUXILIARY)
3051 printf (_("Auxiliary library"));
3052 else
3053 printf (_("Filter library"));
3054
3055 if (dynamic_strings)
3056 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3057 else
3058 {
3059 printf (": ");
3060 print_vma (entry->d_un.d_val, PREFIX_HEX);
3061 putchar ('\n');
3062 }
3063 }
3064 break;
3065
3066 case DT_FEATURE_1:
3067 if (do_dynamic)
3068 {
3069 printf (_("Flags:"));
3070 if (entry->d_un.d_val == 0)
3071 printf (_(" None\n"));
3072 else
3073 {
3074 unsigned long int val = entry->d_un.d_val;
3075 if (val & DTF_1_PARINIT)
3076 {
3077 printf (" PARINIT");
3078 val ^= DTF_1_PARINIT;
3079 }
3080 if (val != 0)
3081 printf (" %lx", val);
3082 puts ("");
3083 }
3084 }
3085 break;
3086
3087 case DT_POSFLAG_1:
3088 if (do_dynamic)
3089 {
3090 printf (_("Flags:"));
3091 if (entry->d_un.d_val == 0)
3092 printf (_(" None\n"));
3093 else
3094 {
3095 unsigned long int val = entry->d_un.d_val;
3096 if (val & DF_P1_LAZYLOAD)
3097 {
3098 printf (" LAZYLOAD");
3099 val ^= DF_P1_LAZYLOAD;
3100 }
3101 if (val & DF_P1_GROUPPERM)
3102 {
3103 printf (" GROUPPERM");
3104 val ^= DF_P1_GROUPPERM;
3105 }
3106 if (val != 0)
3107 printf (" %lx", val);
3108 puts ("");
3109 }
3110 }
3111 break;
3112
3113 case DT_FLAGS_1:
3114 if (do_dynamic)
3115 {
3116 printf (_("Flags:"));
3117 if (entry->d_un.d_val == 0)
3118 printf (_(" None\n"));
3119 else
3120 {
3121 unsigned long int val = entry->d_un.d_val;
3122 if (val & DF_1_NOW)
3123 {
3124 printf (" NOW");
3125 val ^= DF_1_NOW;
3126 }
3127 if (val & DF_1_GLOBAL)
3128 {
3129 printf (" GLOBAL");
3130 val ^= DF_1_GLOBAL;
3131 }
3132 if (val & DF_1_GROUP)
3133 {
3134 printf (" GROUP");
3135 val ^= DF_1_GROUP;
3136 }
3137 if (val & DF_1_NODELETE)
3138 {
3139 printf (" NODELETE");
3140 val ^= DF_1_NODELETE;
3141 }
3142 if (val & DF_1_LOADFLTR)
3143 {
3144 printf (" LOADFLTR");
3145 val ^= DF_1_LOADFLTR;
3146 }
3147 if (val & DF_1_INITFIRST)
3148 {
3149 printf (" INITFIRST");
3150 val ^= DF_1_INITFIRST;
3151 }
3152 if (val & DF_1_NOOPEN)
3153 {
3154 printf (" NOOPEN");
3155 val ^= DF_1_NOOPEN;
3156 }
3157 if (val & DF_1_ORIGIN)
3158 {
3159 printf (" ORIGIN");
3160 val ^= DF_1_ORIGIN;
3161 }
3162 if (val & DF_1_DIRECT)
3163 {
3164 printf (" DIRECT");
3165 val ^= DF_1_DIRECT;
3166 }
3167 if (val & DF_1_TRANS)
3168 {
3169 printf (" TRANS");
3170 val ^= DF_1_TRANS;
3171 }
3172 if (val & DF_1_INTERPOSE)
3173 {
3174 printf (" INTERPOSE");
3175 val ^= DF_1_INTERPOSE;
3176 }
3177 if (val != 0)
3178 printf (" %lx", val);
3179 puts ("");
3180 }
3181 }
3182 break;
3183
3184 case DT_PLTREL:
3185 if (do_dynamic)
3186 puts (get_dynamic_type (entry->d_un.d_val));
3187 break;
3188
3189 case DT_NULL :
3190 case DT_NEEDED :
3191 case DT_PLTGOT :
3192 case DT_HASH :
3193 case DT_STRTAB :
3194 case DT_SYMTAB :
3195 case DT_RELA :
3196 case DT_INIT :
3197 case DT_FINI :
3198 case DT_SONAME :
3199 case DT_RPATH :
3200 case DT_SYMBOLIC:
3201 case DT_REL :
3202 case DT_DEBUG :
3203 case DT_TEXTREL :
3204 case DT_JMPREL :
3205 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3206
3207 if (do_dynamic)
3208 {
3209 char * name;
3210
3211 if (dynamic_strings == NULL)
3212 name = NULL;
3213 else
3214 name = dynamic_strings + entry->d_un.d_val;
3215
3216 if (name)
3217 {
3218 switch (entry->d_tag)
3219 {
3220 case DT_NEEDED:
3221 printf (_("Shared library: [%s]"), name);
3222
3223 if (strcmp (name, program_interpreter) == 0)
3224 printf (_(" program interpreter"));
3225 break;
3226
3227 case DT_SONAME:
3228 printf (_("Library soname: [%s]"), name);
3229 break;
3230
3231 case DT_RPATH:
3232 printf (_("Library rpath: [%s]"), name);
3233 break;
3234
3235 default:
3236 print_vma (entry->d_un.d_val, PREFIX_HEX);
3237 break;
3238 }
3239 }
3240 else
3241 print_vma (entry->d_un.d_val, PREFIX_HEX);
3242
3243 putchar ('\n');
3244 }
3245 break;
3246
3247 case DT_PLTRELSZ:
3248 case DT_RELASZ :
3249 case DT_STRSZ :
3250 case DT_RELSZ :
3251 case DT_RELAENT :
3252 case DT_SYMENT :
3253 case DT_RELENT :
3254 case DT_PLTPADSZ:
3255 case DT_MOVEENT :
3256 case DT_MOVESZ :
3257 case DT_INIT_ARRAYSZ:
3258 case DT_FINI_ARRAYSZ:
3259 if (do_dynamic)
3260 {
3261 print_vma (entry->d_un.d_val, UNSIGNED);
3262 printf (" (bytes)\n");
3263 }
3264 break;
3265
3266 case DT_VERDEFNUM:
3267 case DT_VERNEEDNUM:
3268 case DT_RELACOUNT:
3269 case DT_RELCOUNT:
3270 if (do_dynamic)
3271 {
3272 print_vma (entry->d_un.d_val, UNSIGNED);
3273 putchar ('\n');
3274 }
3275 break;
3276
3277 case DT_SYMINSZ:
3278 case DT_SYMINENT:
3279 case DT_SYMINFO:
3280 case DT_USED:
3281 case DT_INIT_ARRAY:
3282 case DT_FINI_ARRAY:
3283 if (do_dynamic)
3284 {
3285 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3286 {
3287 char * name;
3288
3289 name = dynamic_strings + entry->d_un.d_val;
3290
3291 if (* name)
3292 {
3293 printf (_("Not needed object: [%s]\n"), name);
3294 break;
3295 }
3296 }
3297
3298 print_vma (entry->d_un.d_val, PREFIX_HEX);
3299 putchar ('\n');
3300 }
3301 break;
3302
3303 case DT_BIND_NOW:
3304 /* The value of this entry is ignored. */
3305 break;
3306
3307 default:
3308 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3309 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3310 entry->d_un.d_val;
3311
3312 if (do_dynamic)
3313 {
3314 switch (elf_header.e_machine)
3315 {
3316 case EM_MIPS:
3317 case EM_MIPS_RS4_BE:
3318 dynamic_segment_mips_val (entry);
3319 break;
3320 case EM_PARISC:
3321 dynamic_segment_parisc_val (entry);
3322 break;
3323 default:
3324 print_vma (entry->d_un.d_val, PREFIX_HEX);
3325 putchar ('\n');
3326 }
3327 }
3328 break;
3329 }
3330 }
3331
3332 return 1;
3333 }
3334
3335 static char *
3336 get_ver_flags (flags)
3337 unsigned int flags;
3338 {
3339 static char buff [32];
3340
3341 buff[0] = 0;
3342
3343 if (flags == 0)
3344 return _("none");
3345
3346 if (flags & VER_FLG_BASE)
3347 strcat (buff, "BASE ");
3348
3349 if (flags & VER_FLG_WEAK)
3350 {
3351 if (flags & VER_FLG_BASE)
3352 strcat (buff, "| ");
3353
3354 strcat (buff, "WEAK ");
3355 }
3356
3357 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3358 strcat (buff, "| <unknown>");
3359
3360 return buff;
3361 }
3362
3363 /* Display the contents of the version sections. */
3364 static int
3365 process_version_sections (file)
3366 FILE * file;
3367 {
3368 Elf32_Internal_Shdr * section;
3369 unsigned i;
3370 int found = 0;
3371
3372 if (! do_version)
3373 return 1;
3374
3375 for (i = 0, section = section_headers;
3376 i < elf_header.e_shnum;
3377 i++, section ++)
3378 {
3379 switch (section->sh_type)
3380 {
3381 case SHT_GNU_verdef:
3382 {
3383 Elf_External_Verdef * edefs;
3384 unsigned int idx;
3385 unsigned int cnt;
3386
3387 found = 1;
3388
3389 printf
3390 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3391 SECTION_NAME (section), section->sh_info);
3392
3393 printf (_(" Addr: 0x"));
3394 printf_vma (section->sh_addr);
3395 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3396 (unsigned long) section->sh_offset, section->sh_link,
3397 SECTION_NAME (section_headers + section->sh_link));
3398
3399 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3400 edefs, Elf_External_Verdef *,
3401 "version definition section");
3402
3403 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3404 {
3405 char * vstart;
3406 Elf_External_Verdef * edef;
3407 Elf_Internal_Verdef ent;
3408 Elf_External_Verdaux * eaux;
3409 Elf_Internal_Verdaux aux;
3410 int j;
3411 int isum;
3412
3413 vstart = ((char *) edefs) + idx;
3414
3415 edef = (Elf_External_Verdef *) vstart;
3416
3417 ent.vd_version = BYTE_GET (edef->vd_version);
3418 ent.vd_flags = BYTE_GET (edef->vd_flags);
3419 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3420 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3421 ent.vd_hash = BYTE_GET (edef->vd_hash);
3422 ent.vd_aux = BYTE_GET (edef->vd_aux);
3423 ent.vd_next = BYTE_GET (edef->vd_next);
3424
3425 printf (_(" %#06x: Rev: %d Flags: %s"),
3426 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3427
3428 printf (_(" Index: %d Cnt: %d "),
3429 ent.vd_ndx, ent.vd_cnt);
3430
3431 vstart += ent.vd_aux;
3432
3433 eaux = (Elf_External_Verdaux *) vstart;
3434
3435 aux.vda_name = BYTE_GET (eaux->vda_name);
3436 aux.vda_next = BYTE_GET (eaux->vda_next);
3437
3438 if (dynamic_strings)
3439 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3440 else
3441 printf (_("Name index: %ld\n"), aux.vda_name);
3442
3443 isum = idx + ent.vd_aux;
3444
3445 for (j = 1; j < ent.vd_cnt; j ++)
3446 {
3447 isum += aux.vda_next;
3448 vstart += aux.vda_next;
3449
3450 eaux = (Elf_External_Verdaux *) vstart;
3451
3452 aux.vda_name = BYTE_GET (eaux->vda_name);
3453 aux.vda_next = BYTE_GET (eaux->vda_next);
3454
3455 if (dynamic_strings)
3456 printf (_(" %#06x: Parent %d: %s\n"),
3457 isum, j, dynamic_strings + aux.vda_name);
3458 else
3459 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3460 isum, j, aux.vda_name);
3461 }
3462
3463 idx += ent.vd_next;
3464 }
3465
3466 free (edefs);
3467 }
3468 break;
3469
3470 case SHT_GNU_verneed:
3471 {
3472 Elf_External_Verneed * eneed;
3473 unsigned int idx;
3474 unsigned int cnt;
3475
3476 found = 1;
3477
3478 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3479 SECTION_NAME (section), section->sh_info);
3480
3481 printf (_(" Addr: 0x"));
3482 printf_vma (section->sh_addr);
3483 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3484 (unsigned long) section->sh_offset, section->sh_link,
3485 SECTION_NAME (section_headers + section->sh_link));
3486
3487 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3488 eneed, Elf_External_Verneed *,
3489 "version need section");
3490
3491 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3492 {
3493 Elf_External_Verneed * entry;
3494 Elf_Internal_Verneed ent;
3495 int j;
3496 int isum;
3497 char * vstart;
3498
3499 vstart = ((char *) eneed) + idx;
3500
3501 entry = (Elf_External_Verneed *) vstart;
3502
3503 ent.vn_version = BYTE_GET (entry->vn_version);
3504 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3505 ent.vn_file = BYTE_GET (entry->vn_file);
3506 ent.vn_aux = BYTE_GET (entry->vn_aux);
3507 ent.vn_next = BYTE_GET (entry->vn_next);
3508
3509 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3510
3511 if (dynamic_strings)
3512 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3513 else
3514 printf (_(" File: %lx"), ent.vn_file);
3515
3516 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3517
3518 vstart += ent.vn_aux;
3519
3520 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3521 {
3522 Elf_External_Vernaux * eaux;
3523 Elf_Internal_Vernaux aux;
3524
3525 eaux = (Elf_External_Vernaux *) vstart;
3526
3527 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3528 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3529 aux.vna_other = BYTE_GET (eaux->vna_other);
3530 aux.vna_name = BYTE_GET (eaux->vna_name);
3531 aux.vna_next = BYTE_GET (eaux->vna_next);
3532
3533 if (dynamic_strings)
3534 printf (_(" %#06x: Name: %s"),
3535 isum, dynamic_strings + aux.vna_name);
3536 else
3537 printf (_(" %#06x: Name index: %lx"),
3538 isum, aux.vna_name);
3539
3540 printf (_(" Flags: %s Version: %d\n"),
3541 get_ver_flags (aux.vna_flags), aux.vna_other);
3542
3543 isum += aux.vna_next;
3544 vstart += aux.vna_next;
3545 }
3546
3547 idx += ent.vn_next;
3548 }
3549
3550 free (eneed);
3551 }
3552 break;
3553
3554 case SHT_GNU_versym:
3555 {
3556 Elf32_Internal_Shdr * link_section;
3557 int total;
3558 int cnt;
3559 unsigned char * edata;
3560 unsigned short * data;
3561 char * strtab;
3562 Elf_Internal_Sym * symbols;
3563 Elf32_Internal_Shdr * string_sec;
3564
3565 link_section = section_headers + section->sh_link;
3566 total = section->sh_size / section->sh_entsize;
3567
3568 found = 1;
3569
3570 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3571 link_section->sh_size / link_section->sh_entsize);
3572
3573 string_sec = section_headers + link_section->sh_link;
3574
3575 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3576 strtab, char *, "version string table");
3577
3578 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3579 SECTION_NAME (section), total);
3580
3581 printf (_(" Addr: "));
3582 printf_vma (section->sh_addr);
3583 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3584 (unsigned long) section->sh_offset, section->sh_link,
3585 SECTION_NAME (link_section));
3586
3587 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3588 - loadaddr,
3589 total * sizeof (short), edata,
3590 unsigned char *, "version symbol data");
3591
3592 data = (unsigned short *) malloc (total * sizeof (short));
3593
3594 for (cnt = total; cnt --;)
3595 data [cnt] = byte_get (edata + cnt * sizeof (short),
3596 sizeof (short));
3597
3598 free (edata);
3599
3600 for (cnt = 0; cnt < total; cnt += 4)
3601 {
3602 int j, nn;
3603
3604 printf (" %03x:", cnt);
3605
3606 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3607 switch (data [cnt + j])
3608 {
3609 case 0:
3610 fputs (_(" 0 (*local*) "), stdout);
3611 break;
3612
3613 case 1:
3614 fputs (_(" 1 (*global*) "), stdout);
3615 break;
3616
3617 default:
3618 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3619 data [cnt + j] & 0x8000 ? 'h' : ' ');
3620
3621 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3622 && section_headers[symbols [cnt + j].st_shndx].sh_type
3623 == SHT_NOBITS)
3624 {
3625 /* We must test both. */
3626 Elf_Internal_Verneed ivn;
3627 unsigned long offset;
3628
3629 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3630 - loadaddr;
3631
3632 do
3633 {
3634 Elf_External_Verneed evn;
3635 Elf_External_Vernaux evna;
3636 Elf_Internal_Vernaux ivna;
3637 unsigned long vna_off;
3638
3639 GET_DATA (offset, evn, "version need");
3640
3641 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3642 ivn.vn_next = BYTE_GET (evn.vn_next);
3643
3644 vna_off = offset + ivn.vn_aux;
3645
3646 do
3647 {
3648 GET_DATA (vna_off, evna,
3649 "version need aux (1)");
3650
3651 ivna.vna_next = BYTE_GET (evna.vna_next);
3652 ivna.vna_other = BYTE_GET (evna.vna_other);
3653
3654 vna_off += ivna.vna_next;
3655 }
3656 while (ivna.vna_other != data [cnt + j]
3657 && ivna.vna_next != 0);
3658
3659 if (ivna.vna_other == data [cnt + j])
3660 {
3661 ivna.vna_name = BYTE_GET (evna.vna_name);
3662
3663 nn += printf ("(%s%-*s",
3664 strtab + ivna.vna_name,
3665 12 - strlen (strtab
3666 + ivna.vna_name),
3667 ")");
3668 break;
3669 }
3670 else if (ivn.vn_next == 0)
3671 {
3672 if (data [cnt + j] != 0x8001)
3673 {
3674 Elf_Internal_Verdef ivd;
3675 Elf_External_Verdef evd;
3676
3677 offset = version_info
3678 [DT_VERSIONTAGIDX (DT_VERDEF)]
3679 - loadaddr;
3680
3681 do
3682 {
3683 GET_DATA (offset, evd,
3684 "version definition");
3685
3686 ivd.vd_next = BYTE_GET (evd.vd_next);
3687 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3688
3689 offset += ivd.vd_next;
3690 }
3691 while (ivd.vd_ndx
3692 != (data [cnt + j] & 0x7fff)
3693 && ivd.vd_next != 0);
3694
3695 if (ivd.vd_ndx
3696 == (data [cnt + j] & 0x7fff))
3697 {
3698 Elf_External_Verdaux evda;
3699 Elf_Internal_Verdaux ivda;
3700
3701 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3702
3703 GET_DATA (offset + ivd.vd_aux, evda,
3704 "version definition aux");
3705
3706 ivda.vda_name =
3707 BYTE_GET (evda.vda_name);
3708
3709 nn +=
3710 printf ("(%s%-*s",
3711 strtab + ivda.vda_name,
3712 12
3713 - strlen (strtab
3714 + ivda.vda_name),
3715 ")");
3716 }
3717 }
3718
3719 break;
3720 }
3721 else
3722 offset += ivn.vn_next;
3723 }
3724 while (ivn.vn_next);
3725 }
3726 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3727 {
3728 Elf_Internal_Verneed ivn;
3729 unsigned long offset;
3730
3731 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3732 - loadaddr;
3733
3734 do
3735 {
3736 Elf_Internal_Vernaux ivna;
3737 Elf_External_Verneed evn;
3738 Elf_External_Vernaux evna;
3739 unsigned long a_off;
3740
3741 GET_DATA (offset, evn, "version need");
3742
3743 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3744 ivn.vn_next = BYTE_GET (evn.vn_next);
3745
3746 a_off = offset + ivn.vn_aux;
3747
3748 do
3749 {
3750 GET_DATA (a_off, evna,
3751 "version need aux (2)");
3752
3753 ivna.vna_next = BYTE_GET (evna.vna_next);
3754 ivna.vna_other = BYTE_GET (evna.vna_other);
3755
3756 a_off += ivna.vna_next;
3757 }
3758 while (ivna.vna_other != data [cnt + j]
3759 && ivna.vna_next != 0);
3760
3761 if (ivna.vna_other == data [cnt + j])
3762 {
3763 ivna.vna_name = BYTE_GET (evna.vna_name);
3764
3765 nn += printf ("(%s%-*s",
3766 strtab + ivna.vna_name,
3767 12 - strlen (strtab
3768 + ivna.vna_name),
3769 ")");
3770 break;
3771 }
3772
3773 offset += ivn.vn_next;
3774 }
3775 while (ivn.vn_next);
3776 }
3777 else if (data [cnt + j] != 0x8001)
3778 {
3779 Elf_Internal_Verdef ivd;
3780 Elf_External_Verdef evd;
3781 unsigned long offset;
3782
3783 offset = version_info
3784 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
3785
3786 do
3787 {
3788 GET_DATA (offset, evd, "version def");
3789
3790 ivd.vd_next = BYTE_GET (evd.vd_next);
3791 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3792
3793 offset += ivd.vd_next;
3794 }
3795 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
3796 && ivd.vd_next != 0);
3797
3798 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
3799 {
3800 Elf_External_Verdaux evda;
3801 Elf_Internal_Verdaux ivda;
3802
3803 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3804
3805 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
3806 evda, "version def aux");
3807
3808 ivda.vda_name = BYTE_GET (evda.vda_name);
3809
3810 nn += printf ("(%s%-*s",
3811 strtab + ivda.vda_name,
3812 12 - strlen (strtab
3813 + ivda.vda_name),
3814 ")");
3815 }
3816 }
3817
3818 if (nn < 18)
3819 printf ("%*c", 18 - nn, ' ');
3820 }
3821
3822 putchar ('\n');
3823 }
3824
3825 free (data);
3826 free (strtab);
3827 free (symbols);
3828 }
3829 break;
3830
3831 default:
3832 break;
3833 }
3834 }
3835
3836 if (! found)
3837 printf (_("\nNo version information found in this file.\n"));
3838
3839 return 1;
3840 }
3841
3842 static char *
3843 get_symbol_binding (binding)
3844 unsigned int binding;
3845 {
3846 static char buff [32];
3847
3848 switch (binding)
3849 {
3850 case STB_LOCAL: return "LOCAL";
3851 case STB_GLOBAL: return "GLOBAL";
3852 case STB_WEAK: return "WEAK";
3853 default:
3854 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
3855 sprintf (buff, _("<processor specific>: %d"), binding);
3856 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3857 sprintf (buff, _("<OS specific>: %d"), binding);
3858 else
3859 sprintf (buff, _("<unknown>: %d"), binding);
3860 return buff;
3861 }
3862 }
3863
3864 static char *
3865 get_symbol_type (type)
3866 unsigned int type;
3867 {
3868 static char buff [32];
3869
3870 switch (type)
3871 {
3872 case STT_NOTYPE: return "NOTYPE";
3873 case STT_OBJECT: return "OBJECT";
3874 case STT_FUNC: return "FUNC";
3875 case STT_SECTION: return "SECTION";
3876 case STT_FILE: return "FILE";
3877 default:
3878 if (type >= STT_LOPROC && type <= STT_HIPROC)
3879 {
3880 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
3881 return "THUMB_FUNC";
3882
3883 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
3884 return "REGISTER";
3885
3886 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
3887 return "PARISC_MILLI";
3888
3889 sprintf (buff, _("<processor specific>: %d"), type);
3890 }
3891 else if (type >= STT_LOOS && type <= STT_HIOS)
3892 {
3893 if (elf_header.e_machine == EM_PARISC)
3894 {
3895 if (type == STT_HP_OPAQUE)
3896 return "HP_OPAQUE";
3897 if (type == STT_HP_STUB)
3898 return "HP_STUB";
3899 }
3900
3901 sprintf (buff, _("<OS specific>: %d"), type);
3902 }
3903 else
3904 sprintf (buff, _("<unknown>: %d"), type);
3905 return buff;
3906 }
3907 }
3908
3909 static char *
3910 get_symbol_index_type (type)
3911 unsigned int type;
3912 {
3913 switch (type)
3914 {
3915 case SHN_UNDEF: return "UND";
3916 case SHN_ABS: return "ABS";
3917 case SHN_COMMON: return "COM";
3918 default:
3919 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
3920 return "PRC";
3921 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
3922 return "RSV";
3923 else if (type >= SHN_LOOS && type <= SHN_HIOS)
3924 return "OS ";
3925 else
3926 {
3927 static char buff [32];
3928
3929 sprintf (buff, "%3d", type);
3930 return buff;
3931 }
3932 }
3933 }
3934
3935
3936 static int *
3937 get_dynamic_data (file, number)
3938 FILE * file;
3939 unsigned int number;
3940 {
3941 char * e_data;
3942 int * i_data;
3943
3944 e_data = (char *) malloc (number * 4);
3945
3946 if (e_data == NULL)
3947 {
3948 error (_("Out of memory\n"));
3949 return NULL;
3950 }
3951
3952 if (fread (e_data, 4, number, file) != number)
3953 {
3954 error (_("Unable to read in dynamic data\n"));
3955 return NULL;
3956 }
3957
3958 i_data = (int *) malloc (number * sizeof (* i_data));
3959
3960 if (i_data == NULL)
3961 {
3962 error (_("Out of memory\n"));
3963 free (e_data);
3964 return NULL;
3965 }
3966
3967 while (number--)
3968 i_data [number] = byte_get (e_data + number * 4, 4);
3969
3970 free (e_data);
3971
3972 return i_data;
3973 }
3974
3975 /* Dump the symbol table */
3976 static int
3977 process_symbol_table (file)
3978 FILE * file;
3979 {
3980 Elf32_Internal_Shdr * section;
3981 char nb [4];
3982 char nc [4];
3983 int nbuckets = 0;
3984 int nchains;
3985 int * buckets = NULL;
3986 int * chains = NULL;
3987
3988 if (! do_syms && !do_histogram)
3989 return 1;
3990
3991 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
3992 || do_histogram))
3993 {
3994 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
3995 {
3996 error (_("Unable to seek to start of dynamic information"));
3997 return 0;
3998 }
3999
4000 if (fread (nb, sizeof (nb), 1, file) != 1)
4001 {
4002 error (_("Failed to read in number of buckets\n"));
4003 return 0;
4004 }
4005
4006 if (fread (nc, sizeof (nc), 1, file) != 1)
4007 {
4008 error (_("Failed to read in number of chains\n"));
4009 return 0;
4010 }
4011
4012 nbuckets = byte_get (nb, 4);
4013 nchains = byte_get (nc, 4);
4014
4015 buckets = get_dynamic_data (file, nbuckets);
4016 chains = get_dynamic_data (file, nchains);
4017
4018 if (buckets == NULL || chains == NULL)
4019 return 0;
4020 }
4021
4022 if (do_syms
4023 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4024 {
4025 int hn;
4026 int si;
4027
4028 printf (_("\nSymbol table for image:\n"));
4029 if (is_32bit_elf)
4030 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
4031 else
4032 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
4033
4034 for (hn = 0; hn < nbuckets; hn++)
4035 {
4036 if (! buckets [hn])
4037 continue;
4038
4039 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4040 {
4041 Elf_Internal_Sym * psym;
4042
4043 psym = dynamic_symbols + si;
4044
4045 printf (" %3d %3d: ", si, hn);
4046 print_vma (psym->st_value, LONG_HEX);
4047 putchar (' ' );
4048 print_vma (psym->st_size, DEC_5);
4049
4050 printf (" %6s %6s %2d ",
4051 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
4052 get_symbol_binding (ELF_ST_BIND (psym->st_info)),
4053 psym->st_other);
4054
4055 printf ("%3.3s", get_symbol_index_type (psym->st_shndx));
4056
4057 printf (" %s\n", dynamic_strings + psym->st_name);
4058 }
4059 }
4060 }
4061 else if (do_syms && !do_using_dynamic)
4062 {
4063 unsigned int i;
4064
4065 for (i = 0, section = section_headers;
4066 i < elf_header.e_shnum;
4067 i++, section++)
4068 {
4069 unsigned int si;
4070 char * strtab;
4071 Elf_Internal_Sym * symtab;
4072 Elf_Internal_Sym * psym;
4073
4074
4075 if ( section->sh_type != SHT_SYMTAB
4076 && section->sh_type != SHT_DYNSYM)
4077 continue;
4078
4079 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4080 SECTION_NAME (section),
4081 (unsigned long) (section->sh_size / section->sh_entsize));
4082 if (is_32bit_elf)
4083 printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
4084 else
4085 printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
4086
4087 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4088 section->sh_size / section->sh_entsize);
4089 if (symtab == NULL)
4090 continue;
4091
4092 if (section->sh_link == elf_header.e_shstrndx)
4093 strtab = string_table;
4094 else
4095 {
4096 Elf32_Internal_Shdr * string_sec;
4097
4098 string_sec = section_headers + section->sh_link;
4099
4100 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4101 strtab, char *, "string table");
4102 }
4103
4104 for (si = 0, psym = symtab;
4105 si < section->sh_size / section->sh_entsize;
4106 si ++, psym ++)
4107 {
4108 printf (" %3d: ", si);
4109 print_vma (psym->st_value, LONG_HEX);
4110 putchar (' ');
4111 print_vma (psym->st_size, DEC_5);
4112 printf (" %-7s %-6s %2d ",
4113 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
4114 get_symbol_binding (ELF_ST_BIND (psym->st_info)),
4115 psym->st_other);
4116
4117 printf ("%4s", get_symbol_index_type (psym->st_shndx));
4118
4119 printf (" %s", strtab + psym->st_name);
4120
4121 if (section->sh_type == SHT_DYNSYM &&
4122 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4123 {
4124 unsigned char data[2];
4125 unsigned short vers_data;
4126 unsigned long offset;
4127 int is_nobits;
4128 int check_def;
4129
4130 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4131 - loadaddr;
4132
4133 GET_DATA (offset + si * sizeof (vers_data), data,
4134 "version data");
4135
4136 vers_data = byte_get (data, 2);
4137
4138 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4139 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4140 : 0;
4141
4142 check_def = (psym->st_shndx != SHN_UNDEF);
4143
4144 if ((vers_data & 0x8000) || vers_data > 1)
4145 {
4146 if (is_nobits || ! check_def)
4147 {
4148 Elf_External_Verneed evn;
4149 Elf_Internal_Verneed ivn;
4150 Elf_Internal_Vernaux ivna;
4151
4152 /* We must test both. */
4153 offset = version_info
4154 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4155
4156 GET_DATA (offset, evn, "version need");
4157
4158 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4159 ivn.vn_next = BYTE_GET (evn.vn_next);
4160
4161 do
4162 {
4163 unsigned long vna_off;
4164
4165 vna_off = offset + ivn.vn_aux;
4166
4167 do
4168 {
4169 Elf_External_Vernaux evna;
4170
4171 GET_DATA (vna_off, evna,
4172 "version need aux (3)");
4173
4174 ivna.vna_other = BYTE_GET (evna.vna_other);
4175 ivna.vna_next = BYTE_GET (evna.vna_next);
4176 ivna.vna_name = BYTE_GET (evna.vna_name);
4177
4178 vna_off += ivna.vna_next;
4179 }
4180 while (ivna.vna_other != vers_data
4181 && ivna.vna_next != 0);
4182
4183 if (ivna.vna_other == vers_data)
4184 break;
4185
4186 offset += ivn.vn_next;
4187 }
4188 while (ivn.vn_next != 0);
4189
4190 if (ivna.vna_other == vers_data)
4191 {
4192 printf ("@%s (%d)",
4193 strtab + ivna.vna_name, ivna.vna_other);
4194 check_def = 0;
4195 }
4196 else if (! is_nobits)
4197 error (_("bad dynamic symbol"));
4198 else
4199 check_def = 1;
4200 }
4201
4202 if (check_def)
4203 {
4204 if (vers_data != 0x8001)
4205 {
4206 Elf_Internal_Verdef ivd;
4207 Elf_Internal_Verdaux ivda;
4208 Elf_External_Verdaux evda;
4209 unsigned long offset;
4210
4211 offset =
4212 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4213 - loadaddr;
4214
4215 do
4216 {
4217 Elf_External_Verdef evd;
4218
4219 GET_DATA (offset, evd, "version def");
4220
4221 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4222 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4223 ivd.vd_next = BYTE_GET (evd.vd_next);
4224
4225 offset += ivd.vd_next;
4226 }
4227 while (ivd.vd_ndx != (vers_data & 0x7fff)
4228 && ivd.vd_next != 0);
4229
4230 offset -= ivd.vd_next;
4231 offset += ivd.vd_aux;
4232
4233 GET_DATA (offset, evda, "version def aux");
4234
4235 ivda.vda_name = BYTE_GET (evda.vda_name);
4236
4237 if (psym->st_name != ivda.vda_name)
4238 printf ((vers_data & 0x8000)
4239 ? "@%s" : "@@%s",
4240 strtab + ivda.vda_name);
4241 }
4242 }
4243 }
4244 }
4245
4246 putchar ('\n');
4247 }
4248
4249 free (symtab);
4250 if (strtab != string_table)
4251 free (strtab);
4252 }
4253 }
4254 else if (do_syms)
4255 printf
4256 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4257
4258 if (do_histogram && buckets != NULL)
4259 {
4260 int *lengths;
4261 int *counts;
4262 int hn;
4263 int si;
4264 int maxlength = 0;
4265 int nzero_counts = 0;
4266 int nsyms = 0;
4267
4268 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4269 nbuckets);
4270 printf (_(" Length Number %% of total Coverage\n"));
4271
4272 lengths = (int *) calloc (nbuckets, sizeof (int));
4273 if (lengths == NULL)
4274 {
4275 error (_("Out of memory"));
4276 return 0;
4277 }
4278 for (hn = 0; hn < nbuckets; ++hn)
4279 {
4280 if (! buckets [hn])
4281 continue;
4282
4283 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4284 {
4285 ++ nsyms;
4286 if (maxlength < ++lengths[hn])
4287 ++ maxlength;
4288 }
4289 }
4290
4291 counts = (int *) calloc (maxlength + 1, sizeof (int));
4292 if (counts == NULL)
4293 {
4294 error (_("Out of memory"));
4295 return 0;
4296 }
4297
4298 for (hn = 0; hn < nbuckets; ++hn)
4299 ++counts[lengths [hn]];
4300
4301 if (nbuckets > 0)
4302 {
4303 printf (" 0 %-10d (%5.1f%%)\n",
4304 counts[0], (counts[0] * 100.0) / nbuckets);
4305 for (si = 1; si <= maxlength; ++si)
4306 {
4307 nzero_counts += counts[si] * si;
4308 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4309 si, counts[si], (counts[si] * 100.0) / nbuckets,
4310 (nzero_counts * 100.0) / nsyms);
4311 }
4312 }
4313
4314 free (counts);
4315 free (lengths);
4316 }
4317
4318 if (buckets != NULL)
4319 {
4320 free (buckets);
4321 free (chains);
4322 }
4323
4324 return 1;
4325 }
4326
4327 static int
4328 process_syminfo (file)
4329 FILE * file ATTRIBUTE_UNUSED;
4330 {
4331 unsigned int i;
4332
4333 if (dynamic_syminfo == NULL
4334 || !do_dynamic)
4335 /* No syminfo, this is ok. */
4336 return 1;
4337
4338 /* There better should be a dynamic symbol section. */
4339 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4340 return 0;
4341
4342 if (dynamic_addr)
4343 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4344 dynamic_syminfo_offset, dynamic_syminfo_nent);
4345
4346 printf (_(" Num: Name BoundTo Flags\n"));
4347 for (i = 0; i < dynamic_syminfo_nent; ++i)
4348 {
4349 unsigned short int flags = dynamic_syminfo[i].si_flags;
4350
4351 printf ("%4d: %-30s ", i,
4352 dynamic_strings + dynamic_symbols[i].st_name);
4353
4354 switch (dynamic_syminfo[i].si_boundto)
4355 {
4356 case SYMINFO_BT_SELF:
4357 fputs ("SELF ", stdout);
4358 break;
4359 case SYMINFO_BT_PARENT:
4360 fputs ("PARENT ", stdout);
4361 break;
4362 default:
4363 if (dynamic_syminfo[i].si_boundto > 0
4364 && dynamic_syminfo[i].si_boundto < dynamic_size)
4365 printf ("%-10s ",
4366 dynamic_strings
4367 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4368 else
4369 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4370 break;
4371 }
4372
4373 if (flags & SYMINFO_FLG_DIRECT)
4374 printf (" DIRECT");
4375 if (flags & SYMINFO_FLG_PASSTHRU)
4376 printf (" PASSTHRU");
4377 if (flags & SYMINFO_FLG_COPY)
4378 printf (" COPY");
4379 if (flags & SYMINFO_FLG_LAZYLOAD)
4380 printf (" LAZYLOAD");
4381
4382 puts ("");
4383 }
4384
4385 return 1;
4386 }
4387
4388 #ifdef SUPPORT_DISASSEMBLY
4389 static void
4390 disassemble_section (section, file)
4391 Elf32_Internal_Shdr * section;
4392 FILE * file;
4393 {
4394 printf (_("\nAssembly dump of section %s\n"),
4395 SECTION_NAME (section));
4396
4397 /* XXX -- to be done --- XXX */
4398
4399 return 1;
4400 }
4401 #endif
4402
4403 static int
4404 dump_section (section, file)
4405 Elf32_Internal_Shdr * section;
4406 FILE * file;
4407 {
4408 bfd_size_type bytes;
4409 bfd_vma addr;
4410 unsigned char * data;
4411 unsigned char * start;
4412
4413 bytes = section->sh_size;
4414
4415 if (bytes == 0)
4416 {
4417 printf (_("\nSection '%s' has no data to dump.\n"),
4418 SECTION_NAME (section));
4419 return 0;
4420 }
4421 else
4422 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4423
4424 addr = section->sh_addr;
4425
4426 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4427 "section data");
4428
4429 data = start;
4430
4431 while (bytes)
4432 {
4433 int j;
4434 int k;
4435 int lbytes;
4436
4437 lbytes = (bytes > 16 ? 16 : bytes);
4438
4439 printf (" 0x%8.8lx ", (unsigned long) addr);
4440
4441 switch (elf_header.e_ident [EI_DATA])
4442 {
4443 default:
4444 case ELFDATA2LSB:
4445 for (j = 15; j >= 0; j --)
4446 {
4447 if (j < lbytes)
4448 printf ("%2.2x", data [j]);
4449 else
4450 printf (" ");
4451
4452 if (!(j & 0x3))
4453 printf (" ");
4454 }
4455 break;
4456
4457 case ELFDATA2MSB:
4458 for (j = 0; j < 16; j++)
4459 {
4460 if (j < lbytes)
4461 printf ("%2.2x", data [j]);
4462 else
4463 printf (" ");
4464
4465 if ((j & 3) == 3)
4466 printf (" ");
4467 }
4468 break;
4469 }
4470
4471 for (j = 0; j < lbytes; j++)
4472 {
4473 k = data [j];
4474 if (k >= ' ' && k < 0x80)
4475 printf ("%c", k);
4476 else
4477 printf (".");
4478 }
4479
4480 putchar ('\n');
4481
4482 data += lbytes;
4483 addr += lbytes;
4484 bytes -= lbytes;
4485 }
4486
4487 free (start);
4488
4489 return 1;
4490 }
4491
4492
4493 static unsigned long int
4494 read_leb128 (data, length_return, sign)
4495 unsigned char * data;
4496 int * length_return;
4497 int sign;
4498 {
4499 unsigned long int result = 0;
4500 unsigned int num_read = 0;
4501 int shift = 0;
4502 unsigned char byte;
4503
4504 do
4505 {
4506 byte = * data ++;
4507 num_read ++;
4508
4509 result |= (byte & 0x7f) << shift;
4510
4511 shift += 7;
4512
4513 }
4514 while (byte & 0x80);
4515
4516 if (length_return != NULL)
4517 * length_return = num_read;
4518
4519 if (sign && (shift < 32) && (byte & 0x40))
4520 result |= -1 << shift;
4521
4522 return result;
4523 }
4524
4525 typedef struct State_Machine_Registers
4526 {
4527 unsigned long address;
4528 unsigned int file;
4529 unsigned int line;
4530 unsigned int column;
4531 int is_stmt;
4532 int basic_block;
4533 int end_sequence;
4534 /* This variable hold the number of the last entry seen
4535 in the File Table. */
4536 unsigned int last_file_entry;
4537 } SMR;
4538
4539 static SMR state_machine_regs;
4540
4541 static void
4542 reset_state_machine (is_stmt)
4543 int is_stmt;
4544 {
4545 state_machine_regs.address = 0;
4546 state_machine_regs.file = 1;
4547 state_machine_regs.line = 1;
4548 state_machine_regs.column = 0;
4549 state_machine_regs.is_stmt = is_stmt;
4550 state_machine_regs.basic_block = 0;
4551 state_machine_regs.end_sequence = 0;
4552 state_machine_regs.last_file_entry = 0;
4553 }
4554
4555 /* Handled an extend line op. Returns true if this is the end
4556 of sequence. */
4557 static int
4558 process_extended_line_op (data, is_stmt, pointer_size)
4559 unsigned char * data;
4560 int is_stmt;
4561 int pointer_size;
4562 {
4563 unsigned char op_code;
4564 int bytes_read;
4565 unsigned int len;
4566 unsigned char * name;
4567 unsigned long adr;
4568
4569 len = read_leb128 (data, & bytes_read, 0);
4570 data += bytes_read;
4571
4572 if (len == 0)
4573 {
4574 warn (_("badly formed extended line op encountered!"));
4575 return bytes_read;
4576 }
4577
4578 len += bytes_read;
4579 op_code = * data ++;
4580
4581 printf (_(" Extended opcode %d: "), op_code);
4582
4583 switch (op_code)
4584 {
4585 case DW_LNE_end_sequence:
4586 printf (_("End of Sequence\n\n"));
4587 reset_state_machine (is_stmt);
4588 break;
4589
4590 case DW_LNE_set_address:
4591 adr = byte_get (data, pointer_size);
4592 printf (_("set Address to 0x%lx\n"), adr);
4593 state_machine_regs.address = adr;
4594 break;
4595
4596 case DW_LNE_define_file:
4597 printf (_(" define new File Table entry\n"));
4598 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4599
4600 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4601 name = data;
4602 data += strlen (data) + 1;
4603 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4604 data += bytes_read;
4605 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4606 data += bytes_read;
4607 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4608 printf (_("%s\n\n"), name);
4609 break;
4610
4611 default:
4612 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4613 break;
4614 }
4615
4616 return len;
4617 }
4618
4619 /* Size of pointers in the .debug_line section. This information is not
4620 really present in that section. It's obtained before dumping the debug
4621 sections by doing some pre-scan of the .debug_info section. */
4622 static int debug_line_pointer_size = 4;
4623
4624 static int
4625 display_debug_lines (section, start, file)
4626 Elf32_Internal_Shdr * section;
4627 unsigned char * start;
4628 FILE * file ATTRIBUTE_UNUSED;
4629 {
4630 DWARF2_External_LineInfo * external;
4631 DWARF2_Internal_LineInfo info;
4632 unsigned char * standard_opcodes;
4633 unsigned char * data = start;
4634 unsigned char * end = start + section->sh_size;
4635 unsigned char * end_of_sequence;
4636 int i;
4637
4638 printf (_("\nDump of debug contents of section %s:\n\n"),
4639 SECTION_NAME (section));
4640
4641 while (data < end)
4642 {
4643 external = (DWARF2_External_LineInfo *) data;
4644
4645 /* Check the length of the block. */
4646 info.li_length = BYTE_GET (external->li_length);
4647 if (info.li_length > section->sh_size)
4648 {
4649 warn
4650 (_("The line info appears to be corrupt - the section is too small\n"));
4651 return 0;
4652 }
4653
4654 /* Check its version number. */
4655 info.li_version = BYTE_GET (external->li_version);
4656 if (info.li_version != 2)
4657 {
4658 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4659 return 0;
4660 }
4661
4662 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4663 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4664 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4665 info.li_line_base = BYTE_GET (external->li_line_base);
4666 info.li_line_range = BYTE_GET (external->li_line_range);
4667 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
4668
4669 /* Sign extend the line base field. */
4670 info.li_line_base <<= 24;
4671 info.li_line_base >>= 24;
4672
4673 printf (_(" Length: %ld\n"), info.li_length);
4674 printf (_(" DWARF Version: %d\n"), info.li_version);
4675 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4676 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4677 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4678 printf (_(" Line Base: %d\n"), info.li_line_base);
4679 printf (_(" Line Range: %d\n"), info.li_line_range);
4680 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4681
4682 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4683
4684 reset_state_machine (info.li_default_is_stmt);
4685
4686 /* Display the contents of the Opcodes table. */
4687 standard_opcodes = data + sizeof (* external);
4688
4689 printf (_("\n Opcodes:\n"));
4690
4691 for (i = 1; i < info.li_opcode_base; i++)
4692 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4693
4694 /* Display the contents of the Directory table. */
4695 data = standard_opcodes + info.li_opcode_base - 1;
4696
4697 if (* data == 0)
4698 printf (_("\n The Directory Table is empty.\n"));
4699 else
4700 {
4701 printf (_("\n The Directory Table:\n"));
4702
4703 while (* data != 0)
4704 {
4705 printf (_(" %s\n"), data);
4706
4707 data += strlen (data) + 1;
4708 }
4709 }
4710
4711 /* Skip the NUL at the end of the table. */
4712 data ++;
4713
4714 /* Display the contents of the File Name table. */
4715 if (* data == 0)
4716 printf (_("\n The File Name Table is empty.\n"));
4717 else
4718 {
4719 printf (_("\n The File Name Table:\n"));
4720 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4721
4722 while (* data != 0)
4723 {
4724 char * name;
4725 int bytes_read;
4726
4727 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4728 name = data;
4729
4730 data += strlen (data) + 1;
4731
4732 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4733 data += bytes_read;
4734 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4735 data += bytes_read;
4736 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4737 data += bytes_read;
4738 printf (_("%s\n"), name);
4739 }
4740 }
4741
4742 /* Skip the NUL at the end of the table. */
4743 data ++;
4744
4745 /* Now display the statements. */
4746 printf (_("\n Line Number Statements:\n"));
4747
4748
4749 while (data < end_of_sequence)
4750 {
4751 unsigned char op_code;
4752 int adv;
4753 int bytes_read;
4754
4755 op_code = * data ++;
4756
4757 switch (op_code)
4758 {
4759 case DW_LNS_extended_op:
4760 data += process_extended_line_op (data, info.li_default_is_stmt,
4761 debug_line_pointer_size);
4762 break;
4763
4764 case DW_LNS_copy:
4765 printf (_(" Copy\n"));
4766 break;
4767
4768 case DW_LNS_advance_pc:
4769 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
4770 data += bytes_read;
4771 state_machine_regs.address += adv;
4772 printf (_(" Advance PC by %d to %lx\n"), adv,
4773 state_machine_regs.address);
4774 break;
4775
4776 case DW_LNS_advance_line:
4777 adv = read_leb128 (data, & bytes_read, 1);
4778 data += bytes_read;
4779 state_machine_regs.line += adv;
4780 printf (_(" Advance Line by %d to %d\n"), adv,
4781 state_machine_regs.line);
4782 break;
4783
4784 case DW_LNS_set_file:
4785 adv = read_leb128 (data, & bytes_read, 0);
4786 data += bytes_read;
4787 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4788 adv);
4789 state_machine_regs.file = adv;
4790 break;
4791
4792 case DW_LNS_set_column:
4793 adv = read_leb128 (data, & bytes_read, 0);
4794 data += bytes_read;
4795 printf (_(" Set column to %d\n"), adv);
4796 state_machine_regs.column = adv;
4797 break;
4798
4799 case DW_LNS_negate_stmt:
4800 adv = state_machine_regs.is_stmt;
4801 adv = ! adv;
4802 printf (_(" Set is_stmt to %d\n"), adv);
4803 state_machine_regs.is_stmt = adv;
4804 break;
4805
4806 case DW_LNS_set_basic_block:
4807 printf (_(" Set basic block\n"));
4808 state_machine_regs.basic_block = 1;
4809 break;
4810
4811 case DW_LNS_const_add_pc:
4812 adv = (((255 - info.li_opcode_base) / info.li_line_range)
4813 * info.li_min_insn_length);
4814 state_machine_regs.address += adv;
4815 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
4816 state_machine_regs.address);
4817 break;
4818
4819 case DW_LNS_fixed_advance_pc:
4820 adv = byte_get (data, 2);
4821 data += 2;
4822 state_machine_regs.address += adv;
4823 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4824 adv, state_machine_regs.address);
4825 break;
4826
4827 default:
4828 op_code -= info.li_opcode_base;
4829 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
4830 state_machine_regs.address += adv;
4831 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4832 op_code, adv, state_machine_regs.address);
4833 adv = (op_code % info.li_line_range) + info.li_line_base;
4834 state_machine_regs.line += adv;
4835 printf (_(" and Line by %d to %d\n"),
4836 adv, state_machine_regs.line);
4837 break;
4838 }
4839 }
4840 printf ("\n");
4841 }
4842
4843 return 1;
4844 }
4845
4846 static int
4847 display_debug_pubnames (section, start, file)
4848 Elf32_Internal_Shdr * section;
4849 unsigned char * start;
4850 FILE * file ATTRIBUTE_UNUSED;
4851 {
4852 DWARF2_External_PubNames * external;
4853 DWARF2_Internal_PubNames pubnames;
4854 unsigned char * end;
4855
4856 end = start + section->sh_size;
4857
4858 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
4859
4860 while (start < end)
4861 {
4862 unsigned char * data;
4863 unsigned long offset;
4864
4865 external = (DWARF2_External_PubNames *) start;
4866
4867 pubnames.pn_length = BYTE_GET (external->pn_length);
4868 pubnames.pn_version = BYTE_GET (external->pn_version);
4869 pubnames.pn_offset = BYTE_GET (external->pn_offset);
4870 pubnames.pn_size = BYTE_GET (external->pn_size);
4871
4872 data = start + sizeof (* external);
4873 start += pubnames.pn_length + sizeof (external->pn_length);
4874
4875 if (pubnames.pn_version != 2)
4876 {
4877 warn (_("Only DWARF 2 pubnames are currently supported"));
4878 continue;
4879 }
4880
4881 printf (_(" Length: %ld\n"),
4882 pubnames.pn_length);
4883 printf (_(" Version: %d\n"),
4884 pubnames.pn_version);
4885 printf (_(" Offset into .debug_info section: %ld\n"),
4886 pubnames.pn_offset);
4887 printf (_(" Size of area in .debug_info section: %ld\n"),
4888 pubnames.pn_size);
4889
4890 printf (_("\n Offset\tName\n"));
4891
4892 do
4893 {
4894 offset = byte_get (data, 4);
4895
4896 if (offset != 0)
4897 {
4898 data += 4;
4899 printf (" %ld\t\t%s\n", offset, data);
4900 data += strlen (data) + 1;
4901 }
4902 }
4903 while (offset != 0);
4904 }
4905
4906 printf ("\n");
4907 return 1;
4908 }
4909
4910 static char *
4911 get_TAG_name (tag)
4912 unsigned long tag;
4913 {
4914 switch (tag)
4915 {
4916 case DW_TAG_padding: return "DW_TAG_padding";
4917 case DW_TAG_array_type: return "DW_TAG_array_type";
4918 case DW_TAG_class_type: return "DW_TAG_class_type";
4919 case DW_TAG_entry_point: return "DW_TAG_entry_point";
4920 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
4921 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
4922 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
4923 case DW_TAG_label: return "DW_TAG_label";
4924 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
4925 case DW_TAG_member: return "DW_TAG_member";
4926 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
4927 case DW_TAG_reference_type: return "DW_TAG_reference_type";
4928 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
4929 case DW_TAG_string_type: return "DW_TAG_string_type";
4930 case DW_TAG_structure_type: return "DW_TAG_structure_type";
4931 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
4932 case DW_TAG_typedef: return "DW_TAG_typedef";
4933 case DW_TAG_union_type: return "DW_TAG_union_type";
4934 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
4935 case DW_TAG_variant: return "DW_TAG_variant";
4936 case DW_TAG_common_block: return "DW_TAG_common_block";
4937 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
4938 case DW_TAG_inheritance: return "DW_TAG_inheritance";
4939 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
4940 case DW_TAG_module: return "DW_TAG_module";
4941 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
4942 case DW_TAG_set_type: return "DW_TAG_set_type";
4943 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
4944 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
4945 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
4946 case DW_TAG_base_type: return "DW_TAG_base_type";
4947 case DW_TAG_catch_block: return "DW_TAG_catch_block";
4948 case DW_TAG_const_type: return "DW_TAG_const_type";
4949 case DW_TAG_constant: return "DW_TAG_constant";
4950 case DW_TAG_enumerator: return "DW_TAG_enumerator";
4951 case DW_TAG_file_type: return "DW_TAG_file_type";
4952 case DW_TAG_friend: return "DW_TAG_friend";
4953 case DW_TAG_namelist: return "DW_TAG_namelist";
4954 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
4955 case DW_TAG_packed_type: return "DW_TAG_packed_type";
4956 case DW_TAG_subprogram: return "DW_TAG_subprogram";
4957 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
4958 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
4959 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
4960 case DW_TAG_try_block: return "DW_TAG_try_block";
4961 case DW_TAG_variant_part: return "DW_TAG_variant_part";
4962 case DW_TAG_variable: return "DW_TAG_variable";
4963 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
4964 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
4965 case DW_TAG_format_label: return "DW_TAG_format_label";
4966 case DW_TAG_function_template: return "DW_TAG_function_template";
4967 case DW_TAG_class_template: return "DW_TAG_class_template";
4968 default:
4969 {
4970 static char buffer [100];
4971
4972 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
4973 return buffer;
4974 }
4975 }
4976 }
4977
4978 static char *
4979 get_AT_name (attribute)
4980 unsigned long attribute;
4981 {
4982 switch (attribute)
4983 {
4984 case DW_AT_sibling: return "DW_AT_sibling";
4985 case DW_AT_location: return "DW_AT_location";
4986 case DW_AT_name: return "DW_AT_name";
4987 case DW_AT_ordering: return "DW_AT_ordering";
4988 case DW_AT_subscr_data: return "DW_AT_subscr_data";
4989 case DW_AT_byte_size: return "DW_AT_byte_size";
4990 case DW_AT_bit_offset: return "DW_AT_bit_offset";
4991 case DW_AT_bit_size: return "DW_AT_bit_size";
4992 case DW_AT_element_list: return "DW_AT_element_list";
4993 case DW_AT_stmt_list: return "DW_AT_stmt_list";
4994 case DW_AT_low_pc: return "DW_AT_low_pc";
4995 case DW_AT_high_pc: return "DW_AT_high_pc";
4996 case DW_AT_language: return "DW_AT_language";
4997 case DW_AT_member: return "DW_AT_member";
4998 case DW_AT_discr: return "DW_AT_discr";
4999 case DW_AT_discr_value: return "DW_AT_discr_value";
5000 case DW_AT_visibility: return "DW_AT_visibility";
5001 case DW_AT_import: return "DW_AT_import";
5002 case DW_AT_string_length: return "DW_AT_string_length";
5003 case DW_AT_common_reference: return "DW_AT_common_reference";
5004 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5005 case DW_AT_const_value: return "DW_AT_const_value";
5006 case DW_AT_containing_type: return "DW_AT_containing_type";
5007 case DW_AT_default_value: return "DW_AT_default_value";
5008 case DW_AT_inline: return "DW_AT_inline";
5009 case DW_AT_is_optional: return "DW_AT_is_optional";
5010 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5011 case DW_AT_producer: return "DW_AT_producer";
5012 case DW_AT_prototyped: return "DW_AT_prototyped";
5013 case DW_AT_return_addr: return "DW_AT_return_addr";
5014 case DW_AT_start_scope: return "DW_AT_start_scope";
5015 case DW_AT_stride_size: return "DW_AT_stride_size";
5016 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5017 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5018 case DW_AT_accessibility: return "DW_AT_accessibility";
5019 case DW_AT_address_class: return "DW_AT_address_class";
5020 case DW_AT_artificial: return "DW_AT_artificial";
5021 case DW_AT_base_types: return "DW_AT_base_types";
5022 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5023 case DW_AT_count: return "DW_AT_count";
5024 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5025 case DW_AT_decl_column: return "DW_AT_decl_column";
5026 case DW_AT_decl_file: return "DW_AT_decl_file";
5027 case DW_AT_decl_line: return "DW_AT_decl_line";
5028 case DW_AT_declaration: return "DW_AT_declaration";
5029 case DW_AT_discr_list: return "DW_AT_discr_list";
5030 case DW_AT_encoding: return "DW_AT_encoding";
5031 case DW_AT_external: return "DW_AT_external";
5032 case DW_AT_frame_base: return "DW_AT_frame_base";
5033 case DW_AT_friend: return "DW_AT_friend";
5034 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5035 case DW_AT_macro_info: return "DW_AT_macro_info";
5036 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5037 case DW_AT_priority: return "DW_AT_priority";
5038 case DW_AT_segment: return "DW_AT_segment";
5039 case DW_AT_specification: return "DW_AT_specification";
5040 case DW_AT_static_link: return "DW_AT_static_link";
5041 case DW_AT_type: return "DW_AT_type";
5042 case DW_AT_use_location: return "DW_AT_use_location";
5043 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5044 case DW_AT_virtuality: return "DW_AT_virtuality";
5045 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5046 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5047 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5048 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5049 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5050 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5051 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5052 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5053 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5054 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5055 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5056 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5057 case DW_AT_sf_names: return "DW_AT_sf_names";
5058 case DW_AT_src_info: return "DW_AT_src_info";
5059 case DW_AT_mac_info: return "DW_AT_mac_info";
5060 case DW_AT_src_coords: return "DW_AT_src_coords";
5061 case DW_AT_body_begin: return "DW_AT_body_begin";
5062 case DW_AT_body_end: return "DW_AT_body_end";
5063 default:
5064 {
5065 static char buffer [100];
5066
5067 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5068 return buffer;
5069 }
5070 }
5071 }
5072
5073 static char *
5074 get_FORM_name (form)
5075 unsigned long form;
5076 {
5077 switch (form)
5078 {
5079 case DW_FORM_addr: return "DW_FORM_addr";
5080 case DW_FORM_block2: return "DW_FORM_block2";
5081 case DW_FORM_block4: return "DW_FORM_block4";
5082 case DW_FORM_data2: return "DW_FORM_data2";
5083 case DW_FORM_data4: return "DW_FORM_data4";
5084 case DW_FORM_data8: return "DW_FORM_data8";
5085 case DW_FORM_string: return "DW_FORM_string";
5086 case DW_FORM_block: return "DW_FORM_block";
5087 case DW_FORM_block1: return "DW_FORM_block1";
5088 case DW_FORM_data1: return "DW_FORM_data1";
5089 case DW_FORM_flag: return "DW_FORM_flag";
5090 case DW_FORM_sdata: return "DW_FORM_sdata";
5091 case DW_FORM_strp: return "DW_FORM_strp";
5092 case DW_FORM_udata: return "DW_FORM_udata";
5093 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5094 case DW_FORM_ref1: return "DW_FORM_ref1";
5095 case DW_FORM_ref2: return "DW_FORM_ref2";
5096 case DW_FORM_ref4: return "DW_FORM_ref4";
5097 case DW_FORM_ref8: return "DW_FORM_ref8";
5098 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5099 case DW_FORM_indirect: return "DW_FORM_indirect";
5100 default:
5101 {
5102 static char buffer [100];
5103
5104 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5105 return buffer;
5106 }
5107 }
5108 }
5109
5110 /* FIXME: There are better and more effiecint ways to handle
5111 these structures. For now though, I just want something that
5112 is simple to implement. */
5113 typedef struct abbrev_attr
5114 {
5115 unsigned long attribute;
5116 unsigned long form;
5117 struct abbrev_attr * next;
5118 }
5119 abbrev_attr;
5120
5121 typedef struct abbrev_entry
5122 {
5123 unsigned long entry;
5124 unsigned long tag;
5125 int children;
5126 struct abbrev_attr * first_attr;
5127 struct abbrev_attr * last_attr;
5128 struct abbrev_entry * next;
5129 }
5130 abbrev_entry;
5131
5132 static abbrev_entry * first_abbrev = NULL;
5133 static abbrev_entry * last_abbrev = NULL;
5134
5135 static void
5136 free_abbrevs PARAMS ((void))
5137 {
5138 abbrev_entry * abbrev;
5139
5140 for (abbrev = first_abbrev; abbrev;)
5141 {
5142 abbrev_entry * next = abbrev->next;
5143 abbrev_attr * attr;
5144
5145 for (attr = abbrev->first_attr; attr;)
5146 {
5147 abbrev_attr * next = attr->next;
5148
5149 free (attr);
5150 attr = next;
5151 }
5152
5153 free (abbrev);
5154 abbrev = next;
5155 }
5156
5157 last_abbrev = first_abbrev = NULL;
5158 }
5159
5160 static void
5161 add_abbrev (number, tag, children)
5162 unsigned long number;
5163 unsigned long tag;
5164 int children;
5165 {
5166 abbrev_entry * entry;
5167
5168 entry = (abbrev_entry *) malloc (sizeof (* entry));
5169
5170 if (entry == NULL)
5171 /* ugg */
5172 return;
5173
5174 entry->entry = number;
5175 entry->tag = tag;
5176 entry->children = children;
5177 entry->first_attr = NULL;
5178 entry->last_attr = NULL;
5179 entry->next = NULL;
5180
5181 if (first_abbrev == NULL)
5182 first_abbrev = entry;
5183 else
5184 last_abbrev->next = entry;
5185
5186 last_abbrev = entry;
5187 }
5188
5189 static void
5190 add_abbrev_attr (attribute, form)
5191 unsigned long attribute;
5192 unsigned long form;
5193 {
5194 abbrev_attr * attr;
5195
5196 attr = (abbrev_attr *) malloc (sizeof (* attr));
5197
5198 if (attr == NULL)
5199 /* ugg */
5200 return;
5201
5202 attr->attribute = attribute;
5203 attr->form = form;
5204 attr->next = NULL;
5205
5206 if (last_abbrev->first_attr == NULL)
5207 last_abbrev->first_attr = attr;
5208 else
5209 last_abbrev->last_attr->next = attr;
5210
5211 last_abbrev->last_attr = attr;
5212 }
5213
5214 /* Processes the (partial) contents of a .debug_abbrev section.
5215 Returns NULL if the end of the section was encountered.
5216 Returns the address after the last byte read if the end of
5217 an abbreviation set was found. */
5218
5219 static unsigned char *
5220 process_abbrev_section (start, end)
5221 unsigned char * start;
5222 unsigned char * end;
5223 {
5224 if (first_abbrev != NULL)
5225 return NULL;
5226
5227 while (start < end)
5228 {
5229 int bytes_read;
5230 unsigned long entry;
5231 unsigned long tag;
5232 unsigned long attribute;
5233 int children;
5234
5235 entry = read_leb128 (start, & bytes_read, 0);
5236 start += bytes_read;
5237
5238 /* A single zero is supposed to end the section according
5239 to the standard. If there's more, then signal that to
5240 the caller. */
5241 if (entry == 0)
5242 return start == end ? NULL : start;
5243
5244 tag = read_leb128 (start, & bytes_read, 0);
5245 start += bytes_read;
5246
5247 children = * start ++;
5248
5249 add_abbrev (entry, tag, children);
5250
5251 do
5252 {
5253 unsigned long form;
5254
5255 attribute = read_leb128 (start, & bytes_read, 0);
5256 start += bytes_read;
5257
5258 form = read_leb128 (start, & bytes_read, 0);
5259 start += bytes_read;
5260
5261 if (attribute != 0)
5262 add_abbrev_attr (attribute, form);
5263 }
5264 while (attribute != 0);
5265 }
5266
5267 return NULL;
5268 }
5269
5270
5271 static int
5272 display_debug_abbrev (section, start, file)
5273 Elf32_Internal_Shdr * section;
5274 unsigned char * start;
5275 FILE * file ATTRIBUTE_UNUSED;
5276 {
5277 abbrev_entry * entry;
5278 unsigned char * end = start + section->sh_size;
5279
5280 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5281
5282 do
5283 {
5284 start = process_abbrev_section (start, end);
5285
5286 printf (_(" Number TAG\n"));
5287
5288 for (entry = first_abbrev; entry; entry = entry->next)
5289 {
5290 abbrev_attr * attr;
5291
5292 printf (_(" %ld %s [%s]\n"),
5293 entry->entry,
5294 get_TAG_name (entry->tag),
5295 entry->children ? _("has children") : _("no children"));
5296
5297 for (attr = entry->first_attr; attr; attr = attr->next)
5298 {
5299 printf (_(" %-18s %s\n"),
5300 get_AT_name (attr->attribute),
5301 get_FORM_name (attr->form));
5302 }
5303 }
5304 }
5305 while (start);
5306
5307 printf ("\n");
5308
5309 return 1;
5310 }
5311
5312
5313 static unsigned char *
5314 display_block (data, length)
5315 unsigned char * data;
5316 unsigned long length;
5317 {
5318 printf (_(" %lu byte block: "), length);
5319
5320 while (length --)
5321 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5322
5323 return data;
5324 }
5325
5326 static void
5327 decode_location_expression (data, pointer_size)
5328 unsigned char * data;
5329 unsigned int pointer_size;
5330 {
5331 unsigned char op;
5332 int bytes_read;
5333 unsigned long uvalue;
5334
5335 op = * data ++;
5336
5337 switch (op)
5338 {
5339 case DW_OP_addr:
5340 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5341 break;
5342 case DW_OP_deref:
5343 printf ("DW_OP_deref");
5344 break;
5345 case DW_OP_const1u:
5346 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5347 break;
5348 case DW_OP_const1s:
5349 printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5350 break;
5351 case DW_OP_const2u:
5352 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5353 break;
5354 case DW_OP_const2s:
5355 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5356 break;
5357 case DW_OP_const4u:
5358 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5359 break;
5360 case DW_OP_const4s:
5361 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5362 break;
5363 case DW_OP_const8u:
5364 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5365 (unsigned long) byte_get (data + 4, 4));
5366 break;
5367 case DW_OP_const8s:
5368 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5369 (long) byte_get (data + 4, 4));
5370 break;
5371 case DW_OP_constu:
5372 printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5373 break;
5374 case DW_OP_consts:
5375 printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5376 break;
5377 case DW_OP_dup:
5378 printf ("DW_OP_dup");
5379 break;
5380 case DW_OP_drop:
5381 printf ("DW_OP_drop");
5382 break;
5383 case DW_OP_over:
5384 printf ("DW_OP_over");
5385 break;
5386 case DW_OP_pick:
5387 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5388 break;
5389 case DW_OP_swap:
5390 printf ("DW_OP_swap");
5391 break;
5392 case DW_OP_rot:
5393 printf ("DW_OP_rot");
5394 break;
5395 case DW_OP_xderef:
5396 printf ("DW_OP_xderef");
5397 break;
5398 case DW_OP_abs:
5399 printf ("DW_OP_abs");
5400 break;
5401 case DW_OP_and:
5402 printf ("DW_OP_and");
5403 break;
5404 case DW_OP_div:
5405 printf ("DW_OP_div");
5406 break;
5407 case DW_OP_minus:
5408 printf ("DW_OP_minus");
5409 break;
5410 case DW_OP_mod:
5411 printf ("DW_OP_mod");
5412 break;
5413 case DW_OP_mul:
5414 printf ("DW_OP_mul");
5415 break;
5416 case DW_OP_neg:
5417 printf ("DW_OP_neg");
5418 break;
5419 case DW_OP_not:
5420 printf ("DW_OP_not");
5421 break;
5422 case DW_OP_or:
5423 printf ("DW_OP_or");
5424 break;
5425 case DW_OP_plus:
5426 printf ("DW_OP_plus");
5427 break;
5428 case DW_OP_plus_uconst:
5429 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5430 break;
5431 case DW_OP_shl:
5432 printf ("DW_OP_shl");
5433 break;
5434 case DW_OP_shr:
5435 printf ("DW_OP_shr");
5436 break;
5437 case DW_OP_shra:
5438 printf ("DW_OP_shra");
5439 break;
5440 case DW_OP_xor:
5441 printf ("DW_OP_xor");
5442 break;
5443 case DW_OP_bra:
5444 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5445 break;
5446 case DW_OP_eq:
5447 printf ("DW_OP_eq");
5448 break;
5449 case DW_OP_ge:
5450 printf ("DW_OP_ge");
5451 break;
5452 case DW_OP_gt:
5453 printf ("DW_OP_gt");
5454 break;
5455 case DW_OP_le:
5456 printf ("DW_OP_le");
5457 break;
5458 case DW_OP_lt:
5459 printf ("DW_OP_lt");
5460 break;
5461 case DW_OP_ne:
5462 printf ("DW_OP_ne");
5463 break;
5464 case DW_OP_skip:
5465 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5466 break;
5467 case DW_OP_lit0:
5468 printf ("DW_OP_lit0");
5469 break;
5470 case DW_OP_lit1:
5471 printf ("DW_OP_lit1");
5472 break;
5473 case DW_OP_lit2:
5474 printf ("DW_OP_lit2");
5475 break;
5476 case DW_OP_lit3:
5477 printf ("DW_OP_lit3");
5478 break;
5479 case DW_OP_lit4:
5480 printf ("DW_OP_lit4");
5481 break;
5482 case DW_OP_lit5:
5483 printf ("DW_OP_lit5");
5484 break;
5485 case DW_OP_lit6:
5486 printf ("DW_OP_lit6");
5487 break;
5488 case DW_OP_lit7:
5489 printf ("DW_OP_lit7");
5490 break;
5491 case DW_OP_lit8:
5492 printf ("DW_OP_lit8");
5493 break;
5494 case DW_OP_lit9:
5495 printf ("DW_OP_lit9");
5496 break;
5497 case DW_OP_lit10:
5498 printf ("DW_OP_lit10");
5499 break;
5500 case DW_OP_lit11:
5501 printf ("DW_OP_lit11");
5502 break;
5503 case DW_OP_lit12:
5504 printf ("DW_OP_lit12");
5505 break;
5506 case DW_OP_lit13:
5507 printf ("DW_OP_lit13");
5508 break;
5509 case DW_OP_lit14:
5510 printf ("DW_OP_lit14");
5511 break;
5512 case DW_OP_lit15:
5513 printf ("DW_OP_lit15");
5514 break;
5515 case DW_OP_lit16:
5516 printf ("DW_OP_lit16");
5517 break;
5518 case DW_OP_lit17:
5519 printf ("DW_OP_lit17");
5520 break;
5521 case DW_OP_lit18:
5522 printf ("DW_OP_lit18");
5523 break;
5524 case DW_OP_lit19:
5525 printf ("DW_OP_lit19");
5526 break;
5527 case DW_OP_lit20:
5528 printf ("DW_OP_lit20");
5529 break;
5530 case DW_OP_lit21:
5531 printf ("DW_OP_lit21");
5532 break;
5533 case DW_OP_lit22:
5534 printf ("DW_OP_lit22");
5535 break;
5536 case DW_OP_lit23:
5537 printf ("DW_OP_lit23");
5538 break;
5539 case DW_OP_lit24:
5540 printf ("DW_OP_lit24");
5541 break;
5542 case DW_OP_lit25:
5543 printf ("DW_OP_lit25");
5544 break;
5545 case DW_OP_lit26:
5546 printf ("DW_OP_lit26");
5547 break;
5548 case DW_OP_lit27:
5549 printf ("DW_OP_lit27");
5550 break;
5551 case DW_OP_lit28:
5552 printf ("DW_OP_lit28");
5553 break;
5554 case DW_OP_lit29:
5555 printf ("DW_OP_lit29");
5556 break;
5557 case DW_OP_lit30:
5558 printf ("DW_OP_lit30");
5559 break;
5560 case DW_OP_lit31:
5561 printf ("DW_OP_lit31");
5562 break;
5563 case DW_OP_reg0:
5564 printf ("DW_OP_reg0");
5565 break;
5566 case DW_OP_reg1:
5567 printf ("DW_OP_reg1");
5568 break;
5569 case DW_OP_reg2:
5570 printf ("DW_OP_reg2");
5571 break;
5572 case DW_OP_reg3:
5573 printf ("DW_OP_reg3");
5574 break;
5575 case DW_OP_reg4:
5576 printf ("DW_OP_reg4");
5577 break;
5578 case DW_OP_reg5:
5579 printf ("DW_OP_reg5");
5580 break;
5581 case DW_OP_reg6:
5582 printf ("DW_OP_reg6");
5583 break;
5584 case DW_OP_reg7:
5585 printf ("DW_OP_reg7");
5586 break;
5587 case DW_OP_reg8:
5588 printf ("DW_OP_reg8");
5589 break;
5590 case DW_OP_reg9:
5591 printf ("DW_OP_reg9");
5592 break;
5593 case DW_OP_reg10:
5594 printf ("DW_OP_reg10");
5595 break;
5596 case DW_OP_reg11:
5597 printf ("DW_OP_reg11");
5598 break;
5599 case DW_OP_reg12:
5600 printf ("DW_OP_reg12");
5601 break;
5602 case DW_OP_reg13:
5603 printf ("DW_OP_reg13");
5604 break;
5605 case DW_OP_reg14:
5606 printf ("DW_OP_reg14");
5607 break;
5608 case DW_OP_reg15:
5609 printf ("DW_OP_reg15");
5610 break;
5611 case DW_OP_reg16:
5612 printf ("DW_OP_reg16");
5613 break;
5614 case DW_OP_reg17:
5615 printf ("DW_OP_reg17");
5616 break;
5617 case DW_OP_reg18:
5618 printf ("DW_OP_reg18");
5619 break;
5620 case DW_OP_reg19:
5621 printf ("DW_OP_reg19");
5622 break;
5623 case DW_OP_reg20:
5624 printf ("DW_OP_reg20");
5625 break;
5626 case DW_OP_reg21:
5627 printf ("DW_OP_reg21");
5628 break;
5629 case DW_OP_reg22:
5630 printf ("DW_OP_reg22");
5631 break;
5632 case DW_OP_reg23:
5633 printf ("DW_OP_reg23");
5634 break;
5635 case DW_OP_reg24:
5636 printf ("DW_OP_reg24");
5637 break;
5638 case DW_OP_reg25:
5639 printf ("DW_OP_reg25");
5640 break;
5641 case DW_OP_reg26:
5642 printf ("DW_OP_reg26");
5643 break;
5644 case DW_OP_reg27:
5645 printf ("DW_OP_reg27");
5646 break;
5647 case DW_OP_reg28:
5648 printf ("DW_OP_reg28");
5649 break;
5650 case DW_OP_reg29:
5651 printf ("DW_OP_reg29");
5652 break;
5653 case DW_OP_reg30:
5654 printf ("DW_OP_reg30");
5655 break;
5656 case DW_OP_reg31:
5657 printf ("DW_OP_reg31");
5658 break;
5659 case DW_OP_breg0:
5660 printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5661 break;
5662 case DW_OP_breg1:
5663 printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5664 break;
5665 case DW_OP_breg2:
5666 printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5667 break;
5668 case DW_OP_breg3:
5669 printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5670 break;
5671 case DW_OP_breg4:
5672 printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5673 break;
5674 case DW_OP_breg5:
5675 printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5676 break;
5677 case DW_OP_breg6:
5678 printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5679 break;
5680 case DW_OP_breg7:
5681 printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5682 break;
5683 case DW_OP_breg8:
5684 printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5685 break;
5686 case DW_OP_breg9:
5687 printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5688 break;
5689 case DW_OP_breg10:
5690 printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5691 break;
5692 case DW_OP_breg11:
5693 printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5694 break;
5695 case DW_OP_breg12:
5696 printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5697 break;
5698 case DW_OP_breg13:
5699 printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5700 break;
5701 case DW_OP_breg14:
5702 printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5703 break;
5704 case DW_OP_breg15:
5705 printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5706 break;
5707 case DW_OP_breg16:
5708 printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5709 break;
5710 case DW_OP_breg17:
5711 printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5712 break;
5713 case DW_OP_breg18:
5714 printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5715 break;
5716 case DW_OP_breg19:
5717 printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5718 break;
5719 case DW_OP_breg20:
5720 printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5721 break;
5722 case DW_OP_breg21:
5723 printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5724 break;
5725 case DW_OP_breg22:
5726 printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
5727 break;
5728 case DW_OP_breg23:
5729 printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
5730 break;
5731 case DW_OP_breg24:
5732 printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
5733 break;
5734 case DW_OP_breg25:
5735 printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
5736 break;
5737 case DW_OP_breg26:
5738 printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
5739 break;
5740 case DW_OP_breg27:
5741 printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
5742 break;
5743 case DW_OP_breg28:
5744 printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
5745 break;
5746 case DW_OP_breg29:
5747 printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
5748 break;
5749 case DW_OP_breg30:
5750 printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
5751 break;
5752 case DW_OP_breg31:
5753 printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
5754 break;
5755 case DW_OP_regx:
5756 printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
5757 break;
5758 case DW_OP_fbreg:
5759 printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
5760 break;
5761 case DW_OP_bregx:
5762 uvalue = read_leb128 (data, &bytes_read, 0);
5763 printf ("DW_OP_bregx: %lu %ld", uvalue,
5764 read_leb128 (data + bytes_read, NULL, 1));
5765 break;
5766 case DW_OP_piece:
5767 printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
5768 break;
5769 case DW_OP_deref_size:
5770 printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
5771 break;
5772 case DW_OP_xderef_size:
5773 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
5774 break;
5775 case DW_OP_nop:
5776 printf ("DW_OP_nop");
5777 break;
5778
5779 default:
5780 if (op >= DW_OP_lo_user
5781 && op <= DW_OP_hi_user)
5782 printf (_("(User defined location op)"));
5783 else
5784 printf (_("(Unknown location op)"));
5785 break;
5786 }
5787 }
5788
5789
5790 static unsigned char *
5791 read_and_display_attr (attribute, form, data, pointer_size)
5792 unsigned long attribute;
5793 unsigned long form;
5794 unsigned char * data;
5795 unsigned long pointer_size;
5796 {
5797 unsigned long uvalue = 0;
5798 unsigned char * block_start = NULL;
5799 int bytes_read;
5800 int is_ref = 0;
5801
5802 printf (" %-18s:", get_AT_name (attribute));
5803
5804 switch (form)
5805 {
5806 case DW_FORM_ref_addr:
5807 case DW_FORM_ref1:
5808 case DW_FORM_ref2:
5809 case DW_FORM_ref4:
5810 case DW_FORM_ref8:
5811 case DW_FORM_ref_udata:
5812 is_ref = 1;
5813 }
5814
5815 switch (form)
5816 {
5817 case DW_FORM_ref_addr:
5818 case DW_FORM_addr:
5819 uvalue = byte_get (data, pointer_size);
5820 printf (is_ref ? " <%x>" : " %#x", uvalue);
5821 data += pointer_size;
5822 break;
5823
5824 case DW_FORM_ref1:
5825 case DW_FORM_flag:
5826 case DW_FORM_data1:
5827 uvalue = byte_get (data ++, 1);
5828 printf (is_ref ? " <%x>" : " %d", uvalue);
5829 break;
5830
5831 case DW_FORM_ref2:
5832 case DW_FORM_data2:
5833 uvalue = byte_get (data, 2);
5834 data += 2;
5835 printf (is_ref ? " <%x>" : " %d", uvalue);
5836 break;
5837
5838 case DW_FORM_ref4:
5839 case DW_FORM_data4:
5840 uvalue = byte_get (data, 4);
5841 data += 4;
5842 printf (is_ref ? " <%x>" : " %d", uvalue);
5843 break;
5844
5845 case DW_FORM_ref8:
5846 case DW_FORM_data8:
5847 uvalue = byte_get (data, 4);
5848 printf (" %lx", uvalue);
5849 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
5850 data += 8;
5851 break;
5852
5853 case DW_FORM_string:
5854 printf (" %s", data);
5855 data += strlen (data) + 1;
5856 break;
5857
5858 case DW_FORM_sdata:
5859 uvalue = read_leb128 (data, & bytes_read, 1);
5860 data += bytes_read;
5861 printf (" %ld", (long) uvalue);
5862 break;
5863
5864 case DW_FORM_ref_udata:
5865 case DW_FORM_udata:
5866 uvalue = read_leb128 (data, & bytes_read, 0);
5867 data += bytes_read;
5868 printf (is_ref ? " <%lx>" : " %ld", uvalue);
5869 break;
5870
5871 case DW_FORM_block:
5872 uvalue = read_leb128 (data, & bytes_read, 0);
5873 block_start = data + bytes_read;
5874 data = display_block (block_start, uvalue);
5875 uvalue = * block_start;
5876 break;
5877
5878 case DW_FORM_block1:
5879 uvalue = byte_get (data, 1);
5880 block_start = data + 1;
5881 data = display_block (block_start, uvalue);
5882 uvalue = * block_start;
5883 break;
5884
5885 case DW_FORM_block2:
5886 uvalue = byte_get (data, 2);
5887 block_start = data + 2;
5888 data = display_block (block_start, uvalue);
5889 uvalue = * block_start;
5890 break;
5891
5892 case DW_FORM_block4:
5893 uvalue = byte_get (data, 4);
5894 block_start = data + 4;
5895 data = display_block (block_start, uvalue);
5896 uvalue = * block_start;
5897 break;
5898
5899 case DW_FORM_strp:
5900 case DW_FORM_indirect:
5901 warn (_("Unable to handle FORM: %d"), form);
5902 break;
5903
5904 default:
5905 warn (_("Unrecognised form: %d"), form);
5906 break;
5907 }
5908
5909 /* For some attributes we can display futher information. */
5910
5911 printf ("\t");
5912
5913 switch (attribute)
5914 {
5915 case DW_AT_inline:
5916 switch (uvalue)
5917 {
5918 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
5919 case DW_INL_inlined: printf (_("(inlined)")); break;
5920 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
5921 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
5922 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
5923 }
5924 break;
5925
5926 case DW_AT_frame_base:
5927 if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
5928 printf ("(reg %ld)", uvalue - DW_OP_reg0);
5929 break;
5930
5931 case DW_AT_language:
5932 switch (uvalue)
5933 {
5934 case DW_LANG_C: printf ("(non-ANSI C)"); break;
5935 case DW_LANG_C89: printf ("(ANSI C)"); break;
5936 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
5937 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
5938 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
5939 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
5940 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
5941 case DW_LANG_Ada83: printf ("(Ada)"); break;
5942 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
5943 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
5944 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
5945 default: printf ("(Unknown: %lx)", uvalue); break;
5946 }
5947 break;
5948
5949 case DW_AT_encoding:
5950 switch (uvalue)
5951 {
5952 case DW_ATE_void: printf ("(void)"); break;
5953 case DW_ATE_address: printf ("(machine address)"); break;
5954 case DW_ATE_boolean: printf ("(boolean)"); break;
5955 case DW_ATE_complex_float: printf ("(complex float)"); break;
5956 case DW_ATE_float: printf ("(float)"); break;
5957 case DW_ATE_signed: printf ("(signed)"); break;
5958 case DW_ATE_signed_char: printf ("(signed char)"); break;
5959 case DW_ATE_unsigned: printf ("(unsigned)"); break;
5960 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
5961 default:
5962 if (uvalue >= DW_ATE_lo_user
5963 && uvalue <= DW_ATE_hi_user)
5964 printf ("(user defined type)");
5965 else
5966 printf ("(unknown type)");
5967 break;
5968 }
5969 break;
5970
5971 case DW_AT_accessibility:
5972 switch (uvalue)
5973 {
5974 case DW_ACCESS_public: printf ("(public)"); break;
5975 case DW_ACCESS_protected: printf ("(protected)"); break;
5976 case DW_ACCESS_private: printf ("(private)"); break;
5977 default: printf ("(unknown accessibility)"); break;
5978 }
5979 break;
5980
5981 case DW_AT_visibility:
5982 switch (uvalue)
5983 {
5984 case DW_VIS_local: printf ("(local)"); break;
5985 case DW_VIS_exported: printf ("(exported)"); break;
5986 case DW_VIS_qualified: printf ("(qualified)"); break;
5987 default: printf ("(unknown visibility)"); break;
5988 }
5989 break;
5990
5991 case DW_AT_virtuality:
5992 switch (uvalue)
5993 {
5994 case DW_VIRTUALITY_none: printf ("(none)"); break;
5995 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
5996 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
5997 default: printf ("(unknown virtuality)"); break;
5998 }
5999 break;
6000
6001 case DW_AT_identifier_case:
6002 switch (uvalue)
6003 {
6004 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6005 case DW_ID_up_case: printf ("(up_case)"); break;
6006 case DW_ID_down_case: printf ("(down_case)"); break;
6007 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6008 default: printf ("(unknown case)"); break;
6009 }
6010 break;
6011
6012 case DW_AT_calling_convention:
6013 switch (uvalue)
6014 {
6015 case DW_CC_normal: printf ("(normal)"); break;
6016 case DW_CC_program: printf ("(program)"); break;
6017 case DW_CC_nocall: printf ("(nocall)"); break;
6018 default:
6019 if (uvalue >= DW_CC_lo_user
6020 && uvalue <= DW_CC_hi_user)
6021 printf ("(user defined)");
6022 else
6023 printf ("(unknown convention)");
6024 }
6025 break;
6026
6027 case DW_AT_location:
6028 case DW_AT_data_member_location:
6029 case DW_AT_vtable_elem_location:
6030 printf ("(");
6031 decode_location_expression (block_start, pointer_size);
6032 printf (")");
6033 break;
6034
6035 default:
6036 break;
6037 }
6038
6039 printf ("\n");
6040 return data;
6041 }
6042
6043 static int
6044 display_debug_info (section, start, file)
6045 Elf32_Internal_Shdr * section;
6046 unsigned char * start;
6047 FILE * file;
6048 {
6049 unsigned char * end = start + section->sh_size;
6050 unsigned char * section_begin = start;
6051
6052 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6053
6054 while (start < end)
6055 {
6056 DWARF2_External_CompUnit * external;
6057 DWARF2_Internal_CompUnit compunit;
6058 unsigned char * tags;
6059 int i;
6060 int level;
6061
6062 external = (DWARF2_External_CompUnit *) start;
6063
6064 compunit.cu_length = BYTE_GET (external->cu_length);
6065 compunit.cu_version = BYTE_GET (external->cu_version);
6066 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6067 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6068
6069 tags = start + sizeof (* external);
6070 start += compunit.cu_length + sizeof (external->cu_length);
6071
6072 if (compunit.cu_version != 2)
6073 {
6074 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6075 continue;
6076 }
6077
6078 printf (_(" Compilation Unit:\n"));
6079 printf (_(" Length: %ld\n"), compunit.cu_length);
6080 printf (_(" Version: %d\n"), compunit.cu_version);
6081 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6082 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6083
6084 if (first_abbrev != NULL)
6085 free_abbrevs ();
6086
6087 /* Read in the abbrevs used by this compilation unit. */
6088
6089 {
6090 Elf32_Internal_Shdr * sec;
6091 unsigned char * begin;
6092
6093 /* Locate the .debug_abbrev section and process it. */
6094 for (i = 0, sec = section_headers;
6095 i < elf_header.e_shnum;
6096 i ++, sec ++)
6097 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6098 break;
6099
6100 if (i == -1 || sec->sh_size == 0)
6101 {
6102 warn (_("Unable to locate .debug_abbrev section!\n"));
6103 return 0;
6104 }
6105
6106 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6107 "debug_abbrev section data");
6108
6109 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6110 begin + sec->sh_size);
6111
6112 free (begin);
6113 }
6114
6115 level = 0;
6116 while (tags < start)
6117 {
6118 int bytes_read;
6119 unsigned long abbrev_number;
6120 abbrev_entry * entry;
6121 abbrev_attr * attr;
6122
6123 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6124 tags += bytes_read;
6125
6126 /* A null DIE marks the end of a list of children. */
6127 if (abbrev_number == 0)
6128 {
6129 --level;
6130 continue;
6131 }
6132
6133 /* Scan through the abbreviation list until we reach the
6134 correct entry. */
6135 for (entry = first_abbrev;
6136 entry && entry->entry != abbrev_number;
6137 entry = entry->next)
6138 continue;
6139
6140 if (entry == NULL)
6141 {
6142 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6143 abbrev_number);
6144 return 0;
6145 }
6146
6147 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6148 level, tags - section_begin - bytes_read,
6149 abbrev_number,
6150 get_TAG_name (entry->tag));
6151
6152 for (attr = entry->first_attr; attr; attr = attr->next)
6153 tags = read_and_display_attr (attr->attribute,
6154 attr->form,
6155 tags,
6156 compunit.cu_pointer_size);
6157
6158 if (entry->children)
6159 ++level;
6160 }
6161 }
6162
6163 printf ("\n");
6164
6165 return 1;
6166 }
6167
6168 static int
6169 display_debug_aranges (section, start, file)
6170 Elf32_Internal_Shdr * section;
6171 unsigned char * start;
6172 FILE * file ATTRIBUTE_UNUSED;
6173 {
6174 unsigned char * end = start + section->sh_size;
6175
6176 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6177
6178 while (start < end)
6179 {
6180 DWARF2_External_ARange * external;
6181 DWARF2_Internal_ARange arange;
6182 unsigned char * ranges;
6183 unsigned long length;
6184 unsigned long address;
6185 int excess;
6186
6187 external = (DWARF2_External_ARange *) start;
6188
6189 arange.ar_length = BYTE_GET (external->ar_length);
6190 arange.ar_version = BYTE_GET (external->ar_version);
6191 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6192 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6193 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6194
6195 printf (_(" Length: %ld\n"), arange.ar_length);
6196 printf (_(" Version: %d\n"), arange.ar_version);
6197 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6198 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6199 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6200
6201 printf (_("\n Address Length\n"));
6202
6203 ranges = start + sizeof (* external);
6204
6205 /* Must pad to an alignment boundary that is twice the pointer size. */
6206 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6207 if (excess)
6208 ranges += (2 * arange.ar_pointer_size) - excess;
6209
6210 for (;;)
6211 {
6212 address = byte_get (ranges, arange.ar_pointer_size);
6213
6214 ranges += arange.ar_pointer_size;
6215
6216 length = byte_get (ranges, arange.ar_pointer_size);
6217
6218 ranges += arange.ar_pointer_size;
6219
6220 /* A pair of zeros marks the end of the list. */
6221 if (address == 0 && length == 0)
6222 break;
6223
6224 printf (" %8.8lx %lu\n", address, length);
6225 }
6226
6227 start += arange.ar_length + sizeof (external->ar_length);
6228 }
6229
6230 printf ("\n");
6231
6232 return 1;
6233 }
6234
6235
6236 static int
6237 display_debug_not_supported (section, start, file)
6238 Elf32_Internal_Shdr * section;
6239 unsigned char * start ATTRIBUTE_UNUSED;
6240 FILE * file ATTRIBUTE_UNUSED;
6241 {
6242 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6243 SECTION_NAME (section));
6244
6245 return 1;
6246 }
6247
6248 /* Pre-scan the .debug_info section to record the size of address.
6249 When dumping the .debug_line, we use that size information, assuming
6250 that all compilation units have the same address size. */
6251 static int
6252 prescan_debug_info (section, start, file)
6253 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6254 unsigned char * start;
6255 FILE * file ATTRIBUTE_UNUSED;
6256 {
6257 DWARF2_External_CompUnit * external;
6258
6259 external = (DWARF2_External_CompUnit *) start;
6260
6261 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6262 return 0;
6263 }
6264
6265 /* A structure containing the name of a debug section and a pointer
6266 to a function that can decode it. The third field is a prescan
6267 function to be run over the section before displaying any of the
6268 sections. */
6269 struct
6270 {
6271 char * name;
6272 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6273 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6274 }
6275 debug_displays[] =
6276 {
6277 { ".debug_info", display_debug_info, prescan_debug_info },
6278 { ".debug_abbrev", display_debug_abbrev, NULL },
6279 { ".debug_line", display_debug_lines, NULL },
6280 { ".debug_aranges", display_debug_aranges, NULL },
6281 { ".debug_pubnames", display_debug_pubnames, NULL },
6282 { ".debug_macinfo", display_debug_not_supported, NULL },
6283 { ".debug_frame", display_debug_not_supported, NULL },
6284 { ".debug_str", display_debug_not_supported, NULL },
6285 { ".debug_static_func", display_debug_not_supported, NULL },
6286 { ".debug_static_vars", display_debug_not_supported, NULL },
6287 { ".debug_types", display_debug_not_supported, NULL },
6288 { ".debug_weaknames", display_debug_not_supported, NULL }
6289 };
6290
6291 static int
6292 display_debug_section (section, file)
6293 Elf32_Internal_Shdr * section;
6294 FILE * file;
6295 {
6296 char * name = SECTION_NAME (section);
6297 bfd_size_type length;
6298 unsigned char * start;
6299 int i;
6300
6301 length = section->sh_size;
6302 if (length == 0)
6303 {
6304 printf (_("\nSection '%s' has no debugging data.\n"), name);
6305 return 0;
6306 }
6307
6308 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6309 "debug section data");
6310
6311 /* See if we know how to display the contents of this section. */
6312 for (i = NUM_ELEM (debug_displays); i--;)
6313 if (strcmp (debug_displays[i].name, name) == 0)
6314 {
6315 debug_displays[i].display (section, start, file);
6316 break;
6317 }
6318
6319 if (i == -1)
6320 printf (_("Unrecognised debug section: %s\n"), name);
6321
6322 free (start);
6323
6324 /* If we loaded in the abbrev section at some point,
6325 we must release it here. */
6326 if (first_abbrev != NULL)
6327 free_abbrevs ();
6328
6329 return 1;
6330 }
6331
6332 static int
6333 process_section_contents (file)
6334 FILE * file;
6335 {
6336 Elf32_Internal_Shdr * section;
6337 unsigned int i;
6338
6339 if (! do_dump)
6340 return 1;
6341
6342 /* Pre-scan the debug sections to find some debug information not
6343 present in some of them. For the .debug_line, we must find out the
6344 size of address (specified in .debug_info and .debug_aranges). */
6345 for (i = 0, section = section_headers;
6346 i < elf_header.e_shnum && i < num_dump_sects;
6347 i ++, section ++)
6348 {
6349 char * name = SECTION_NAME (section);
6350 int j;
6351
6352 if (section->sh_size == 0)
6353 continue;
6354
6355 /* See if there is some pre-scan operation for this section. */
6356 for (j = NUM_ELEM (debug_displays); j--;)
6357 if (strcmp (debug_displays[j].name, name) == 0)
6358 {
6359 if (debug_displays[j].prescan != NULL)
6360 {
6361 bfd_size_type length;
6362 unsigned char * start;
6363
6364 length = section->sh_size;
6365 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6366 "debug section data");
6367
6368 debug_displays[j].prescan (section, start, file);
6369 free (start);
6370 }
6371
6372 break;
6373 }
6374 }
6375
6376 for (i = 0, section = section_headers;
6377 i < elf_header.e_shnum && i < num_dump_sects;
6378 i ++, section ++)
6379 {
6380 #ifdef SUPPORT_DISASSEMBLY
6381 if (dump_sects[i] & DISASS_DUMP)
6382 disassemble_section (section, file);
6383 #endif
6384 if (dump_sects[i] & HEX_DUMP)
6385 dump_section (section, file);
6386
6387 if (dump_sects[i] & DEBUG_DUMP)
6388 display_debug_section (section, file);
6389 }
6390
6391 if (i < num_dump_sects)
6392 warn (_("Some sections were not dumped because they do not exist!\n"));
6393
6394 return 1;
6395 }
6396
6397 static void
6398 process_mips_fpe_exception (mask)
6399 int mask;
6400 {
6401 if (mask)
6402 {
6403 int first = 1;
6404 if (mask & OEX_FPU_INEX)
6405 fputs ("INEX", stdout), first = 0;
6406 if (mask & OEX_FPU_UFLO)
6407 printf ("%sUFLO", first ? "" : "|"), first = 0;
6408 if (mask & OEX_FPU_OFLO)
6409 printf ("%sOFLO", first ? "" : "|"), first = 0;
6410 if (mask & OEX_FPU_DIV0)
6411 printf ("%sDIV0", first ? "" : "|"), first = 0;
6412 if (mask & OEX_FPU_INVAL)
6413 printf ("%sINVAL", first ? "" : "|");
6414 }
6415 else
6416 fputs ("0", stdout);
6417 }
6418
6419 static int
6420 process_mips_specific (file)
6421 FILE * file;
6422 {
6423 Elf_Internal_Dyn * entry;
6424 size_t liblist_offset = 0;
6425 size_t liblistno = 0;
6426 size_t conflictsno = 0;
6427 size_t options_offset = 0;
6428 size_t conflicts_offset = 0;
6429
6430 /* We have a lot of special sections. Thanks SGI! */
6431 if (dynamic_segment == NULL)
6432 /* No information available. */
6433 return 0;
6434
6435 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6436 switch (entry->d_tag)
6437 {
6438 case DT_MIPS_LIBLIST:
6439 liblist_offset = entry->d_un.d_val - loadaddr;
6440 break;
6441 case DT_MIPS_LIBLISTNO:
6442 liblistno = entry->d_un.d_val;
6443 break;
6444 case DT_MIPS_OPTIONS:
6445 options_offset = entry->d_un.d_val - loadaddr;
6446 break;
6447 case DT_MIPS_CONFLICT:
6448 conflicts_offset = entry->d_un.d_val - loadaddr;
6449 break;
6450 case DT_MIPS_CONFLICTNO:
6451 conflictsno = entry->d_un.d_val;
6452 break;
6453 default:
6454 break;
6455 }
6456
6457 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6458 {
6459 Elf32_External_Lib * elib;
6460 size_t cnt;
6461
6462 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6463 elib, Elf32_External_Lib *, "liblist");
6464
6465 printf ("\nSection '.liblist' contains %d entries:\n", liblistno);
6466 fputs (" Library Time Stamp Checksum Version Flags\n",
6467 stdout);
6468
6469 for (cnt = 0; cnt < liblistno; ++cnt)
6470 {
6471 Elf32_Lib liblist;
6472 time_t time;
6473 char timebuf[20];
6474
6475 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6476 time = BYTE_GET (elib[cnt].l_time_stamp);
6477 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6478 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6479 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6480
6481 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6482
6483 printf ("%3d: %-20s %s %#10lx %-7ld", cnt,
6484 dynamic_strings + liblist.l_name, timebuf,
6485 liblist.l_checksum, liblist.l_version);
6486
6487 if (liblist.l_flags == 0)
6488 puts (" NONE");
6489 else
6490 {
6491 static const struct
6492 {
6493 const char *name;
6494 int bit;
6495 } l_flags_vals[] =
6496 {
6497 { " EXACT_MATCH", LL_EXACT_MATCH },
6498 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6499 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6500 { " EXPORTS", LL_EXPORTS },
6501 { " DELAY_LOAD", LL_DELAY_LOAD },
6502 { " DELTA", LL_DELTA }
6503 };
6504 int flags = liblist.l_flags;
6505 size_t fcnt;
6506
6507 for (fcnt = 0;
6508 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6509 ++fcnt)
6510 if ((flags & l_flags_vals[fcnt].bit) != 0)
6511 {
6512 fputs (l_flags_vals[fcnt].name, stdout);
6513 flags ^= l_flags_vals[fcnt].bit;
6514 }
6515 if (flags != 0)
6516 printf (" %#x", (unsigned int) flags);
6517
6518 puts ("");
6519 }
6520 }
6521
6522 free (elib);
6523 }
6524
6525 if (options_offset != 0)
6526 {
6527 Elf_External_Options * eopt;
6528 Elf_Internal_Shdr * sect = section_headers;
6529 Elf_Internal_Options * iopt;
6530 Elf_Internal_Options * option;
6531 size_t offset;
6532 int cnt;
6533
6534 /* Find the section header so that we get the size. */
6535 while (sect->sh_type != SHT_MIPS_OPTIONS)
6536 ++sect;
6537
6538 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6539 Elf_External_Options *, "options");
6540
6541 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6542 * sizeof (*iopt));
6543 if (iopt == NULL)
6544 {
6545 error (_("Out of memory"));
6546 return 0;
6547 }
6548
6549 offset = cnt = 0;
6550 option = iopt;
6551 while (offset < sect->sh_size)
6552 {
6553 Elf_External_Options * eoption;
6554
6555 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6556
6557 option->kind = BYTE_GET (eoption->kind);
6558 option->size = BYTE_GET (eoption->size);
6559 option->section = BYTE_GET (eoption->section);
6560 option->info = BYTE_GET (eoption->info);
6561
6562 offset += option->size;
6563 ++option;
6564 ++cnt;
6565 }
6566
6567 printf (_("\nSection '%s' contains %d entries:\n"),
6568 string_table + sect->sh_name, cnt);
6569
6570 option = iopt;
6571 while (cnt-- > 0)
6572 {
6573 size_t len;
6574
6575 switch (option->kind)
6576 {
6577 case ODK_NULL:
6578 /* This shouldn't happen. */
6579 printf (" NULL %d %lx", option->section, option->info);
6580 break;
6581 case ODK_REGINFO:
6582 printf (" REGINFO ");
6583 if (elf_header.e_machine == EM_MIPS)
6584 {
6585 /* 32bit form. */
6586 Elf32_External_RegInfo *ereg;
6587 Elf32_RegInfo reginfo;
6588
6589 ereg = (Elf32_External_RegInfo *) (option + 1);
6590 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6591 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6592 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6593 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6594 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6595 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6596
6597 printf ("GPR %08lx GP 0x%lx\n",
6598 reginfo.ri_gprmask,
6599 (unsigned long) reginfo.ri_gp_value);
6600 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6601 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6602 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6603 }
6604 else
6605 {
6606 /* 64 bit form. */
6607 Elf64_External_RegInfo * ereg;
6608 Elf64_Internal_RegInfo reginfo;
6609
6610 ereg = (Elf64_External_RegInfo *) (option + 1);
6611 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6612 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6613 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6614 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6615 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6616 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6617
6618 printf ("GPR %08lx GP 0x",
6619 reginfo.ri_gprmask);
6620 printf_vma (reginfo.ri_gp_value);
6621 printf ("\n");
6622
6623 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6624 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6625 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6626 }
6627 ++option;
6628 continue;
6629 case ODK_EXCEPTIONS:
6630 fputs (" EXCEPTIONS fpe_min(", stdout);
6631 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6632 fputs (") fpe_max(", stdout);
6633 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6634 fputs (")", stdout);
6635
6636 if (option->info & OEX_PAGE0)
6637 fputs (" PAGE0", stdout);
6638 if (option->info & OEX_SMM)
6639 fputs (" SMM", stdout);
6640 if (option->info & OEX_FPDBUG)
6641 fputs (" FPDBUG", stdout);
6642 if (option->info & OEX_DISMISS)
6643 fputs (" DISMISS", stdout);
6644 break;
6645 case ODK_PAD:
6646 fputs (" PAD ", stdout);
6647 if (option->info & OPAD_PREFIX)
6648 fputs (" PREFIX", stdout);
6649 if (option->info & OPAD_POSTFIX)
6650 fputs (" POSTFIX", stdout);
6651 if (option->info & OPAD_SYMBOL)
6652 fputs (" SYMBOL", stdout);
6653 break;
6654 case ODK_HWPATCH:
6655 fputs (" HWPATCH ", stdout);
6656 if (option->info & OHW_R4KEOP)
6657 fputs (" R4KEOP", stdout);
6658 if (option->info & OHW_R8KPFETCH)
6659 fputs (" R8KPFETCH", stdout);
6660 if (option->info & OHW_R5KEOP)
6661 fputs (" R5KEOP", stdout);
6662 if (option->info & OHW_R5KCVTL)
6663 fputs (" R5KCVTL", stdout);
6664 break;
6665 case ODK_FILL:
6666 fputs (" FILL ", stdout);
6667 /* XXX Print content of info word? */
6668 break;
6669 case ODK_TAGS:
6670 fputs (" TAGS ", stdout);
6671 /* XXX Print content of info word? */
6672 break;
6673 case ODK_HWAND:
6674 fputs (" HWAND ", stdout);
6675 if (option->info & OHWA0_R4KEOP_CHECKED)
6676 fputs (" R4KEOP_CHECKED", stdout);
6677 if (option->info & OHWA0_R4KEOP_CLEAN)
6678 fputs (" R4KEOP_CLEAN", stdout);
6679 break;
6680 case ODK_HWOR:
6681 fputs (" HWOR ", stdout);
6682 if (option->info & OHWA0_R4KEOP_CHECKED)
6683 fputs (" R4KEOP_CHECKED", stdout);
6684 if (option->info & OHWA0_R4KEOP_CLEAN)
6685 fputs (" R4KEOP_CLEAN", stdout);
6686 break;
6687 case ODK_GP_GROUP:
6688 printf (" GP_GROUP %#06lx self-contained %#06lx",
6689 option->info & OGP_GROUP,
6690 (option->info & OGP_SELF) >> 16);
6691 break;
6692 case ODK_IDENT:
6693 printf (" IDENT %#06lx self-contained %#06lx",
6694 option->info & OGP_GROUP,
6695 (option->info & OGP_SELF) >> 16);
6696 break;
6697 default:
6698 /* This shouldn't happen. */
6699 printf (" %3d ??? %d %lx",
6700 option->kind, option->section, option->info);
6701 break;
6702 }
6703
6704 len = sizeof (*eopt);
6705 while (len < option->size)
6706 if (((char *) option)[len] >= ' '
6707 && ((char *) option)[len] < 0x7f)
6708 printf ("%c", ((char *) option)[len++]);
6709 else
6710 printf ("\\%03o", ((char *) option)[len++]);
6711
6712 fputs ("\n", stdout);
6713 ++option;
6714 }
6715
6716 free (eopt);
6717 }
6718
6719 if (conflicts_offset != 0 && conflictsno != 0)
6720 {
6721 Elf32_External_Conflict * econf32;
6722 Elf64_External_Conflict * econf64;
6723 Elf32_Conflict * iconf;
6724 size_t cnt;
6725
6726 if (dynamic_symbols == NULL)
6727 {
6728 error (_("conflict list with without table"));
6729 return 0;
6730 }
6731
6732 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6733 if (iconf == NULL)
6734 {
6735 error (_("Out of memory"));
6736 return 0;
6737 }
6738
6739 if (is_32bit_elf)
6740 {
6741 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6742 econf32, Elf32_External_Conflict *, "conflict");
6743
6744 for (cnt = 0; cnt < conflictsno; ++cnt)
6745 iconf[cnt] = BYTE_GET (econf32[cnt]);
6746 }
6747 else
6748 {
6749 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6750 econf64, Elf64_External_Conflict *, "conflict");
6751
6752 for (cnt = 0; cnt < conflictsno; ++cnt)
6753 iconf[cnt] = BYTE_GET (econf64[cnt]);
6754 }
6755
6756 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6757 puts (_(" Num: Index Value Name"));
6758
6759 for (cnt = 0; cnt < conflictsno; ++cnt)
6760 {
6761 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
6762
6763 printf ("%5u: %8lu ", cnt, iconf[cnt]);
6764 print_vma (psym->st_value, FULL_HEX);
6765 printf (" %s\n", dynamic_strings + psym->st_name);
6766 }
6767
6768 free (iconf);
6769 }
6770
6771 return 1;
6772 }
6773
6774 static char *
6775 get_note_type (e_type)
6776 unsigned e_type;
6777 {
6778 static char buff[64];
6779
6780 switch (e_type)
6781 {
6782 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
6783 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
6784 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
6785 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
6786 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
6787 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
6788 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
6789 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6790 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6791 default:
6792 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
6793 return buff;
6794 }
6795 }
6796
6797 /* Note that by the ELF standard, the name field is already null byte
6798 terminated, and namesz includes the terminating null byte.
6799 I.E. the value of namesz for the name "FSF" is 4.
6800
6801 If the value of namesz is zero, there is no name present. */
6802 static int
6803 process_note (pnote)
6804 Elf32_Internal_Note * pnote;
6805 {
6806 printf (" %s\t\t0x%08lx\t%s\n",
6807 pnote->namesz ? pnote->namedata : "(NONE)",
6808 pnote->descsz, get_note_type (pnote->type));
6809 return 1;
6810 }
6811
6812
6813 static int
6814 process_corefile_note_segment (file, offset, length)
6815 FILE * file;
6816 bfd_vma offset;
6817 bfd_vma length;
6818 {
6819 Elf_External_Note * pnotes;
6820 Elf_External_Note * external;
6821 int res = 1;
6822
6823 if (length <= 0)
6824 return 0;
6825
6826 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
6827
6828 external = pnotes;
6829
6830 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"), offset, length);
6831 printf (_(" Owner\t\tData size\tDescription\n"));
6832
6833 while (external < (Elf_External_Note *)((char *) pnotes + length))
6834 {
6835 Elf32_Internal_Note inote;
6836 char * temp = NULL;
6837
6838 inote.type = BYTE_GET (external->type);
6839 inote.namesz = BYTE_GET (external->namesz);
6840 inote.namedata = external->name;
6841 inote.descsz = BYTE_GET (external->descsz);
6842 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
6843 inote.descpos = offset + (inote.descdata - (char *) pnotes);
6844
6845 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
6846
6847 /* Verify that name is null terminated. It appears that at least
6848 one version of Linux (RedHat 6.0) generates corefiles that don't
6849 comply with the ELF spec by failing to include the null byte in
6850 namesz. */
6851 if (inote.namedata[inote.namesz] != '\0')
6852 {
6853 temp = malloc (inote.namesz + 1);
6854
6855 if (temp == NULL)
6856 {
6857 error (_("Out of memory\n"));
6858 res = 0;
6859 break;
6860 }
6861
6862 strncpy (temp, inote.namedata, inote.namesz);
6863 temp[inote.namesz] = 0;
6864
6865 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
6866 inote.namedata = temp;
6867 }
6868
6869 res &= process_note (& inote);
6870
6871 if (temp != NULL)
6872 {
6873 free (temp);
6874 temp = NULL;
6875 }
6876 }
6877
6878 free (pnotes);
6879
6880 return res;
6881 }
6882
6883 static int
6884 process_corefile_note_segments (file)
6885 FILE * file;
6886 {
6887 Elf_Internal_Phdr * program_headers;
6888 Elf_Internal_Phdr * segment;
6889 unsigned int i;
6890 int res = 1;
6891
6892 program_headers = (Elf_Internal_Phdr *) malloc
6893 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
6894
6895 if (program_headers == NULL)
6896 {
6897 error (_("Out of memory\n"));
6898 return 0;
6899 }
6900
6901 if (is_32bit_elf)
6902 i = get_32bit_program_headers (file, program_headers);
6903 else
6904 i = get_64bit_program_headers (file, program_headers);
6905
6906 if (i == 0)
6907 {
6908 free (program_headers);
6909 return 0;
6910 }
6911
6912 for (i = 0, segment = program_headers;
6913 i < elf_header.e_phnum;
6914 i ++, segment ++)
6915 {
6916 if (segment->p_type == PT_NOTE)
6917 res &= process_corefile_note_segment (file,
6918 (bfd_vma)segment->p_offset,
6919 (bfd_vma)segment->p_filesz);
6920 }
6921
6922 free (program_headers);
6923
6924 return res;
6925 }
6926
6927 static int
6928 process_corefile_contents (file)
6929 FILE * file;
6930 {
6931 /* If we have not been asked to display the notes then do nothing. */
6932 if (! do_notes)
6933 return 1;
6934
6935 /* If file is not a core file then exit. */
6936 if (elf_header.e_type != ET_CORE)
6937 return 1;
6938
6939 /* No program headers means no NOTE segment. */
6940 if (elf_header.e_phnum == 0)
6941 {
6942 printf (_("No note segments present in the core file.\n"));
6943 return 1;
6944 }
6945
6946 return process_corefile_note_segments (file);
6947 }
6948
6949 static int
6950 process_arch_specific (file)
6951 FILE * file;
6952 {
6953 if (! do_arch)
6954 return 1;
6955
6956 switch (elf_header.e_machine)
6957 {
6958 case EM_MIPS:
6959 case EM_MIPS_RS4_BE:
6960 return process_mips_specific (file);
6961 break;
6962 default:
6963 break;
6964 }
6965 return 1;
6966 }
6967
6968 static int
6969 get_file_header (file)
6970 FILE * file;
6971 {
6972 /* Read in the identity array. */
6973 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
6974 return 0;
6975
6976 /* Determine how to read the rest of the header. */
6977 switch (elf_header.e_ident [EI_DATA])
6978 {
6979 default: /* fall through */
6980 case ELFDATANONE: /* fall through */
6981 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
6982 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
6983 }
6984
6985 /* For now we only support 32 bit and 64 bit ELF files. */
6986 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
6987
6988 /* Read in the rest of the header. */
6989 if (is_32bit_elf)
6990 {
6991 Elf32_External_Ehdr ehdr32;
6992
6993 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
6994 return 0;
6995
6996 elf_header.e_type = BYTE_GET (ehdr32.e_type);
6997 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
6998 elf_header.e_version = BYTE_GET (ehdr32.e_version);
6999 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7000 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7001 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7002 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7003 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7004 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7005 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7006 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7007 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7008 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7009 }
7010 else
7011 {
7012 Elf64_External_Ehdr ehdr64;
7013
7014 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7015 we will not be able to cope with the 64bit data found in
7016 64 ELF files. Detect this now and abort before we start
7017 overwritting things. */
7018 if (sizeof (bfd_vma) < 8)
7019 {
7020 error (_("This instance of readelf has been built without support for a\n"));
7021 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7022 return 0;
7023 }
7024
7025 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7026 return 0;
7027
7028 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7029 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7030 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7031 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7032 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7033 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7034 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7035 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7036 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7037 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7038 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7039 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7040 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7041 }
7042
7043 return 1;
7044 }
7045
7046 static void
7047 process_file (file_name)
7048 char * file_name;
7049 {
7050 FILE * file;
7051 struct stat statbuf;
7052 unsigned int i;
7053
7054 if (stat (file_name, & statbuf) < 0)
7055 {
7056 error (_("Cannot stat input file %s.\n"), file_name);
7057 return;
7058 }
7059
7060 file = fopen (file_name, "rb");
7061 if (file == NULL)
7062 {
7063 error (_("Input file %s not found.\n"), file_name);
7064 return;
7065 }
7066
7067 if (! get_file_header (file))
7068 {
7069 error (_("%s: Failed to read file header\n"), file_name);
7070 fclose (file);
7071 return;
7072 }
7073
7074 /* Initialise per file variables. */
7075 for (i = NUM_ELEM (version_info); i--;)
7076 version_info[i] = 0;
7077
7078 for (i = NUM_ELEM (dynamic_info); i--;)
7079 dynamic_info[i] = 0;
7080
7081 /* Process the file. */
7082 if (show_name)
7083 printf (_("\nFile: %s\n"), file_name);
7084
7085 if (! process_file_header ())
7086 {
7087 fclose (file);
7088 return;
7089 }
7090
7091 process_section_headers (file);
7092
7093 process_program_headers (file);
7094
7095 process_dynamic_segment (file);
7096
7097 process_relocs (file);
7098
7099 process_symbol_table (file);
7100
7101 process_syminfo (file);
7102
7103 process_version_sections (file);
7104
7105 process_section_contents (file);
7106
7107 process_corefile_contents (file);
7108
7109 process_arch_specific (file);
7110
7111 fclose (file);
7112
7113 if (section_headers)
7114 {
7115 free (section_headers);
7116 section_headers = NULL;
7117 }
7118
7119 if (string_table)
7120 {
7121 free (string_table);
7122 string_table = NULL;
7123 }
7124
7125 if (dynamic_strings)
7126 {
7127 free (dynamic_strings);
7128 dynamic_strings = NULL;
7129 }
7130
7131 if (dynamic_symbols)
7132 {
7133 free (dynamic_symbols);
7134 dynamic_symbols = NULL;
7135 num_dynamic_syms = 0;
7136 }
7137
7138 if (dynamic_syminfo)
7139 {
7140 free (dynamic_syminfo);
7141 dynamic_syminfo = NULL;
7142 }
7143 }
7144
7145 #ifdef SUPPORT_DISASSEMBLY
7146 /* Needed by the i386 disassembler. For extra credit, someone could
7147 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7148 symbols */
7149
7150 void
7151 print_address (unsigned int addr, FILE * outfile)
7152 {
7153 fprintf (outfile,"0x%8.8x", addr);
7154 }
7155
7156 /* Needed by the i386 disassembler. */
7157 void
7158 db_task_printsym (unsigned int addr)
7159 {
7160 print_address (addr, stderr);
7161 }
7162 #endif
7163
7164 int
7165 main (argc, argv)
7166 int argc;
7167 char ** argv;
7168 {
7169 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7170 setlocale (LC_MESSAGES, "");
7171 #endif
7172 bindtextdomain (PACKAGE, LOCALEDIR);
7173 textdomain (PACKAGE);
7174
7175 parse_args (argc, argv);
7176
7177 if (optind < (argc - 1))
7178 show_name = 1;
7179
7180 while (optind < argc)
7181 process_file (argv [optind ++]);
7182
7183 if (dump_sects != NULL)
7184 free (dump_sects);
7185
7186 return 0;
7187 }