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