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