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