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