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