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