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