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