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