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