projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Prevent seg fault with corrupt section name indicies
[deliverable/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 char * name;
4001
4002 printf (" %03x:", cnt);
4003
4004 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4005 switch (data [cnt + j])
4006 {
4007 case 0:
4008 fputs (_(" 0 (*local*) "), stdout);
4009 break;
4010
4011 case 1:
4012 fputs (_(" 1 (*global*) "), stdout);
4013 break;
4014
4015 default:
4016 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4017 data [cnt + j] & 0x8000 ? 'h' : ' ');
4018
4019 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
4020 && section_headers[symbols [cnt + j].st_shndx].sh_type
4021 == SHT_NOBITS)
4022 {
4023 /* We must test both. */
4024 Elf_Internal_Verneed ivn;
4025 unsigned long offset;
4026
4027 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4028 - loadaddr;
4029
4030 do
4031 {
4032 Elf_External_Verneed evn;
4033 Elf_External_Vernaux evna;
4034 Elf_Internal_Vernaux ivna;
4035 unsigned long vna_off;
4036
4037 GET_DATA (offset, evn, "version need");
4038
4039 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4040 ivn.vn_next = BYTE_GET (evn.vn_next);
4041
4042 vna_off = offset + ivn.vn_aux;
4043
4044 do
4045 {
4046 GET_DATA (vna_off, evna,
4047 "version need aux (1)");
4048
4049 ivna.vna_next = BYTE_GET (evna.vna_next);
4050 ivna.vna_other = BYTE_GET (evna.vna_other);
4051
4052 vna_off += ivna.vna_next;
4053 }
4054 while (ivna.vna_other != data [cnt + j]
4055 && ivna.vna_next != 0);
4056
4057 if (ivna.vna_other == data [cnt + j])
4058 {
4059 ivna.vna_name = BYTE_GET (evna.vna_name);
4060
4061 name = strtab + ivna.vna_name;
4062 nn += printf ("(%s%-*s",
4063 name,
4064 12 - (int) strlen (name),
4065 ")");
4066 break;
4067 }
4068 else if (ivn.vn_next == 0)
4069 {
4070 if (data [cnt + j] != 0x8001)
4071 {
4072 Elf_Internal_Verdef ivd;
4073 Elf_External_Verdef evd;
4074
4075 offset = version_info
4076 [DT_VERSIONTAGIDX (DT_VERDEF)]
4077 - loadaddr;
4078
4079 do
4080 {
4081 GET_DATA (offset, evd,
4082 "version definition");
4083
4084 ivd.vd_next = BYTE_GET (evd.vd_next);
4085 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4086
4087 offset += ivd.vd_next;
4088 }
4089 while (ivd.vd_ndx
4090 != (data [cnt + j] & 0x7fff)
4091 && ivd.vd_next != 0);
4092
4093 if (ivd.vd_ndx
4094 == (data [cnt + j] & 0x7fff))
4095 {
4096 Elf_External_Verdaux evda;
4097 Elf_Internal_Verdaux ivda;
4098
4099 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4100
4101 GET_DATA (offset + ivd.vd_aux, evda,
4102 "version definition aux");
4103
4104 ivda.vda_name =
4105 BYTE_GET (evda.vda_name);
4106
4107 name = strtab + ivda.vda_name;
4108 nn +=
4109 printf ("(%s%-*s",
4110 name,
4111 12 - (int) strlen (name),
4112 ")");
4113 }
4114 }
4115
4116 break;
4117 }
4118 else
4119 offset += ivn.vn_next;
4120 }
4121 while (ivn.vn_next);
4122 }
4123 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4124 {
4125 Elf_Internal_Verneed ivn;
4126 unsigned long offset;
4127
4128 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4129 - loadaddr;
4130
4131 do
4132 {
4133 Elf_Internal_Vernaux ivna;
4134 Elf_External_Verneed evn;
4135 Elf_External_Vernaux evna;
4136 unsigned long a_off;
4137
4138 GET_DATA (offset, evn, "version need");
4139
4140 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4141 ivn.vn_next = BYTE_GET (evn.vn_next);
4142
4143 a_off = offset + ivn.vn_aux;
4144
4145 do
4146 {
4147 GET_DATA (a_off, evna,
4148 "version need aux (2)");
4149
4150 ivna.vna_next = BYTE_GET (evna.vna_next);
4151 ivna.vna_other = BYTE_GET (evna.vna_other);
4152
4153 a_off += ivna.vna_next;
4154 }
4155 while (ivna.vna_other != data [cnt + j]
4156 && ivna.vna_next != 0);
4157
4158 if (ivna.vna_other == data [cnt + j])
4159 {
4160 ivna.vna_name = BYTE_GET (evna.vna_name);
4161
4162 name = strtab + ivna.vna_name;
4163 nn += printf ("(%s%-*s",
4164 name,
4165 12 - (int) strlen (name),
4166 ")");
4167 break;
4168 }
4169
4170 offset += ivn.vn_next;
4171 }
4172 while (ivn.vn_next);
4173 }
4174 else if (data [cnt + j] != 0x8001)
4175 {
4176 Elf_Internal_Verdef ivd;
4177 Elf_External_Verdef evd;
4178 unsigned long offset;
4179
4180 offset = version_info
4181 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4182
4183 do
4184 {
4185 GET_DATA (offset, evd, "version def");
4186
4187 ivd.vd_next = BYTE_GET (evd.vd_next);
4188 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4189
4190 offset += ivd.vd_next;
4191 }
4192 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4193 && ivd.vd_next != 0);
4194
4195 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4196 {
4197 Elf_External_Verdaux evda;
4198 Elf_Internal_Verdaux ivda;
4199
4200 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4201
4202 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4203 evda, "version def aux");
4204
4205 ivda.vda_name = BYTE_GET (evda.vda_name);
4206
4207 name = strtab + ivda.vda_name;
4208 nn += printf ("(%s%-*s",
4209 name,
4210 12 - (int) strlen (name),
4211 ")");
4212 }
4213 }
4214
4215 if (nn < 18)
4216 printf ("%*c", 18 - nn, ' ');
4217 }
4218
4219 putchar ('\n');
4220 }
4221
4222 free (data);
4223 free (strtab);
4224 free (symbols);
4225 }
4226 break;
4227
4228 default:
4229 break;
4230 }
4231 }
4232
4233 if (! found)
4234 printf (_("\nNo version information found in this file.\n"));
4235
4236 return 1;
4237 }
4238
4239 static const char *
4240 get_symbol_binding (binding)
4241 unsigned int binding;
4242 {
4243 static char buff [32];
4244
4245 switch (binding)
4246 {
4247 case STB_LOCAL: return "LOCAL";
4248 case STB_GLOBAL: return "GLOBAL";
4249 case STB_WEAK: return "WEAK";
4250 default:
4251 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4252 sprintf (buff, _("<processor specific>: %d"), binding);
4253 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4254 sprintf (buff, _("<OS specific>: %d"), binding);
4255 else
4256 sprintf (buff, _("<unknown>: %d"), binding);
4257 return buff;
4258 }
4259 }
4260
4261 static const char *
4262 get_symbol_type (type)
4263 unsigned int type;
4264 {
4265 static char buff [32];
4266
4267 switch (type)
4268 {
4269 case STT_NOTYPE: return "NOTYPE";
4270 case STT_OBJECT: return "OBJECT";
4271 case STT_FUNC: return "FUNC";
4272 case STT_SECTION: return "SECTION";
4273 case STT_FILE: return "FILE";
4274 case STT_COMMON: return "COMMON";
4275 default:
4276 if (type >= STT_LOPROC && type <= STT_HIPROC)
4277 {
4278 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4279 return "THUMB_FUNC";
4280
4281 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4282 return "REGISTER";
4283
4284 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4285 return "PARISC_MILLI";
4286
4287 sprintf (buff, _("<processor specific>: %d"), type);
4288 }
4289 else if (type >= STT_LOOS && type <= STT_HIOS)
4290 {
4291 if (elf_header.e_machine == EM_PARISC)
4292 {
4293 if (type == STT_HP_OPAQUE)
4294 return "HP_OPAQUE";
4295 if (type == STT_HP_STUB)
4296 return "HP_STUB";
4297 }
4298
4299 sprintf (buff, _("<OS specific>: %d"), type);
4300 }
4301 else
4302 sprintf (buff, _("<unknown>: %d"), type);
4303 return buff;
4304 }
4305 }
4306
4307 static const char *
4308 get_symbol_visibility (visibility)
4309 unsigned int visibility;
4310 {
4311 switch (visibility)
4312 {
4313 case STV_DEFAULT: return "DEFAULT";
4314 case STV_INTERNAL: return "INTERNAL";
4315 case STV_HIDDEN: return "HIDDEN";
4316 case STV_PROTECTED: return "PROTECTED";
4317 default: abort ();
4318 }
4319 }
4320
4321 static const char *
4322 get_symbol_index_type (type)
4323 unsigned int type;
4324 {
4325 switch (type)
4326 {
4327 case SHN_UNDEF: return "UND";
4328 case SHN_ABS: return "ABS";
4329 case SHN_COMMON: return "COM";
4330 default:
4331 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4332 return "PRC";
4333 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4334 return "RSV";
4335 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4336 return "OS ";
4337 else
4338 {
4339 static char buff [32];
4340
4341 sprintf (buff, "%3d", type);
4342 return buff;
4343 }
4344 }
4345 }
4346
4347 static int *
4348 get_dynamic_data (file, number)
4349 FILE * file;
4350 unsigned int number;
4351 {
4352 unsigned char * e_data;
4353 int * i_data;
4354
4355 e_data = (unsigned char *) malloc (number * 4);
4356
4357 if (e_data == NULL)
4358 {
4359 error (_("Out of memory\n"));
4360 return NULL;
4361 }
4362
4363 if (fread (e_data, 4, number, file) != number)
4364 {
4365 error (_("Unable to read in dynamic data\n"));
4366 return NULL;
4367 }
4368
4369 i_data = (int *) malloc (number * sizeof (* i_data));
4370
4371 if (i_data == NULL)
4372 {
4373 error (_("Out of memory\n"));
4374 free (e_data);
4375 return NULL;
4376 }
4377
4378 while (number--)
4379 i_data [number] = byte_get (e_data + number * 4, 4);
4380
4381 free (e_data);
4382
4383 return i_data;
4384 }
4385
4386 /* Dump the symbol table */
4387 static int
4388 process_symbol_table (file)
4389 FILE * file;
4390 {
4391 Elf32_Internal_Shdr * section;
4392 unsigned char nb [4];
4393 unsigned char nc [4];
4394 int nbuckets = 0;
4395 int nchains = 0;
4396 int * buckets = NULL;
4397 int * chains = NULL;
4398
4399 if (! do_syms && !do_histogram)
4400 return 1;
4401
4402 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4403 || do_histogram))
4404 {
4405 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4406 {
4407 error (_("Unable to seek to start of dynamic information"));
4408 return 0;
4409 }
4410
4411 if (fread (nb, sizeof (nb), 1, file) != 1)
4412 {
4413 error (_("Failed to read in number of buckets\n"));
4414 return 0;
4415 }
4416
4417 if (fread (nc, sizeof (nc), 1, file) != 1)
4418 {
4419 error (_("Failed to read in number of chains\n"));
4420 return 0;
4421 }
4422
4423 nbuckets = byte_get (nb, 4);
4424 nchains = byte_get (nc, 4);
4425
4426 buckets = get_dynamic_data (file, nbuckets);
4427 chains = get_dynamic_data (file, nchains);
4428
4429 if (buckets == NULL || chains == NULL)
4430 return 0;
4431 }
4432
4433 if (do_syms
4434 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4435 {
4436 int hn;
4437 int si;
4438
4439 printf (_("\nSymbol table for image:\n"));
4440 if (is_32bit_elf)
4441 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4442 else
4443 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4444
4445 for (hn = 0; hn < nbuckets; hn++)
4446 {
4447 if (! buckets [hn])
4448 continue;
4449
4450 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4451 {
4452 Elf_Internal_Sym * psym;
4453
4454 psym = dynamic_symbols + si;
4455
4456 printf (" %3d %3d: ", si, hn);
4457 print_vma (psym->st_value, LONG_HEX);
4458 putchar (' ' );
4459 print_vma (psym->st_size, DEC_5);
4460
4461 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4462 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4463 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4464 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4465 printf (" %s\n", dynamic_strings + psym->st_name);
4466 }
4467 }
4468 }
4469 else if (do_syms && !do_using_dynamic)
4470 {
4471 unsigned int i;
4472
4473 for (i = 0, section = section_headers;
4474 i < elf_header.e_shnum;
4475 i++, section++)
4476 {
4477 unsigned int si;
4478 char * strtab;
4479 Elf_Internal_Sym * symtab;
4480 Elf_Internal_Sym * psym;
4481
4482
4483 if ( section->sh_type != SHT_SYMTAB
4484 && section->sh_type != SHT_DYNSYM)
4485 continue;
4486
4487 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4488 SECTION_NAME (section),
4489 (unsigned long) (section->sh_size / section->sh_entsize));
4490 if (is_32bit_elf)
4491 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4492 else
4493 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4494
4495 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4496 section->sh_size / section->sh_entsize);
4497 if (symtab == NULL)
4498 continue;
4499
4500 if (section->sh_link == elf_header.e_shstrndx)
4501 strtab = string_table;
4502 else
4503 {
4504 Elf32_Internal_Shdr * string_sec;
4505
4506 string_sec = section_headers + section->sh_link;
4507
4508 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4509 strtab, char *, "string table");
4510 }
4511
4512 for (si = 0, psym = symtab;
4513 si < section->sh_size / section->sh_entsize;
4514 si ++, psym ++)
4515 {
4516 printf ("%6d: ", si);
4517 print_vma (psym->st_value, LONG_HEX);
4518 putchar (' ');
4519 print_vma (psym->st_size, DEC_5);
4520 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4521 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4522 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4523 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4524 printf (" %s", strtab + psym->st_name);
4525
4526 if (section->sh_type == SHT_DYNSYM &&
4527 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4528 {
4529 unsigned char data[2];
4530 unsigned short vers_data;
4531 unsigned long offset;
4532 int is_nobits;
4533 int check_def;
4534
4535 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4536 - loadaddr;
4537
4538 GET_DATA (offset + si * sizeof (vers_data), data,
4539 "version data");
4540
4541 vers_data = byte_get (data, 2);
4542
4543 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4544 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4545 : 0;
4546
4547 check_def = (psym->st_shndx != SHN_UNDEF);
4548
4549 if ((vers_data & 0x8000) || vers_data > 1)
4550 {
4551 if (is_nobits || ! check_def)
4552 {
4553 Elf_External_Verneed evn;
4554 Elf_Internal_Verneed ivn;
4555 Elf_Internal_Vernaux ivna;
4556
4557 /* We must test both. */
4558 offset = version_info
4559 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4560
4561 do
4562 {
4563 unsigned long vna_off;
4564
4565 GET_DATA (offset, evn, "version need");
4566
4567 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4568 ivn.vn_next = BYTE_GET (evn.vn_next);
4569
4570 vna_off = offset + ivn.vn_aux;
4571
4572 do
4573 {
4574 Elf_External_Vernaux evna;
4575
4576 GET_DATA (vna_off, evna,
4577 "version need aux (3)");
4578
4579 ivna.vna_other = BYTE_GET (evna.vna_other);
4580 ivna.vna_next = BYTE_GET (evna.vna_next);
4581 ivna.vna_name = BYTE_GET (evna.vna_name);
4582
4583 vna_off += ivna.vna_next;
4584 }
4585 while (ivna.vna_other != vers_data
4586 && ivna.vna_next != 0);
4587
4588 if (ivna.vna_other == vers_data)
4589 break;
4590
4591 offset += ivn.vn_next;
4592 }
4593 while (ivn.vn_next != 0);
4594
4595 if (ivna.vna_other == vers_data)
4596 {
4597 printf ("@%s (%d)",
4598 strtab + ivna.vna_name, ivna.vna_other);
4599 check_def = 0;
4600 }
4601 else if (! is_nobits)
4602 error (_("bad dynamic symbol"));
4603 else
4604 check_def = 1;
4605 }
4606
4607 if (check_def)
4608 {
4609 if (vers_data != 0x8001)
4610 {
4611 Elf_Internal_Verdef ivd;
4612 Elf_Internal_Verdaux ivda;
4613 Elf_External_Verdaux evda;
4614 unsigned long offset;
4615
4616 offset =
4617 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4618 - loadaddr;
4619
4620 do
4621 {
4622 Elf_External_Verdef evd;
4623
4624 GET_DATA (offset, evd, "version def");
4625
4626 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4627 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4628 ivd.vd_next = BYTE_GET (evd.vd_next);
4629
4630 offset += ivd.vd_next;
4631 }
4632 while (ivd.vd_ndx != (vers_data & 0x7fff)
4633 && ivd.vd_next != 0);
4634
4635 offset -= ivd.vd_next;
4636 offset += ivd.vd_aux;
4637
4638 GET_DATA (offset, evda, "version def aux");
4639
4640 ivda.vda_name = BYTE_GET (evda.vda_name);
4641
4642 if (psym->st_name != ivda.vda_name)
4643 printf ((vers_data & 0x8000)
4644 ? "@%s" : "@@%s",
4645 strtab + ivda.vda_name);
4646 }
4647 }
4648 }
4649 }
4650
4651 putchar ('\n');
4652 }
4653
4654 free (symtab);
4655 if (strtab != string_table)
4656 free (strtab);
4657 }
4658 }
4659 else if (do_syms)
4660 printf
4661 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4662
4663 if (do_histogram && buckets != NULL)
4664 {
4665 int * lengths;
4666 int * counts;
4667 int hn;
4668 int si;
4669 int maxlength = 0;
4670 int nzero_counts = 0;
4671 int nsyms = 0;
4672
4673 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4674 nbuckets);
4675 printf (_(" Length Number %% of total Coverage\n"));
4676
4677 lengths = (int *) calloc (nbuckets, sizeof (int));
4678 if (lengths == NULL)
4679 {
4680 error (_("Out of memory"));
4681 return 0;
4682 }
4683 for (hn = 0; hn < nbuckets; ++hn)
4684 {
4685 if (! buckets [hn])
4686 continue;
4687
4688 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4689 {
4690 ++ nsyms;
4691 if (maxlength < ++lengths[hn])
4692 ++ maxlength;
4693 }
4694 }
4695
4696 counts = (int *) calloc (maxlength + 1, sizeof (int));
4697 if (counts == NULL)
4698 {
4699 error (_("Out of memory"));
4700 return 0;
4701 }
4702
4703 for (hn = 0; hn < nbuckets; ++hn)
4704 ++ counts [lengths [hn]];
4705
4706 if (nbuckets > 0)
4707 {
4708 printf (" 0 %-10d (%5.1f%%)\n",
4709 counts[0], (counts[0] * 100.0) / nbuckets);
4710 for (si = 1; si <= maxlength; ++si)
4711 {
4712 nzero_counts += counts[si] * si;
4713 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4714 si, counts[si], (counts[si] * 100.0) / nbuckets,
4715 (nzero_counts * 100.0) / nsyms);
4716 }
4717 }
4718
4719 free (counts);
4720 free (lengths);
4721 }
4722
4723 if (buckets != NULL)
4724 {
4725 free (buckets);
4726 free (chains);
4727 }
4728
4729 return 1;
4730 }
4731
4732 static int
4733 process_syminfo (file)
4734 FILE * file ATTRIBUTE_UNUSED;
4735 {
4736 unsigned int i;
4737
4738 if (dynamic_syminfo == NULL
4739 || !do_dynamic)
4740 /* No syminfo, this is ok. */
4741 return 1;
4742
4743 /* There better should be a dynamic symbol section. */
4744 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4745 return 0;
4746
4747 if (dynamic_addr)
4748 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4749 dynamic_syminfo_offset, dynamic_syminfo_nent);
4750
4751 printf (_(" Num: Name BoundTo Flags\n"));
4752 for (i = 0; i < dynamic_syminfo_nent; ++i)
4753 {
4754 unsigned short int flags = dynamic_syminfo[i].si_flags;
4755
4756 printf ("%4d: %-30s ", i,
4757 dynamic_strings + dynamic_symbols[i].st_name);
4758
4759 switch (dynamic_syminfo[i].si_boundto)
4760 {
4761 case SYMINFO_BT_SELF:
4762 fputs ("SELF ", stdout);
4763 break;
4764 case SYMINFO_BT_PARENT:
4765 fputs ("PARENT ", stdout);
4766 break;
4767 default:
4768 if (dynamic_syminfo[i].si_boundto > 0
4769 && dynamic_syminfo[i].si_boundto < dynamic_size)
4770 printf ("%-10s ",
4771 dynamic_strings
4772 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4773 else
4774 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4775 break;
4776 }
4777
4778 if (flags & SYMINFO_FLG_DIRECT)
4779 printf (" DIRECT");
4780 if (flags & SYMINFO_FLG_PASSTHRU)
4781 printf (" PASSTHRU");
4782 if (flags & SYMINFO_FLG_COPY)
4783 printf (" COPY");
4784 if (flags & SYMINFO_FLG_LAZYLOAD)
4785 printf (" LAZYLOAD");
4786
4787 puts ("");
4788 }
4789
4790 return 1;
4791 }
4792
4793 #ifdef SUPPORT_DISASSEMBLY
4794 static void
4795 disassemble_section (section, file)
4796 Elf32_Internal_Shdr * section;
4797 FILE * file;
4798 {
4799 printf (_("\nAssembly dump of section %s\n"),
4800 SECTION_NAME (section));
4801
4802 /* XXX -- to be done --- XXX */
4803
4804 return 1;
4805 }
4806 #endif
4807
4808 static int
4809 dump_section (section, file)
4810 Elf32_Internal_Shdr * section;
4811 FILE * file;
4812 {
4813 bfd_size_type bytes;
4814 bfd_vma addr;
4815 unsigned char * data;
4816 unsigned char * start;
4817
4818 bytes = section->sh_size;
4819
4820 if (bytes == 0)
4821 {
4822 printf (_("\nSection '%s' has no data to dump.\n"),
4823 SECTION_NAME (section));
4824 return 0;
4825 }
4826 else
4827 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4828
4829 addr = section->sh_addr;
4830
4831 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4832 "section data");
4833
4834 data = start;
4835
4836 while (bytes)
4837 {
4838 int j;
4839 int k;
4840 int lbytes;
4841
4842 lbytes = (bytes > 16 ? 16 : bytes);
4843
4844 printf (" 0x%8.8lx ", (unsigned long) addr);
4845
4846 switch (elf_header.e_ident [EI_DATA])
4847 {
4848 default:
4849 case ELFDATA2LSB:
4850 for (j = 15; j >= 0; j --)
4851 {
4852 if (j < lbytes)
4853 printf ("%2.2x", data [j]);
4854 else
4855 printf (" ");
4856
4857 if (!(j & 0x3))
4858 printf (" ");
4859 }
4860 break;
4861
4862 case ELFDATA2MSB:
4863 for (j = 0; j < 16; j++)
4864 {
4865 if (j < lbytes)
4866 printf ("%2.2x", data [j]);
4867 else
4868 printf (" ");
4869
4870 if ((j & 3) == 3)
4871 printf (" ");
4872 }
4873 break;
4874 }
4875
4876 for (j = 0; j < lbytes; j++)
4877 {
4878 k = data [j];
4879 if (k >= ' ' && k < 0x80)
4880 printf ("%c", k);
4881 else
4882 printf (".");
4883 }
4884
4885 putchar ('\n');
4886
4887 data += lbytes;
4888 addr += lbytes;
4889 bytes -= lbytes;
4890 }
4891
4892 free (start);
4893
4894 return 1;
4895 }
4896
4897
4898 static unsigned long int
4899 read_leb128 (data, length_return, sign)
4900 unsigned char * data;
4901 int * length_return;
4902 int sign;
4903 {
4904 unsigned long int result = 0;
4905 unsigned int num_read = 0;
4906 int shift = 0;
4907 unsigned char byte;
4908
4909 do
4910 {
4911 byte = * data ++;
4912 num_read ++;
4913
4914 result |= (byte & 0x7f) << shift;
4915
4916 shift += 7;
4917
4918 }
4919 while (byte & 0x80);
4920
4921 if (length_return != NULL)
4922 * length_return = num_read;
4923
4924 if (sign && (shift < 32) && (byte & 0x40))
4925 result |= -1 << shift;
4926
4927 return result;
4928 }
4929
4930 typedef struct State_Machine_Registers
4931 {
4932 unsigned long address;
4933 unsigned int file;
4934 unsigned int line;
4935 unsigned int column;
4936 int is_stmt;
4937 int basic_block;
4938 int end_sequence;
4939 /* This variable hold the number of the last entry seen
4940 in the File Table. */
4941 unsigned int last_file_entry;
4942 } SMR;
4943
4944 static SMR state_machine_regs;
4945
4946 static void
4947 reset_state_machine (is_stmt)
4948 int is_stmt;
4949 {
4950 state_machine_regs.address = 0;
4951 state_machine_regs.file = 1;
4952 state_machine_regs.line = 1;
4953 state_machine_regs.column = 0;
4954 state_machine_regs.is_stmt = is_stmt;
4955 state_machine_regs.basic_block = 0;
4956 state_machine_regs.end_sequence = 0;
4957 state_machine_regs.last_file_entry = 0;
4958 }
4959
4960 /* Handled an extend line op. Returns true if this is the end
4961 of sequence. */
4962 static int
4963 process_extended_line_op (data, is_stmt, pointer_size)
4964 unsigned char * data;
4965 int is_stmt;
4966 int pointer_size;
4967 {
4968 unsigned char op_code;
4969 int bytes_read;
4970 unsigned int len;
4971 unsigned char * name;
4972 unsigned long adr;
4973
4974 len = read_leb128 (data, & bytes_read, 0);
4975 data += bytes_read;
4976
4977 if (len == 0)
4978 {
4979 warn (_("badly formed extended line op encountered!"));
4980 return bytes_read;
4981 }
4982
4983 len += bytes_read;
4984 op_code = * data ++;
4985
4986 printf (_(" Extended opcode %d: "), op_code);
4987
4988 switch (op_code)
4989 {
4990 case DW_LNE_end_sequence:
4991 printf (_("End of Sequence\n\n"));
4992 reset_state_machine (is_stmt);
4993 break;
4994
4995 case DW_LNE_set_address:
4996 adr = byte_get (data, pointer_size);
4997 printf (_("set Address to 0x%lx\n"), adr);
4998 state_machine_regs.address = adr;
4999 break;
5000
5001 case DW_LNE_define_file:
5002 printf (_(" define new File Table entry\n"));
5003 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5004
5005 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5006 name = data;
5007 data += strlen ((char *) data) + 1;
5008 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5009 data += bytes_read;
5010 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5011 data += bytes_read;
5012 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5013 printf (_("%s\n\n"), name);
5014 break;
5015
5016 default:
5017 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5018 break;
5019 }
5020
5021 return len;
5022 }
5023
5024 /* Size of pointers in the .debug_line section. This information is not
5025 really present in that section. It's obtained before dumping the debug
5026 sections by doing some pre-scan of the .debug_info section. */
5027 static int debug_line_pointer_size = 4;
5028
5029 static int
5030 display_debug_lines (section, start, file)
5031 Elf32_Internal_Shdr * section;
5032 unsigned char * start;
5033 FILE * file ATTRIBUTE_UNUSED;
5034 {
5035 DWARF2_External_LineInfo * external;
5036 DWARF2_Internal_LineInfo info;
5037 unsigned char * standard_opcodes;
5038 unsigned char * data = start;
5039 unsigned char * end = start + section->sh_size;
5040 unsigned char * end_of_sequence;
5041 int i;
5042
5043 printf (_("\nDump of debug contents of section %s:\n\n"),
5044 SECTION_NAME (section));
5045
5046 while (data < end)
5047 {
5048 external = (DWARF2_External_LineInfo *) data;
5049
5050 /* Check the length of the block. */
5051 info.li_length = BYTE_GET (external->li_length);
5052 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5053 {
5054 warn
5055 (_("The line info appears to be corrupt - the section is too small\n"));
5056 return 0;
5057 }
5058
5059 /* Check its version number. */
5060 info.li_version = BYTE_GET (external->li_version);
5061 if (info.li_version != 2)
5062 {
5063 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5064 return 0;
5065 }
5066
5067 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5068 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5069 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5070 info.li_line_base = BYTE_GET (external->li_line_base);
5071 info.li_line_range = BYTE_GET (external->li_line_range);
5072 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5073
5074 /* Sign extend the line base field. */
5075 info.li_line_base <<= 24;
5076 info.li_line_base >>= 24;
5077
5078 printf (_(" Length: %ld\n"), info.li_length);
5079 printf (_(" DWARF Version: %d\n"), info.li_version);
5080 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5081 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5082 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5083 printf (_(" Line Base: %d\n"), info.li_line_base);
5084 printf (_(" Line Range: %d\n"), info.li_line_range);
5085 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5086
5087 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5088
5089 reset_state_machine (info.li_default_is_stmt);
5090
5091 /* Display the contents of the Opcodes table. */
5092 standard_opcodes = data + sizeof (* external);
5093
5094 printf (_("\n Opcodes:\n"));
5095
5096 for (i = 1; i < info.li_opcode_base; i++)
5097 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5098
5099 /* Display the contents of the Directory table. */
5100 data = standard_opcodes + info.li_opcode_base - 1;
5101
5102 if (* data == 0)
5103 printf (_("\n The Directory Table is empty.\n"));
5104 else
5105 {
5106 printf (_("\n The Directory Table:\n"));
5107
5108 while (* data != 0)
5109 {
5110 printf (_(" %s\n"), data);
5111
5112 data += strlen ((char *) data) + 1;
5113 }
5114 }
5115
5116 /* Skip the NUL at the end of the table. */
5117 data ++;
5118
5119 /* Display the contents of the File Name table. */
5120 if (* data == 0)
5121 printf (_("\n The File Name Table is empty.\n"));
5122 else
5123 {
5124 printf (_("\n The File Name Table:\n"));
5125 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5126
5127 while (* data != 0)
5128 {
5129 unsigned char * name;
5130 int bytes_read;
5131
5132 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5133 name = data;
5134
5135 data += strlen ((char *) data) + 1;
5136
5137 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5138 data += bytes_read;
5139 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5140 data += bytes_read;
5141 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5142 data += bytes_read;
5143 printf (_("%s\n"), name);
5144 }
5145 }
5146
5147 /* Skip the NUL at the end of the table. */
5148 data ++;
5149
5150 /* Now display the statements. */
5151 printf (_("\n Line Number Statements:\n"));
5152
5153
5154 while (data < end_of_sequence)
5155 {
5156 unsigned char op_code;
5157 int adv;
5158 int bytes_read;
5159
5160 op_code = * data ++;
5161
5162 switch (op_code)
5163 {
5164 case DW_LNS_extended_op:
5165 data += process_extended_line_op (data, info.li_default_is_stmt,
5166 debug_line_pointer_size);
5167 break;
5168
5169 case DW_LNS_copy:
5170 printf (_(" Copy\n"));
5171 break;
5172
5173 case DW_LNS_advance_pc:
5174 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5175 data += bytes_read;
5176 state_machine_regs.address += adv;
5177 printf (_(" Advance PC by %d to %lx\n"), adv,
5178 state_machine_regs.address);
5179 break;
5180
5181 case DW_LNS_advance_line:
5182 adv = read_leb128 (data, & bytes_read, 1);
5183 data += bytes_read;
5184 state_machine_regs.line += adv;
5185 printf (_(" Advance Line by %d to %d\n"), adv,
5186 state_machine_regs.line);
5187 break;
5188
5189 case DW_LNS_set_file:
5190 adv = read_leb128 (data, & bytes_read, 0);
5191 data += bytes_read;
5192 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5193 adv);
5194 state_machine_regs.file = adv;
5195 break;
5196
5197 case DW_LNS_set_column:
5198 adv = read_leb128 (data, & bytes_read, 0);
5199 data += bytes_read;
5200 printf (_(" Set column to %d\n"), adv);
5201 state_machine_regs.column = adv;
5202 break;
5203
5204 case DW_LNS_negate_stmt:
5205 adv = state_machine_regs.is_stmt;
5206 adv = ! adv;
5207 printf (_(" Set is_stmt to %d\n"), adv);
5208 state_machine_regs.is_stmt = adv;
5209 break;
5210
5211 case DW_LNS_set_basic_block:
5212 printf (_(" Set basic block\n"));
5213 state_machine_regs.basic_block = 1;
5214 break;
5215
5216 case DW_LNS_const_add_pc:
5217 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5218 * info.li_min_insn_length);
5219 state_machine_regs.address += adv;
5220 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5221 state_machine_regs.address);
5222 break;
5223
5224 case DW_LNS_fixed_advance_pc:
5225 adv = byte_get (data, 2);
5226 data += 2;
5227 state_machine_regs.address += adv;
5228 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5229 adv, state_machine_regs.address);
5230 break;
5231
5232 default:
5233 op_code -= info.li_opcode_base;
5234 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5235 state_machine_regs.address += adv;
5236 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5237 op_code, adv, state_machine_regs.address);
5238 adv = (op_code % info.li_line_range) + info.li_line_base;
5239 state_machine_regs.line += adv;
5240 printf (_(" and Line by %d to %d\n"),
5241 adv, state_machine_regs.line);
5242 break;
5243 }
5244 }
5245 printf ("\n");
5246 }
5247
5248 return 1;
5249 }
5250
5251 static int
5252 display_debug_pubnames (section, start, file)
5253 Elf32_Internal_Shdr * section;
5254 unsigned char * start;
5255 FILE * file ATTRIBUTE_UNUSED;
5256 {
5257 DWARF2_External_PubNames * external;
5258 DWARF2_Internal_PubNames pubnames;
5259 unsigned char * end;
5260
5261 end = start + section->sh_size;
5262
5263 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5264
5265 while (start < end)
5266 {
5267 unsigned char * data;
5268 unsigned long offset;
5269
5270 external = (DWARF2_External_PubNames *) start;
5271
5272 pubnames.pn_length = BYTE_GET (external->pn_length);
5273 pubnames.pn_version = BYTE_GET (external->pn_version);
5274 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5275 pubnames.pn_size = BYTE_GET (external->pn_size);
5276
5277 data = start + sizeof (* external);
5278 start += pubnames.pn_length + sizeof (external->pn_length);
5279
5280 if (pubnames.pn_version != 2)
5281 {
5282 static int warned = 0;
5283
5284 if (! warned)
5285 {
5286 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5287 warned = 1;
5288 }
5289
5290 continue;
5291 }
5292
5293 printf (_(" Length: %ld\n"),
5294 pubnames.pn_length);
5295 printf (_(" Version: %d\n"),
5296 pubnames.pn_version);
5297 printf (_(" Offset into .debug_info section: %ld\n"),
5298 pubnames.pn_offset);
5299 printf (_(" Size of area in .debug_info section: %ld\n"),
5300 pubnames.pn_size);
5301
5302 printf (_("\n Offset\tName\n"));
5303
5304 do
5305 {
5306 offset = byte_get (data, 4);
5307
5308 if (offset != 0)
5309 {
5310 data += 4;
5311 printf (" %ld\t\t%s\n", offset, data);
5312 data += strlen ((char *) data) + 1;
5313 }
5314 }
5315 while (offset != 0);
5316 }
5317
5318 printf ("\n");
5319 return 1;
5320 }
5321
5322 static char *
5323 get_TAG_name (tag)
5324 unsigned long tag;
5325 {
5326 switch (tag)
5327 {
5328 case DW_TAG_padding: return "DW_TAG_padding";
5329 case DW_TAG_array_type: return "DW_TAG_array_type";
5330 case DW_TAG_class_type: return "DW_TAG_class_type";
5331 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5332 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5333 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5334 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5335 case DW_TAG_label: return "DW_TAG_label";
5336 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5337 case DW_TAG_member: return "DW_TAG_member";
5338 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5339 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5340 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5341 case DW_TAG_string_type: return "DW_TAG_string_type";
5342 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5343 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5344 case DW_TAG_typedef: return "DW_TAG_typedef";
5345 case DW_TAG_union_type: return "DW_TAG_union_type";
5346 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5347 case DW_TAG_variant: return "DW_TAG_variant";
5348 case DW_TAG_common_block: return "DW_TAG_common_block";
5349 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5350 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5351 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5352 case DW_TAG_module: return "DW_TAG_module";
5353 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5354 case DW_TAG_set_type: return "DW_TAG_set_type";
5355 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5356 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5357 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5358 case DW_TAG_base_type: return "DW_TAG_base_type";
5359 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5360 case DW_TAG_const_type: return "DW_TAG_const_type";
5361 case DW_TAG_constant: return "DW_TAG_constant";
5362 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5363 case DW_TAG_file_type: return "DW_TAG_file_type";
5364 case DW_TAG_friend: return "DW_TAG_friend";
5365 case DW_TAG_namelist: return "DW_TAG_namelist";
5366 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5367 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5368 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5369 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5370 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5371 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5372 case DW_TAG_try_block: return "DW_TAG_try_block";
5373 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5374 case DW_TAG_variable: return "DW_TAG_variable";
5375 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5376 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5377 case DW_TAG_format_label: return "DW_TAG_format_label";
5378 case DW_TAG_function_template: return "DW_TAG_function_template";
5379 case DW_TAG_class_template: return "DW_TAG_class_template";
5380 default:
5381 {
5382 static char buffer [100];
5383
5384 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5385 return buffer;
5386 }
5387 }
5388 }
5389
5390 static char *
5391 get_AT_name (attribute)
5392 unsigned long attribute;
5393 {
5394 switch (attribute)
5395 {
5396 case DW_AT_sibling: return "DW_AT_sibling";
5397 case DW_AT_location: return "DW_AT_location";
5398 case DW_AT_name: return "DW_AT_name";
5399 case DW_AT_ordering: return "DW_AT_ordering";
5400 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5401 case DW_AT_byte_size: return "DW_AT_byte_size";
5402 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5403 case DW_AT_bit_size: return "DW_AT_bit_size";
5404 case DW_AT_element_list: return "DW_AT_element_list";
5405 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5406 case DW_AT_low_pc: return "DW_AT_low_pc";
5407 case DW_AT_high_pc: return "DW_AT_high_pc";
5408 case DW_AT_language: return "DW_AT_language";
5409 case DW_AT_member: return "DW_AT_member";
5410 case DW_AT_discr: return "DW_AT_discr";
5411 case DW_AT_discr_value: return "DW_AT_discr_value";
5412 case DW_AT_visibility: return "DW_AT_visibility";
5413 case DW_AT_import: return "DW_AT_import";
5414 case DW_AT_string_length: return "DW_AT_string_length";
5415 case DW_AT_common_reference: return "DW_AT_common_reference";
5416 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5417 case DW_AT_const_value: return "DW_AT_const_value";
5418 case DW_AT_containing_type: return "DW_AT_containing_type";
5419 case DW_AT_default_value: return "DW_AT_default_value";
5420 case DW_AT_inline: return "DW_AT_inline";
5421 case DW_AT_is_optional: return "DW_AT_is_optional";
5422 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5423 case DW_AT_producer: return "DW_AT_producer";
5424 case DW_AT_prototyped: return "DW_AT_prototyped";
5425 case DW_AT_return_addr: return "DW_AT_return_addr";
5426 case DW_AT_start_scope: return "DW_AT_start_scope";
5427 case DW_AT_stride_size: return "DW_AT_stride_size";
5428 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5429 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5430 case DW_AT_accessibility: return "DW_AT_accessibility";
5431 case DW_AT_address_class: return "DW_AT_address_class";
5432 case DW_AT_artificial: return "DW_AT_artificial";
5433 case DW_AT_base_types: return "DW_AT_base_types";
5434 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5435 case DW_AT_count: return "DW_AT_count";
5436 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5437 case DW_AT_decl_column: return "DW_AT_decl_column";
5438 case DW_AT_decl_file: return "DW_AT_decl_file";
5439 case DW_AT_decl_line: return "DW_AT_decl_line";
5440 case DW_AT_declaration: return "DW_AT_declaration";
5441 case DW_AT_discr_list: return "DW_AT_discr_list";
5442 case DW_AT_encoding: return "DW_AT_encoding";
5443 case DW_AT_external: return "DW_AT_external";
5444 case DW_AT_frame_base: return "DW_AT_frame_base";
5445 case DW_AT_friend: return "DW_AT_friend";
5446 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5447 case DW_AT_macro_info: return "DW_AT_macro_info";
5448 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5449 case DW_AT_priority: return "DW_AT_priority";
5450 case DW_AT_segment: return "DW_AT_segment";
5451 case DW_AT_specification: return "DW_AT_specification";
5452 case DW_AT_static_link: return "DW_AT_static_link";
5453 case DW_AT_type: return "DW_AT_type";
5454 case DW_AT_use_location: return "DW_AT_use_location";
5455 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5456 case DW_AT_virtuality: return "DW_AT_virtuality";
5457 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5458 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5459 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5460 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5461 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5462 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5463 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5464 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5465 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5466 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5467 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5468 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5469 case DW_AT_sf_names: return "DW_AT_sf_names";
5470 case DW_AT_src_info: return "DW_AT_src_info";
5471 case DW_AT_mac_info: return "DW_AT_mac_info";
5472 case DW_AT_src_coords: return "DW_AT_src_coords";
5473 case DW_AT_body_begin: return "DW_AT_body_begin";
5474 case DW_AT_body_end: return "DW_AT_body_end";
5475 default:
5476 {
5477 static char buffer [100];
5478
5479 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5480 return buffer;
5481 }
5482 }
5483 }
5484
5485 static char *
5486 get_FORM_name (form)
5487 unsigned long form;
5488 {
5489 switch (form)
5490 {
5491 case DW_FORM_addr: return "DW_FORM_addr";
5492 case DW_FORM_block2: return "DW_FORM_block2";
5493 case DW_FORM_block4: return "DW_FORM_block4";
5494 case DW_FORM_data2: return "DW_FORM_data2";
5495 case DW_FORM_data4: return "DW_FORM_data4";
5496 case DW_FORM_data8: return "DW_FORM_data8";
5497 case DW_FORM_string: return "DW_FORM_string";
5498 case DW_FORM_block: return "DW_FORM_block";
5499 case DW_FORM_block1: return "DW_FORM_block1";
5500 case DW_FORM_data1: return "DW_FORM_data1";
5501 case DW_FORM_flag: return "DW_FORM_flag";
5502 case DW_FORM_sdata: return "DW_FORM_sdata";
5503 case DW_FORM_strp: return "DW_FORM_strp";
5504 case DW_FORM_udata: return "DW_FORM_udata";
5505 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5506 case DW_FORM_ref1: return "DW_FORM_ref1";
5507 case DW_FORM_ref2: return "DW_FORM_ref2";
5508 case DW_FORM_ref4: return "DW_FORM_ref4";
5509 case DW_FORM_ref8: return "DW_FORM_ref8";
5510 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5511 case DW_FORM_indirect: return "DW_FORM_indirect";
5512 default:
5513 {
5514 static char buffer [100];
5515
5516 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5517 return buffer;
5518 }
5519 }
5520 }
5521
5522 /* FIXME: There are better and more effiecint ways to handle
5523 these structures. For now though, I just want something that
5524 is simple to implement. */
5525 typedef struct abbrev_attr
5526 {
5527 unsigned long attribute;
5528 unsigned long form;
5529 struct abbrev_attr * next;
5530 }
5531 abbrev_attr;
5532
5533 typedef struct abbrev_entry
5534 {
5535 unsigned long entry;
5536 unsigned long tag;
5537 int children;
5538 struct abbrev_attr * first_attr;
5539 struct abbrev_attr * last_attr;
5540 struct abbrev_entry * next;
5541 }
5542 abbrev_entry;
5543
5544 static abbrev_entry * first_abbrev = NULL;
5545 static abbrev_entry * last_abbrev = NULL;
5546
5547 static void
5548 free_abbrevs PARAMS ((void))
5549 {
5550 abbrev_entry * abbrev;
5551
5552 for (abbrev = first_abbrev; abbrev;)
5553 {
5554 abbrev_entry * next = abbrev->next;
5555 abbrev_attr * attr;
5556
5557 for (attr = abbrev->first_attr; attr;)
5558 {
5559 abbrev_attr * next = attr->next;
5560
5561 free (attr);
5562 attr = next;
5563 }
5564
5565 free (abbrev);
5566 abbrev = next;
5567 }
5568
5569 last_abbrev = first_abbrev = NULL;
5570 }
5571
5572 static void
5573 add_abbrev (number, tag, children)
5574 unsigned long number;
5575 unsigned long tag;
5576 int children;
5577 {
5578 abbrev_entry * entry;
5579
5580 entry = (abbrev_entry *) malloc (sizeof (* entry));
5581
5582 if (entry == NULL)
5583 /* ugg */
5584 return;
5585
5586 entry->entry = number;
5587 entry->tag = tag;
5588 entry->children = children;
5589 entry->first_attr = NULL;
5590 entry->last_attr = NULL;
5591 entry->next = NULL;
5592
5593 if (first_abbrev == NULL)
5594 first_abbrev = entry;
5595 else
5596 last_abbrev->next = entry;
5597
5598 last_abbrev = entry;
5599 }
5600
5601 static void
5602 add_abbrev_attr (attribute, form)
5603 unsigned long attribute;
5604 unsigned long form;
5605 {
5606 abbrev_attr * attr;
5607
5608 attr = (abbrev_attr *) malloc (sizeof (* attr));
5609
5610 if (attr == NULL)
5611 /* ugg */
5612 return;
5613
5614 attr->attribute = attribute;
5615 attr->form = form;
5616 attr->next = NULL;
5617
5618 if (last_abbrev->first_attr == NULL)
5619 last_abbrev->first_attr = attr;
5620 else
5621 last_abbrev->last_attr->next = attr;
5622
5623 last_abbrev->last_attr = attr;
5624 }
5625
5626 /* Processes the (partial) contents of a .debug_abbrev section.
5627 Returns NULL if the end of the section was encountered.
5628 Returns the address after the last byte read if the end of
5629 an abbreviation set was found. */
5630
5631 static unsigned char *
5632 process_abbrev_section (start, end)
5633 unsigned char * start;
5634 unsigned char * end;
5635 {
5636 if (first_abbrev != NULL)
5637 return NULL;
5638
5639 while (start < end)
5640 {
5641 int bytes_read;
5642 unsigned long entry;
5643 unsigned long tag;
5644 unsigned long attribute;
5645 int children;
5646
5647 entry = read_leb128 (start, & bytes_read, 0);
5648 start += bytes_read;
5649
5650 /* A single zero is supposed to end the section according
5651 to the standard. If there's more, then signal that to
5652 the caller. */
5653 if (entry == 0)
5654 return start == end ? NULL : start;
5655
5656 tag = read_leb128 (start, & bytes_read, 0);
5657 start += bytes_read;
5658
5659 children = * start ++;
5660
5661 add_abbrev (entry, tag, children);
5662
5663 do
5664 {
5665 unsigned long form;
5666
5667 attribute = read_leb128 (start, & bytes_read, 0);
5668 start += bytes_read;
5669
5670 form = read_leb128 (start, & bytes_read, 0);
5671 start += bytes_read;
5672
5673 if (attribute != 0)
5674 add_abbrev_attr (attribute, form);
5675 }
5676 while (attribute != 0);
5677 }
5678
5679 return NULL;
5680 }
5681
5682
5683 static int
5684 display_debug_abbrev (section, start, file)
5685 Elf32_Internal_Shdr * section;
5686 unsigned char * start;
5687 FILE * file ATTRIBUTE_UNUSED;
5688 {
5689 abbrev_entry * entry;
5690 unsigned char * end = start + section->sh_size;
5691
5692 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5693
5694 do
5695 {
5696 start = process_abbrev_section (start, end);
5697
5698 printf (_(" Number TAG\n"));
5699
5700 for (entry = first_abbrev; entry; entry = entry->next)
5701 {
5702 abbrev_attr * attr;
5703
5704 printf (_(" %ld %s [%s]\n"),
5705 entry->entry,
5706 get_TAG_name (entry->tag),
5707 entry->children ? _("has children") : _("no children"));
5708
5709 for (attr = entry->first_attr; attr; attr = attr->next)
5710 {
5711 printf (_(" %-18s %s\n"),
5712 get_AT_name (attr->attribute),
5713 get_FORM_name (attr->form));
5714 }
5715 }
5716 }
5717 while (start);
5718
5719 printf ("\n");
5720
5721 return 1;
5722 }
5723
5724
5725 static unsigned char *
5726 display_block (data, length)
5727 unsigned char * data;
5728 unsigned long length;
5729 {
5730 printf (_(" %lu byte block: "), length);
5731
5732 while (length --)
5733 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5734
5735 return data;
5736 }
5737
5738 static void
5739 decode_location_expression (data, pointer_size, length)
5740 unsigned char * data;
5741 unsigned int pointer_size;
5742 unsigned long length;
5743 {
5744 unsigned op;
5745 int bytes_read;
5746 unsigned long uvalue;
5747 unsigned char * end = data + length;
5748
5749 while (data < end)
5750 {
5751 op = * data ++;
5752
5753 switch (op)
5754 {
5755 case DW_OP_addr:
5756 printf ("DW_OP_addr: %lx",
5757 (unsigned long) byte_get (data, pointer_size));
5758 data += pointer_size;
5759 break;
5760 case DW_OP_deref:
5761 printf ("DW_OP_deref");
5762 break;
5763 case DW_OP_const1u:
5764 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5765 break;
5766 case DW_OP_const1s:
5767 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5768 break;
5769 case DW_OP_const2u:
5770 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5771 data += 2;
5772 break;
5773 case DW_OP_const2s:
5774 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5775 data += 2;
5776 break;
5777 case DW_OP_const4u:
5778 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5779 data += 4;
5780 break;
5781 case DW_OP_const4s:
5782 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5783 data += 4;
5784 break;
5785 case DW_OP_const8u:
5786 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5787 (unsigned long) byte_get (data + 4, 4));
5788 data += 8;
5789 break;
5790 case DW_OP_const8s:
5791 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5792 (long) byte_get (data + 4, 4));
5793 data += 8;
5794 break;
5795 case DW_OP_constu:
5796 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5797 data += bytes_read;
5798 break;
5799 case DW_OP_consts:
5800 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5801 data += bytes_read;
5802 break;
5803 case DW_OP_dup:
5804 printf ("DW_OP_dup");
5805 break;
5806 case DW_OP_drop:
5807 printf ("DW_OP_drop");
5808 break;
5809 case DW_OP_over:
5810 printf ("DW_OP_over");
5811 break;
5812 case DW_OP_pick:
5813 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5814 break;
5815 case DW_OP_swap:
5816 printf ("DW_OP_swap");
5817 break;
5818 case DW_OP_rot:
5819 printf ("DW_OP_rot");
5820 break;
5821 case DW_OP_xderef:
5822 printf ("DW_OP_xderef");
5823 break;
5824 case DW_OP_abs:
5825 printf ("DW_OP_abs");
5826 break;
5827 case DW_OP_and:
5828 printf ("DW_OP_and");
5829 break;
5830 case DW_OP_div:
5831 printf ("DW_OP_div");
5832 break;
5833 case DW_OP_minus:
5834 printf ("DW_OP_minus");
5835 break;
5836 case DW_OP_mod:
5837 printf ("DW_OP_mod");
5838 break;
5839 case DW_OP_mul:
5840 printf ("DW_OP_mul");
5841 break;
5842 case DW_OP_neg:
5843 printf ("DW_OP_neg");
5844 break;
5845 case DW_OP_not:
5846 printf ("DW_OP_not");
5847 break;
5848 case DW_OP_or:
5849 printf ("DW_OP_or");
5850 break;
5851 case DW_OP_plus:
5852 printf ("DW_OP_plus");
5853 break;
5854 case DW_OP_plus_uconst:
5855 printf ("DW_OP_plus_uconst: %lu",
5856 read_leb128 (data, &bytes_read, 0));
5857 data += bytes_read;
5858 break;
5859 case DW_OP_shl:
5860 printf ("DW_OP_shl");
5861 break;
5862 case DW_OP_shr:
5863 printf ("DW_OP_shr");
5864 break;
5865 case DW_OP_shra:
5866 printf ("DW_OP_shra");
5867 break;
5868 case DW_OP_xor:
5869 printf ("DW_OP_xor");
5870 break;
5871 case DW_OP_bra:
5872 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5873 data += 2;
5874 break;
5875 case DW_OP_eq:
5876 printf ("DW_OP_eq");
5877 break;
5878 case DW_OP_ge:
5879 printf ("DW_OP_ge");
5880 break;
5881 case DW_OP_gt:
5882 printf ("DW_OP_gt");
5883 break;
5884 case DW_OP_le:
5885 printf ("DW_OP_le");
5886 break;
5887 case DW_OP_lt:
5888 printf ("DW_OP_lt");
5889 break;
5890 case DW_OP_ne:
5891 printf ("DW_OP_ne");
5892 break;
5893 case DW_OP_skip:
5894 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5895 data += 2;
5896 break;
5897
5898 case DW_OP_lit0:
5899 case DW_OP_lit1:
5900 case DW_OP_lit2:
5901 case DW_OP_lit3:
5902 case DW_OP_lit4:
5903 case DW_OP_lit5:
5904 case DW_OP_lit6:
5905 case DW_OP_lit7:
5906 case DW_OP_lit8:
5907 case DW_OP_lit9:
5908 case DW_OP_lit10:
5909 case DW_OP_lit11:
5910 case DW_OP_lit12:
5911 case DW_OP_lit13:
5912 case DW_OP_lit14:
5913 case DW_OP_lit15:
5914 case DW_OP_lit16:
5915 case DW_OP_lit17:
5916 case DW_OP_lit18:
5917 case DW_OP_lit19:
5918 case DW_OP_lit20:
5919 case DW_OP_lit21:
5920 case DW_OP_lit22:
5921 case DW_OP_lit23:
5922 case DW_OP_lit24:
5923 case DW_OP_lit25:
5924 case DW_OP_lit26:
5925 case DW_OP_lit27:
5926 case DW_OP_lit28:
5927 case DW_OP_lit29:
5928 case DW_OP_lit30:
5929 case DW_OP_lit31:
5930 printf ("DW_OP_lit%d", op - DW_OP_lit0);
5931 break;
5932
5933 case DW_OP_reg0:
5934 case DW_OP_reg1:
5935 case DW_OP_reg2:
5936 case DW_OP_reg3:
5937 case DW_OP_reg4:
5938 case DW_OP_reg5:
5939 case DW_OP_reg6:
5940 case DW_OP_reg7:
5941 case DW_OP_reg8:
5942 case DW_OP_reg9:
5943 case DW_OP_reg10:
5944 case DW_OP_reg11:
5945 case DW_OP_reg12:
5946 case DW_OP_reg13:
5947 case DW_OP_reg14:
5948 case DW_OP_reg15:
5949 case DW_OP_reg16:
5950 case DW_OP_reg17:
5951 case DW_OP_reg18:
5952 case DW_OP_reg19:
5953 case DW_OP_reg20:
5954 case DW_OP_reg21:
5955 case DW_OP_reg22:
5956 case DW_OP_reg23:
5957 case DW_OP_reg24:
5958 case DW_OP_reg25:
5959 case DW_OP_reg26:
5960 case DW_OP_reg27:
5961 case DW_OP_reg28:
5962 case DW_OP_reg29:
5963 case DW_OP_reg30:
5964 case DW_OP_reg31:
5965 printf ("DW_OP_reg%d", op - DW_OP_reg0);
5966 break;
5967
5968 case DW_OP_breg0:
5969 case DW_OP_breg1:
5970 case DW_OP_breg2:
5971 case DW_OP_breg3:
5972 case DW_OP_breg4:
5973 case DW_OP_breg5:
5974 case DW_OP_breg6:
5975 case DW_OP_breg7:
5976 case DW_OP_breg8:
5977 case DW_OP_breg9:
5978 case DW_OP_breg10:
5979 case DW_OP_breg11:
5980 case DW_OP_breg12:
5981 case DW_OP_breg13:
5982 case DW_OP_breg14:
5983 case DW_OP_breg15:
5984 case DW_OP_breg16:
5985 case DW_OP_breg17:
5986 case DW_OP_breg18:
5987 case DW_OP_breg19:
5988 case DW_OP_breg20:
5989 case DW_OP_breg21:
5990 case DW_OP_breg22:
5991 case DW_OP_breg23:
5992 case DW_OP_breg24:
5993 case DW_OP_breg25:
5994 case DW_OP_breg26:
5995 case DW_OP_breg27:
5996 case DW_OP_breg28:
5997 case DW_OP_breg29:
5998 case DW_OP_breg30:
5999 case DW_OP_breg31:
6000 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6001 read_leb128 (data, &bytes_read, 1));
6002 data += bytes_read;
6003 break;
6004
6005 case DW_OP_regx:
6006 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6007 data += bytes_read;
6008 break;
6009 case DW_OP_fbreg:
6010 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6011 data += bytes_read;
6012 break;
6013 case DW_OP_bregx:
6014 uvalue = read_leb128 (data, &bytes_read, 0);
6015 data += bytes_read;
6016 printf ("DW_OP_bregx: %lu %ld", uvalue,
6017 read_leb128 (data, &bytes_read, 1));
6018 data += bytes_read;
6019 break;
6020 case DW_OP_piece:
6021 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6022 data += bytes_read;
6023 break;
6024 case DW_OP_deref_size:
6025 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6026 break;
6027 case DW_OP_xderef_size:
6028 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6029 break;
6030 case DW_OP_nop:
6031 printf ("DW_OP_nop");
6032 break;
6033
6034 default:
6035 if (op >= DW_OP_lo_user
6036 && op <= DW_OP_hi_user)
6037 printf (_("(User defined location op)"));
6038 else
6039 printf (_("(Unknown location op)"));
6040 /* No way to tell where the next op is, so just bail. */
6041 return;
6042 }
6043 }
6044 }
6045
6046
6047 static unsigned char *
6048 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6049 unsigned long attribute;
6050 unsigned long form;
6051 unsigned char * data;
6052 unsigned long cu_offset;
6053 unsigned long pointer_size;
6054 {
6055 unsigned long uvalue = 0;
6056 unsigned char * block_start = NULL;
6057 int bytes_read;
6058
6059 printf (" %-18s:", get_AT_name (attribute));
6060
6061 switch (form)
6062 {
6063 default:
6064 break;
6065
6066 case DW_FORM_ref_addr:
6067 case DW_FORM_addr:
6068 uvalue = byte_get (data, pointer_size);
6069 data += pointer_size;
6070 break;
6071
6072 case DW_FORM_ref1:
6073 case DW_FORM_flag:
6074 case DW_FORM_data1:
6075 uvalue = byte_get (data ++, 1);
6076 break;
6077
6078 case DW_FORM_ref2:
6079 case DW_FORM_data2:
6080 uvalue = byte_get (data, 2);
6081 data += 2;
6082 break;
6083
6084 case DW_FORM_ref4:
6085 case DW_FORM_data4:
6086 uvalue = byte_get (data, 4);
6087 data += 4;
6088 break;
6089
6090 case DW_FORM_sdata:
6091 uvalue = read_leb128 (data, & bytes_read, 1);
6092 data += bytes_read;
6093 break;
6094
6095 case DW_FORM_ref_udata:
6096 case DW_FORM_udata:
6097 uvalue = read_leb128 (data, & bytes_read, 0);
6098 data += bytes_read;
6099 break;
6100 }
6101
6102 switch (form)
6103 {
6104 case DW_FORM_ref_addr:
6105 printf (" <#%lx>", uvalue);
6106 break;
6107
6108 case DW_FORM_ref1:
6109 case DW_FORM_ref2:
6110 case DW_FORM_ref4:
6111 case DW_FORM_ref_udata:
6112 printf (" <%lx>", uvalue + cu_offset);
6113 break;
6114
6115 case DW_FORM_addr:
6116 printf (" %#lx", uvalue);
6117
6118 case DW_FORM_flag:
6119 case DW_FORM_data1:
6120 case DW_FORM_data2:
6121 case DW_FORM_data4:
6122 case DW_FORM_sdata:
6123 case DW_FORM_udata:
6124 printf (" %ld", uvalue);
6125 break;
6126
6127 case DW_FORM_ref8:
6128 case DW_FORM_data8:
6129 uvalue = byte_get (data, 4);
6130 printf (" %lx", uvalue);
6131 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6132 data += 8;
6133 break;
6134
6135 case DW_FORM_string:
6136 printf (" %s", data);
6137 data += strlen ((char *) data) + 1;
6138 break;
6139
6140 case DW_FORM_block:
6141 uvalue = read_leb128 (data, & bytes_read, 0);
6142 block_start = data + bytes_read;
6143 data = display_block (block_start, uvalue);
6144 break;
6145
6146 case DW_FORM_block1:
6147 uvalue = byte_get (data, 1);
6148 block_start = data + 1;
6149 data = display_block (block_start, uvalue);
6150 break;
6151
6152 case DW_FORM_block2:
6153 uvalue = byte_get (data, 2);
6154 block_start = data + 2;
6155 data = display_block (block_start, uvalue);
6156 break;
6157
6158 case DW_FORM_block4:
6159 uvalue = byte_get (data, 4);
6160 block_start = data + 4;
6161 data = display_block (block_start, uvalue);
6162 break;
6163
6164 case DW_FORM_strp:
6165 case DW_FORM_indirect:
6166 warn (_("Unable to handle FORM: %d"), form);
6167 break;
6168
6169 default:
6170 warn (_("Unrecognised form: %d"), form);
6171 break;
6172 }
6173
6174 /* For some attributes we can display futher information. */
6175
6176 printf ("\t");
6177
6178 switch (attribute)
6179 {
6180 case DW_AT_inline:
6181 switch (uvalue)
6182 {
6183 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6184 case DW_INL_inlined: printf (_("(inlined)")); break;
6185 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6186 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6187 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6188 }
6189 break;
6190
6191 case DW_AT_language:
6192 switch (uvalue)
6193 {
6194 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6195 case DW_LANG_C89: printf ("(ANSI C)"); break;
6196 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6197 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6198 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6199 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6200 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6201 case DW_LANG_Ada83: printf ("(Ada)"); break;
6202 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6203 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6204 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6205 default: printf ("(Unknown: %lx)", uvalue); break;
6206 }
6207 break;
6208
6209 case DW_AT_encoding:
6210 switch (uvalue)
6211 {
6212 case DW_ATE_void: printf ("(void)"); break;
6213 case DW_ATE_address: printf ("(machine address)"); break;
6214 case DW_ATE_boolean: printf ("(boolean)"); break;
6215 case DW_ATE_complex_float: printf ("(complex float)"); break;
6216 case DW_ATE_float: printf ("(float)"); break;
6217 case DW_ATE_signed: printf ("(signed)"); break;
6218 case DW_ATE_signed_char: printf ("(signed char)"); break;
6219 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6220 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6221 default:
6222 if (uvalue >= DW_ATE_lo_user
6223 && uvalue <= DW_ATE_hi_user)
6224 printf ("(user defined type)");
6225 else
6226 printf ("(unknown type)");
6227 break;
6228 }
6229 break;
6230
6231 case DW_AT_accessibility:
6232 switch (uvalue)
6233 {
6234 case DW_ACCESS_public: printf ("(public)"); break;
6235 case DW_ACCESS_protected: printf ("(protected)"); break;
6236 case DW_ACCESS_private: printf ("(private)"); break;
6237 default: printf ("(unknown accessibility)"); break;
6238 }
6239 break;
6240
6241 case DW_AT_visibility:
6242 switch (uvalue)
6243 {
6244 case DW_VIS_local: printf ("(local)"); break;
6245 case DW_VIS_exported: printf ("(exported)"); break;
6246 case DW_VIS_qualified: printf ("(qualified)"); break;
6247 default: printf ("(unknown visibility)"); break;
6248 }
6249 break;
6250
6251 case DW_AT_virtuality:
6252 switch (uvalue)
6253 {
6254 case DW_VIRTUALITY_none: printf ("(none)"); break;
6255 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6256 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6257 default: printf ("(unknown virtuality)"); break;
6258 }
6259 break;
6260
6261 case DW_AT_identifier_case:
6262 switch (uvalue)
6263 {
6264 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6265 case DW_ID_up_case: printf ("(up_case)"); break;
6266 case DW_ID_down_case: printf ("(down_case)"); break;
6267 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6268 default: printf ("(unknown case)"); break;
6269 }
6270 break;
6271
6272 case DW_AT_calling_convention:
6273 switch (uvalue)
6274 {
6275 case DW_CC_normal: printf ("(normal)"); break;
6276 case DW_CC_program: printf ("(program)"); break;
6277 case DW_CC_nocall: printf ("(nocall)"); break;
6278 default:
6279 if (uvalue >= DW_CC_lo_user
6280 && uvalue <= DW_CC_hi_user)
6281 printf ("(user defined)");
6282 else
6283 printf ("(unknown convention)");
6284 }
6285 break;
6286
6287 case DW_AT_frame_base:
6288 case DW_AT_location:
6289 case DW_AT_data_member_location:
6290 case DW_AT_vtable_elem_location:
6291 if (block_start)
6292 {
6293 printf ("(");
6294 decode_location_expression (block_start, pointer_size, uvalue);
6295 printf (")");
6296 }
6297 break;
6298
6299 default:
6300 break;
6301 }
6302
6303 printf ("\n");
6304 return data;
6305 }
6306
6307 static int
6308 display_debug_info (section, start, file)
6309 Elf32_Internal_Shdr * section;
6310 unsigned char * start;
6311 FILE * file;
6312 {
6313 unsigned char * end = start + section->sh_size;
6314 unsigned char * section_begin = start;
6315
6316 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6317
6318 while (start < end)
6319 {
6320 DWARF2_External_CompUnit * external;
6321 DWARF2_Internal_CompUnit compunit;
6322 unsigned char * tags;
6323 int i;
6324 int level;
6325 unsigned long cu_offset;
6326
6327 external = (DWARF2_External_CompUnit *) start;
6328
6329 compunit.cu_length = BYTE_GET (external->cu_length);
6330 compunit.cu_version = BYTE_GET (external->cu_version);
6331 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6332 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6333
6334 tags = start + sizeof (* external);
6335 cu_offset = start - section_begin;
6336 start += compunit.cu_length + sizeof (external->cu_length);
6337
6338 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6339 printf (_(" Length: %ld\n"), compunit.cu_length);
6340 printf (_(" Version: %d\n"), compunit.cu_version);
6341 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6342 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6343
6344 if (compunit.cu_version != 2)
6345 {
6346 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6347 continue;
6348 }
6349
6350 if (first_abbrev != NULL)
6351 free_abbrevs ();
6352
6353 /* Read in the abbrevs used by this compilation unit. */
6354
6355 {
6356 Elf32_Internal_Shdr * sec;
6357 unsigned char * begin;
6358
6359 /* Locate the .debug_abbrev section and process it. */
6360 for (i = 0, sec = section_headers;
6361 i < elf_header.e_shnum;
6362 i ++, sec ++)
6363 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6364 break;
6365
6366 if (i == -1 || sec->sh_size == 0)
6367 {
6368 warn (_("Unable to locate .debug_abbrev section!\n"));
6369 return 0;
6370 }
6371
6372 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6373 "debug_abbrev section data");
6374
6375 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6376 begin + sec->sh_size);
6377
6378 free (begin);
6379 }
6380
6381 level = 0;
6382 while (tags < start)
6383 {
6384 int bytes_read;
6385 unsigned long abbrev_number;
6386 abbrev_entry * entry;
6387 abbrev_attr * attr;
6388
6389 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6390 tags += bytes_read;
6391
6392 /* A null DIE marks the end of a list of children. */
6393 if (abbrev_number == 0)
6394 {
6395 --level;
6396 continue;
6397 }
6398
6399 /* Scan through the abbreviation list until we reach the
6400 correct entry. */
6401 for (entry = first_abbrev;
6402 entry && entry->entry != abbrev_number;
6403 entry = entry->next)
6404 continue;
6405
6406 if (entry == NULL)
6407 {
6408 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6409 abbrev_number);
6410 return 0;
6411 }
6412
6413 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6414 level, tags - section_begin - bytes_read,
6415 abbrev_number,
6416 get_TAG_name (entry->tag));
6417
6418 for (attr = entry->first_attr; attr; attr = attr->next)
6419 tags = read_and_display_attr (attr->attribute,
6420 attr->form,
6421 tags, cu_offset,
6422 compunit.cu_pointer_size);
6423
6424 if (entry->children)
6425 ++level;
6426 }
6427 }
6428
6429 printf ("\n");
6430
6431 return 1;
6432 }
6433
6434 static int
6435 display_debug_aranges (section, start, file)
6436 Elf32_Internal_Shdr * section;
6437 unsigned char * start;
6438 FILE * file ATTRIBUTE_UNUSED;
6439 {
6440 unsigned char * end = start + section->sh_size;
6441
6442 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6443
6444 while (start < end)
6445 {
6446 DWARF2_External_ARange * external;
6447 DWARF2_Internal_ARange arange;
6448 unsigned char * ranges;
6449 unsigned long length;
6450 unsigned long address;
6451 int excess;
6452
6453 external = (DWARF2_External_ARange *) start;
6454
6455 arange.ar_length = BYTE_GET (external->ar_length);
6456 arange.ar_version = BYTE_GET (external->ar_version);
6457 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6458 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6459 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6460
6461 if (arange.ar_version != 2)
6462 {
6463 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6464 break;
6465 }
6466
6467 printf (_(" Length: %ld\n"), arange.ar_length);
6468 printf (_(" Version: %d\n"), arange.ar_version);
6469 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6470 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6471 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6472
6473 printf (_("\n Address Length\n"));
6474
6475 ranges = start + sizeof (* external);
6476
6477 /* Must pad to an alignment boundary that is twice the pointer size. */
6478 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6479 if (excess)
6480 ranges += (2 * arange.ar_pointer_size) - excess;
6481
6482 for (;;)
6483 {
6484 address = byte_get (ranges, arange.ar_pointer_size);
6485
6486 ranges += arange.ar_pointer_size;
6487
6488 length = byte_get (ranges, arange.ar_pointer_size);
6489
6490 ranges += arange.ar_pointer_size;
6491
6492 /* A pair of zeros marks the end of the list. */
6493 if (address == 0 && length == 0)
6494 break;
6495
6496 printf (" %8.8lx %lu\n", address, length);
6497 }
6498
6499 start += arange.ar_length + sizeof (external->ar_length);
6500 }
6501
6502 printf ("\n");
6503
6504 return 1;
6505 }
6506
6507 typedef struct Frame_Chunk
6508 {
6509 struct Frame_Chunk * next;
6510 unsigned char * chunk_start;
6511 int ncols;
6512 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6513 short int * col_type;
6514 int * col_offset;
6515 char * augmentation;
6516 unsigned int code_factor;
6517 unsigned int data_factor;
6518 unsigned long pc_begin;
6519 unsigned long pc_range;
6520 int cfa_reg;
6521 int cfa_offset;
6522 int ra;
6523 }
6524 Frame_Chunk;
6525
6526 /* A marker for a col_type that means this column was never referenced
6527 in the frame info. */
6528 #define DW_CFA_unreferenced (-1)
6529
6530 static void
6531 frame_need_space (fc, reg)
6532 Frame_Chunk * fc;
6533 int reg;
6534 {
6535 int prev = fc->ncols;
6536
6537 if (reg < fc->ncols)
6538 return;
6539
6540 fc->ncols = reg + 1;
6541 fc->col_type = (short int *) xrealloc (fc->col_type,
6542 fc->ncols * sizeof (short int));
6543 fc->col_offset = (int *) xrealloc (fc->col_offset,
6544 fc->ncols * sizeof (int));
6545
6546 while (prev < fc->ncols)
6547 {
6548 fc->col_type[prev] = DW_CFA_unreferenced;
6549 fc->col_offset[prev] = 0;
6550 prev++;
6551 }
6552 }
6553
6554 static void
6555 frame_display_row (fc, need_col_headers, max_regs)
6556 Frame_Chunk * fc;
6557 int * need_col_headers;
6558 int * max_regs;
6559 {
6560 int r;
6561 char tmp[100];
6562
6563 if (* max_regs < fc->ncols)
6564 * max_regs = fc->ncols;
6565
6566 if (* need_col_headers)
6567 {
6568 * need_col_headers = 0;
6569
6570 printf (" LOC CFA ");
6571
6572 for (r = 0; r < * max_regs; r++)
6573 if (fc->col_type[r] != DW_CFA_unreferenced)
6574 {
6575 if (r == fc->ra)
6576 printf ("ra ");
6577 else
6578 printf ("r%-4d", r);
6579 }
6580
6581 printf ("\n");
6582 }
6583
6584 printf ("%08x ", (unsigned int) fc->pc_begin);
6585 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6586 printf ("%-8s ", tmp);
6587
6588 for (r = 0; r < fc->ncols; r++)
6589 {
6590 if (fc->col_type[r] != DW_CFA_unreferenced)
6591 {
6592 switch (fc->col_type[r])
6593 {
6594 case DW_CFA_undefined:
6595 strcpy (tmp, "u");
6596 break;
6597 case DW_CFA_same_value:
6598 strcpy (tmp, "s");
6599 break;
6600 case DW_CFA_offset:
6601 sprintf (tmp, "c%+d", fc->col_offset[r]);
6602 break;
6603 case DW_CFA_register:
6604 sprintf (tmp, "r%d", fc->col_offset[r]);
6605 break;
6606 default:
6607 strcpy (tmp, "n/a");
6608 break;
6609 }
6610 printf ("%-5s", tmp);
6611 }
6612 }
6613 printf ("\n");
6614 }
6615
6616 #define GET(N) byte_get (start, N); start += N
6617 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
6618 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
6619
6620 static int
6621 display_debug_frames (section, start, file)
6622 Elf32_Internal_Shdr * section;
6623 unsigned char * start;
6624 FILE * file ATTRIBUTE_UNUSED;
6625 {
6626 unsigned char * end = start + section->sh_size;
6627 unsigned char * section_start = start;
6628 Frame_Chunk * chunks = 0;
6629 Frame_Chunk * remembered_state = 0;
6630 Frame_Chunk * rs;
6631 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
6632 int length_return;
6633 int max_regs = 0;
6634
6635 printf (_("The section %s contains:\n"), SECTION_NAME (section));
6636
6637 while (start < end)
6638 {
6639 unsigned char * saved_start;
6640 unsigned char * block_end;
6641 unsigned long length;
6642 unsigned long cie_id;
6643 Frame_Chunk * fc;
6644 Frame_Chunk * cie;
6645 int need_col_headers = 1;
6646
6647 saved_start = start;
6648 length = byte_get (start, 4); start += 4;
6649
6650 if (length == 0)
6651 return 1;
6652
6653 block_end = saved_start + length + 4;
6654 cie_id = byte_get (start, 4); start += 4;
6655
6656 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
6657
6658 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
6659 {
6660 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6661 memset (fc, 0, sizeof (Frame_Chunk));
6662
6663 fc->next = chunks;
6664 chunks = fc;
6665 fc->chunk_start = saved_start;
6666 fc->ncols = 0;
6667 fc->col_type = (short int *) xmalloc (sizeof (short int));
6668 fc->col_offset = (int *) xmalloc (sizeof (int));
6669 frame_need_space (fc, max_regs-1);
6670
6671 start ++; /* version */
6672 fc->augmentation = start;
6673
6674 while (* start)
6675 start++;
6676
6677 start++; /* skip past NUL */
6678
6679 if (fc->augmentation[0] == 'z')
6680 {
6681 int xtra;
6682 fc->code_factor = LEB ();
6683 fc->data_factor = SLEB ();
6684 fc->ra = byte_get (start, 1); start += 1;
6685 xtra = LEB ();
6686 printf ("skipping %d extra bytes\n", xtra);
6687 start += xtra;
6688 }
6689 else if (strcmp (fc->augmentation, "eh") == 0)
6690 {
6691 start += 4;
6692 fc->code_factor = LEB ();
6693 fc->data_factor = SLEB ();
6694 fc->ra = byte_get (start, 1); start += 1;
6695 }
6696 else
6697 {
6698 fc->code_factor = LEB ();
6699 fc->data_factor = SLEB ();
6700 fc->ra = byte_get (start, 1); start += 1;
6701 }
6702 cie = fc;
6703 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
6704 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
6705
6706 frame_need_space (fc, fc->ra);
6707 }
6708 else
6709 {
6710 unsigned char * look_for;
6711 static Frame_Chunk fde_fc;
6712
6713 fc = & fde_fc;
6714 memset (fc, 0, sizeof (Frame_Chunk));
6715
6716 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
6717
6718 fc->pc_begin = byte_get (start, 4); start += 4;
6719 fc->pc_range = byte_get (start, 4); start += 4;
6720
6721 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
6722 if (!cie)
6723 {
6724 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
6725 start = block_end;
6726 fc->ncols = 0;
6727 fc->col_type = (short int *) xmalloc (sizeof (short int));
6728 fc->col_offset = (int *) xmalloc (sizeof (int));
6729 frame_need_space (fc, max_regs - 1);
6730 cie = fc;
6731 fc->augmentation = "";
6732 }
6733 else
6734 {
6735 fc->ncols = cie->ncols;
6736 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
6737 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
6738 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
6739 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
6740 fc->augmentation = cie->augmentation;
6741 fc->code_factor = cie->code_factor;
6742 fc->data_factor = cie->data_factor;
6743 fc->cfa_reg = cie->cfa_reg;
6744 fc->cfa_offset = cie->cfa_offset;
6745 fc->ra = cie->ra;
6746 frame_need_space (fc, max_regs-1);
6747 }
6748
6749 if (cie->augmentation[0] == 'z')
6750 {
6751 unsigned long l = LEB ();
6752 start += l;
6753 }
6754
6755 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
6756 cie->chunk_start-section_start, fc->pc_begin,
6757 fc->pc_begin + fc->pc_range);
6758 }
6759
6760 /* At this point, fc is the current chunk, cie (if any) is set, and we're
6761 about to interpret instructions for the chunk. */
6762
6763 /* This exists for readelf maintainers. */
6764 #define FDEBUG 0
6765
6766 {
6767 /* Start by making a pass over the chunk, allocating storage
6768 and taking note of what registers are used. */
6769 unsigned char * tmp = start;
6770
6771 while (start < block_end)
6772 {
6773 unsigned op, opa;
6774 unsigned long reg;
6775 bfd_vma vma;
6776
6777 op = * start ++;
6778 opa = op & 0x3f;
6779 if (op & 0xc0)
6780 op &= 0xc0;
6781
6782 /* Warning: if you add any more cases to this switch, be
6783 sure to add them to the corresponding switch below. */
6784 switch (op)
6785 {
6786 case DW_CFA_advance_loc:
6787 break;
6788 case DW_CFA_offset:
6789 LEB ();
6790 frame_need_space (fc, opa);
6791 fc->col_type[opa] = DW_CFA_undefined;
6792 break;
6793 case DW_CFA_restore:
6794 frame_need_space (fc, opa);
6795 fc->col_type[opa] = DW_CFA_undefined;
6796 break;
6797 case DW_CFA_set_loc:
6798 start += sizeof (vma);
6799 break;
6800 case DW_CFA_advance_loc1:
6801 start += 1;
6802 break;
6803 case DW_CFA_advance_loc2:
6804 start += 2;
6805 break;
6806 case DW_CFA_advance_loc4:
6807 start += 4;
6808 break;
6809 case DW_CFA_offset_extended:
6810 reg = LEB (); LEB ();
6811 frame_need_space (fc, reg);
6812 fc->col_type[reg] = DW_CFA_undefined;
6813 break;
6814 case DW_CFA_restore_extended:
6815 reg = LEB ();
6816 frame_need_space (fc, reg);
6817 fc->col_type[reg] = DW_CFA_undefined;
6818 break;
6819 case DW_CFA_undefined:
6820 reg = LEB ();
6821 frame_need_space (fc, reg);
6822 fc->col_type[reg] = DW_CFA_undefined;
6823 break;
6824 case DW_CFA_same_value:
6825 reg = LEB ();
6826 frame_need_space (fc, reg);
6827 fc->col_type[reg] = DW_CFA_undefined;
6828 break;
6829 case DW_CFA_register:
6830 reg = LEB (); LEB ();
6831 frame_need_space (fc, reg);
6832 fc->col_type[reg] = DW_CFA_undefined;
6833 break;
6834 case DW_CFA_def_cfa:
6835 LEB (); LEB ();
6836 break;
6837 case DW_CFA_def_cfa_register:
6838 LEB ();
6839 break;
6840 case DW_CFA_def_cfa_offset:
6841 LEB ();
6842 break;
6843 #ifndef DW_CFA_GNU_args_size
6844 #define DW_CFA_GNU_args_size 0x2e
6845 #endif
6846 case DW_CFA_GNU_args_size:
6847 LEB ();
6848 break;
6849 #ifndef DW_CFA_GNU_negative_offset_extended
6850 #define DW_CFA_GNU_negative_offset_extended 0x2f
6851 #endif
6852 case DW_CFA_GNU_negative_offset_extended:
6853 reg = LEB (); LEB ();
6854 frame_need_space (fc, reg);
6855 fc->col_type[reg] = DW_CFA_undefined;
6856
6857 default:
6858 break;
6859 }
6860 }
6861 start = tmp;
6862 }
6863
6864 /* Now we know what registers are used, make a second pass over
6865 the chunk, this time actually printing out the info. */
6866
6867 while (start < block_end)
6868 {
6869 unsigned op, opa;
6870 unsigned long ul, reg, roffs;
6871 long l, ofs;
6872 bfd_vma vma;
6873
6874 op = * start ++;
6875 opa = op & 0x3f;
6876 if (op & 0xc0)
6877 op &= 0xc0;
6878
6879 /* Warning: if you add any more cases to this switch, be
6880 sure to add them to the corresponding switch above. */
6881 switch (op)
6882 {
6883 case DW_CFA_advance_loc:
6884 frame_display_row (fc, &need_col_headers, &max_regs);
6885 #if FDEBUG
6886 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
6887 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
6888 #endif
6889 fc->pc_begin += opa * fc->code_factor;
6890 break;
6891
6892 case DW_CFA_offset:
6893 roffs = LEB ();
6894 #if FDEBUG
6895 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
6896 #endif
6897 fc->col_type[opa] = DW_CFA_offset;
6898 fc->col_offset[opa] = roffs * fc->data_factor;
6899 break;
6900
6901 case DW_CFA_restore:
6902 #if FDEBUG
6903 printf (" DW_CFA_restore: r%d\n", opa);
6904 #endif
6905 fc->col_type[opa] = cie->col_type[opa];
6906 fc->col_offset[opa] = cie->col_offset[opa];
6907 break;
6908
6909 case DW_CFA_set_loc:
6910 frame_display_row (fc, &need_col_headers, &max_regs);
6911 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
6912 #if FDEBUG
6913 printf (" DW_CFA_set_loc: %08x\n", vma);
6914 #endif
6915 fc->pc_begin = vma;
6916 break;
6917
6918 case DW_CFA_advance_loc1:
6919 frame_display_row (fc, &need_col_headers, &max_regs);
6920 ofs = byte_get (start, 1); start += 1;
6921 #if FDEBUG
6922 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
6923 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6924 #endif
6925 fc->pc_begin += ofs * fc->code_factor;
6926 break;
6927
6928 case DW_CFA_advance_loc2:
6929 frame_display_row (fc, &need_col_headers, &max_regs);
6930 ofs = byte_get (start, 2); start += 2;
6931 #if FDEBUG
6932 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
6933 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6934 #endif
6935 fc->pc_begin += ofs * fc->code_factor;
6936 break;
6937
6938 case DW_CFA_advance_loc4:
6939 frame_display_row (fc, &need_col_headers, &max_regs);
6940 ofs = byte_get (start, 4); start += 4;
6941 #if FDEBUG
6942 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
6943 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6944 #endif
6945 fc->pc_begin += ofs * fc->code_factor;
6946 break;
6947
6948 case DW_CFA_offset_extended:
6949 reg = LEB ();
6950 roffs = LEB ();
6951 #if FDEBUG
6952 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
6953 #endif
6954 fc->col_type[reg] = DW_CFA_offset;
6955 fc->col_offset[reg] = roffs * fc->data_factor;
6956 break;
6957
6958 case DW_CFA_restore_extended:
6959 reg = LEB ();
6960 #if FDEBUG
6961 printf (" DW_CFA_restore_extended: r%d\n", reg);
6962 #endif
6963 fc->col_type[reg] = cie->col_type[reg];
6964 fc->col_offset[reg] = cie->col_offset[reg];
6965 break;
6966
6967 case DW_CFA_undefined:
6968 reg = LEB ();
6969 #if FDEBUG
6970 printf (" DW_CFA_undefined: r%d\n", reg);
6971 #endif
6972 fc->col_type[reg] = DW_CFA_undefined;
6973 fc->col_offset[reg] = 0;
6974 break;
6975
6976 case DW_CFA_same_value:
6977 reg = LEB ();
6978 #if FDEBUG
6979 printf (" DW_CFA_same_value: r%d\n", reg);
6980 #endif
6981 fc->col_type[reg] = DW_CFA_same_value;
6982 fc->col_offset[reg] = 0;
6983 break;
6984
6985 case DW_CFA_register:
6986 reg = LEB ();
6987 roffs = LEB ();
6988 #if FDEBUG
6989 printf (" DW_CFA_register: r%d\n", reg);
6990 #endif
6991 fc->col_type[reg] = DW_CFA_register;
6992 fc->col_offset[reg] = roffs;
6993 break;
6994
6995 case DW_CFA_remember_state:
6996 #if FDEBUG
6997 printf (" DW_CFA_remember_state\n");
6998 #endif
6999 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7000 rs->ncols = fc->ncols;
7001 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
7002 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
7003 memcpy (rs->col_type, fc->col_type, rs->ncols);
7004 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
7005 rs->next = remembered_state;
7006 remembered_state = rs;
7007 break;
7008
7009 case DW_CFA_restore_state:
7010 #if FDEBUG
7011 printf (" DW_CFA_restore_state\n");
7012 #endif
7013 rs = remembered_state;
7014 remembered_state = rs->next;
7015 frame_need_space (fc, rs->ncols-1);
7016 memcpy (fc->col_type, rs->col_type, rs->ncols);
7017 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7018 free (rs->col_type);
7019 free (rs->col_offset);
7020 free (rs);
7021 break;
7022
7023 case DW_CFA_def_cfa:
7024 fc->cfa_reg = LEB ();
7025 fc->cfa_offset = LEB ();
7026 #if FDEBUG
7027 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7028 #endif
7029 break;
7030
7031 case DW_CFA_def_cfa_register:
7032 fc->cfa_reg = LEB ();
7033 #if FDEBUG
7034 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7035 #endif
7036 break;
7037
7038 case DW_CFA_def_cfa_offset:
7039 fc->cfa_offset = LEB ();
7040 #if FDEBUG
7041 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7042 #endif
7043 break;
7044
7045 case DW_CFA_nop:
7046 #if FDEBUG
7047 printf (" DW_CFA_nop\n");
7048 #endif
7049 break;
7050
7051 #ifndef DW_CFA_GNU_window_save
7052 #define DW_CFA_GNU_window_save 0x2d
7053 #endif
7054 case DW_CFA_GNU_window_save:
7055 #if FDEBUG
7056 printf (" DW_CFA_GNU_window_save\n");
7057 #endif
7058 break;
7059
7060 #ifndef DW_CFA_GNU_args_size
7061 #define DW_CFA_GNU_args_size 0x2e
7062 #endif
7063 case DW_CFA_GNU_args_size:
7064 ul = LEB ();
7065 #if FDEBUG
7066 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7067 #endif
7068 break;
7069
7070 #ifndef DW_CFA_GNU_negative_offset_extended
7071 #define DW_CFA_GNU_negative_offset_extended 0x2f
7072 #endif
7073 case DW_CFA_GNU_negative_offset_extended:
7074 reg = LEB ();
7075 l = - LEB ();
7076 frame_need_space (fc, reg);
7077 #if FDEBUG
7078 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7079 #endif
7080 fc->col_type[reg] = DW_CFA_offset;
7081 fc->col_offset[reg] = l * fc->data_factor;
7082 break;
7083
7084 default:
7085 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7086 start = block_end;
7087 }
7088 }
7089
7090 frame_display_row (fc, &need_col_headers, &max_regs);
7091
7092 start = block_end;
7093 }
7094
7095 printf ("\n");
7096
7097 return 1;
7098 }
7099
7100 #undef GET
7101 #undef LEB
7102 #undef SLEB
7103
7104 static int
7105 display_debug_not_supported (section, start, file)
7106 Elf32_Internal_Shdr * section;
7107 unsigned char * start ATTRIBUTE_UNUSED;
7108 FILE * file ATTRIBUTE_UNUSED;
7109 {
7110 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7111 SECTION_NAME (section));
7112
7113 return 1;
7114 }
7115
7116 /* Pre-scan the .debug_info section to record the size of address.
7117 When dumping the .debug_line, we use that size information, assuming
7118 that all compilation units have the same address size. */
7119 static int
7120 prescan_debug_info (section, start, file)
7121 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7122 unsigned char * start;
7123 FILE * file ATTRIBUTE_UNUSED;
7124 {
7125 DWARF2_External_CompUnit * external;
7126
7127 external = (DWARF2_External_CompUnit *) start;
7128
7129 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7130 return 0;
7131 }
7132
7133 /* A structure containing the name of a debug section and a pointer
7134 to a function that can decode it. The third field is a prescan
7135 function to be run over the section before displaying any of the
7136 sections. */
7137 struct
7138 {
7139 char * name;
7140 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7141 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7142 }
7143 debug_displays[] =
7144 {
7145 { ".debug_info", display_debug_info, prescan_debug_info },
7146 { ".debug_abbrev", display_debug_abbrev, NULL },
7147 { ".debug_line", display_debug_lines, NULL },
7148 { ".debug_aranges", display_debug_aranges, NULL },
7149 { ".debug_pubnames", display_debug_pubnames, NULL },
7150 { ".debug_frame", display_debug_frames, NULL },
7151 { ".eh_frame", display_debug_frames, NULL },
7152 { ".debug_macinfo", display_debug_not_supported, NULL },
7153 { ".debug_frame", display_debug_not_supported, NULL },
7154 { ".debug_str", display_debug_not_supported, NULL },
7155 { ".debug_static_func", display_debug_not_supported, NULL },
7156 { ".debug_static_vars", display_debug_not_supported, NULL },
7157 { ".debug_types", display_debug_not_supported, NULL },
7158 { ".debug_weaknames", display_debug_not_supported, NULL }
7159 };
7160
7161 static int
7162 display_debug_section (section, file)
7163 Elf32_Internal_Shdr * section;
7164 FILE * file;
7165 {
7166 char * name = SECTION_NAME (section);
7167 bfd_size_type length;
7168 unsigned char * start;
7169 int i;
7170
7171 length = section->sh_size;
7172 if (length == 0)
7173 {
7174 printf (_("\nSection '%s' has no debugging data.\n"), name);
7175 return 0;
7176 }
7177
7178 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7179 "debug section data");
7180
7181 /* See if we know how to display the contents of this section. */
7182 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7183 name = ".debug_info";
7184
7185 for (i = NUM_ELEM (debug_displays); i--;)
7186 if (strcmp (debug_displays[i].name, name) == 0)
7187 {
7188 debug_displays[i].display (section, start, file);
7189 break;
7190 }
7191
7192 if (i == -1)
7193 printf (_("Unrecognised debug section: %s\n"), name);
7194
7195 free (start);
7196
7197 /* If we loaded in the abbrev section at some point,
7198 we must release it here. */
7199 if (first_abbrev != NULL)
7200 free_abbrevs ();
7201
7202 return 1;
7203 }
7204
7205 static int
7206 process_section_contents (file)
7207 FILE * file;
7208 {
7209 Elf32_Internal_Shdr * section;
7210 unsigned int i;
7211
7212 if (! do_dump)
7213 return 1;
7214
7215 /* Pre-scan the debug sections to find some debug information not
7216 present in some of them. For the .debug_line, we must find out the
7217 size of address (specified in .debug_info and .debug_aranges). */
7218 for (i = 0, section = section_headers;
7219 i < elf_header.e_shnum && i < num_dump_sects;
7220 i ++, section ++)
7221 {
7222 char * name = SECTION_NAME (section);
7223 int j;
7224
7225 if (section->sh_size == 0)
7226 continue;
7227
7228 /* See if there is some pre-scan operation for this section. */
7229 for (j = NUM_ELEM (debug_displays); j--;)
7230 if (strcmp (debug_displays[j].name, name) == 0)
7231 {
7232 if (debug_displays[j].prescan != NULL)
7233 {
7234 bfd_size_type length;
7235 unsigned char * start;
7236
7237 length = section->sh_size;
7238 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7239 "debug section data");
7240
7241 debug_displays[j].prescan (section, start, file);
7242 free (start);
7243 }
7244
7245 break;
7246 }
7247 }
7248
7249 for (i = 0, section = section_headers;
7250 i < elf_header.e_shnum && i < num_dump_sects;
7251 i ++, section ++)
7252 {
7253 #ifdef SUPPORT_DISASSEMBLY
7254 if (dump_sects[i] & DISASS_DUMP)
7255 disassemble_section (section, file);
7256 #endif
7257 if (dump_sects[i] & HEX_DUMP)
7258 dump_section (section, file);
7259
7260 if (dump_sects[i] & DEBUG_DUMP)
7261 display_debug_section (section, file);
7262 }
7263
7264 if (i < num_dump_sects)
7265 warn (_("Some sections were not dumped because they do not exist!\n"));
7266
7267 return 1;
7268 }
7269
7270 static void
7271 process_mips_fpe_exception (mask)
7272 int mask;
7273 {
7274 if (mask)
7275 {
7276 int first = 1;
7277 if (mask & OEX_FPU_INEX)
7278 fputs ("INEX", stdout), first = 0;
7279 if (mask & OEX_FPU_UFLO)
7280 printf ("%sUFLO", first ? "" : "|"), first = 0;
7281 if (mask & OEX_FPU_OFLO)
7282 printf ("%sOFLO", first ? "" : "|"), first = 0;
7283 if (mask & OEX_FPU_DIV0)
7284 printf ("%sDIV0", first ? "" : "|"), first = 0;
7285 if (mask & OEX_FPU_INVAL)
7286 printf ("%sINVAL", first ? "" : "|");
7287 }
7288 else
7289 fputs ("0", stdout);
7290 }
7291
7292 static int
7293 process_mips_specific (file)
7294 FILE * file;
7295 {
7296 Elf_Internal_Dyn * entry;
7297 size_t liblist_offset = 0;
7298 size_t liblistno = 0;
7299 size_t conflictsno = 0;
7300 size_t options_offset = 0;
7301 size_t conflicts_offset = 0;
7302
7303 /* We have a lot of special sections. Thanks SGI! */
7304 if (dynamic_segment == NULL)
7305 /* No information available. */
7306 return 0;
7307
7308 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7309 switch (entry->d_tag)
7310 {
7311 case DT_MIPS_LIBLIST:
7312 liblist_offset = entry->d_un.d_val - loadaddr;
7313 break;
7314 case DT_MIPS_LIBLISTNO:
7315 liblistno = entry->d_un.d_val;
7316 break;
7317 case DT_MIPS_OPTIONS:
7318 options_offset = entry->d_un.d_val - loadaddr;
7319 break;
7320 case DT_MIPS_CONFLICT:
7321 conflicts_offset = entry->d_un.d_val - loadaddr;
7322 break;
7323 case DT_MIPS_CONFLICTNO:
7324 conflictsno = entry->d_un.d_val;
7325 break;
7326 default:
7327 break;
7328 }
7329
7330 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7331 {
7332 Elf32_External_Lib * elib;
7333 size_t cnt;
7334
7335 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7336 elib, Elf32_External_Lib *, "liblist");
7337
7338 printf ("\nSection '.liblist' contains %lu entries:\n",
7339 (unsigned long) liblistno);
7340 fputs (" Library Time Stamp Checksum Version Flags\n",
7341 stdout);
7342
7343 for (cnt = 0; cnt < liblistno; ++cnt)
7344 {
7345 Elf32_Lib liblist;
7346 time_t time;
7347 char timebuf[20];
7348 struct tm * tmp;
7349
7350 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7351 time = BYTE_GET (elib[cnt].l_time_stamp);
7352 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7353 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7354 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7355
7356 tmp = gmtime (&time);
7357 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7358 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7359 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7360
7361 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7362 dynamic_strings + liblist.l_name, timebuf,
7363 liblist.l_checksum, liblist.l_version);
7364
7365 if (liblist.l_flags == 0)
7366 puts (" NONE");
7367 else
7368 {
7369 static const struct
7370 {
7371 const char * name;
7372 int bit;
7373 }
7374 l_flags_vals[] =
7375 {
7376 { " EXACT_MATCH", LL_EXACT_MATCH },
7377 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7378 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7379 { " EXPORTS", LL_EXPORTS },
7380 { " DELAY_LOAD", LL_DELAY_LOAD },
7381 { " DELTA", LL_DELTA }
7382 };
7383 int flags = liblist.l_flags;
7384 size_t fcnt;
7385
7386 for (fcnt = 0;
7387 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7388 ++fcnt)
7389 if ((flags & l_flags_vals[fcnt].bit) != 0)
7390 {
7391 fputs (l_flags_vals[fcnt].name, stdout);
7392 flags ^= l_flags_vals[fcnt].bit;
7393 }
7394 if (flags != 0)
7395 printf (" %#x", (unsigned int) flags);
7396
7397 puts ("");
7398 }
7399 }
7400
7401 free (elib);
7402 }
7403
7404 if (options_offset != 0)
7405 {
7406 Elf_External_Options * eopt;
7407 Elf_Internal_Shdr * sect = section_headers;
7408 Elf_Internal_Options * iopt;
7409 Elf_Internal_Options * option;
7410 size_t offset;
7411 int cnt;
7412
7413 /* Find the section header so that we get the size. */
7414 while (sect->sh_type != SHT_MIPS_OPTIONS)
7415 ++ sect;
7416
7417 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7418 Elf_External_Options *, "options");
7419
7420 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7421 * sizeof (* iopt));
7422 if (iopt == NULL)
7423 {
7424 error (_("Out of memory"));
7425 return 0;
7426 }
7427
7428 offset = cnt = 0;
7429 option = iopt;
7430
7431 while (offset < sect->sh_size)
7432 {
7433 Elf_External_Options * eoption;
7434
7435 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7436
7437 option->kind = BYTE_GET (eoption->kind);
7438 option->size = BYTE_GET (eoption->size);
7439 option->section = BYTE_GET (eoption->section);
7440 option->info = BYTE_GET (eoption->info);
7441
7442 offset += option->size;
7443
7444 ++option;
7445 ++cnt;
7446 }
7447
7448 printf (_("\nSection '%s' contains %d entries:\n"),
7449 SECTION_NAME (sect), cnt);
7450
7451 option = iopt;
7452
7453 while (cnt-- > 0)
7454 {
7455 size_t len;
7456
7457 switch (option->kind)
7458 {
7459 case ODK_NULL:
7460 /* This shouldn't happen. */
7461 printf (" NULL %d %lx", option->section, option->info);
7462 break;
7463 case ODK_REGINFO:
7464 printf (" REGINFO ");
7465 if (elf_header.e_machine == EM_MIPS)
7466 {
7467 /* 32bit form. */
7468 Elf32_External_RegInfo * ereg;
7469 Elf32_RegInfo reginfo;
7470
7471 ereg = (Elf32_External_RegInfo *) (option + 1);
7472 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7473 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7474 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7475 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7476 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7477 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7478
7479 printf ("GPR %08lx GP 0x%lx\n",
7480 reginfo.ri_gprmask,
7481 (unsigned long) reginfo.ri_gp_value);
7482 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7483 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7484 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7485 }
7486 else
7487 {
7488 /* 64 bit form. */
7489 Elf64_External_RegInfo * ereg;
7490 Elf64_Internal_RegInfo reginfo;
7491
7492 ereg = (Elf64_External_RegInfo *) (option + 1);
7493 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7494 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7495 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7496 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7497 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7498 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7499
7500 printf ("GPR %08lx GP 0x",
7501 reginfo.ri_gprmask);
7502 printf_vma (reginfo.ri_gp_value);
7503 printf ("\n");
7504
7505 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7506 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7507 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7508 }
7509 ++option;
7510 continue;
7511 case ODK_EXCEPTIONS:
7512 fputs (" EXCEPTIONS fpe_min(", stdout);
7513 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7514 fputs (") fpe_max(", stdout);
7515 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7516 fputs (")", stdout);
7517
7518 if (option->info & OEX_PAGE0)
7519 fputs (" PAGE0", stdout);
7520 if (option->info & OEX_SMM)
7521 fputs (" SMM", stdout);
7522 if (option->info & OEX_FPDBUG)
7523 fputs (" FPDBUG", stdout);
7524 if (option->info & OEX_DISMISS)
7525 fputs (" DISMISS", stdout);
7526 break;
7527 case ODK_PAD:
7528 fputs (" PAD ", stdout);
7529 if (option->info & OPAD_PREFIX)
7530 fputs (" PREFIX", stdout);
7531 if (option->info & OPAD_POSTFIX)
7532 fputs (" POSTFIX", stdout);
7533 if (option->info & OPAD_SYMBOL)
7534 fputs (" SYMBOL", stdout);
7535 break;
7536 case ODK_HWPATCH:
7537 fputs (" HWPATCH ", stdout);
7538 if (option->info & OHW_R4KEOP)
7539 fputs (" R4KEOP", stdout);
7540 if (option->info & OHW_R8KPFETCH)
7541 fputs (" R8KPFETCH", stdout);
7542 if (option->info & OHW_R5KEOP)
7543 fputs (" R5KEOP", stdout);
7544 if (option->info & OHW_R5KCVTL)
7545 fputs (" R5KCVTL", stdout);
7546 break;
7547 case ODK_FILL:
7548 fputs (" FILL ", stdout);
7549 /* XXX Print content of info word? */
7550 break;
7551 case ODK_TAGS:
7552 fputs (" TAGS ", stdout);
7553 /* XXX Print content of info word? */
7554 break;
7555 case ODK_HWAND:
7556 fputs (" HWAND ", stdout);
7557 if (option->info & OHWA0_R4KEOP_CHECKED)
7558 fputs (" R4KEOP_CHECKED", stdout);
7559 if (option->info & OHWA0_R4KEOP_CLEAN)
7560 fputs (" R4KEOP_CLEAN", stdout);
7561 break;
7562 case ODK_HWOR:
7563 fputs (" HWOR ", stdout);
7564 if (option->info & OHWA0_R4KEOP_CHECKED)
7565 fputs (" R4KEOP_CHECKED", stdout);
7566 if (option->info & OHWA0_R4KEOP_CLEAN)
7567 fputs (" R4KEOP_CLEAN", stdout);
7568 break;
7569 case ODK_GP_GROUP:
7570 printf (" GP_GROUP %#06lx self-contained %#06lx",
7571 option->info & OGP_GROUP,
7572 (option->info & OGP_SELF) >> 16);
7573 break;
7574 case ODK_IDENT:
7575 printf (" IDENT %#06lx self-contained %#06lx",
7576 option->info & OGP_GROUP,
7577 (option->info & OGP_SELF) >> 16);
7578 break;
7579 default:
7580 /* This shouldn't happen. */
7581 printf (" %3d ??? %d %lx",
7582 option->kind, option->section, option->info);
7583 break;
7584 }
7585
7586 len = sizeof (* eopt);
7587 while (len < option->size)
7588 if (((char *) option)[len] >= ' '
7589 && ((char *) option)[len] < 0x7f)
7590 printf ("%c", ((char *) option)[len++]);
7591 else
7592 printf ("\\%03o", ((char *) option)[len++]);
7593
7594 fputs ("\n", stdout);
7595 ++option;
7596 }
7597
7598 free (eopt);
7599 }
7600
7601 if (conflicts_offset != 0 && conflictsno != 0)
7602 {
7603 Elf32_External_Conflict * econf32;
7604 Elf64_External_Conflict * econf64;
7605 Elf32_Conflict * iconf;
7606 size_t cnt;
7607
7608 if (dynamic_symbols == NULL)
7609 {
7610 error (_("conflict list with without table"));
7611 return 0;
7612 }
7613
7614 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
7615 if (iconf == NULL)
7616 {
7617 error (_("Out of memory"));
7618 return 0;
7619 }
7620
7621 if (is_32bit_elf)
7622 {
7623 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
7624 econf32, Elf32_External_Conflict *, "conflict");
7625
7626 for (cnt = 0; cnt < conflictsno; ++cnt)
7627 iconf[cnt] = BYTE_GET (econf32[cnt]);
7628 }
7629 else
7630 {
7631 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
7632 econf64, Elf64_External_Conflict *, "conflict");
7633
7634 for (cnt = 0; cnt < conflictsno; ++cnt)
7635 iconf[cnt] = BYTE_GET (econf64[cnt]);
7636 }
7637
7638 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7639 puts (_(" Num: Index Value Name"));
7640
7641 for (cnt = 0; cnt < conflictsno; ++cnt)
7642 {
7643 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7644
7645 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
7646 print_vma (psym->st_value, FULL_HEX);
7647 printf (" %s\n", dynamic_strings + psym->st_name);
7648 }
7649
7650 free (iconf);
7651 }
7652
7653 return 1;
7654 }
7655
7656 static char *
7657 get_note_type (e_type)
7658 unsigned e_type;
7659 {
7660 static char buff[64];
7661
7662 switch (e_type)
7663 {
7664 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
7665 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
7666 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
7667 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7668 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
7669 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
7670 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
7671 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
7672 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7673 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7674 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7675 default:
7676 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7677 return buff;
7678 }
7679 }
7680
7681 /* Note that by the ELF standard, the name field is already null byte
7682 terminated, and namesz includes the terminating null byte.
7683 I.E. the value of namesz for the name "FSF" is 4.
7684
7685 If the value of namesz is zero, there is no name present. */
7686 static int
7687 process_note (pnote)
7688 Elf32_Internal_Note * pnote;
7689 {
7690 printf (" %s\t\t0x%08lx\t%s\n",
7691 pnote->namesz ? pnote->namedata : "(NONE)",
7692 pnote->descsz, get_note_type (pnote->type));
7693 return 1;
7694 }
7695
7696
7697 static int
7698 process_corefile_note_segment (file, offset, length)
7699 FILE * file;
7700 bfd_vma offset;
7701 bfd_vma length;
7702 {
7703 Elf_External_Note * pnotes;
7704 Elf_External_Note * external;
7705 int res = 1;
7706
7707 if (length <= 0)
7708 return 0;
7709
7710 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7711
7712 external = pnotes;
7713
7714 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7715 (unsigned long) offset, (unsigned long) length);
7716 printf (_(" Owner\t\tData size\tDescription\n"));
7717
7718 while (external < (Elf_External_Note *)((char *) pnotes + length))
7719 {
7720 Elf32_Internal_Note inote;
7721 char * temp = NULL;
7722
7723 inote.type = BYTE_GET (external->type);
7724 inote.namesz = BYTE_GET (external->namesz);
7725 inote.namedata = external->name;
7726 inote.descsz = BYTE_GET (external->descsz);
7727 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7728 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7729
7730 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7731
7732 /* Verify that name is null terminated. It appears that at least
7733 one version of Linux (RedHat 6.0) generates corefiles that don't
7734 comply with the ELF spec by failing to include the null byte in
7735 namesz. */
7736 if (inote.namedata[inote.namesz] != '\0')
7737 {
7738 temp = malloc (inote.namesz + 1);
7739
7740 if (temp == NULL)
7741 {
7742 error (_("Out of memory\n"));
7743 res = 0;
7744 break;
7745 }
7746
7747 strncpy (temp, inote.namedata, inote.namesz);
7748 temp[inote.namesz] = 0;
7749
7750 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7751 inote.namedata = temp;
7752 }
7753
7754 res &= process_note (& inote);
7755
7756 if (temp != NULL)
7757 {
7758 free (temp);
7759 temp = NULL;
7760 }
7761 }
7762
7763 free (pnotes);
7764
7765 return res;
7766 }
7767
7768 static int
7769 process_corefile_note_segments (file)
7770 FILE * file;
7771 {
7772 Elf_Internal_Phdr * program_headers;
7773 Elf_Internal_Phdr * segment;
7774 unsigned int i;
7775 int res = 1;
7776
7777 program_headers = (Elf_Internal_Phdr *) malloc
7778 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7779
7780 if (program_headers == NULL)
7781 {
7782 error (_("Out of memory\n"));
7783 return 0;
7784 }
7785
7786 if (is_32bit_elf)
7787 i = get_32bit_program_headers (file, program_headers);
7788 else
7789 i = get_64bit_program_headers (file, program_headers);
7790
7791 if (i == 0)
7792 {
7793 free (program_headers);
7794 return 0;
7795 }
7796
7797 for (i = 0, segment = program_headers;
7798 i < elf_header.e_phnum;
7799 i ++, segment ++)
7800 {
7801 if (segment->p_type == PT_NOTE)
7802 res &= process_corefile_note_segment (file,
7803 (bfd_vma) segment->p_offset,
7804 (bfd_vma) segment->p_filesz);
7805 }
7806
7807 free (program_headers);
7808
7809 return res;
7810 }
7811
7812 static int
7813 process_corefile_contents (file)
7814 FILE * file;
7815 {
7816 /* If we have not been asked to display the notes then do nothing. */
7817 if (! do_notes)
7818 return 1;
7819
7820 /* If file is not a core file then exit. */
7821 if (elf_header.e_type != ET_CORE)
7822 return 1;
7823
7824 /* No program headers means no NOTE segment. */
7825 if (elf_header.e_phnum == 0)
7826 {
7827 printf (_("No note segments present in the core file.\n"));
7828 return 1;
7829 }
7830
7831 return process_corefile_note_segments (file);
7832 }
7833
7834 static int
7835 process_arch_specific (file)
7836 FILE * file;
7837 {
7838 if (! do_arch)
7839 return 1;
7840
7841 switch (elf_header.e_machine)
7842 {
7843 case EM_MIPS:
7844 case EM_MIPS_RS4_BE:
7845 return process_mips_specific (file);
7846 break;
7847 default:
7848 break;
7849 }
7850 return 1;
7851 }
7852
7853 static int
7854 get_file_header (file)
7855 FILE * file;
7856 {
7857 /* Read in the identity array. */
7858 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7859 return 0;
7860
7861 /* Determine how to read the rest of the header. */
7862 switch (elf_header.e_ident [EI_DATA])
7863 {
7864 default: /* fall through */
7865 case ELFDATANONE: /* fall through */
7866 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7867 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7868 }
7869
7870 /* For now we only support 32 bit and 64 bit ELF files. */
7871 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7872
7873 /* Read in the rest of the header. */
7874 if (is_32bit_elf)
7875 {
7876 Elf32_External_Ehdr ehdr32;
7877
7878 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7879 return 0;
7880
7881 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7882 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7883 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7884 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7885 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7886 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7887 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7888 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7889 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7890 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7891 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7892 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7893 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7894 }
7895 else
7896 {
7897 Elf64_External_Ehdr ehdr64;
7898
7899 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7900 we will not be able to cope with the 64bit data found in
7901 64 ELF files. Detect this now and abort before we start
7902 overwritting things. */
7903 if (sizeof (bfd_vma) < 8)
7904 {
7905 error (_("This instance of readelf has been built without support for a\n"));
7906 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7907 return 0;
7908 }
7909
7910 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7911 return 0;
7912
7913 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7914 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7915 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7916 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7917 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7918 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7919 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7920 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7921 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7922 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7923 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7924 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7925 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7926 }
7927
7928 return 1;
7929 }
7930
7931 static void
7932 process_file (file_name)
7933 char * file_name;
7934 {
7935 FILE * file;
7936 struct stat statbuf;
7937 unsigned int i;
7938
7939 if (stat (file_name, & statbuf) < 0)
7940 {
7941 error (_("Cannot stat input file %s.\n"), file_name);
7942 return;
7943 }
7944
7945 file = fopen (file_name, "rb");
7946 if (file == NULL)
7947 {
7948 error (_("Input file %s not found.\n"), file_name);
7949 return;
7950 }
7951
7952 if (! get_file_header (file))
7953 {
7954 error (_("%s: Failed to read file header\n"), file_name);
7955 fclose (file);
7956 return;
7957 }
7958
7959 /* Initialise per file variables. */
7960 for (i = NUM_ELEM (version_info); i--;)
7961 version_info[i] = 0;
7962
7963 for (i = NUM_ELEM (dynamic_info); i--;)
7964 dynamic_info[i] = 0;
7965
7966 /* Process the file. */
7967 if (show_name)
7968 printf (_("\nFile: %s\n"), file_name);
7969
7970 if (! process_file_header ())
7971 {
7972 fclose (file);
7973 return;
7974 }
7975
7976 process_section_headers (file);
7977
7978 process_program_headers (file);
7979
7980 process_dynamic_segment (file);
7981
7982 process_relocs (file);
7983
7984 process_symbol_table (file);
7985
7986 process_syminfo (file);
7987
7988 process_version_sections (file);
7989
7990 process_section_contents (file);
7991
7992 process_corefile_contents (file);
7993
7994 process_arch_specific (file);
7995
7996 fclose (file);
7997
7998 if (section_headers)
7999 {
8000 free (section_headers);
8001 section_headers = NULL;
8002 }
8003
8004 if (string_table)
8005 {
8006 free (string_table);
8007 string_table = NULL;
8008 string_table_length = 0;
8009 }
8010
8011 if (dynamic_strings)
8012 {
8013 free (dynamic_strings);
8014 dynamic_strings = NULL;
8015 }
8016
8017 if (dynamic_symbols)
8018 {
8019 free (dynamic_symbols);
8020 dynamic_symbols = NULL;
8021 num_dynamic_syms = 0;
8022 }
8023
8024 if (dynamic_syminfo)
8025 {
8026 free (dynamic_syminfo);
8027 dynamic_syminfo = NULL;
8028 }
8029 }
8030
8031 #ifdef SUPPORT_DISASSEMBLY
8032 /* Needed by the i386 disassembler. For extra credit, someone could
8033 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8034 symbols */
8035
8036 void
8037 print_address (unsigned int addr, FILE * outfile)
8038 {
8039 fprintf (outfile,"0x%8.8x", addr);
8040 }
8041
8042 /* Needed by the i386 disassembler. */
8043 void
8044 db_task_printsym (unsigned int addr)
8045 {
8046 print_address (addr, stderr);
8047 }
8048 #endif
8049
8050 int
8051 main (argc, argv)
8052 int argc;
8053 char ** argv;
8054 {
8055 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8056 setlocale (LC_MESSAGES, "");
8057 #endif
8058 bindtextdomain (PACKAGE, LOCALEDIR);
8059 textdomain (PACKAGE);
8060
8061 parse_args (argc, argv);
8062
8063 if (optind < (argc - 1))
8064 show_name = 1;
8065
8066 while (optind < argc)
8067 process_file (argv [optind ++]);
8068
8069 if (dump_sects != NULL)
8070 free (dump_sects);
8071
8072 return 0;
8073 }
GDB Binutils - Deliverables
This page took 0.20352 seconds and 5 git commands to generate.