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