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