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