]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* readelf.c (get_machine_flags): Handle E_MIPS_ARCH_32R2.
[thirdparty/binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.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 believe 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/alpha.h"
53 #include "elf/arc.h"
54 #include "elf/arm.h"
55 #include "elf/avr.h"
56 #include "elf/cris.h"
57 #include "elf/d10v.h"
58 #include "elf/d30v.h"
59 #include "elf/dlx.h"
60 #include "elf/fr30.h"
61 #include "elf/frv.h"
62 #include "elf/h8.h"
63 #include "elf/hppa.h"
64 #include "elf/i386.h"
65 #include "elf/i370.h"
66 #include "elf/i860.h"
67 #include "elf/i960.h"
68 #include "elf/ia64.h"
69 #include "elf/ip2k.h"
70 #include "elf/m32r.h"
71 #include "elf/m68k.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
74 #include "elf/mips.h"
75 #include "elf/mmix.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
79 #include "elf/or32.h"
80 #include "elf/pj.h"
81 #include "elf/ppc.h"
82 #include "elf/s390.h"
83 #include "elf/sh.h"
84 #include "elf/sparc.h"
85 #include "elf/v850.h"
86 #include "elf/vax.h"
87 #include "elf/x86-64.h"
88 #include "elf/xstormy16.h"
89
90 #include "bucomm.h"
91 #include "getopt.h"
92
93 char *program_name = "readelf";
94 unsigned long dynamic_addr;
95 bfd_size_type dynamic_size;
96 char *dynamic_strings;
97 char *string_table;
98 unsigned long string_table_length;
99 unsigned long num_dynamic_syms;
100 Elf_Internal_Sym *dynamic_symbols;
101 Elf_Internal_Syminfo *dynamic_syminfo;
102 unsigned long dynamic_syminfo_offset;
103 unsigned int dynamic_syminfo_nent;
104 char program_interpreter[64];
105 long dynamic_info[DT_JMPREL + 1];
106 long version_info[16];
107 long loadaddr = 0;
108 Elf_Internal_Ehdr elf_header;
109 Elf_Internal_Shdr *section_headers;
110 Elf_Internal_Dyn *dynamic_segment;
111 Elf_Internal_Shdr *symtab_shndx_hdr;
112 int show_name;
113 int do_dynamic;
114 int do_syms;
115 int do_reloc;
116 int do_sections;
117 int do_segments;
118 int do_unwind;
119 int do_using_dynamic;
120 int do_header;
121 int do_dump;
122 int do_version;
123 int do_wide;
124 int do_histogram;
125 int do_debugging;
126 int do_debug_info;
127 int do_debug_abbrevs;
128 int do_debug_lines;
129 int do_debug_pubnames;
130 int do_debug_aranges;
131 int do_debug_frames;
132 int do_debug_frames_interp;
133 int do_debug_macinfo;
134 int do_debug_str;
135 int do_debug_loc;
136 int do_arch;
137 int do_notes;
138 int is_32bit_elf;
139
140 /* A dynamic array of flags indicating which sections require dumping. */
141 char *dump_sects = NULL;
142 unsigned int num_dump_sects = 0;
143
144 #define HEX_DUMP (1 << 0)
145 #define DISASS_DUMP (1 << 1)
146 #define DEBUG_DUMP (1 << 2)
147
148 /* How to rpint a vma value. */
149 typedef enum print_mode
150 {
151 HEX,
152 DEC,
153 DEC_5,
154 UNSIGNED,
155 PREFIX_HEX,
156 FULL_HEX,
157 LONG_HEX
158 }
159 print_mode;
160
161 /* Forward declarations for dumb compilers. */
162 static void print_vma
163 PARAMS ((bfd_vma, print_mode));
164 static void print_symbol
165 PARAMS ((int, const char *));
166 static bfd_vma (*byte_get)
167 PARAMS ((unsigned char *, int));
168 static bfd_vma byte_get_little_endian
169 PARAMS ((unsigned char *, int));
170 static bfd_vma byte_get_big_endian
171 PARAMS ((unsigned char *, int));
172 static const char *get_mips_dynamic_type
173 PARAMS ((unsigned long));
174 static const char *get_sparc64_dynamic_type
175 PARAMS ((unsigned long));
176 static const char *get_ppc64_dynamic_type
177 PARAMS ((unsigned long));
178 static const char *get_parisc_dynamic_type
179 PARAMS ((unsigned long));
180 static const char *get_dynamic_type
181 PARAMS ((unsigned long));
182 static int slurp_rela_relocs
183 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **,
184 unsigned long *));
185 static int slurp_rel_relocs
186 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **,
187 unsigned long *));
188 static int dump_relocations
189 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *,
190 unsigned long, char *, int));
191 static char *get_file_type
192 PARAMS ((unsigned));
193 static char *get_machine_name
194 PARAMS ((unsigned));
195 static void decode_ARM_machine_flags
196 PARAMS ((unsigned, char[]));
197 static char *get_machine_flags
198 PARAMS ((unsigned, unsigned));
199 static const char *get_mips_segment_type
200 PARAMS ((unsigned long));
201 static const char *get_parisc_segment_type
202 PARAMS ((unsigned long));
203 static const char *get_ia64_segment_type
204 PARAMS ((unsigned long));
205 static const char *get_segment_type
206 PARAMS ((unsigned long));
207 static const char *get_mips_section_type_name
208 PARAMS ((unsigned int));
209 static const char *get_parisc_section_type_name
210 PARAMS ((unsigned int));
211 static const char *get_ia64_section_type_name
212 PARAMS ((unsigned int));
213 static const char *get_section_type_name
214 PARAMS ((unsigned int));
215 static const char *get_symbol_binding
216 PARAMS ((unsigned int));
217 static const char *get_symbol_type
218 PARAMS ((unsigned int));
219 static const char *get_symbol_visibility
220 PARAMS ((unsigned int));
221 static const char *get_symbol_index_type
222 PARAMS ((unsigned int));
223 static const char *get_dynamic_flags
224 PARAMS ((bfd_vma));
225 static void usage
226 PARAMS ((void));
227 static void parse_args
228 PARAMS ((int, char **));
229 static int process_file_header
230 PARAMS ((void));
231 static int process_program_headers
232 PARAMS ((FILE *));
233 static int process_section_headers
234 PARAMS ((FILE *));
235 static int process_unwind
236 PARAMS ((FILE *));
237 static void dynamic_segment_mips_val
238 PARAMS ((Elf_Internal_Dyn *));
239 static void dynamic_segment_parisc_val
240 PARAMS ((Elf_Internal_Dyn *));
241 static int process_dynamic_segment
242 PARAMS ((FILE *));
243 static int process_symbol_table
244 PARAMS ((FILE *));
245 static int process_syminfo
246 PARAMS ((FILE *));
247 static int process_section_contents
248 PARAMS ((FILE *));
249 static void process_mips_fpe_exception
250 PARAMS ((int));
251 static int process_mips_specific
252 PARAMS ((FILE *));
253 static int process_file
254 PARAMS ((char *));
255 static int process_relocs
256 PARAMS ((FILE *));
257 static int process_version_sections
258 PARAMS ((FILE *));
259 static char *get_ver_flags
260 PARAMS ((unsigned int));
261 static int get_32bit_section_headers
262 PARAMS ((FILE *, unsigned int));
263 static int get_64bit_section_headers
264 PARAMS ((FILE *, unsigned int));
265 static int get_32bit_program_headers
266 PARAMS ((FILE *, Elf_Internal_Phdr *));
267 static int get_64bit_program_headers
268 PARAMS ((FILE *, Elf_Internal_Phdr *));
269 static int get_file_header
270 PARAMS ((FILE *));
271 static Elf_Internal_Sym *get_32bit_elf_symbols
272 PARAMS ((FILE *, Elf_Internal_Shdr *));
273 static Elf_Internal_Sym *get_64bit_elf_symbols
274 PARAMS ((FILE *, Elf_Internal_Shdr *));
275 static const char *get_elf_section_flags
276 PARAMS ((bfd_vma));
277 static int *get_dynamic_data
278 PARAMS ((FILE *, unsigned int));
279 static int get_32bit_dynamic_segment
280 PARAMS ((FILE *));
281 static int get_64bit_dynamic_segment
282 PARAMS ((FILE *));
283 #ifdef SUPPORT_DISASSEMBLY
284 static int disassemble_section
285 PARAMS ((Elf_Internal_Shdr *, FILE *));
286 #endif
287 static int dump_section
288 PARAMS ((Elf_Internal_Shdr *, FILE *));
289 static int display_debug_section
290 PARAMS ((Elf_Internal_Shdr *, FILE *));
291 static int display_debug_info
292 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
293 static int display_debug_not_supported
294 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
295 static int prescan_debug_info
296 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
297 static int display_debug_lines
298 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
299 static int display_debug_pubnames
300 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
301 static int display_debug_abbrev
302 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
303 static int display_debug_aranges
304 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
305 static int display_debug_frames
306 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
307 static int display_debug_macinfo
308 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
309 static int display_debug_str
310 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
311 static int display_debug_loc
312 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
313 static unsigned char *process_abbrev_section
314 PARAMS ((unsigned char *, unsigned char *));
315 static void load_debug_str
316 PARAMS ((FILE *));
317 static void free_debug_str
318 PARAMS ((void));
319 static const char *fetch_indirect_string
320 PARAMS ((unsigned long));
321 static void load_debug_loc
322 PARAMS ((FILE *));
323 static void free_debug_loc
324 PARAMS ((void));
325 static unsigned long read_leb128
326 PARAMS ((unsigned char *, int *, int));
327 static int process_extended_line_op
328 PARAMS ((unsigned char *, int, int));
329 static void reset_state_machine
330 PARAMS ((int));
331 static char *get_TAG_name
332 PARAMS ((unsigned long));
333 static char *get_AT_name
334 PARAMS ((unsigned long));
335 static char *get_FORM_name
336 PARAMS ((unsigned long));
337 static void free_abbrevs
338 PARAMS ((void));
339 static void add_abbrev
340 PARAMS ((unsigned long, unsigned long, int));
341 static void add_abbrev_attr
342 PARAMS ((unsigned long, unsigned long));
343 static unsigned char *read_and_display_attr
344 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
345 unsigned long));
346 static unsigned char *read_and_display_attr_value
347 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
348 unsigned long));
349 static unsigned char *display_block
350 PARAMS ((unsigned char *, unsigned long));
351 static void decode_location_expression
352 PARAMS ((unsigned char *, unsigned int, unsigned long));
353 static void request_dump
354 PARAMS ((unsigned int, int));
355 static const char *get_elf_class
356 PARAMS ((unsigned int));
357 static const char *get_data_encoding
358 PARAMS ((unsigned int));
359 static const char *get_osabi_name
360 PARAMS ((unsigned int));
361 static int guess_is_rela
362 PARAMS ((unsigned long));
363 static const char *get_note_type
364 PARAMS ((unsigned int));
365 static const char *get_netbsd_elfcore_note_type
366 PARAMS ((unsigned int));
367 static int process_note
368 PARAMS ((Elf_Internal_Note *));
369 static int process_corefile_note_segment
370 PARAMS ((FILE *, bfd_vma, bfd_vma));
371 static int process_corefile_note_segments
372 PARAMS ((FILE *));
373 static int process_corefile_contents
374 PARAMS ((FILE *));
375 static int process_arch_specific
376 PARAMS ((FILE *));
377 static int process_gnu_liblist
378 PARAMS ((FILE *));
379
380 typedef int Elf32_Word;
381
382 #define UNKNOWN -1
383
384 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
385 ((X)->sh_name >= string_table_length \
386 ? "<corrupt>" : string_table + (X)->sh_name))
387
388 /* Given st_shndx I, map to section_headers index. */
389 #define SECTION_HEADER_INDEX(I) \
390 ((I) < SHN_LORESERVE \
391 ? (I) \
392 : ((I) <= SHN_HIRESERVE \
393 ? 0 \
394 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
395
396 /* Reverse of the above. */
397 #define SECTION_HEADER_NUM(N) \
398 ((N) < SHN_LORESERVE \
399 ? (N) \
400 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
401
402 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
403
404 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
405
406 #define BYTE_GET(field) byte_get (field, sizeof (field))
407
408 /* If we can support a 64 bit data type then BFD64 should be defined
409 and sizeof (bfd_vma) == 8. In this case when translating from an
410 external 8 byte field to an internal field, we can assume that the
411 internal field is also 8 bytes wide and so we can extract all the data.
412 If, however, BFD64 is not defined, then we must assume that the
413 internal data structure only has 4 byte wide fields that are the
414 equivalent of the 8 byte wide external counterparts, and so we must
415 truncate the data. */
416 #ifdef BFD64
417 #define BYTE_GET8(field) byte_get (field, -8)
418 #else
419 #define BYTE_GET8(field) byte_get (field, 8)
420 #endif
421
422 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
423
424 #define GET_ELF_SYMBOLS(file, section) \
425 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
426 : get_64bit_elf_symbols (file, section))
427
428
429 static void
430 error VPARAMS ((const char *message, ...))
431 {
432 VA_OPEN (args, message);
433 VA_FIXEDARG (args, const char *, message);
434
435 fprintf (stderr, _("%s: Error: "), program_name);
436 vfprintf (stderr, message, args);
437 VA_CLOSE (args);
438 }
439
440 static void
441 warn VPARAMS ((const char *message, ...))
442 {
443 VA_OPEN (args, message);
444 VA_FIXEDARG (args, const char *, message);
445
446 fprintf (stderr, _("%s: Warning: "), program_name);
447 vfprintf (stderr, message, args);
448 VA_CLOSE (args);
449 }
450
451 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
452
453 static PTR
454 get_data (var, file, offset, size, reason)
455 PTR var;
456 FILE *file;
457 long offset;
458 size_t size;
459 const char *reason;
460 {
461 PTR mvar;
462
463 if (size == 0)
464 return NULL;
465
466 if (fseek (file, offset, SEEK_SET))
467 {
468 error (_("Unable to seek to %x for %s\n"), offset, reason);
469 return NULL;
470 }
471
472 mvar = var;
473 if (mvar == NULL)
474 {
475 mvar = (PTR) malloc (size);
476
477 if (mvar == NULL)
478 {
479 error (_("Out of memory allocating %d bytes for %s\n"),
480 size, reason);
481 return NULL;
482 }
483 }
484
485 if (fread (mvar, size, 1, file) != 1)
486 {
487 error (_("Unable to read in %d bytes of %s\n"), size, reason);
488 if (mvar != var)
489 free (mvar);
490 return NULL;
491 }
492
493 return mvar;
494 }
495
496 static bfd_vma
497 byte_get_little_endian (field, size)
498 unsigned char *field;
499 int size;
500 {
501 switch (size)
502 {
503 case 1:
504 return *field;
505
506 case 2:
507 return ((unsigned int) (field[0]))
508 | (((unsigned int) (field[1])) << 8);
509
510 #ifndef BFD64
511 case 8:
512 /* We want to extract data from an 8 byte wide field and
513 place it into a 4 byte wide field. Since this is a little
514 endian source we can just use the 4 byte extraction code. */
515 /* Fall through. */
516 #endif
517 case 4:
518 return ((unsigned long) (field[0]))
519 | (((unsigned long) (field[1])) << 8)
520 | (((unsigned long) (field[2])) << 16)
521 | (((unsigned long) (field[3])) << 24);
522
523 #ifdef BFD64
524 case 8:
525 case -8:
526 /* This is a special case, generated by the BYTE_GET8 macro.
527 It means that we are loading an 8 byte value from a field
528 in an external structure into an 8 byte value in a field
529 in an internal strcuture. */
530 return ((bfd_vma) (field[0]))
531 | (((bfd_vma) (field[1])) << 8)
532 | (((bfd_vma) (field[2])) << 16)
533 | (((bfd_vma) (field[3])) << 24)
534 | (((bfd_vma) (field[4])) << 32)
535 | (((bfd_vma) (field[5])) << 40)
536 | (((bfd_vma) (field[6])) << 48)
537 | (((bfd_vma) (field[7])) << 56);
538 #endif
539 default:
540 error (_("Unhandled data length: %d\n"), size);
541 abort ();
542 }
543 }
544
545 /* Print a VMA value. */
546 static void
547 print_vma (vma, mode)
548 bfd_vma vma;
549 print_mode mode;
550 {
551 #ifdef BFD64
552 if (is_32bit_elf)
553 #endif
554 {
555 switch (mode)
556 {
557 case FULL_HEX: printf ("0x"); /* drop through */
558 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
559 case PREFIX_HEX: printf ("0x"); /* drop through */
560 case HEX: printf ("%lx", (unsigned long) vma); break;
561 case DEC: printf ("%ld", (unsigned long) vma); break;
562 case DEC_5: printf ("%5ld", (long) vma); break;
563 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
564 }
565 }
566 #ifdef BFD64
567 else
568 {
569 switch (mode)
570 {
571 case FULL_HEX:
572 printf ("0x");
573 /* drop through */
574
575 case LONG_HEX:
576 printf_vma (vma);
577 break;
578
579 case PREFIX_HEX:
580 printf ("0x");
581 /* drop through */
582
583 case HEX:
584 #if BFD_HOST_64BIT_LONG
585 printf ("%lx", vma);
586 #else
587 if (_bfd_int64_high (vma))
588 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
589 else
590 printf ("%lx", _bfd_int64_low (vma));
591 #endif
592 break;
593
594 case DEC:
595 #if BFD_HOST_64BIT_LONG
596 printf ("%ld", vma);
597 #else
598 if (_bfd_int64_high (vma))
599 /* ugg */
600 printf ("++%ld", _bfd_int64_low (vma));
601 else
602 printf ("%ld", _bfd_int64_low (vma));
603 #endif
604 break;
605
606 case DEC_5:
607 #if BFD_HOST_64BIT_LONG
608 printf ("%5ld", vma);
609 #else
610 if (_bfd_int64_high (vma))
611 /* ugg */
612 printf ("++%ld", _bfd_int64_low (vma));
613 else
614 printf ("%5ld", _bfd_int64_low (vma));
615 #endif
616 break;
617
618 case UNSIGNED:
619 #if BFD_HOST_64BIT_LONG
620 printf ("%lu", vma);
621 #else
622 if (_bfd_int64_high (vma))
623 /* ugg */
624 printf ("++%lu", _bfd_int64_low (vma));
625 else
626 printf ("%lu", _bfd_int64_low (vma));
627 #endif
628 break;
629 }
630 }
631 #endif
632 }
633
634 /* Display a symbol on stdout. If do_wide is not true then
635 format the symbol to be at most WIDTH characters,
636 truncating as necessary. If WIDTH is negative then
637 format the string to be exactly - WIDTH characters,
638 truncating or padding as necessary. */
639
640 static void
641 print_symbol (width, symbol)
642 int width;
643 const char *symbol;
644 {
645 if (do_wide)
646 printf ("%s", symbol);
647 else if (width < 0)
648 printf ("%-*.*s", width, width, symbol);
649 else
650 printf ("%-.*s", width, symbol);
651 }
652
653 static bfd_vma
654 byte_get_big_endian (field, size)
655 unsigned char *field;
656 int size;
657 {
658 switch (size)
659 {
660 case 1:
661 return *field;
662
663 case 2:
664 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
665
666 case 4:
667 return ((unsigned long) (field[3]))
668 | (((unsigned long) (field[2])) << 8)
669 | (((unsigned long) (field[1])) << 16)
670 | (((unsigned long) (field[0])) << 24);
671
672 #ifndef BFD64
673 case 8:
674 /* Although we are extracing data from an 8 byte wide field, we
675 are returning only 4 bytes of data. */
676 return ((unsigned long) (field[7]))
677 | (((unsigned long) (field[6])) << 8)
678 | (((unsigned long) (field[5])) << 16)
679 | (((unsigned long) (field[4])) << 24);
680 #else
681 case 8:
682 case -8:
683 /* This is a special case, generated by the BYTE_GET8 macro.
684 It means that we are loading an 8 byte value from a field
685 in an external structure into an 8 byte value in a field
686 in an internal strcuture. */
687 return ((bfd_vma) (field[7]))
688 | (((bfd_vma) (field[6])) << 8)
689 | (((bfd_vma) (field[5])) << 16)
690 | (((bfd_vma) (field[4])) << 24)
691 | (((bfd_vma) (field[3])) << 32)
692 | (((bfd_vma) (field[2])) << 40)
693 | (((bfd_vma) (field[1])) << 48)
694 | (((bfd_vma) (field[0])) << 56);
695 #endif
696
697 default:
698 error (_("Unhandled data length: %d\n"), size);
699 abort ();
700 }
701 }
702
703 /* Guess the relocation size commonly used by the specific machines. */
704
705 static int
706 guess_is_rela (e_machine)
707 unsigned long e_machine;
708 {
709 switch (e_machine)
710 {
711 /* Targets that use REL relocations. */
712 case EM_ARM:
713 case EM_386:
714 case EM_486:
715 case EM_960:
716 case EM_DLX:
717 case EM_OPENRISC:
718 case EM_OR32:
719 case EM_M32R:
720 case EM_CYGNUS_M32R:
721 case EM_D10V:
722 case EM_CYGNUS_D10V:
723 case EM_MIPS:
724 case EM_MIPS_RS3_LE:
725 return FALSE;
726
727 /* Targets that use RELA relocations. */
728 case EM_68K:
729 case EM_H8_300:
730 case EM_H8_300H:
731 case EM_H8S:
732 case EM_SPARC32PLUS:
733 case EM_SPARCV9:
734 case EM_SPARC:
735 case EM_PPC:
736 case EM_PPC64:
737 case EM_V850:
738 case EM_CYGNUS_V850:
739 case EM_D30V:
740 case EM_CYGNUS_D30V:
741 case EM_MN10200:
742 case EM_CYGNUS_MN10200:
743 case EM_MN10300:
744 case EM_CYGNUS_MN10300:
745 case EM_FR30:
746 case EM_CYGNUS_FR30:
747 case EM_CYGNUS_FRV:
748 case EM_SH:
749 case EM_ALPHA:
750 case EM_MCORE:
751 case EM_IA_64:
752 case EM_AVR:
753 case EM_AVR_OLD:
754 case EM_CRIS:
755 case EM_860:
756 case EM_X86_64:
757 case EM_S390:
758 case EM_S390_OLD:
759 case EM_MMIX:
760 case EM_MSP430:
761 case EM_MSP430_OLD:
762 case EM_XSTORMY16:
763 case EM_VAX:
764 case EM_IP2K:
765 case EM_IP2K_OLD:
766 return TRUE;
767
768 case EM_MMA:
769 case EM_PCP:
770 case EM_NCPU:
771 case EM_NDR1:
772 case EM_STARCORE:
773 case EM_ME16:
774 case EM_ST100:
775 case EM_TINYJ:
776 case EM_FX66:
777 case EM_ST9PLUS:
778 case EM_ST7:
779 case EM_68HC16:
780 case EM_68HC11:
781 case EM_68HC08:
782 case EM_68HC05:
783 case EM_SVX:
784 case EM_ST19:
785 default:
786 warn (_("Don't know about relocations on this machine architecture\n"));
787 return FALSE;
788 }
789 }
790
791 static int
792 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
793 FILE *file;
794 unsigned long rel_offset;
795 unsigned long rel_size;
796 Elf_Internal_Rela **relasp;
797 unsigned long *nrelasp;
798 {
799 Elf_Internal_Rela *relas;
800 unsigned long nrelas;
801 unsigned int i;
802
803 if (is_32bit_elf)
804 {
805 Elf32_External_Rela *erelas;
806
807 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
808 rel_size, _("relocs"));
809 if (!erelas)
810 return 0;
811
812 nrelas = rel_size / sizeof (Elf32_External_Rela);
813
814 relas = (Elf_Internal_Rela *)
815 malloc (nrelas * sizeof (Elf_Internal_Rela));
816
817 if (relas == NULL)
818 {
819 error(_("out of memory parsing relocs"));
820 return 0;
821 }
822
823 for (i = 0; i < nrelas; i++)
824 {
825 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
826 relas[i].r_info = BYTE_GET (erelas[i].r_info);
827 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
828 }
829
830 free (erelas);
831 }
832 else
833 {
834 Elf64_External_Rela *erelas;
835
836 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
837 rel_size, _("relocs"));
838 if (!erelas)
839 return 0;
840
841 nrelas = rel_size / sizeof (Elf64_External_Rela);
842
843 relas = (Elf_Internal_Rela *)
844 malloc (nrelas * sizeof (Elf_Internal_Rela));
845
846 if (relas == NULL)
847 {
848 error(_("out of memory parsing relocs"));
849 return 0;
850 }
851
852 for (i = 0; i < nrelas; i++)
853 {
854 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
855 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
856 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
857 }
858
859 free (erelas);
860 }
861 *relasp = relas;
862 *nrelasp = nrelas;
863 return 1;
864 }
865
866 static int
867 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
868 FILE *file;
869 unsigned long rel_offset;
870 unsigned long rel_size;
871 Elf_Internal_Rela **relsp;
872 unsigned long *nrelsp;
873 {
874 Elf_Internal_Rela *rels;
875 unsigned long nrels;
876 unsigned int i;
877
878 if (is_32bit_elf)
879 {
880 Elf32_External_Rel *erels;
881
882 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
883 rel_size, _("relocs"));
884 if (!erels)
885 return 0;
886
887 nrels = rel_size / sizeof (Elf32_External_Rel);
888
889 rels = (Elf_Internal_Rela *) malloc (nrels * sizeof (Elf_Internal_Rela));
890
891 if (rels == NULL)
892 {
893 error(_("out of memory parsing relocs"));
894 return 0;
895 }
896
897 for (i = 0; i < nrels; i++)
898 {
899 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
900 rels[i].r_info = BYTE_GET (erels[i].r_info);
901 rels[i].r_addend = 0;
902 }
903
904 free (erels);
905 }
906 else
907 {
908 Elf64_External_Rel *erels;
909
910 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
911 rel_size, _("relocs"));
912 if (!erels)
913 return 0;
914
915 nrels = rel_size / sizeof (Elf64_External_Rel);
916
917 rels = (Elf_Internal_Rela *) malloc (nrels * sizeof (Elf_Internal_Rela));
918
919 if (rels == NULL)
920 {
921 error(_("out of memory parsing relocs"));
922 return 0;
923 }
924
925 for (i = 0; i < nrels; i++)
926 {
927 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
928 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
929 rels[i].r_addend = 0;
930 }
931
932 free (erels);
933 }
934 *relsp = rels;
935 *nrelsp = nrels;
936 return 1;
937 }
938
939 /* Display the contents of the relocation data found at the specified offset. */
940 static int
941 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
942 FILE *file;
943 unsigned long rel_offset;
944 unsigned long rel_size;
945 Elf_Internal_Sym *symtab;
946 unsigned long nsyms;
947 char *strtab;
948 int is_rela;
949 {
950 unsigned int i;
951 Elf_Internal_Rela *rels;
952
953
954 if (is_rela == UNKNOWN)
955 is_rela = guess_is_rela (elf_header.e_machine);
956
957 if (is_rela)
958 {
959 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
960 return 0;
961 }
962 else
963 {
964 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
965 return 0;
966 }
967
968 if (is_32bit_elf)
969 {
970 if (is_rela)
971 {
972 if (do_wide)
973 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
974 else
975 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
976 }
977 else
978 {
979 if (do_wide)
980 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
981 else
982 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
983 }
984 }
985 else
986 {
987 if (is_rela)
988 {
989 if (do_wide)
990 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
991 else
992 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
993 }
994 else
995 {
996 if (do_wide)
997 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
998 else
999 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1000 }
1001 }
1002
1003 for (i = 0; i < rel_size; i++)
1004 {
1005 const char *rtype;
1006 const char *rtype2 = NULL;
1007 const char *rtype3 = NULL;
1008 bfd_vma offset;
1009 bfd_vma info;
1010 bfd_vma symtab_index;
1011 bfd_vma type;
1012 bfd_vma type2 = (bfd_vma) NULL;
1013 bfd_vma type3 = (bfd_vma) NULL;
1014
1015 offset = rels[i].r_offset;
1016 info = rels[i].r_info;
1017
1018 if (is_32bit_elf)
1019 {
1020 type = ELF32_R_TYPE (info);
1021 symtab_index = ELF32_R_SYM (info);
1022 }
1023 else
1024 {
1025 if (elf_header.e_machine == EM_MIPS)
1026 {
1027 type = ELF64_MIPS_R_TYPE (info);
1028 type2 = ELF64_MIPS_R_TYPE2 (info);
1029 type3 = ELF64_MIPS_R_TYPE3 (info);
1030 }
1031 else if (elf_header.e_machine == EM_SPARCV9)
1032 type = ELF64_R_TYPE_ID (info);
1033 else
1034 type = ELF64_R_TYPE (info);
1035 /* The #ifdef BFD64 below is to prevent a compile time warning.
1036 We know that if we do not have a 64 bit data type that we
1037 will never execute this code anyway. */
1038 #ifdef BFD64
1039 symtab_index = ELF64_R_SYM (info);
1040 #endif
1041 }
1042
1043 if (is_32bit_elf)
1044 {
1045 #ifdef _bfd_int64_low
1046 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
1047 #else
1048 printf ("%8.8lx %8.8lx ", offset, info);
1049 #endif
1050 }
1051 else
1052 {
1053 #ifdef _bfd_int64_low
1054 printf (do_wide
1055 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1056 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1057 _bfd_int64_high (offset),
1058 _bfd_int64_low (offset),
1059 _bfd_int64_high (info),
1060 _bfd_int64_low (info));
1061 #else
1062 printf (do_wide
1063 ? "%16.16lx %16.16lx "
1064 : "%12.12lx %12.12lx ",
1065 offset, info);
1066 #endif
1067 }
1068
1069 switch (elf_header.e_machine)
1070 {
1071 default:
1072 rtype = NULL;
1073 break;
1074
1075 case EM_M32R:
1076 case EM_CYGNUS_M32R:
1077 rtype = elf_m32r_reloc_type (type);
1078 break;
1079
1080 case EM_386:
1081 case EM_486:
1082 rtype = elf_i386_reloc_type (type);
1083 break;
1084
1085 case EM_68HC11:
1086 case EM_68HC12:
1087 rtype = elf_m68hc11_reloc_type (type);
1088 break;
1089
1090 case EM_68K:
1091 rtype = elf_m68k_reloc_type (type);
1092 break;
1093
1094 case EM_960:
1095 rtype = elf_i960_reloc_type (type);
1096 break;
1097
1098 case EM_AVR:
1099 case EM_AVR_OLD:
1100 rtype = elf_avr_reloc_type (type);
1101 break;
1102
1103 case EM_OLD_SPARCV9:
1104 case EM_SPARC32PLUS:
1105 case EM_SPARCV9:
1106 case EM_SPARC:
1107 rtype = elf_sparc_reloc_type (type);
1108 break;
1109
1110 case EM_V850:
1111 case EM_CYGNUS_V850:
1112 rtype = v850_reloc_type (type);
1113 break;
1114
1115 case EM_D10V:
1116 case EM_CYGNUS_D10V:
1117 rtype = elf_d10v_reloc_type (type);
1118 break;
1119
1120 case EM_D30V:
1121 case EM_CYGNUS_D30V:
1122 rtype = elf_d30v_reloc_type (type);
1123 break;
1124
1125 case EM_DLX:
1126 rtype = elf_dlx_reloc_type (type);
1127 break;
1128
1129 case EM_SH:
1130 rtype = elf_sh_reloc_type (type);
1131 break;
1132
1133 case EM_MN10300:
1134 case EM_CYGNUS_MN10300:
1135 rtype = elf_mn10300_reloc_type (type);
1136 break;
1137
1138 case EM_MN10200:
1139 case EM_CYGNUS_MN10200:
1140 rtype = elf_mn10200_reloc_type (type);
1141 break;
1142
1143 case EM_FR30:
1144 case EM_CYGNUS_FR30:
1145 rtype = elf_fr30_reloc_type (type);
1146 break;
1147
1148 case EM_CYGNUS_FRV:
1149 rtype = elf_frv_reloc_type (type);
1150 break;
1151
1152 case EM_MCORE:
1153 rtype = elf_mcore_reloc_type (type);
1154 break;
1155
1156 case EM_MMIX:
1157 rtype = elf_mmix_reloc_type (type);
1158 break;
1159
1160 case EM_MSP430:
1161 case EM_MSP430_OLD:
1162 rtype = elf_msp430_reloc_type (type);
1163 break;
1164
1165 case EM_PPC:
1166 case EM_PPC64:
1167 rtype = elf_ppc_reloc_type (type);
1168 break;
1169
1170 case EM_MIPS:
1171 case EM_MIPS_RS3_LE:
1172 rtype = elf_mips_reloc_type (type);
1173 if (!is_32bit_elf)
1174 {
1175 rtype2 = elf_mips_reloc_type (type2);
1176 rtype3 = elf_mips_reloc_type (type3);
1177 }
1178 break;
1179
1180 case EM_ALPHA:
1181 rtype = elf_alpha_reloc_type (type);
1182 break;
1183
1184 case EM_ARM:
1185 rtype = elf_arm_reloc_type (type);
1186 break;
1187
1188 case EM_ARC:
1189 rtype = elf_arc_reloc_type (type);
1190 break;
1191
1192 case EM_PARISC:
1193 rtype = elf_hppa_reloc_type (type);
1194 break;
1195
1196 case EM_H8_300:
1197 case EM_H8_300H:
1198 case EM_H8S:
1199 rtype = elf_h8_reloc_type (type);
1200 break;
1201
1202 case EM_OPENRISC:
1203 case EM_OR32:
1204 rtype = elf_or32_reloc_type (type);
1205 break;
1206
1207 case EM_PJ:
1208 case EM_PJ_OLD:
1209 rtype = elf_pj_reloc_type (type);
1210 break;
1211 case EM_IA_64:
1212 rtype = elf_ia64_reloc_type (type);
1213 break;
1214
1215 case EM_CRIS:
1216 rtype = elf_cris_reloc_type (type);
1217 break;
1218
1219 case EM_860:
1220 rtype = elf_i860_reloc_type (type);
1221 break;
1222
1223 case EM_X86_64:
1224 rtype = elf_x86_64_reloc_type (type);
1225 break;
1226
1227 case EM_S370:
1228 rtype = i370_reloc_type (type);
1229 break;
1230
1231 case EM_S390_OLD:
1232 case EM_S390:
1233 rtype = elf_s390_reloc_type (type);
1234 break;
1235
1236 case EM_XSTORMY16:
1237 rtype = elf_xstormy16_reloc_type (type);
1238 break;
1239
1240 case EM_VAX:
1241 rtype = elf_vax_reloc_type (type);
1242 break;
1243
1244 case EM_IP2K:
1245 case EM_IP2K_OLD:
1246 rtype = elf_ip2k_reloc_type (type);
1247 break;
1248 }
1249
1250 if (rtype == NULL)
1251 #ifdef _bfd_int64_low
1252 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1253 #else
1254 printf (_("unrecognized: %-7lx"), type);
1255 #endif
1256 else
1257 printf (do_wide ? "%-21.21s" : "%-17.17s", rtype);
1258
1259 if (symtab_index)
1260 {
1261 if (symtab == NULL || symtab_index >= nsyms)
1262 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1263 else
1264 {
1265 Elf_Internal_Sym *psym;
1266
1267 psym = symtab + symtab_index;
1268
1269 printf (" ");
1270 print_vma (psym->st_value, LONG_HEX);
1271 printf (is_32bit_elf ? " " : " ");
1272
1273 if (psym->st_name == 0)
1274 {
1275 const char *sec_name = "<null>";
1276 char name_buf[40];
1277
1278 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1279 {
1280 bfd_vma sec_index = (bfd_vma) -1;
1281
1282 if (psym->st_shndx < SHN_LORESERVE)
1283 sec_index = psym->st_shndx;
1284 else if (psym->st_shndx > SHN_LORESERVE)
1285 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1286 - SHN_LORESERVE);
1287
1288 if (sec_index != (bfd_vma) -1)
1289 sec_name = SECTION_NAME (section_headers + sec_index);
1290 else if (psym->st_shndx == SHN_ABS)
1291 sec_name = "ABS";
1292 else if (psym->st_shndx == SHN_COMMON)
1293 sec_name = "COMMON";
1294 else
1295 {
1296 sprintf (name_buf, "<section 0x%x>",
1297 (unsigned int) psym->st_shndx);
1298 sec_name = name_buf;
1299 }
1300 }
1301 print_symbol (22, sec_name);
1302 }
1303 else if (strtab == NULL)
1304 printf (_("<string table index %3ld>"), psym->st_name);
1305 else
1306 print_symbol (22, strtab + psym->st_name);
1307
1308 if (is_rela)
1309 printf (" + %lx", (unsigned long) rels[i].r_addend);
1310 }
1311 }
1312 else if (is_rela)
1313 {
1314 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1315 print_vma (rels[i].r_addend, LONG_HEX);
1316 }
1317
1318 if (elf_header.e_machine == EM_SPARCV9
1319 && !strcmp (rtype, "R_SPARC_OLO10"))
1320 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1321
1322 putchar ('\n');
1323
1324 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1325 {
1326 printf (" Type2: ");
1327
1328 if (rtype2 == NULL)
1329 #ifdef _bfd_int64_low
1330 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1331 #else
1332 printf (_("unrecognized: %-7lx"), type2);
1333 #endif
1334 else
1335 printf ("%-17.17s", rtype2);
1336
1337 printf("\n Type3: ");
1338
1339 if (rtype3 == NULL)
1340 #ifdef _bfd_int64_low
1341 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1342 #else
1343 printf (_("unrecognized: %-7lx"), type3);
1344 #endif
1345 else
1346 printf ("%-17.17s", rtype3);
1347
1348 putchar ('\n');
1349 }
1350 }
1351
1352 free (rels);
1353
1354 return 1;
1355 }
1356
1357 static const char *
1358 get_mips_dynamic_type (type)
1359 unsigned long type;
1360 {
1361 switch (type)
1362 {
1363 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1364 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1365 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1366 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1367 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1368 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1369 case DT_MIPS_MSYM: return "MIPS_MSYM";
1370 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1371 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1372 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1373 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1374 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1375 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1376 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1377 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1378 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1379 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1380 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1381 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1382 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1383 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1384 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1385 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1386 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1387 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1388 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1389 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1390 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1391 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1392 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1393 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1394 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1395 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1396 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1397 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1398 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1399 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1400 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1401 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1402 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1403 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1404 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1405 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1406 default:
1407 return NULL;
1408 }
1409 }
1410
1411 static const char *
1412 get_sparc64_dynamic_type (type)
1413 unsigned long type;
1414 {
1415 switch (type)
1416 {
1417 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1418 default:
1419 return NULL;
1420 }
1421 }
1422
1423 static const char *
1424 get_ppc64_dynamic_type (type)
1425 unsigned long type;
1426 {
1427 switch (type)
1428 {
1429 case DT_PPC64_GLINK: return "PPC64_GLINK";
1430 case DT_PPC64_OPD: return "PPC64_OPD";
1431 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1432 default:
1433 return NULL;
1434 }
1435 }
1436
1437 static const char *
1438 get_parisc_dynamic_type (type)
1439 unsigned long type;
1440 {
1441 switch (type)
1442 {
1443 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1444 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1445 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1446 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1447 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1448 case DT_HP_PREINIT: return "HP_PREINIT";
1449 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1450 case DT_HP_NEEDED: return "HP_NEEDED";
1451 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1452 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1453 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1454 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1455 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1456 default:
1457 return NULL;
1458 }
1459 }
1460
1461 static const char *
1462 get_dynamic_type (type)
1463 unsigned long type;
1464 {
1465 static char buff[32];
1466
1467 switch (type)
1468 {
1469 case DT_NULL: return "NULL";
1470 case DT_NEEDED: return "NEEDED";
1471 case DT_PLTRELSZ: return "PLTRELSZ";
1472 case DT_PLTGOT: return "PLTGOT";
1473 case DT_HASH: return "HASH";
1474 case DT_STRTAB: return "STRTAB";
1475 case DT_SYMTAB: return "SYMTAB";
1476 case DT_RELA: return "RELA";
1477 case DT_RELASZ: return "RELASZ";
1478 case DT_RELAENT: return "RELAENT";
1479 case DT_STRSZ: return "STRSZ";
1480 case DT_SYMENT: return "SYMENT";
1481 case DT_INIT: return "INIT";
1482 case DT_FINI: return "FINI";
1483 case DT_SONAME: return "SONAME";
1484 case DT_RPATH: return "RPATH";
1485 case DT_SYMBOLIC: return "SYMBOLIC";
1486 case DT_REL: return "REL";
1487 case DT_RELSZ: return "RELSZ";
1488 case DT_RELENT: return "RELENT";
1489 case DT_PLTREL: return "PLTREL";
1490 case DT_DEBUG: return "DEBUG";
1491 case DT_TEXTREL: return "TEXTREL";
1492 case DT_JMPREL: return "JMPREL";
1493 case DT_BIND_NOW: return "BIND_NOW";
1494 case DT_INIT_ARRAY: return "INIT_ARRAY";
1495 case DT_FINI_ARRAY: return "FINI_ARRAY";
1496 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1497 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1498 case DT_RUNPATH: return "RUNPATH";
1499 case DT_FLAGS: return "FLAGS";
1500
1501 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1502 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1503
1504 case DT_CHECKSUM: return "CHECKSUM";
1505 case DT_PLTPADSZ: return "PLTPADSZ";
1506 case DT_MOVEENT: return "MOVEENT";
1507 case DT_MOVESZ: return "MOVESZ";
1508 case DT_FEATURE: return "FEATURE";
1509 case DT_POSFLAG_1: return "POSFLAG_1";
1510 case DT_SYMINSZ: return "SYMINSZ";
1511 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1512
1513 case DT_ADDRRNGLO: return "ADDRRNGLO";
1514 case DT_CONFIG: return "CONFIG";
1515 case DT_DEPAUDIT: return "DEPAUDIT";
1516 case DT_AUDIT: return "AUDIT";
1517 case DT_PLTPAD: return "PLTPAD";
1518 case DT_MOVETAB: return "MOVETAB";
1519 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1520
1521 case DT_VERSYM: return "VERSYM";
1522
1523 case DT_RELACOUNT: return "RELACOUNT";
1524 case DT_RELCOUNT: return "RELCOUNT";
1525 case DT_FLAGS_1: return "FLAGS_1";
1526 case DT_VERDEF: return "VERDEF";
1527 case DT_VERDEFNUM: return "VERDEFNUM";
1528 case DT_VERNEED: return "VERNEED";
1529 case DT_VERNEEDNUM: return "VERNEEDNUM";
1530
1531 case DT_AUXILIARY: return "AUXILIARY";
1532 case DT_USED: return "USED";
1533 case DT_FILTER: return "FILTER";
1534
1535 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1536 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1537 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1538 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1539 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1540
1541 default:
1542 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1543 {
1544 const char *result;
1545
1546 switch (elf_header.e_machine)
1547 {
1548 case EM_MIPS:
1549 case EM_MIPS_RS3_LE:
1550 result = get_mips_dynamic_type (type);
1551 break;
1552 case EM_SPARCV9:
1553 result = get_sparc64_dynamic_type (type);
1554 break;
1555 case EM_PPC64:
1556 result = get_ppc64_dynamic_type (type);
1557 break;
1558 default:
1559 result = NULL;
1560 break;
1561 }
1562
1563 if (result != NULL)
1564 return result;
1565
1566 sprintf (buff, _("Processor Specific: %lx"), type);
1567 }
1568 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1569 {
1570 const char *result;
1571
1572 switch (elf_header.e_machine)
1573 {
1574 case EM_PARISC:
1575 result = get_parisc_dynamic_type (type);
1576 break;
1577 default:
1578 result = NULL;
1579 break;
1580 }
1581
1582 if (result != NULL)
1583 return result;
1584
1585 sprintf (buff, _("Operating System specific: %lx"), type);
1586 }
1587 else
1588 sprintf (buff, _("<unknown>: %lx"), type);
1589
1590 return buff;
1591 }
1592 }
1593
1594 static char *
1595 get_file_type (e_type)
1596 unsigned e_type;
1597 {
1598 static char buff[32];
1599
1600 switch (e_type)
1601 {
1602 case ET_NONE: return _("NONE (None)");
1603 case ET_REL: return _("REL (Relocatable file)");
1604 case ET_EXEC: return _("EXEC (Executable file)");
1605 case ET_DYN: return _("DYN (Shared object file)");
1606 case ET_CORE: return _("CORE (Core file)");
1607
1608 default:
1609 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1610 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1611 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1612 sprintf (buff, _("OS Specific: (%x)"), e_type);
1613 else
1614 sprintf (buff, _("<unknown>: %x"), e_type);
1615 return buff;
1616 }
1617 }
1618
1619 static char *
1620 get_machine_name (e_machine)
1621 unsigned e_machine;
1622 {
1623 static char buff[64]; /* XXX */
1624
1625 switch (e_machine)
1626 {
1627 case EM_NONE: return _("None");
1628 case EM_M32: return "WE32100";
1629 case EM_SPARC: return "Sparc";
1630 case EM_386: return "Intel 80386";
1631 case EM_68K: return "MC68000";
1632 case EM_88K: return "MC88000";
1633 case EM_486: return "Intel 80486";
1634 case EM_860: return "Intel 80860";
1635 case EM_MIPS: return "MIPS R3000";
1636 case EM_S370: return "IBM System/370";
1637 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1638 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1639 case EM_PARISC: return "HPPA";
1640 case EM_PPC_OLD: return "Power PC (old)";
1641 case EM_SPARC32PLUS: return "Sparc v8+" ;
1642 case EM_960: return "Intel 90860";
1643 case EM_PPC: return "PowerPC";
1644 case EM_PPC64: return "PowerPC64";
1645 case EM_V800: return "NEC V800";
1646 case EM_FR20: return "Fujitsu FR20";
1647 case EM_RH32: return "TRW RH32";
1648 case EM_MCORE: return "MCORE";
1649 case EM_ARM: return "ARM";
1650 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1651 case EM_SH: return "Hitachi SH";
1652 case EM_SPARCV9: return "Sparc v9";
1653 case EM_TRICORE: return "Siemens Tricore";
1654 case EM_ARC: return "ARC";
1655 case EM_H8_300: return "Hitachi H8/300";
1656 case EM_H8_300H: return "Hitachi H8/300H";
1657 case EM_H8S: return "Hitachi H8S";
1658 case EM_H8_500: return "Hitachi H8/500";
1659 case EM_IA_64: return "Intel IA-64";
1660 case EM_MIPS_X: return "Stanford MIPS-X";
1661 case EM_COLDFIRE: return "Motorola Coldfire";
1662 case EM_68HC12: return "Motorola M68HC12";
1663 case EM_ALPHA: return "Alpha";
1664 case EM_CYGNUS_D10V:
1665 case EM_D10V: return "d10v";
1666 case EM_CYGNUS_D30V:
1667 case EM_D30V: return "d30v";
1668 case EM_CYGNUS_M32R:
1669 case EM_M32R: return "Mitsubishi M32r";
1670 case EM_CYGNUS_V850:
1671 case EM_V850: return "NEC v850";
1672 case EM_CYGNUS_MN10300:
1673 case EM_MN10300: return "mn10300";
1674 case EM_CYGNUS_MN10200:
1675 case EM_MN10200: return "mn10200";
1676 case EM_CYGNUS_FR30:
1677 case EM_FR30: return "Fujitsu FR30";
1678 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1679 case EM_PJ_OLD:
1680 case EM_PJ: return "picoJava";
1681 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1682 case EM_PCP: return "Siemens PCP";
1683 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1684 case EM_NDR1: return "Denso NDR1 microprocesspr";
1685 case EM_STARCORE: return "Motorola Star*Core processor";
1686 case EM_ME16: return "Toyota ME16 processor";
1687 case EM_ST100: return "STMicroelectronics ST100 processor";
1688 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1689 case EM_FX66: return "Siemens FX66 microcontroller";
1690 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1691 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1692 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1693 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1694 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1695 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1696 case EM_SVX: return "Silicon Graphics SVx";
1697 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1698 case EM_VAX: return "Digital VAX";
1699 case EM_AVR_OLD:
1700 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1701 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1702 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1703 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1704 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1705 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1706 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1707 case EM_PRISM: return "SiTera Prism";
1708 case EM_X86_64: return "Advanced Micro Devices X86-64";
1709 case EM_S390_OLD:
1710 case EM_S390: return "IBM S/390";
1711 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1712 case EM_OPENRISC:
1713 case EM_OR32: return "OpenRISC";
1714 case EM_DLX: return "OpenDLX";
1715 case EM_IP2K_OLD:
1716 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1717 default:
1718 sprintf (buff, _("<unknown>: %x"), e_machine);
1719 return buff;
1720 }
1721 }
1722
1723 static void
1724 decode_ARM_machine_flags (e_flags, buf)
1725 unsigned e_flags;
1726 char buf[];
1727 {
1728 unsigned eabi;
1729 int unknown = 0;
1730
1731 eabi = EF_ARM_EABI_VERSION (e_flags);
1732 e_flags &= ~ EF_ARM_EABIMASK;
1733
1734 /* Handle "generic" ARM flags. */
1735 if (e_flags & EF_ARM_RELEXEC)
1736 {
1737 strcat (buf, ", relocatable executable");
1738 e_flags &= ~ EF_ARM_RELEXEC;
1739 }
1740
1741 if (e_flags & EF_ARM_HASENTRY)
1742 {
1743 strcat (buf, ", has entry point");
1744 e_flags &= ~ EF_ARM_HASENTRY;
1745 }
1746
1747 /* Now handle EABI specific flags. */
1748 switch (eabi)
1749 {
1750 default:
1751 strcat (buf, ", <unrecognized EABI>");
1752 if (e_flags)
1753 unknown = 1;
1754 break;
1755
1756 case EF_ARM_EABI_VER1:
1757 strcat (buf, ", Version1 EABI");
1758 while (e_flags)
1759 {
1760 unsigned flag;
1761
1762 /* Process flags one bit at a time. */
1763 flag = e_flags & - e_flags;
1764 e_flags &= ~ flag;
1765
1766 switch (flag)
1767 {
1768 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1769 strcat (buf, ", sorted symbol tables");
1770 break;
1771
1772 default:
1773 unknown = 1;
1774 break;
1775 }
1776 }
1777 break;
1778
1779 case EF_ARM_EABI_VER2:
1780 strcat (buf, ", Version2 EABI");
1781 while (e_flags)
1782 {
1783 unsigned flag;
1784
1785 /* Process flags one bit at a time. */
1786 flag = e_flags & - e_flags;
1787 e_flags &= ~ flag;
1788
1789 switch (flag)
1790 {
1791 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1792 strcat (buf, ", sorted symbol tables");
1793 break;
1794
1795 case EF_ARM_DYNSYMSUSESEGIDX:
1796 strcat (buf, ", dynamic symbols use segment index");
1797 break;
1798
1799 case EF_ARM_MAPSYMSFIRST:
1800 strcat (buf, ", mapping symbols precede others");
1801 break;
1802
1803 default:
1804 unknown = 1;
1805 break;
1806 }
1807 }
1808 break;
1809
1810 case EF_ARM_EABI_UNKNOWN:
1811 strcat (buf, ", GNU EABI");
1812 while (e_flags)
1813 {
1814 unsigned flag;
1815
1816 /* Process flags one bit at a time. */
1817 flag = e_flags & - e_flags;
1818 e_flags &= ~ flag;
1819
1820 switch (flag)
1821 {
1822 case EF_ARM_INTERWORK:
1823 strcat (buf, ", interworking enabled");
1824 break;
1825
1826 case EF_ARM_APCS_26:
1827 strcat (buf, ", uses APCS/26");
1828 break;
1829
1830 case EF_ARM_APCS_FLOAT:
1831 strcat (buf, ", uses APCS/float");
1832 break;
1833
1834 case EF_ARM_PIC:
1835 strcat (buf, ", position independent");
1836 break;
1837
1838 case EF_ARM_ALIGN8:
1839 strcat (buf, ", 8 bit structure alignment");
1840 break;
1841
1842 case EF_ARM_NEW_ABI:
1843 strcat (buf, ", uses new ABI");
1844 break;
1845
1846 case EF_ARM_OLD_ABI:
1847 strcat (buf, ", uses old ABI");
1848 break;
1849
1850 case EF_ARM_SOFT_FLOAT:
1851 strcat (buf, ", software FP");
1852 break;
1853
1854 default:
1855 unknown = 1;
1856 break;
1857 }
1858 }
1859 }
1860
1861 if (unknown)
1862 strcat (buf,", <unknown>");
1863 }
1864
1865 static char *
1866 get_machine_flags (e_flags, e_machine)
1867 unsigned e_flags;
1868 unsigned e_machine;
1869 {
1870 static char buf[1024];
1871
1872 buf[0] = '\0';
1873
1874 if (e_flags)
1875 {
1876 switch (e_machine)
1877 {
1878 default:
1879 break;
1880
1881 case EM_ARM:
1882 decode_ARM_machine_flags (e_flags, buf);
1883 break;
1884
1885 case EM_68K:
1886 if (e_flags & EF_CPU32)
1887 strcat (buf, ", cpu32");
1888 if (e_flags & EF_M68000)
1889 strcat (buf, ", m68000");
1890 break;
1891
1892 case EM_PPC:
1893 if (e_flags & EF_PPC_EMB)
1894 strcat (buf, ", emb");
1895
1896 if (e_flags & EF_PPC_RELOCATABLE)
1897 strcat (buf, ", relocatable");
1898
1899 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1900 strcat (buf, ", relocatable-lib");
1901 break;
1902
1903 case EM_V850:
1904 case EM_CYGNUS_V850:
1905 switch (e_flags & EF_V850_ARCH)
1906 {
1907 case E_V850E_ARCH:
1908 strcat (buf, ", v850e");
1909 break;
1910 case E_V850_ARCH:
1911 strcat (buf, ", v850");
1912 break;
1913 default:
1914 strcat (buf, ", unknown v850 architecture variant");
1915 break;
1916 }
1917 break;
1918
1919 case EM_M32R:
1920 case EM_CYGNUS_M32R:
1921 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1922 strcat (buf, ", m32r");
1923
1924 break;
1925
1926 case EM_MIPS:
1927 case EM_MIPS_RS3_LE:
1928 if (e_flags & EF_MIPS_NOREORDER)
1929 strcat (buf, ", noreorder");
1930
1931 if (e_flags & EF_MIPS_PIC)
1932 strcat (buf, ", pic");
1933
1934 if (e_flags & EF_MIPS_CPIC)
1935 strcat (buf, ", cpic");
1936
1937 if (e_flags & EF_MIPS_UCODE)
1938 strcat (buf, ", ugen_reserved");
1939
1940 if (e_flags & EF_MIPS_ABI2)
1941 strcat (buf, ", abi2");
1942
1943 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1944 strcat (buf, ", odk first");
1945
1946 if (e_flags & EF_MIPS_32BITMODE)
1947 strcat (buf, ", 32bitmode");
1948
1949 switch ((e_flags & EF_MIPS_MACH))
1950 {
1951 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1952 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1953 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1954 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1955 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
1956 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1957 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
1958 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
1959 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1960 case 0:
1961 /* We simply ignore the field in this case to avoid confusion:
1962 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1963 extension. */
1964 break;
1965 default: strcat (buf, ", unknown CPU"); break;
1966 }
1967
1968 switch ((e_flags & EF_MIPS_ABI))
1969 {
1970 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1971 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1972 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1973 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1974 case 0:
1975 /* We simply ignore the field in this case to avoid confusion:
1976 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1977 This means it is likely to be an o32 file, but not for
1978 sure. */
1979 break;
1980 default: strcat (buf, ", unknown ABI"); break;
1981 }
1982
1983 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1984 strcat (buf, ", mdmx");
1985
1986 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1987 strcat (buf, ", mips16");
1988
1989 switch ((e_flags & EF_MIPS_ARCH))
1990 {
1991 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1992 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1993 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1994 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1995 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1996 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1997 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
1998 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1999 default: strcat (buf, ", unknown ISA"); break;
2000 }
2001
2002 break;
2003
2004 case EM_SPARCV9:
2005 if (e_flags & EF_SPARC_32PLUS)
2006 strcat (buf, ", v8+");
2007
2008 if (e_flags & EF_SPARC_SUN_US1)
2009 strcat (buf, ", ultrasparcI");
2010
2011 if (e_flags & EF_SPARC_SUN_US3)
2012 strcat (buf, ", ultrasparcIII");
2013
2014 if (e_flags & EF_SPARC_HAL_R1)
2015 strcat (buf, ", halr1");
2016
2017 if (e_flags & EF_SPARC_LEDATA)
2018 strcat (buf, ", ledata");
2019
2020 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2021 strcat (buf, ", tso");
2022
2023 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2024 strcat (buf, ", pso");
2025
2026 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2027 strcat (buf, ", rmo");
2028 break;
2029
2030 case EM_PARISC:
2031 switch (e_flags & EF_PARISC_ARCH)
2032 {
2033 case EFA_PARISC_1_0:
2034 strcpy (buf, ", PA-RISC 1.0");
2035 break;
2036 case EFA_PARISC_1_1:
2037 strcpy (buf, ", PA-RISC 1.1");
2038 break;
2039 case EFA_PARISC_2_0:
2040 strcpy (buf, ", PA-RISC 2.0");
2041 break;
2042 default:
2043 break;
2044 }
2045 if (e_flags & EF_PARISC_TRAPNIL)
2046 strcat (buf, ", trapnil");
2047 if (e_flags & EF_PARISC_EXT)
2048 strcat (buf, ", ext");
2049 if (e_flags & EF_PARISC_LSB)
2050 strcat (buf, ", lsb");
2051 if (e_flags & EF_PARISC_WIDE)
2052 strcat (buf, ", wide");
2053 if (e_flags & EF_PARISC_NO_KABP)
2054 strcat (buf, ", no kabp");
2055 if (e_flags & EF_PARISC_LAZYSWAP)
2056 strcat (buf, ", lazyswap");
2057 break;
2058
2059 case EM_PJ:
2060 case EM_PJ_OLD:
2061 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2062 strcat (buf, ", new calling convention");
2063
2064 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2065 strcat (buf, ", gnu calling convention");
2066 break;
2067
2068 case EM_IA_64:
2069 if ((e_flags & EF_IA_64_ABI64))
2070 strcat (buf, ", 64-bit");
2071 else
2072 strcat (buf, ", 32-bit");
2073 if ((e_flags & EF_IA_64_REDUCEDFP))
2074 strcat (buf, ", reduced fp model");
2075 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2076 strcat (buf, ", no function descriptors, constant gp");
2077 else if ((e_flags & EF_IA_64_CONS_GP))
2078 strcat (buf, ", constant gp");
2079 if ((e_flags & EF_IA_64_ABSOLUTE))
2080 strcat (buf, ", absolute");
2081 break;
2082
2083 case EM_VAX:
2084 if ((e_flags & EF_VAX_NONPIC))
2085 strcat (buf, ", non-PIC");
2086 if ((e_flags & EF_VAX_DFLOAT))
2087 strcat (buf, ", D-Float");
2088 if ((e_flags & EF_VAX_GFLOAT))
2089 strcat (buf, ", G-Float");
2090 break;
2091 }
2092 }
2093
2094 return buf;
2095 }
2096
2097 static const char *
2098 get_mips_segment_type (type)
2099 unsigned long type;
2100 {
2101 switch (type)
2102 {
2103 case PT_MIPS_REGINFO:
2104 return "REGINFO";
2105 case PT_MIPS_RTPROC:
2106 return "RTPROC";
2107 case PT_MIPS_OPTIONS:
2108 return "OPTIONS";
2109 default:
2110 break;
2111 }
2112
2113 return NULL;
2114 }
2115
2116 static const char *
2117 get_parisc_segment_type (type)
2118 unsigned long type;
2119 {
2120 switch (type)
2121 {
2122 case PT_HP_TLS: return "HP_TLS";
2123 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2124 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2125 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2126 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2127 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2128 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2129 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2130 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2131 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2132 case PT_HP_PARALLEL: return "HP_PARALLEL";
2133 case PT_HP_FASTBIND: return "HP_FASTBIND";
2134 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2135 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2136 default:
2137 break;
2138 }
2139
2140 return NULL;
2141 }
2142
2143 static const char *
2144 get_ia64_segment_type (type)
2145 unsigned long type;
2146 {
2147 switch (type)
2148 {
2149 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2150 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2151 case PT_HP_TLS: return "HP_TLS";
2152 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2153 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2154 case PT_IA_64_HP_STACK: return "HP_STACK";
2155 default:
2156 break;
2157 }
2158
2159 return NULL;
2160 }
2161
2162 static const char *
2163 get_segment_type (p_type)
2164 unsigned long p_type;
2165 {
2166 static char buff[32];
2167
2168 switch (p_type)
2169 {
2170 case PT_NULL: return "NULL";
2171 case PT_LOAD: return "LOAD";
2172 case PT_DYNAMIC: return "DYNAMIC";
2173 case PT_INTERP: return "INTERP";
2174 case PT_NOTE: return "NOTE";
2175 case PT_SHLIB: return "SHLIB";
2176 case PT_PHDR: return "PHDR";
2177 case PT_TLS: return "TLS";
2178
2179 case PT_GNU_EH_FRAME:
2180 return "GNU_EH_FRAME";
2181
2182 default:
2183 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2184 {
2185 const char *result;
2186
2187 switch (elf_header.e_machine)
2188 {
2189 case EM_MIPS:
2190 case EM_MIPS_RS3_LE:
2191 result = get_mips_segment_type (p_type);
2192 break;
2193 case EM_PARISC:
2194 result = get_parisc_segment_type (p_type);
2195 break;
2196 case EM_IA_64:
2197 result = get_ia64_segment_type (p_type);
2198 break;
2199 default:
2200 result = NULL;
2201 break;
2202 }
2203
2204 if (result != NULL)
2205 return result;
2206
2207 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2208 }
2209 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2210 {
2211 const char *result;
2212
2213 switch (elf_header.e_machine)
2214 {
2215 case EM_PARISC:
2216 result = get_parisc_segment_type (p_type);
2217 break;
2218 case EM_IA_64:
2219 result = get_ia64_segment_type (p_type);
2220 break;
2221 default:
2222 result = NULL;
2223 break;
2224 }
2225
2226 if (result != NULL)
2227 return result;
2228
2229 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2230 }
2231 else
2232 sprintf (buff, _("<unknown>: %lx"), p_type);
2233
2234 return buff;
2235 }
2236 }
2237
2238 static const char *
2239 get_mips_section_type_name (sh_type)
2240 unsigned int sh_type;
2241 {
2242 switch (sh_type)
2243 {
2244 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2245 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2246 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2247 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2248 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2249 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2250 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2251 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2252 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2253 case SHT_MIPS_RELD: return "MIPS_RELD";
2254 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2255 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2256 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2257 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2258 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2259 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2260 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2261 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2262 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2263 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2264 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2265 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2266 case SHT_MIPS_LINE: return "MIPS_LINE";
2267 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2268 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2269 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2270 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2271 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2272 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2273 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2274 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2275 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2276 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2277 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2278 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2279 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2280 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2281 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2282 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2283 default:
2284 break;
2285 }
2286 return NULL;
2287 }
2288
2289 static const char *
2290 get_parisc_section_type_name (sh_type)
2291 unsigned int sh_type;
2292 {
2293 switch (sh_type)
2294 {
2295 case SHT_PARISC_EXT: return "PARISC_EXT";
2296 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2297 case SHT_PARISC_DOC: return "PARISC_DOC";
2298 default:
2299 break;
2300 }
2301 return NULL;
2302 }
2303
2304 static const char *
2305 get_ia64_section_type_name (sh_type)
2306 unsigned int sh_type;
2307 {
2308 switch (sh_type)
2309 {
2310 case SHT_IA_64_EXT: return "IA_64_EXT";
2311 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2312 default:
2313 break;
2314 }
2315 return NULL;
2316 }
2317
2318 static const char *
2319 get_section_type_name (sh_type)
2320 unsigned int sh_type;
2321 {
2322 static char buff[32];
2323
2324 switch (sh_type)
2325 {
2326 case SHT_NULL: return "NULL";
2327 case SHT_PROGBITS: return "PROGBITS";
2328 case SHT_SYMTAB: return "SYMTAB";
2329 case SHT_STRTAB: return "STRTAB";
2330 case SHT_RELA: return "RELA";
2331 case SHT_HASH: return "HASH";
2332 case SHT_DYNAMIC: return "DYNAMIC";
2333 case SHT_NOTE: return "NOTE";
2334 case SHT_NOBITS: return "NOBITS";
2335 case SHT_REL: return "REL";
2336 case SHT_SHLIB: return "SHLIB";
2337 case SHT_DYNSYM: return "DYNSYM";
2338 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2339 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2340 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2341 case SHT_GROUP: return "GROUP";
2342 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2343 case SHT_GNU_verdef: return "VERDEF";
2344 case SHT_GNU_verneed: return "VERNEED";
2345 case SHT_GNU_versym: return "VERSYM";
2346 case 0x6ffffff0: return "VERSYM";
2347 case 0x6ffffffc: return "VERDEF";
2348 case 0x7ffffffd: return "AUXILIARY";
2349 case 0x7fffffff: return "FILTER";
2350 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2351
2352 default:
2353 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2354 {
2355 const char *result;
2356
2357 switch (elf_header.e_machine)
2358 {
2359 case EM_MIPS:
2360 case EM_MIPS_RS3_LE:
2361 result = get_mips_section_type_name (sh_type);
2362 break;
2363 case EM_PARISC:
2364 result = get_parisc_section_type_name (sh_type);
2365 break;
2366 case EM_IA_64:
2367 result = get_ia64_section_type_name (sh_type);
2368 break;
2369 default:
2370 result = NULL;
2371 break;
2372 }
2373
2374 if (result != NULL)
2375 return result;
2376
2377 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2378 }
2379 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2380 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2381 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2382 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2383 else
2384 sprintf (buff, _("<unknown>: %x"), sh_type);
2385
2386 return buff;
2387 }
2388 }
2389
2390 #define OPTION_DEBUG_DUMP 512
2391
2392 struct option options[] =
2393 {
2394 {"all", no_argument, 0, 'a'},
2395 {"file-header", no_argument, 0, 'h'},
2396 {"program-headers", no_argument, 0, 'l'},
2397 {"headers", no_argument, 0, 'e'},
2398 {"histogram", no_argument, 0, 'I'},
2399 {"segments", no_argument, 0, 'l'},
2400 {"sections", no_argument, 0, 'S'},
2401 {"section-headers", no_argument, 0, 'S'},
2402 {"symbols", no_argument, 0, 's'},
2403 {"syms", no_argument, 0, 's'},
2404 {"relocs", no_argument, 0, 'r'},
2405 {"notes", no_argument, 0, 'n'},
2406 {"dynamic", no_argument, 0, 'd'},
2407 {"arch-specific", no_argument, 0, 'A'},
2408 {"version-info", no_argument, 0, 'V'},
2409 {"use-dynamic", no_argument, 0, 'D'},
2410 {"hex-dump", required_argument, 0, 'x'},
2411 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2412 {"unwind", no_argument, 0, 'u'},
2413 #ifdef SUPPORT_DISASSEMBLY
2414 {"instruction-dump", required_argument, 0, 'i'},
2415 #endif
2416
2417 {"version", no_argument, 0, 'v'},
2418 {"wide", no_argument, 0, 'W'},
2419 {"help", no_argument, 0, 'H'},
2420 {0, no_argument, 0, 0}
2421 };
2422
2423 static void
2424 usage ()
2425 {
2426 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2427 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2428 fprintf (stdout, _(" Options are:\n\
2429 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2430 -h --file-header Display the ELF file header\n\
2431 -l --program-headers Display the program headers\n\
2432 --segments An alias for --program-headers\n\
2433 -S --section-headers Display the sections' header\n\
2434 --sections An alias for --section-headers\n\
2435 -e --headers Equivalent to: -h -l -S\n\
2436 -s --syms Display the symbol table\n\
2437 --symbols An alias for --syms\n\
2438 -n --notes Display the core notes (if present)\n\
2439 -r --relocs Display the relocations (if present)\n\
2440 -u --unwind Display the unwind info (if present)\n\
2441 -d --dynamic Display the dynamic segment (if present)\n\
2442 -V --version-info Display the version sections (if present)\n\
2443 -A --arch-specific Display architecture specific information (if any).\n\
2444 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2445 -x --hex-dump=<number> Dump the contents of section <number>\n\
2446 -w[liaprmfFso] or\n\
2447 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2448 Display the contents of DWARF2 debug sections\n"));
2449 #ifdef SUPPORT_DISASSEMBLY
2450 fprintf (stdout, _("\
2451 -i --instruction-dump=<number>\n\
2452 Disassemble the contents of section <number>\n"));
2453 #endif
2454 fprintf (stdout, _("\
2455 -I --histogram Display histogram of bucket list lengths\n\
2456 -W --wide Allow output width to exceed 80 characters\n\
2457 -H --help Display this information\n\
2458 -v --version Display the version number of readelf\n"));
2459 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2460
2461 exit (0);
2462 }
2463
2464 static void
2465 request_dump (section, type)
2466 unsigned int section;
2467 int type;
2468 {
2469 if (section >= num_dump_sects)
2470 {
2471 char *new_dump_sects;
2472
2473 new_dump_sects = (char *) calloc (section + 1, 1);
2474
2475 if (new_dump_sects == NULL)
2476 error (_("Out of memory allocating dump request table."));
2477 else
2478 {
2479 /* Copy current flag settings. */
2480 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2481
2482 free (dump_sects);
2483
2484 dump_sects = new_dump_sects;
2485 num_dump_sects = section + 1;
2486 }
2487 }
2488
2489 if (dump_sects)
2490 dump_sects[section] |= type;
2491
2492 return;
2493 }
2494
2495 static void
2496 parse_args (argc, argv)
2497 int argc;
2498 char **argv;
2499 {
2500 int c;
2501
2502 if (argc < 2)
2503 usage ();
2504
2505 while ((c = getopt_long
2506 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2507 {
2508 char *cp;
2509 int section;
2510
2511 switch (c)
2512 {
2513 case 0:
2514 /* Long options. */
2515 break;
2516 case 'H':
2517 usage ();
2518 break;
2519
2520 case 'a':
2521 do_syms++;
2522 do_reloc++;
2523 do_unwind++;
2524 do_dynamic++;
2525 do_header++;
2526 do_sections++;
2527 do_segments++;
2528 do_version++;
2529 do_histogram++;
2530 do_arch++;
2531 do_notes++;
2532 break;
2533 case 'e':
2534 do_header++;
2535 do_sections++;
2536 do_segments++;
2537 break;
2538 case 'A':
2539 do_arch++;
2540 break;
2541 case 'D':
2542 do_using_dynamic++;
2543 break;
2544 case 'r':
2545 do_reloc++;
2546 break;
2547 case 'u':
2548 do_unwind++;
2549 break;
2550 case 'h':
2551 do_header++;
2552 break;
2553 case 'l':
2554 do_segments++;
2555 break;
2556 case 's':
2557 do_syms++;
2558 break;
2559 case 'S':
2560 do_sections++;
2561 break;
2562 case 'd':
2563 do_dynamic++;
2564 break;
2565 case 'I':
2566 do_histogram++;
2567 break;
2568 case 'n':
2569 do_notes++;
2570 break;
2571 case 'x':
2572 do_dump++;
2573 section = strtoul (optarg, & cp, 0);
2574 if (! *cp && section >= 0)
2575 {
2576 request_dump (section, HEX_DUMP);
2577 break;
2578 }
2579 goto oops;
2580 case 'w':
2581 do_dump++;
2582 if (optarg == 0)
2583 do_debugging = 1;
2584 else
2585 {
2586 unsigned int index = 0;
2587
2588 do_debugging = 0;
2589
2590 while (optarg[index])
2591 switch (optarg[index++])
2592 {
2593 case 'i':
2594 case 'I':
2595 do_debug_info = 1;
2596 break;
2597
2598 case 'a':
2599 case 'A':
2600 do_debug_abbrevs = 1;
2601 break;
2602
2603 case 'l':
2604 case 'L':
2605 do_debug_lines = 1;
2606 break;
2607
2608 case 'p':
2609 case 'P':
2610 do_debug_pubnames = 1;
2611 break;
2612
2613 case 'r':
2614 case 'R':
2615 do_debug_aranges = 1;
2616 break;
2617
2618 case 'F':
2619 do_debug_frames_interp = 1;
2620 case 'f':
2621 do_debug_frames = 1;
2622 break;
2623
2624 case 'm':
2625 case 'M':
2626 do_debug_macinfo = 1;
2627 break;
2628
2629 case 's':
2630 case 'S':
2631 do_debug_str = 1;
2632 break;
2633
2634 case 'o':
2635 case 'O':
2636 do_debug_loc = 1;
2637 break;
2638
2639 default:
2640 warn (_("Unrecognized debug option '%s'\n"), optarg);
2641 break;
2642 }
2643 }
2644 break;
2645 case OPTION_DEBUG_DUMP:
2646 do_dump++;
2647 if (optarg == 0)
2648 do_debugging = 1;
2649 else
2650 {
2651 static const char *debug_dump_opt[]
2652 = { "line", "info", "abbrev", "pubnames", "ranges",
2653 "macro", "frames", "frames-interp", "str", "loc", NULL };
2654 unsigned int index;
2655 const char *p;
2656
2657 do_debugging = 0;
2658
2659 p = optarg;
2660 while (*p)
2661 {
2662 for (index = 0; debug_dump_opt[index]; index++)
2663 {
2664 size_t len = strlen (debug_dump_opt[index]);
2665
2666 if (strncmp (p, debug_dump_opt[index], len) == 0
2667 && (p[len] == ',' || p[len] == '\0'))
2668 {
2669 switch (p[0])
2670 {
2671 case 'i':
2672 do_debug_info = 1;
2673 break;
2674
2675 case 'a':
2676 do_debug_abbrevs = 1;
2677 break;
2678
2679 case 'l':
2680 if (p[1] == 'i')
2681 do_debug_lines = 1;
2682 else
2683 do_debug_loc = 1;
2684 break;
2685
2686 case 'p':
2687 do_debug_pubnames = 1;
2688 break;
2689
2690 case 'r':
2691 do_debug_aranges = 1;
2692 break;
2693
2694 case 'f':
2695 if (len > 6)
2696 do_debug_frames_interp = 1;
2697 do_debug_frames = 1;
2698 break;
2699
2700 case 'm':
2701 do_debug_macinfo = 1;
2702 break;
2703
2704 case 's':
2705 do_debug_str = 1;
2706 break;
2707 }
2708
2709 p += len;
2710 break;
2711 }
2712 }
2713
2714 if (debug_dump_opt[index] == NULL)
2715 {
2716 warn (_("Unrecognized debug option '%s'\n"), p);
2717 p = strchr (p, ',');
2718 if (p == NULL)
2719 break;
2720 }
2721
2722 if (*p == ',')
2723 p++;
2724 }
2725 }
2726 break;
2727 #ifdef SUPPORT_DISASSEMBLY
2728 case 'i':
2729 do_dump++;
2730 section = strtoul (optarg, & cp, 0);
2731 if (! *cp && section >= 0)
2732 {
2733 request_dump (section, DISASS_DUMP);
2734 break;
2735 }
2736 goto oops;
2737 #endif
2738 case 'v':
2739 print_version (program_name);
2740 break;
2741 case 'V':
2742 do_version++;
2743 break;
2744 case 'W':
2745 do_wide++;
2746 break;
2747 default:
2748 oops:
2749 /* xgettext:c-format */
2750 error (_("Invalid option '-%c'\n"), c);
2751 /* Drop through. */
2752 case '?':
2753 usage ();
2754 }
2755 }
2756
2757 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2758 && !do_segments && !do_header && !do_dump && !do_version
2759 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2760 usage ();
2761 else if (argc < 3)
2762 {
2763 warn (_("Nothing to do.\n"));
2764 usage();
2765 }
2766 }
2767
2768 static const char *
2769 get_elf_class (elf_class)
2770 unsigned int elf_class;
2771 {
2772 static char buff[32];
2773
2774 switch (elf_class)
2775 {
2776 case ELFCLASSNONE: return _("none");
2777 case ELFCLASS32: return "ELF32";
2778 case ELFCLASS64: return "ELF64";
2779 default:
2780 sprintf (buff, _("<unknown: %x>"), elf_class);
2781 return buff;
2782 }
2783 }
2784
2785 static const char *
2786 get_data_encoding (encoding)
2787 unsigned int encoding;
2788 {
2789 static char buff[32];
2790
2791 switch (encoding)
2792 {
2793 case ELFDATANONE: return _("none");
2794 case ELFDATA2LSB: return _("2's complement, little endian");
2795 case ELFDATA2MSB: return _("2's complement, big endian");
2796 default:
2797 sprintf (buff, _("<unknown: %x>"), encoding);
2798 return buff;
2799 }
2800 }
2801
2802 static const char *
2803 get_osabi_name (osabi)
2804 unsigned int osabi;
2805 {
2806 static char buff[32];
2807
2808 switch (osabi)
2809 {
2810 case ELFOSABI_NONE: return "UNIX - System V";
2811 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2812 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2813 case ELFOSABI_LINUX: return "UNIX - Linux";
2814 case ELFOSABI_HURD: return "GNU/Hurd";
2815 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2816 case ELFOSABI_AIX: return "UNIX - AIX";
2817 case ELFOSABI_IRIX: return "UNIX - IRIX";
2818 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2819 case ELFOSABI_TRU64: return "UNIX - TRU64";
2820 case ELFOSABI_MODESTO: return "Novell - Modesto";
2821 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2822 case ELFOSABI_STANDALONE: return _("Standalone App");
2823 case ELFOSABI_ARM: return "ARM";
2824 default:
2825 sprintf (buff, _("<unknown: %x>"), osabi);
2826 return buff;
2827 }
2828 }
2829
2830 /* Decode the data held in 'elf_header'. */
2831 static int
2832 process_file_header ()
2833 {
2834 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
2835 || elf_header.e_ident[EI_MAG1] != ELFMAG1
2836 || elf_header.e_ident[EI_MAG2] != ELFMAG2
2837 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
2838 {
2839 error
2840 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2841 return 0;
2842 }
2843
2844 if (do_header)
2845 {
2846 int i;
2847
2848 printf (_("ELF Header:\n"));
2849 printf (_(" Magic: "));
2850 for (i = 0; i < EI_NIDENT; i++)
2851 printf ("%2.2x ", elf_header.e_ident[i]);
2852 printf ("\n");
2853 printf (_(" Class: %s\n"),
2854 get_elf_class (elf_header.e_ident[EI_CLASS]));
2855 printf (_(" Data: %s\n"),
2856 get_data_encoding (elf_header.e_ident[EI_DATA]));
2857 printf (_(" Version: %d %s\n"),
2858 elf_header.e_ident[EI_VERSION],
2859 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
2860 ? "(current)"
2861 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2862 ? "<unknown: %lx>"
2863 : "")));
2864 printf (_(" OS/ABI: %s\n"),
2865 get_osabi_name (elf_header.e_ident[EI_OSABI]));
2866 printf (_(" ABI Version: %d\n"),
2867 elf_header.e_ident[EI_ABIVERSION]);
2868 printf (_(" Type: %s\n"),
2869 get_file_type (elf_header.e_type));
2870 printf (_(" Machine: %s\n"),
2871 get_machine_name (elf_header.e_machine));
2872 printf (_(" Version: 0x%lx\n"),
2873 (unsigned long) elf_header.e_version);
2874
2875 printf (_(" Entry point address: "));
2876 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2877 printf (_("\n Start of program headers: "));
2878 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2879 printf (_(" (bytes into file)\n Start of section headers: "));
2880 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2881 printf (_(" (bytes into file)\n"));
2882
2883 printf (_(" Flags: 0x%lx%s\n"),
2884 (unsigned long) elf_header.e_flags,
2885 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2886 printf (_(" Size of this header: %ld (bytes)\n"),
2887 (long) elf_header.e_ehsize);
2888 printf (_(" Size of program headers: %ld (bytes)\n"),
2889 (long) elf_header.e_phentsize);
2890 printf (_(" Number of program headers: %ld\n"),
2891 (long) elf_header.e_phnum);
2892 printf (_(" Size of section headers: %ld (bytes)\n"),
2893 (long) elf_header.e_shentsize);
2894 printf (_(" Number of section headers: %ld"),
2895 (long) elf_header.e_shnum);
2896 if (section_headers != NULL && elf_header.e_shnum == 0)
2897 printf (" (%ld)", (long) section_headers[0].sh_size);
2898 putc ('\n', stdout);
2899 printf (_(" Section header string table index: %ld"),
2900 (long) elf_header.e_shstrndx);
2901 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2902 printf (" (%ld)", (long) section_headers[0].sh_link);
2903 putc ('\n', stdout);
2904 }
2905
2906 if (section_headers != NULL)
2907 {
2908 if (elf_header.e_shnum == 0)
2909 elf_header.e_shnum = section_headers[0].sh_size;
2910 if (elf_header.e_shstrndx == SHN_XINDEX)
2911 elf_header.e_shstrndx = section_headers[0].sh_link;
2912 free (section_headers);
2913 section_headers = NULL;
2914 }
2915
2916 return 1;
2917 }
2918
2919
2920 static int
2921 get_32bit_program_headers (file, program_headers)
2922 FILE *file;
2923 Elf_Internal_Phdr *program_headers;
2924 {
2925 Elf32_External_Phdr *phdrs;
2926 Elf32_External_Phdr *external;
2927 Elf_Internal_Phdr *internal;
2928 unsigned int i;
2929
2930 phdrs = ((Elf32_External_Phdr *)
2931 get_data (NULL, file, elf_header.e_phoff,
2932 elf_header.e_phentsize * elf_header.e_phnum,
2933 _("program headers")));
2934 if (!phdrs)
2935 return 0;
2936
2937 for (i = 0, internal = program_headers, external = phdrs;
2938 i < elf_header.e_phnum;
2939 i++, internal++, external++)
2940 {
2941 internal->p_type = BYTE_GET (external->p_type);
2942 internal->p_offset = BYTE_GET (external->p_offset);
2943 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2944 internal->p_paddr = BYTE_GET (external->p_paddr);
2945 internal->p_filesz = BYTE_GET (external->p_filesz);
2946 internal->p_memsz = BYTE_GET (external->p_memsz);
2947 internal->p_flags = BYTE_GET (external->p_flags);
2948 internal->p_align = BYTE_GET (external->p_align);
2949 }
2950
2951 free (phdrs);
2952
2953 return 1;
2954 }
2955
2956 static int
2957 get_64bit_program_headers (file, program_headers)
2958 FILE *file;
2959 Elf_Internal_Phdr *program_headers;
2960 {
2961 Elf64_External_Phdr *phdrs;
2962 Elf64_External_Phdr *external;
2963 Elf_Internal_Phdr *internal;
2964 unsigned int i;
2965
2966 phdrs = ((Elf64_External_Phdr *)
2967 get_data (NULL, file, elf_header.e_phoff,
2968 elf_header.e_phentsize * elf_header.e_phnum,
2969 _("program headers")));
2970 if (!phdrs)
2971 return 0;
2972
2973 for (i = 0, internal = program_headers, external = phdrs;
2974 i < elf_header.e_phnum;
2975 i++, internal++, external++)
2976 {
2977 internal->p_type = BYTE_GET (external->p_type);
2978 internal->p_flags = BYTE_GET (external->p_flags);
2979 internal->p_offset = BYTE_GET8 (external->p_offset);
2980 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2981 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2982 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2983 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2984 internal->p_align = BYTE_GET8 (external->p_align);
2985 }
2986
2987 free (phdrs);
2988
2989 return 1;
2990 }
2991
2992 /* Returns 1 if the program headers were loaded. */
2993
2994 static int
2995 process_program_headers (file)
2996 FILE *file;
2997 {
2998 Elf_Internal_Phdr *program_headers;
2999 Elf_Internal_Phdr *segment;
3000 unsigned int i;
3001
3002 if (elf_header.e_phnum == 0)
3003 {
3004 if (do_segments)
3005 printf (_("\nThere are no program headers in this file.\n"));
3006 return 0;
3007 }
3008
3009 if (do_segments && !do_header)
3010 {
3011 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3012 printf (_("Entry point "));
3013 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3014 printf (_("\nThere are %d program headers, starting at offset "),
3015 elf_header.e_phnum);
3016 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3017 printf ("\n");
3018 }
3019
3020 program_headers = (Elf_Internal_Phdr *) malloc
3021 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3022
3023 if (program_headers == NULL)
3024 {
3025 error (_("Out of memory\n"));
3026 return 0;
3027 }
3028
3029 if (is_32bit_elf)
3030 i = get_32bit_program_headers (file, program_headers);
3031 else
3032 i = get_64bit_program_headers (file, program_headers);
3033
3034 if (i == 0)
3035 {
3036 free (program_headers);
3037 return 0;
3038 }
3039
3040 if (do_segments)
3041 {
3042 if (elf_header.e_phnum > 1)
3043 printf (_("\nProgram Headers:\n"));
3044 else
3045 printf (_("\nProgram Headers:\n"));
3046
3047 if (is_32bit_elf)
3048 printf
3049 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3050 else if (do_wide)
3051 printf
3052 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3053 else
3054 {
3055 printf
3056 (_(" Type Offset VirtAddr PhysAddr\n"));
3057 printf
3058 (_(" FileSiz MemSiz Flags Align\n"));
3059 }
3060 }
3061
3062 loadaddr = -1;
3063 dynamic_addr = 0;
3064 dynamic_size = 0;
3065
3066 for (i = 0, segment = program_headers;
3067 i < elf_header.e_phnum;
3068 i++, segment++)
3069 {
3070 if (do_segments)
3071 {
3072 printf (" %-14.14s ", get_segment_type (segment->p_type));
3073
3074 if (is_32bit_elf)
3075 {
3076 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3077 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3078 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3079 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3080 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3081 printf ("%c%c%c ",
3082 (segment->p_flags & PF_R ? 'R' : ' '),
3083 (segment->p_flags & PF_W ? 'W' : ' '),
3084 (segment->p_flags & PF_X ? 'E' : ' '));
3085 printf ("%#lx", (unsigned long) segment->p_align);
3086 }
3087 else if (do_wide)
3088 {
3089 if ((unsigned long) segment->p_offset == segment->p_offset)
3090 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3091 else
3092 {
3093 print_vma (segment->p_offset, FULL_HEX);
3094 putchar (' ');
3095 }
3096
3097 print_vma (segment->p_vaddr, FULL_HEX);
3098 putchar (' ');
3099 print_vma (segment->p_paddr, FULL_HEX);
3100 putchar (' ');
3101
3102 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3103 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3104 else
3105 {
3106 print_vma (segment->p_filesz, FULL_HEX);
3107 putchar (' ');
3108 }
3109
3110 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3111 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3112 else
3113 {
3114 print_vma (segment->p_offset, FULL_HEX);
3115 }
3116
3117 printf (" %c%c%c ",
3118 (segment->p_flags & PF_R ? 'R' : ' '),
3119 (segment->p_flags & PF_W ? 'W' : ' '),
3120 (segment->p_flags & PF_X ? 'E' : ' '));
3121
3122 if ((unsigned long) segment->p_align == segment->p_align)
3123 printf ("%#lx", (unsigned long) segment->p_align);
3124 else
3125 {
3126 print_vma (segment->p_align, PREFIX_HEX);
3127 }
3128 }
3129 else
3130 {
3131 print_vma (segment->p_offset, FULL_HEX);
3132 putchar (' ');
3133 print_vma (segment->p_vaddr, FULL_HEX);
3134 putchar (' ');
3135 print_vma (segment->p_paddr, FULL_HEX);
3136 printf ("\n ");
3137 print_vma (segment->p_filesz, FULL_HEX);
3138 putchar (' ');
3139 print_vma (segment->p_memsz, FULL_HEX);
3140 printf (" %c%c%c ",
3141 (segment->p_flags & PF_R ? 'R' : ' '),
3142 (segment->p_flags & PF_W ? 'W' : ' '),
3143 (segment->p_flags & PF_X ? 'E' : ' '));
3144 print_vma (segment->p_align, HEX);
3145 }
3146 }
3147
3148 switch (segment->p_type)
3149 {
3150 case PT_LOAD:
3151 if (loadaddr == -1)
3152 {
3153 unsigned long align_mask = -segment->p_align;
3154
3155 if (align_mask == 0)
3156 --align_mask;
3157 loadaddr = ((segment->p_vaddr & align_mask)
3158 - (segment->p_offset & align_mask));
3159 }
3160 break;
3161
3162 case PT_DYNAMIC:
3163 if (dynamic_addr)
3164 error (_("more than one dynamic segment\n"));
3165
3166 dynamic_addr = segment->p_offset;
3167 dynamic_size = segment->p_filesz;
3168 break;
3169
3170 case PT_INTERP:
3171 if (fseek (file, (long) segment->p_offset, SEEK_SET))
3172 error (_("Unable to find program interpreter name\n"));
3173 else
3174 {
3175 program_interpreter[0] = 0;
3176 fscanf (file, "%63s", program_interpreter);
3177
3178 if (do_segments)
3179 printf (_("\n [Requesting program interpreter: %s]"),
3180 program_interpreter);
3181 }
3182 break;
3183 }
3184
3185 if (do_segments)
3186 putc ('\n', stdout);
3187 }
3188
3189 if (loadaddr == -1)
3190 {
3191 /* Very strange. */
3192 loadaddr = 0;
3193 }
3194
3195 if (do_segments && section_headers != NULL)
3196 {
3197 printf (_("\n Section to Segment mapping:\n"));
3198 printf (_(" Segment Sections...\n"));
3199
3200 assert (string_table != NULL);
3201
3202 for (i = 0; i < elf_header.e_phnum; i++)
3203 {
3204 unsigned int j;
3205 Elf_Internal_Shdr *section;
3206
3207 segment = program_headers + i;
3208 section = section_headers;
3209
3210 printf (" %2.2d ", i);
3211
3212 for (j = 1; j < elf_header.e_shnum; j++, section++)
3213 {
3214 if (section->sh_size > 0
3215 /* Compare allocated sections by VMA, unallocated
3216 sections by file offset. */
3217 && (section->sh_flags & SHF_ALLOC
3218 ? (section->sh_addr >= segment->p_vaddr
3219 && section->sh_addr + section->sh_size
3220 <= segment->p_vaddr + segment->p_memsz)
3221 : ((bfd_vma) section->sh_offset >= segment->p_offset
3222 && (section->sh_offset + section->sh_size
3223 <= segment->p_offset + segment->p_filesz))))
3224 printf ("%s ", SECTION_NAME (section));
3225 }
3226
3227 putc ('\n',stdout);
3228 }
3229 }
3230
3231 free (program_headers);
3232
3233 return 1;
3234 }
3235
3236
3237 static int
3238 get_32bit_section_headers (file, num)
3239 FILE *file;
3240 unsigned int num;
3241 {
3242 Elf32_External_Shdr *shdrs;
3243 Elf_Internal_Shdr *internal;
3244 unsigned int i;
3245
3246 shdrs = ((Elf32_External_Shdr *)
3247 get_data (NULL, file, elf_header.e_shoff,
3248 elf_header.e_shentsize * num,
3249 _("section headers")));
3250 if (!shdrs)
3251 return 0;
3252
3253 section_headers = ((Elf_Internal_Shdr *)
3254 malloc (num * sizeof (Elf_Internal_Shdr)));
3255
3256 if (section_headers == NULL)
3257 {
3258 error (_("Out of memory\n"));
3259 return 0;
3260 }
3261
3262 for (i = 0, internal = section_headers;
3263 i < num;
3264 i++, internal++)
3265 {
3266 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3267 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3268 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3269 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3270 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3271 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3272 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3273 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3274 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3275 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3276 }
3277
3278 free (shdrs);
3279
3280 return 1;
3281 }
3282
3283 static int
3284 get_64bit_section_headers (file, num)
3285 FILE *file;
3286 unsigned int num;
3287 {
3288 Elf64_External_Shdr *shdrs;
3289 Elf_Internal_Shdr *internal;
3290 unsigned int i;
3291
3292 shdrs = ((Elf64_External_Shdr *)
3293 get_data (NULL, file, elf_header.e_shoff,
3294 elf_header.e_shentsize * num,
3295 _("section headers")));
3296 if (!shdrs)
3297 return 0;
3298
3299 section_headers = ((Elf_Internal_Shdr *)
3300 malloc (num * sizeof (Elf_Internal_Shdr)));
3301
3302 if (section_headers == NULL)
3303 {
3304 error (_("Out of memory\n"));
3305 return 0;
3306 }
3307
3308 for (i = 0, internal = section_headers;
3309 i < num;
3310 i++, internal++)
3311 {
3312 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3313 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3314 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3315 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3316 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3317 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3318 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3319 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3320 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3321 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3322 }
3323
3324 free (shdrs);
3325
3326 return 1;
3327 }
3328
3329 static Elf_Internal_Sym *
3330 get_32bit_elf_symbols (file, section)
3331 FILE *file;
3332 Elf_Internal_Shdr *section;
3333 {
3334 unsigned long number;
3335 Elf32_External_Sym *esyms;
3336 Elf_External_Sym_Shndx *shndx;
3337 Elf_Internal_Sym *isyms;
3338 Elf_Internal_Sym *psym;
3339 unsigned int j;
3340
3341 esyms = ((Elf32_External_Sym *)
3342 get_data (NULL, file, section->sh_offset,
3343 section->sh_size, _("symbols")));
3344 if (!esyms)
3345 return NULL;
3346
3347 shndx = NULL;
3348 if (symtab_shndx_hdr != NULL
3349 && (symtab_shndx_hdr->sh_link
3350 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3351 {
3352 shndx = ((Elf_External_Sym_Shndx *)
3353 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3354 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3355 if (!shndx)
3356 {
3357 free (esyms);
3358 return NULL;
3359 }
3360 }
3361
3362 number = section->sh_size / section->sh_entsize;
3363 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3364
3365 if (isyms == NULL)
3366 {
3367 error (_("Out of memory\n"));
3368 if (shndx)
3369 free (shndx);
3370 free (esyms);
3371 return NULL;
3372 }
3373
3374 for (j = 0, psym = isyms;
3375 j < number;
3376 j++, psym++)
3377 {
3378 psym->st_name = BYTE_GET (esyms[j].st_name);
3379 psym->st_value = BYTE_GET (esyms[j].st_value);
3380 psym->st_size = BYTE_GET (esyms[j].st_size);
3381 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3382 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3383 psym->st_shndx
3384 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3385 psym->st_info = BYTE_GET (esyms[j].st_info);
3386 psym->st_other = BYTE_GET (esyms[j].st_other);
3387 }
3388
3389 if (shndx)
3390 free (shndx);
3391 free (esyms);
3392
3393 return isyms;
3394 }
3395
3396 static Elf_Internal_Sym *
3397 get_64bit_elf_symbols (file, section)
3398 FILE *file;
3399 Elf_Internal_Shdr *section;
3400 {
3401 unsigned long number;
3402 Elf64_External_Sym *esyms;
3403 Elf_External_Sym_Shndx *shndx;
3404 Elf_Internal_Sym *isyms;
3405 Elf_Internal_Sym *psym;
3406 unsigned int j;
3407
3408 esyms = ((Elf64_External_Sym *)
3409 get_data (NULL, file, section->sh_offset,
3410 section->sh_size, _("symbols")));
3411 if (!esyms)
3412 return NULL;
3413
3414 shndx = NULL;
3415 if (symtab_shndx_hdr != NULL
3416 && (symtab_shndx_hdr->sh_link
3417 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3418 {
3419 shndx = ((Elf_External_Sym_Shndx *)
3420 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3421 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3422 if (!shndx)
3423 {
3424 free (esyms);
3425 return NULL;
3426 }
3427 }
3428
3429 number = section->sh_size / section->sh_entsize;
3430 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3431
3432 if (isyms == NULL)
3433 {
3434 error (_("Out of memory\n"));
3435 if (shndx)
3436 free (shndx);
3437 free (esyms);
3438 return NULL;
3439 }
3440
3441 for (j = 0, psym = isyms;
3442 j < number;
3443 j++, psym++)
3444 {
3445 psym->st_name = BYTE_GET (esyms[j].st_name);
3446 psym->st_info = BYTE_GET (esyms[j].st_info);
3447 psym->st_other = BYTE_GET (esyms[j].st_other);
3448 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3449 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3450 psym->st_shndx
3451 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3452 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3453 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3454 }
3455
3456 if (shndx)
3457 free (shndx);
3458 free (esyms);
3459
3460 return isyms;
3461 }
3462
3463 static const char *
3464 get_elf_section_flags (sh_flags)
3465 bfd_vma sh_flags;
3466 {
3467 static char buff[32];
3468
3469 *buff = 0;
3470
3471 while (sh_flags)
3472 {
3473 bfd_vma flag;
3474
3475 flag = sh_flags & - sh_flags;
3476 sh_flags &= ~ flag;
3477
3478 switch (flag)
3479 {
3480 case SHF_WRITE: strcat (buff, "W"); break;
3481 case SHF_ALLOC: strcat (buff, "A"); break;
3482 case SHF_EXECINSTR: strcat (buff, "X"); break;
3483 case SHF_MERGE: strcat (buff, "M"); break;
3484 case SHF_STRINGS: strcat (buff, "S"); break;
3485 case SHF_INFO_LINK: strcat (buff, "I"); break;
3486 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3487 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3488 case SHF_GROUP: strcat (buff, "G"); break;
3489 case SHF_TLS: strcat (buff, "T"); break;
3490
3491 default:
3492 if (flag & SHF_MASKOS)
3493 {
3494 strcat (buff, "o");
3495 sh_flags &= ~ SHF_MASKOS;
3496 }
3497 else if (flag & SHF_MASKPROC)
3498 {
3499 strcat (buff, "p");
3500 sh_flags &= ~ SHF_MASKPROC;
3501 }
3502 else
3503 strcat (buff, "x");
3504 break;
3505 }
3506 }
3507
3508 return buff;
3509 }
3510
3511 static int
3512 process_section_headers (file)
3513 FILE *file;
3514 {
3515 Elf_Internal_Shdr *section;
3516 unsigned int i;
3517
3518 section_headers = NULL;
3519
3520 if (elf_header.e_shnum == 0)
3521 {
3522 if (do_sections)
3523 printf (_("\nThere are no sections in this file.\n"));
3524
3525 return 1;
3526 }
3527
3528 if (do_sections && !do_header)
3529 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3530 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3531
3532 if (is_32bit_elf)
3533 {
3534 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3535 return 0;
3536 }
3537 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3538 return 0;
3539
3540 /* Read in the string table, so that we have names to display. */
3541 section = SECTION_HEADER (elf_header.e_shstrndx);
3542
3543 if (section->sh_size != 0)
3544 {
3545 string_table = (char *) get_data (NULL, file, section->sh_offset,
3546 section->sh_size, _("string table"));
3547
3548 string_table_length = section->sh_size;
3549 }
3550
3551 /* Scan the sections for the dynamic symbol table
3552 and dynamic string table and debug sections. */
3553 dynamic_symbols = NULL;
3554 dynamic_strings = NULL;
3555 dynamic_syminfo = NULL;
3556 symtab_shndx_hdr = NULL;
3557
3558 for (i = 0, section = section_headers;
3559 i < elf_header.e_shnum;
3560 i++, section++)
3561 {
3562 char *name = SECTION_NAME (section);
3563
3564 if (section->sh_type == SHT_DYNSYM)
3565 {
3566 if (dynamic_symbols != NULL)
3567 {
3568 error (_("File contains multiple dynamic symbol tables\n"));
3569 continue;
3570 }
3571
3572 num_dynamic_syms = section->sh_size / section->sh_entsize;
3573 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3574 }
3575 else if (section->sh_type == SHT_STRTAB
3576 && strcmp (name, ".dynstr") == 0)
3577 {
3578 if (dynamic_strings != NULL)
3579 {
3580 error (_("File contains multiple dynamic string tables\n"));
3581 continue;
3582 }
3583
3584 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3585 section->sh_size,
3586 _("dynamic strings"));
3587 }
3588 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3589 {
3590 if (symtab_shndx_hdr != NULL)
3591 {
3592 error (_("File contains multiple symtab shndx tables\n"));
3593 continue;
3594 }
3595 symtab_shndx_hdr = section;
3596 }
3597 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3598 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3599 || do_debug_frames || do_debug_macinfo || do_debug_str
3600 || do_debug_loc)
3601 && strncmp (name, ".debug_", 7) == 0)
3602 {
3603 name += 7;
3604
3605 if (do_debugging
3606 || (do_debug_info && (strcmp (name, "info") == 0))
3607 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3608 || (do_debug_lines && (strcmp (name, "line") == 0))
3609 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3610 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3611 || (do_debug_frames && (strcmp (name, "frame") == 0))
3612 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3613 || (do_debug_str && (strcmp (name, "str") == 0))
3614 || (do_debug_loc && (strcmp (name, "loc") == 0))
3615 )
3616 request_dump (i, DEBUG_DUMP);
3617 }
3618 /* linkonce section to be combined with .debug_info at link time. */
3619 else if ((do_debugging || do_debug_info)
3620 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3621 request_dump (i, DEBUG_DUMP);
3622 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3623 request_dump (i, DEBUG_DUMP);
3624 }
3625
3626 if (! do_sections)
3627 return 1;
3628
3629 if (elf_header.e_shnum > 1)
3630 printf (_("\nSection Headers:\n"));
3631 else
3632 printf (_("\nSection Header:\n"));
3633
3634 if (is_32bit_elf)
3635 printf
3636 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3637 else if (do_wide)
3638 printf
3639 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3640 else
3641 {
3642 printf (_(" [Nr] Name Type Address Offset\n"));
3643 printf (_(" Size EntSize Flags Link Info Align\n"));
3644 }
3645
3646 for (i = 0, section = section_headers;
3647 i < elf_header.e_shnum;
3648 i++, section++)
3649 {
3650 printf (" [%2u] %-17.17s %-15.15s ",
3651 SECTION_HEADER_NUM (i),
3652 SECTION_NAME (section),
3653 get_section_type_name (section->sh_type));
3654
3655 if (is_32bit_elf)
3656 {
3657 print_vma (section->sh_addr, LONG_HEX);
3658
3659 printf ( " %6.6lx %6.6lx %2.2lx",
3660 (unsigned long) section->sh_offset,
3661 (unsigned long) section->sh_size,
3662 (unsigned long) section->sh_entsize);
3663
3664 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3665
3666 printf ("%2ld %3lx %2ld\n",
3667 (unsigned long) section->sh_link,
3668 (unsigned long) section->sh_info,
3669 (unsigned long) section->sh_addralign);
3670 }
3671 else if (do_wide)
3672 {
3673 print_vma (section->sh_addr, LONG_HEX);
3674
3675 if ((long) section->sh_offset == section->sh_offset)
3676 printf (" %6.6lx", (unsigned long) section->sh_offset);
3677 else
3678 {
3679 putchar (' ');
3680 print_vma (section->sh_offset, LONG_HEX);
3681 }
3682
3683 if ((unsigned long) section->sh_size == section->sh_size)
3684 printf (" %6.6lx", (unsigned long) section->sh_size);
3685 else
3686 {
3687 putchar (' ');
3688 print_vma (section->sh_size, LONG_HEX);
3689 }
3690
3691 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3692 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3693 else
3694 {
3695 putchar (' ');
3696 print_vma (section->sh_entsize, LONG_HEX);
3697 }
3698
3699 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3700
3701 printf ("%2ld %3lx ",
3702 (unsigned long) section->sh_link,
3703 (unsigned long) section->sh_info);
3704
3705 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3706 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3707 else
3708 {
3709 print_vma (section->sh_addralign, DEC);
3710 putchar ('\n');
3711 }
3712 }
3713 else
3714 {
3715 putchar (' ');
3716 print_vma (section->sh_addr, LONG_HEX);
3717 if ((long) section->sh_offset == section->sh_offset)
3718 printf (" %8.8lx", (unsigned long) section->sh_offset);
3719 else
3720 {
3721 printf (" ");
3722 print_vma (section->sh_offset, LONG_HEX);
3723 }
3724 printf ("\n ");
3725 print_vma (section->sh_size, LONG_HEX);
3726 printf (" ");
3727 print_vma (section->sh_entsize, LONG_HEX);
3728
3729 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3730
3731 printf (" %2ld %3lx %ld\n",
3732 (unsigned long) section->sh_link,
3733 (unsigned long) section->sh_info,
3734 (unsigned long) section->sh_addralign);
3735 }
3736 }
3737
3738 printf (_("Key to Flags:\n\
3739 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3740 I (info), L (link order), G (group), x (unknown)\n\
3741 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3742
3743 return 1;
3744 }
3745
3746 /* Process the reloc section. */
3747 static int
3748 process_relocs (file)
3749 FILE *file;
3750 {
3751 unsigned long rel_size;
3752 unsigned long rel_offset;
3753
3754
3755 if (!do_reloc)
3756 return 1;
3757
3758 if (do_using_dynamic)
3759 {
3760 int is_rela = FALSE;
3761
3762 rel_size = 0;
3763 rel_offset = 0;
3764
3765 if (dynamic_info[DT_REL])
3766 {
3767 rel_offset = dynamic_info[DT_REL];
3768 rel_size = dynamic_info[DT_RELSZ];
3769 is_rela = FALSE;
3770 }
3771 else if (dynamic_info[DT_RELA])
3772 {
3773 rel_offset = dynamic_info[DT_RELA];
3774 rel_size = dynamic_info[DT_RELASZ];
3775 is_rela = TRUE;
3776 }
3777 else if (dynamic_info[DT_JMPREL])
3778 {
3779 rel_offset = dynamic_info[DT_JMPREL];
3780 rel_size = dynamic_info[DT_PLTRELSZ];
3781
3782 switch (dynamic_info[DT_PLTREL])
3783 {
3784 case DT_REL:
3785 is_rela = FALSE;
3786 break;
3787 case DT_RELA:
3788 is_rela = TRUE;
3789 break;
3790 default:
3791 is_rela = UNKNOWN;
3792 break;
3793 }
3794 }
3795
3796 if (rel_size)
3797 {
3798 printf
3799 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3800 rel_offset, rel_size);
3801
3802 dump_relocations (file, rel_offset - loadaddr, rel_size,
3803 dynamic_symbols, num_dynamic_syms, dynamic_strings,
3804 is_rela);
3805 }
3806 else
3807 printf (_("\nThere are no dynamic relocations in this file.\n"));
3808 }
3809 else
3810 {
3811 Elf_Internal_Shdr *section;
3812 unsigned long i;
3813 int found = 0;
3814
3815 for (i = 0, section = section_headers;
3816 i < elf_header.e_shnum;
3817 i++, section++)
3818 {
3819 if ( section->sh_type != SHT_RELA
3820 && section->sh_type != SHT_REL)
3821 continue;
3822
3823 rel_offset = section->sh_offset;
3824 rel_size = section->sh_size;
3825
3826 if (rel_size)
3827 {
3828 Elf_Internal_Shdr *strsec;
3829 Elf_Internal_Sym *symtab;
3830 char *strtab;
3831 int is_rela;
3832 unsigned long nsyms;
3833
3834 printf (_("\nRelocation section "));
3835
3836 if (string_table == NULL)
3837 printf ("%d", section->sh_name);
3838 else
3839 printf (_("'%s'"), SECTION_NAME (section));
3840
3841 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3842 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3843
3844 symtab = NULL;
3845 strtab = NULL;
3846 nsyms = 0;
3847 if (section->sh_link)
3848 {
3849 Elf_Internal_Shdr *symsec;
3850
3851 symsec = SECTION_HEADER (section->sh_link);
3852 nsyms = symsec->sh_size / symsec->sh_entsize;
3853 symtab = GET_ELF_SYMBOLS (file, symsec);
3854
3855 if (symtab == NULL)
3856 continue;
3857
3858 strsec = SECTION_HEADER (symsec->sh_link);
3859
3860 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3861 strsec->sh_size,
3862 _("string table"));
3863 }
3864 is_rela = section->sh_type == SHT_RELA;
3865
3866 dump_relocations (file, rel_offset, rel_size,
3867 symtab, nsyms, strtab, is_rela);
3868
3869 if (strtab)
3870 free (strtab);
3871 if (symtab)
3872 free (symtab);
3873
3874 found = 1;
3875 }
3876 }
3877
3878 if (! found)
3879 printf (_("\nThere are no relocations in this file.\n"));
3880 }
3881
3882 return 1;
3883 }
3884
3885 #include "unwind-ia64.h"
3886
3887 /* An absolute address consists of a section and an offset. If the
3888 section is NULL, the offset itself is the address, otherwise, the
3889 address equals to LOAD_ADDRESS(section) + offset. */
3890
3891 struct absaddr
3892 {
3893 unsigned short section;
3894 bfd_vma offset;
3895 };
3896
3897 struct unw_aux_info
3898 {
3899 struct unw_table_entry
3900 {
3901 struct absaddr start;
3902 struct absaddr end;
3903 struct absaddr info;
3904 }
3905 *table; /* Unwind table. */
3906 unsigned long table_len; /* Length of unwind table. */
3907 unsigned char *info; /* Unwind info. */
3908 unsigned long info_size; /* Size of unwind info. */
3909 bfd_vma info_addr; /* starting address of unwind info. */
3910 bfd_vma seg_base; /* Starting address of segment. */
3911 Elf_Internal_Sym *symtab; /* The symbol table. */
3912 unsigned long nsyms; /* Number of symbols. */
3913 char *strtab; /* The string table. */
3914 unsigned long strtab_size; /* Size of string table. */
3915 };
3916
3917 static void find_symbol_for_address
3918 PARAMS ((struct unw_aux_info *, struct absaddr, const char **, bfd_vma *));
3919 static void dump_ia64_unwind
3920 PARAMS ((struct unw_aux_info *));
3921 static int slurp_ia64_unwind_table
3922 PARAMS ((FILE *, struct unw_aux_info *, Elf_Internal_Shdr *));
3923
3924 static void
3925 find_symbol_for_address (aux, addr, symname, offset)
3926 struct unw_aux_info *aux;
3927 struct absaddr addr;
3928 const char **symname;
3929 bfd_vma *offset;
3930 {
3931 bfd_vma dist = (bfd_vma) 0x100000;
3932 Elf_Internal_Sym *sym, *best = NULL;
3933 unsigned long i;
3934
3935 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3936 {
3937 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3938 && sym->st_name != 0
3939 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3940 && addr.offset >= sym->st_value
3941 && addr.offset - sym->st_value < dist)
3942 {
3943 best = sym;
3944 dist = addr.offset - sym->st_value;
3945 if (!dist)
3946 break;
3947 }
3948 }
3949 if (best)
3950 {
3951 *symname = (best->st_name >= aux->strtab_size
3952 ? "<corrupt>" : aux->strtab + best->st_name);
3953 *offset = dist;
3954 return;
3955 }
3956 *symname = NULL;
3957 *offset = addr.offset;
3958 }
3959
3960 static void
3961 dump_ia64_unwind (aux)
3962 struct unw_aux_info *aux;
3963 {
3964 bfd_vma addr_size;
3965 struct unw_table_entry *tp;
3966 int in_body;
3967
3968 addr_size = is_32bit_elf ? 4 : 8;
3969
3970 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3971 {
3972 bfd_vma stamp;
3973 bfd_vma offset;
3974 const unsigned char *dp;
3975 const unsigned char *head;
3976 const char *procname;
3977
3978 find_symbol_for_address (aux, tp->start, &procname, &offset);
3979
3980 fputs ("\n<", stdout);
3981
3982 if (procname)
3983 {
3984 fputs (procname, stdout);
3985
3986 if (offset)
3987 printf ("+%lx", (unsigned long) offset);
3988 }
3989
3990 fputs (">: [", stdout);
3991 print_vma (tp->start.offset, PREFIX_HEX);
3992 fputc ('-', stdout);
3993 print_vma (tp->end.offset, PREFIX_HEX);
3994 printf ("], info at +0x%lx\n",
3995 (unsigned long) (tp->info.offset - aux->seg_base));
3996
3997 head = aux->info + (tp->info.offset - aux->info_addr);
3998 stamp = BYTE_GET8 ((unsigned char *) head);
3999
4000 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4001 (unsigned) UNW_VER (stamp),
4002 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4003 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4004 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4005 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
4006
4007 if (UNW_VER (stamp) != 1)
4008 {
4009 printf ("\tUnknown version.\n");
4010 continue;
4011 }
4012
4013 in_body = 0;
4014 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
4015 dp = unw_decode (dp, in_body, & in_body);
4016 }
4017 }
4018
4019 static int
4020 slurp_ia64_unwind_table (file, aux, sec)
4021 FILE *file;
4022 struct unw_aux_info *aux;
4023 Elf_Internal_Shdr *sec;
4024 {
4025 unsigned long size, addr_size, nrelas, i;
4026 Elf_Internal_Phdr *prog_hdrs, *seg;
4027 struct unw_table_entry *tep;
4028 Elf_Internal_Shdr *relsec;
4029 Elf_Internal_Rela *rela, *rp;
4030 unsigned char *table, *tp;
4031 Elf_Internal_Sym *sym;
4032 const char *relname;
4033 int result;
4034
4035 addr_size = is_32bit_elf ? 4 : 8;
4036
4037 /* First, find the starting address of the segment that includes
4038 this section: */
4039
4040 if (elf_header.e_phnum)
4041 {
4042 prog_hdrs = (Elf_Internal_Phdr *)
4043 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
4044
4045 if (is_32bit_elf)
4046 result = get_32bit_program_headers (file, prog_hdrs);
4047 else
4048 result = get_64bit_program_headers (file, prog_hdrs);
4049
4050 if (!result)
4051 {
4052 free (prog_hdrs);
4053 return 0;
4054 }
4055
4056 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
4057 {
4058 if (seg->p_type != PT_LOAD)
4059 continue;
4060
4061 if (sec->sh_addr >= seg->p_vaddr
4062 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4063 {
4064 aux->seg_base = seg->p_vaddr;
4065 break;
4066 }
4067 }
4068
4069 free (prog_hdrs);
4070 }
4071
4072 /* Second, build the unwind table from the contents of the unwind section: */
4073 size = sec->sh_size;
4074 table = (char *) get_data (NULL, file, sec->sh_offset,
4075 size, _("unwind table"));
4076 if (!table)
4077 return 0;
4078
4079 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
4080 for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
4081 {
4082 tep->start.section = SHN_UNDEF;
4083 tep->end.section = SHN_UNDEF;
4084 tep->info.section = SHN_UNDEF;
4085 if (is_32bit_elf)
4086 {
4087 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4088 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4089 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4090 }
4091 else
4092 {
4093 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
4094 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
4095 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
4096 }
4097 tep->start.offset += aux->seg_base;
4098 tep->end.offset += aux->seg_base;
4099 tep->info.offset += aux->seg_base;
4100 }
4101 free (table);
4102
4103 /* Third, apply any relocations to the unwind table: */
4104
4105 for (relsec = section_headers;
4106 relsec < section_headers + elf_header.e_shnum;
4107 ++relsec)
4108 {
4109 if (relsec->sh_type != SHT_RELA
4110 || SECTION_HEADER (relsec->sh_info) != sec)
4111 continue;
4112
4113 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4114 & rela, & nrelas))
4115 return 0;
4116
4117 for (rp = rela; rp < rela + nrelas; ++rp)
4118 {
4119 if (is_32bit_elf)
4120 {
4121 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4122 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4123
4124 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
4125 {
4126 warn (_("Skipping unexpected symbol type %u\n"),
4127 ELF32_ST_TYPE (sym->st_info));
4128 continue;
4129 }
4130 }
4131 else
4132 {
4133 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4134 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4135
4136 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
4137 {
4138 warn (_("Skipping unexpected symbol type %u\n"),
4139 ELF64_ST_TYPE (sym->st_info));
4140 continue;
4141 }
4142 }
4143
4144 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4145 {
4146 warn (_("Skipping unexpected relocation type %s\n"), relname);
4147 continue;
4148 }
4149
4150 i = rp->r_offset / (3 * addr_size);
4151
4152 switch (rp->r_offset/addr_size % 3)
4153 {
4154 case 0:
4155 aux->table[i].start.section = sym->st_shndx;
4156 aux->table[i].start.offset += rp->r_addend;
4157 break;
4158 case 1:
4159 aux->table[i].end.section = sym->st_shndx;
4160 aux->table[i].end.offset += rp->r_addend;
4161 break;
4162 case 2:
4163 aux->table[i].info.section = sym->st_shndx;
4164 aux->table[i].info.offset += rp->r_addend;
4165 break;
4166 default:
4167 break;
4168 }
4169 }
4170
4171 free (rela);
4172 }
4173
4174 aux->table_len = size / (3 * addr_size);
4175 return 1;
4176 }
4177
4178 static int
4179 process_unwind (file)
4180 FILE *file;
4181 {
4182 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4183 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4184 struct unw_aux_info aux;
4185
4186 if (!do_unwind)
4187 return 1;
4188
4189 if (elf_header.e_machine != EM_IA_64)
4190 {
4191 printf (_("\nThere are no unwind sections in this file.\n"));
4192 return 1;
4193 }
4194
4195 memset (& aux, 0, sizeof (aux));
4196
4197 addr_size = is_32bit_elf ? 4 : 8;
4198
4199 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4200 {
4201 if (sec->sh_type == SHT_SYMTAB)
4202 {
4203 aux.nsyms = sec->sh_size / sec->sh_entsize;
4204 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4205
4206 strsec = SECTION_HEADER (sec->sh_link);
4207 aux.strtab_size = strsec->sh_size;
4208 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4209 aux.strtab_size, _("string table"));
4210 }
4211 else if (sec->sh_type == SHT_IA_64_UNWIND)
4212 unwcount++;
4213 }
4214
4215 if (!unwcount)
4216 printf (_("\nThere are no unwind sections in this file.\n"));
4217
4218 while (unwcount-- > 0)
4219 {
4220 char *suffix;
4221 size_t len, len2;
4222
4223 for (i = unwstart, sec = section_headers + unwstart;
4224 i < elf_header.e_shnum; ++i, ++sec)
4225 if (sec->sh_type == SHT_IA_64_UNWIND)
4226 {
4227 unwsec = sec;
4228 break;
4229 }
4230
4231 unwstart = i + 1;
4232 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4233
4234 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4235 len) == 0)
4236 {
4237 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4238 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4239 suffix = SECTION_NAME (unwsec) + len;
4240 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4241 ++i, ++sec)
4242 if (strncmp (SECTION_NAME (sec),
4243 ELF_STRING_ia64_unwind_info_once, len2) == 0
4244 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4245 break;
4246 }
4247 else
4248 {
4249 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4250 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4251 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4252 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4253 suffix = "";
4254 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4255 len) == 0)
4256 suffix = SECTION_NAME (unwsec) + len;
4257 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4258 ++i, ++sec)
4259 if (strncmp (SECTION_NAME (sec),
4260 ELF_STRING_ia64_unwind_info, len2) == 0
4261 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4262 break;
4263 }
4264
4265 if (i == elf_header.e_shnum)
4266 {
4267 printf (_("\nCould not find unwind info section for "));
4268
4269 if (string_table == NULL)
4270 printf ("%d", unwsec->sh_name);
4271 else
4272 printf (_("'%s'"), SECTION_NAME (unwsec));
4273 }
4274 else
4275 {
4276 aux.info_size = sec->sh_size;
4277 aux.info_addr = sec->sh_addr;
4278 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
4279 aux.info_size, _("unwind info"));
4280
4281 printf (_("\nUnwind section "));
4282
4283 if (string_table == NULL)
4284 printf ("%d", unwsec->sh_name);
4285 else
4286 printf (_("'%s'"), SECTION_NAME (unwsec));
4287
4288 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4289 (unsigned long) unwsec->sh_offset,
4290 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4291
4292 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4293
4294 if (aux.table_len > 0)
4295 dump_ia64_unwind (& aux);
4296
4297 if (aux.table)
4298 free ((char *) aux.table);
4299 if (aux.info)
4300 free ((char *) aux.info);
4301 aux.table = NULL;
4302 aux.info = NULL;
4303 }
4304 }
4305
4306 if (aux.symtab)
4307 free (aux.symtab);
4308 if (aux.strtab)
4309 free ((char *) aux.strtab);
4310
4311 return 1;
4312 }
4313
4314 static void
4315 dynamic_segment_mips_val (entry)
4316 Elf_Internal_Dyn *entry;
4317 {
4318 switch (entry->d_tag)
4319 {
4320 case DT_MIPS_FLAGS:
4321 if (entry->d_un.d_val == 0)
4322 printf ("NONE\n");
4323 else
4324 {
4325 static const char * opts[] =
4326 {
4327 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4328 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4329 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4330 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4331 "RLD_ORDER_SAFE"
4332 };
4333 unsigned int cnt;
4334 int first = 1;
4335 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
4336 if (entry->d_un.d_val & (1 << cnt))
4337 {
4338 printf ("%s%s", first ? "" : " ", opts[cnt]);
4339 first = 0;
4340 }
4341 puts ("");
4342 }
4343 break;
4344
4345 case DT_MIPS_IVERSION:
4346 if (dynamic_strings != NULL)
4347 printf ("Interface Version: %s\n",
4348 dynamic_strings + entry->d_un.d_val);
4349 else
4350 printf ("%ld\n", (long) entry->d_un.d_ptr);
4351 break;
4352
4353 case DT_MIPS_TIME_STAMP:
4354 {
4355 char timebuf[20];
4356 struct tm *tmp;
4357
4358 time_t time = entry->d_un.d_val;
4359 tmp = gmtime (&time);
4360 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4361 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4362 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4363 printf ("Time Stamp: %s\n", timebuf);
4364 }
4365 break;
4366
4367 case DT_MIPS_RLD_VERSION:
4368 case DT_MIPS_LOCAL_GOTNO:
4369 case DT_MIPS_CONFLICTNO:
4370 case DT_MIPS_LIBLISTNO:
4371 case DT_MIPS_SYMTABNO:
4372 case DT_MIPS_UNREFEXTNO:
4373 case DT_MIPS_HIPAGENO:
4374 case DT_MIPS_DELTA_CLASS_NO:
4375 case DT_MIPS_DELTA_INSTANCE_NO:
4376 case DT_MIPS_DELTA_RELOC_NO:
4377 case DT_MIPS_DELTA_SYM_NO:
4378 case DT_MIPS_DELTA_CLASSSYM_NO:
4379 case DT_MIPS_COMPACT_SIZE:
4380 printf ("%ld\n", (long) entry->d_un.d_ptr);
4381 break;
4382
4383 default:
4384 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4385 }
4386 }
4387
4388
4389 static void
4390 dynamic_segment_parisc_val (entry)
4391 Elf_Internal_Dyn *entry;
4392 {
4393 switch (entry->d_tag)
4394 {
4395 case DT_HP_DLD_FLAGS:
4396 {
4397 static struct
4398 {
4399 long int bit;
4400 const char *str;
4401 }
4402 flags[] =
4403 {
4404 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4405 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4406 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4407 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4408 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4409 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4410 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4411 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4412 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4413 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4414 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4415 };
4416 int first = 1;
4417 size_t cnt;
4418 bfd_vma val = entry->d_un.d_val;
4419
4420 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4421 if (val & flags[cnt].bit)
4422 {
4423 if (! first)
4424 putchar (' ');
4425 fputs (flags[cnt].str, stdout);
4426 first = 0;
4427 val ^= flags[cnt].bit;
4428 }
4429
4430 if (val != 0 || first)
4431 {
4432 if (! first)
4433 putchar (' ');
4434 print_vma (val, HEX);
4435 }
4436 }
4437 break;
4438
4439 default:
4440 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4441 break;
4442 }
4443 putchar ('\n');
4444 }
4445
4446 static int
4447 get_32bit_dynamic_segment (file)
4448 FILE *file;
4449 {
4450 Elf32_External_Dyn *edyn;
4451 Elf_Internal_Dyn *entry;
4452 bfd_size_type i;
4453
4454 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
4455 dynamic_size, _("dynamic segment"));
4456 if (!edyn)
4457 return 0;
4458
4459 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4460 how large this .dynamic is now. We can do this even before the byte
4461 swapping since the DT_NULL tag is recognizable. */
4462 dynamic_size = 0;
4463 while (*(Elf32_Word *) edyn[dynamic_size++].d_tag != DT_NULL)
4464 ;
4465
4466 dynamic_segment = (Elf_Internal_Dyn *)
4467 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4468
4469 if (dynamic_segment == NULL)
4470 {
4471 error (_("Out of memory\n"));
4472 free (edyn);
4473 return 0;
4474 }
4475
4476 for (i = 0, entry = dynamic_segment;
4477 i < dynamic_size;
4478 i++, entry++)
4479 {
4480 entry->d_tag = BYTE_GET (edyn[i].d_tag);
4481 entry->d_un.d_val = BYTE_GET (edyn[i].d_un.d_val);
4482 }
4483
4484 free (edyn);
4485
4486 return 1;
4487 }
4488
4489 static int
4490 get_64bit_dynamic_segment (file)
4491 FILE *file;
4492 {
4493 Elf64_External_Dyn *edyn;
4494 Elf_Internal_Dyn *entry;
4495 bfd_size_type i;
4496
4497 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
4498 dynamic_size, _("dynamic segment"));
4499 if (!edyn)
4500 return 0;
4501
4502 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4503 how large this .dynamic is now. We can do this even before the byte
4504 swapping since the DT_NULL tag is recognizable. */
4505 dynamic_size = 0;
4506 while (*(bfd_vma *) edyn[dynamic_size++].d_tag != DT_NULL)
4507 ;
4508
4509 dynamic_segment = (Elf_Internal_Dyn *)
4510 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4511
4512 if (dynamic_segment == NULL)
4513 {
4514 error (_("Out of memory\n"));
4515 free (edyn);
4516 return 0;
4517 }
4518
4519 for (i = 0, entry = dynamic_segment;
4520 i < dynamic_size;
4521 i++, entry++)
4522 {
4523 entry->d_tag = BYTE_GET8 (edyn[i].d_tag);
4524 entry->d_un.d_val = BYTE_GET8 (edyn[i].d_un.d_val);
4525 }
4526
4527 free (edyn);
4528
4529 return 1;
4530 }
4531
4532 static const char *
4533 get_dynamic_flags (flags)
4534 bfd_vma flags;
4535 {
4536 static char buff[128];
4537 char *p = buff;
4538
4539 *p = '\0';
4540 while (flags)
4541 {
4542 bfd_vma flag;
4543
4544 flag = flags & - flags;
4545 flags &= ~ flag;
4546
4547 if (p != buff)
4548 *p++ = ' ';
4549
4550 switch (flag)
4551 {
4552 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4553 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4554 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4555 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4556 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4557 default: strcpy (p, "unknown"); break;
4558 }
4559
4560 p = strchr (p, '\0');
4561 }
4562 return buff;
4563 }
4564
4565 /* Parse and display the contents of the dynamic segment. */
4566 static int
4567 process_dynamic_segment (file)
4568 FILE *file;
4569 {
4570 Elf_Internal_Dyn *entry;
4571 bfd_size_type i;
4572
4573 if (dynamic_size == 0)
4574 {
4575 if (do_dynamic)
4576 printf (_("\nThere is no dynamic segment in this file.\n"));
4577
4578 return 1;
4579 }
4580
4581 if (is_32bit_elf)
4582 {
4583 if (! get_32bit_dynamic_segment (file))
4584 return 0;
4585 }
4586 else if (! get_64bit_dynamic_segment (file))
4587 return 0;
4588
4589 /* Find the appropriate symbol table. */
4590 if (dynamic_symbols == NULL)
4591 {
4592 for (i = 0, entry = dynamic_segment;
4593 i < dynamic_size;
4594 ++i, ++entry)
4595 {
4596 Elf_Internal_Shdr section;
4597
4598 if (entry->d_tag != DT_SYMTAB)
4599 continue;
4600
4601 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4602
4603 /* Since we do not know how big the symbol table is,
4604 we default to reading in the entire file (!) and
4605 processing that. This is overkill, I know, but it
4606 should work. */
4607 section.sh_offset = entry->d_un.d_val - loadaddr;
4608
4609 if (fseek (file, 0, SEEK_END))
4610 error (_("Unable to seek to end of file!"));
4611
4612 section.sh_size = ftell (file) - section.sh_offset;
4613 if (is_32bit_elf)
4614 section.sh_entsize = sizeof (Elf32_External_Sym);
4615 else
4616 section.sh_entsize = sizeof (Elf64_External_Sym);
4617
4618 num_dynamic_syms = section.sh_size / section.sh_entsize;
4619 if (num_dynamic_syms < 1)
4620 {
4621 error (_("Unable to determine the number of symbols to load\n"));
4622 continue;
4623 }
4624
4625 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
4626 }
4627 }
4628
4629 /* Similarly find a string table. */
4630 if (dynamic_strings == NULL)
4631 {
4632 for (i = 0, entry = dynamic_segment;
4633 i < dynamic_size;
4634 ++i, ++entry)
4635 {
4636 unsigned long offset;
4637 long str_tab_len;
4638
4639 if (entry->d_tag != DT_STRTAB)
4640 continue;
4641
4642 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4643
4644 /* Since we do not know how big the string table is,
4645 we default to reading in the entire file (!) and
4646 processing that. This is overkill, I know, but it
4647 should work. */
4648
4649 offset = entry->d_un.d_val - loadaddr;
4650 if (fseek (file, 0, SEEK_END))
4651 error (_("Unable to seek to end of file\n"));
4652 str_tab_len = ftell (file) - offset;
4653
4654 if (str_tab_len < 1)
4655 {
4656 error
4657 (_("Unable to determine the length of the dynamic string table\n"));
4658 continue;
4659 }
4660
4661 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4662 _("dynamic string table"));
4663 break;
4664 }
4665 }
4666
4667 /* And find the syminfo section if available. */
4668 if (dynamic_syminfo == NULL)
4669 {
4670 unsigned long syminsz = 0;
4671
4672 for (i = 0, entry = dynamic_segment;
4673 i < dynamic_size;
4674 ++i, ++entry)
4675 {
4676 if (entry->d_tag == DT_SYMINENT)
4677 {
4678 /* Note: these braces are necessary to avoid a syntax
4679 error from the SunOS4 C compiler. */
4680 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4681 }
4682 else if (entry->d_tag == DT_SYMINSZ)
4683 syminsz = entry->d_un.d_val;
4684 else if (entry->d_tag == DT_SYMINFO)
4685 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4686 }
4687
4688 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4689 {
4690 Elf_External_Syminfo *extsyminfo;
4691 Elf_Internal_Syminfo *syminfo;
4692
4693 /* There is a syminfo section. Read the data. */
4694 extsyminfo = ((Elf_External_Syminfo *)
4695 get_data (NULL, file, dynamic_syminfo_offset,
4696 syminsz, _("symbol information")));
4697 if (!extsyminfo)
4698 return 0;
4699
4700 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4701 if (dynamic_syminfo == NULL)
4702 {
4703 error (_("Out of memory\n"));
4704 return 0;
4705 }
4706
4707 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4708 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4709 ++i, ++syminfo)
4710 {
4711 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4712 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4713 }
4714
4715 free (extsyminfo);
4716 }
4717 }
4718
4719 if (do_dynamic && dynamic_addr)
4720 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4721 dynamic_addr, (long) dynamic_size);
4722 if (do_dynamic)
4723 printf (_(" Tag Type Name/Value\n"));
4724
4725 for (i = 0, entry = dynamic_segment;
4726 i < dynamic_size;
4727 i++, entry++)
4728 {
4729 if (do_dynamic)
4730 {
4731 const char *dtype;
4732
4733 putchar (' ');
4734 print_vma (entry->d_tag, FULL_HEX);
4735 dtype = get_dynamic_type (entry->d_tag);
4736 printf (" (%s)%*s", dtype,
4737 ((is_32bit_elf ? 27 : 19)
4738 - (int) strlen (dtype)),
4739 " ");
4740 }
4741
4742 switch (entry->d_tag)
4743 {
4744 case DT_FLAGS:
4745 if (do_dynamic)
4746 puts (get_dynamic_flags (entry->d_un.d_val));
4747 break;
4748
4749 case DT_AUXILIARY:
4750 case DT_FILTER:
4751 case DT_CONFIG:
4752 case DT_DEPAUDIT:
4753 case DT_AUDIT:
4754 if (do_dynamic)
4755 {
4756 switch (entry->d_tag)
4757 {
4758 case DT_AUXILIARY:
4759 printf (_("Auxiliary library"));
4760 break;
4761
4762 case DT_FILTER:
4763 printf (_("Filter library"));
4764 break;
4765
4766 case DT_CONFIG:
4767 printf (_("Configuration file"));
4768 break;
4769
4770 case DT_DEPAUDIT:
4771 printf (_("Dependency audit library"));
4772 break;
4773
4774 case DT_AUDIT:
4775 printf (_("Audit library"));
4776 break;
4777 }
4778
4779 if (dynamic_strings)
4780 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4781 else
4782 {
4783 printf (": ");
4784 print_vma (entry->d_un.d_val, PREFIX_HEX);
4785 putchar ('\n');
4786 }
4787 }
4788 break;
4789
4790 case DT_FEATURE:
4791 if (do_dynamic)
4792 {
4793 printf (_("Flags:"));
4794
4795 if (entry->d_un.d_val == 0)
4796 printf (_(" None\n"));
4797 else
4798 {
4799 unsigned long int val = entry->d_un.d_val;
4800
4801 if (val & DTF_1_PARINIT)
4802 {
4803 printf (" PARINIT");
4804 val ^= DTF_1_PARINIT;
4805 }
4806 if (val & DTF_1_CONFEXP)
4807 {
4808 printf (" CONFEXP");
4809 val ^= DTF_1_CONFEXP;
4810 }
4811 if (val != 0)
4812 printf (" %lx", val);
4813 puts ("");
4814 }
4815 }
4816 break;
4817
4818 case DT_POSFLAG_1:
4819 if (do_dynamic)
4820 {
4821 printf (_("Flags:"));
4822
4823 if (entry->d_un.d_val == 0)
4824 printf (_(" None\n"));
4825 else
4826 {
4827 unsigned long int val = entry->d_un.d_val;
4828
4829 if (val & DF_P1_LAZYLOAD)
4830 {
4831 printf (" LAZYLOAD");
4832 val ^= DF_P1_LAZYLOAD;
4833 }
4834 if (val & DF_P1_GROUPPERM)
4835 {
4836 printf (" GROUPPERM");
4837 val ^= DF_P1_GROUPPERM;
4838 }
4839 if (val != 0)
4840 printf (" %lx", val);
4841 puts ("");
4842 }
4843 }
4844 break;
4845
4846 case DT_FLAGS_1:
4847 if (do_dynamic)
4848 {
4849 printf (_("Flags:"));
4850 if (entry->d_un.d_val == 0)
4851 printf (_(" None\n"));
4852 else
4853 {
4854 unsigned long int val = entry->d_un.d_val;
4855
4856 if (val & DF_1_NOW)
4857 {
4858 printf (" NOW");
4859 val ^= DF_1_NOW;
4860 }
4861 if (val & DF_1_GLOBAL)
4862 {
4863 printf (" GLOBAL");
4864 val ^= DF_1_GLOBAL;
4865 }
4866 if (val & DF_1_GROUP)
4867 {
4868 printf (" GROUP");
4869 val ^= DF_1_GROUP;
4870 }
4871 if (val & DF_1_NODELETE)
4872 {
4873 printf (" NODELETE");
4874 val ^= DF_1_NODELETE;
4875 }
4876 if (val & DF_1_LOADFLTR)
4877 {
4878 printf (" LOADFLTR");
4879 val ^= DF_1_LOADFLTR;
4880 }
4881 if (val & DF_1_INITFIRST)
4882 {
4883 printf (" INITFIRST");
4884 val ^= DF_1_INITFIRST;
4885 }
4886 if (val & DF_1_NOOPEN)
4887 {
4888 printf (" NOOPEN");
4889 val ^= DF_1_NOOPEN;
4890 }
4891 if (val & DF_1_ORIGIN)
4892 {
4893 printf (" ORIGIN");
4894 val ^= DF_1_ORIGIN;
4895 }
4896 if (val & DF_1_DIRECT)
4897 {
4898 printf (" DIRECT");
4899 val ^= DF_1_DIRECT;
4900 }
4901 if (val & DF_1_TRANS)
4902 {
4903 printf (" TRANS");
4904 val ^= DF_1_TRANS;
4905 }
4906 if (val & DF_1_INTERPOSE)
4907 {
4908 printf (" INTERPOSE");
4909 val ^= DF_1_INTERPOSE;
4910 }
4911 if (val & DF_1_NODEFLIB)
4912 {
4913 printf (" NODEFLIB");
4914 val ^= DF_1_NODEFLIB;
4915 }
4916 if (val & DF_1_NODUMP)
4917 {
4918 printf (" NODUMP");
4919 val ^= DF_1_NODUMP;
4920 }
4921 if (val & DF_1_CONLFAT)
4922 {
4923 printf (" CONLFAT");
4924 val ^= DF_1_CONLFAT;
4925 }
4926 if (val != 0)
4927 printf (" %lx", val);
4928 puts ("");
4929 }
4930 }
4931 break;
4932
4933 case DT_PLTREL:
4934 if (do_dynamic)
4935 puts (get_dynamic_type (entry->d_un.d_val));
4936 break;
4937
4938 case DT_NULL :
4939 case DT_NEEDED :
4940 case DT_PLTGOT :
4941 case DT_HASH :
4942 case DT_STRTAB :
4943 case DT_SYMTAB :
4944 case DT_RELA :
4945 case DT_INIT :
4946 case DT_FINI :
4947 case DT_SONAME :
4948 case DT_RPATH :
4949 case DT_SYMBOLIC:
4950 case DT_REL :
4951 case DT_DEBUG :
4952 case DT_TEXTREL :
4953 case DT_JMPREL :
4954 case DT_RUNPATH :
4955 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4956
4957 if (do_dynamic)
4958 {
4959 char *name;
4960
4961 if (dynamic_strings == NULL)
4962 name = NULL;
4963 else
4964 name = dynamic_strings + entry->d_un.d_val;
4965
4966 if (name)
4967 {
4968 switch (entry->d_tag)
4969 {
4970 case DT_NEEDED:
4971 printf (_("Shared library: [%s]"), name);
4972
4973 if (strcmp (name, program_interpreter) == 0)
4974 printf (_(" program interpreter"));
4975 break;
4976
4977 case DT_SONAME:
4978 printf (_("Library soname: [%s]"), name);
4979 break;
4980
4981 case DT_RPATH:
4982 printf (_("Library rpath: [%s]"), name);
4983 break;
4984
4985 case DT_RUNPATH:
4986 printf (_("Library runpath: [%s]"), name);
4987 break;
4988
4989 default:
4990 print_vma (entry->d_un.d_val, PREFIX_HEX);
4991 break;
4992 }
4993 }
4994 else
4995 print_vma (entry->d_un.d_val, PREFIX_HEX);
4996
4997 putchar ('\n');
4998 }
4999 break;
5000
5001 case DT_PLTRELSZ:
5002 case DT_RELASZ :
5003 case DT_STRSZ :
5004 case DT_RELSZ :
5005 case DT_RELAENT :
5006 case DT_SYMENT :
5007 case DT_RELENT :
5008 case DT_PLTPADSZ:
5009 case DT_MOVEENT :
5010 case DT_MOVESZ :
5011 case DT_INIT_ARRAYSZ:
5012 case DT_FINI_ARRAYSZ:
5013 case DT_GNU_CONFLICTSZ:
5014 case DT_GNU_LIBLISTSZ:
5015 if (do_dynamic)
5016 {
5017 print_vma (entry->d_un.d_val, UNSIGNED);
5018 printf (" (bytes)\n");
5019 }
5020 break;
5021
5022 case DT_VERDEFNUM:
5023 case DT_VERNEEDNUM:
5024 case DT_RELACOUNT:
5025 case DT_RELCOUNT:
5026 if (do_dynamic)
5027 {
5028 print_vma (entry->d_un.d_val, UNSIGNED);
5029 putchar ('\n');
5030 }
5031 break;
5032
5033 case DT_SYMINSZ:
5034 case DT_SYMINENT:
5035 case DT_SYMINFO:
5036 case DT_USED:
5037 case DT_INIT_ARRAY:
5038 case DT_FINI_ARRAY:
5039 if (do_dynamic)
5040 {
5041 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
5042 {
5043 char *name;
5044
5045 name = dynamic_strings + entry->d_un.d_val;
5046
5047 if (*name)
5048 {
5049 printf (_("Not needed object: [%s]\n"), name);
5050 break;
5051 }
5052 }
5053
5054 print_vma (entry->d_un.d_val, PREFIX_HEX);
5055 putchar ('\n');
5056 }
5057 break;
5058
5059 case DT_BIND_NOW:
5060 /* The value of this entry is ignored. */
5061 if (do_dynamic)
5062 putchar ('\n');
5063 break;
5064
5065 case DT_GNU_PRELINKED:
5066 if (do_dynamic)
5067 {
5068 struct tm *tmp;
5069 time_t time = entry->d_un.d_val;
5070
5071 tmp = gmtime (&time);
5072 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5073 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5074 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5075
5076 }
5077 break;
5078
5079 default:
5080 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
5081 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
5082 entry->d_un.d_val;
5083
5084 if (do_dynamic)
5085 {
5086 switch (elf_header.e_machine)
5087 {
5088 case EM_MIPS:
5089 case EM_MIPS_RS3_LE:
5090 dynamic_segment_mips_val (entry);
5091 break;
5092 case EM_PARISC:
5093 dynamic_segment_parisc_val (entry);
5094 break;
5095 default:
5096 print_vma (entry->d_un.d_val, PREFIX_HEX);
5097 putchar ('\n');
5098 }
5099 }
5100 break;
5101 }
5102 }
5103
5104 return 1;
5105 }
5106
5107 static char *
5108 get_ver_flags (flags)
5109 unsigned int flags;
5110 {
5111 static char buff[32];
5112
5113 buff[0] = 0;
5114
5115 if (flags == 0)
5116 return _("none");
5117
5118 if (flags & VER_FLG_BASE)
5119 strcat (buff, "BASE ");
5120
5121 if (flags & VER_FLG_WEAK)
5122 {
5123 if (flags & VER_FLG_BASE)
5124 strcat (buff, "| ");
5125
5126 strcat (buff, "WEAK ");
5127 }
5128
5129 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
5130 strcat (buff, "| <unknown>");
5131
5132 return buff;
5133 }
5134
5135 /* Display the contents of the version sections. */
5136 static int
5137 process_version_sections (file)
5138 FILE *file;
5139 {
5140 Elf_Internal_Shdr *section;
5141 unsigned i;
5142 int found = 0;
5143
5144 if (! do_version)
5145 return 1;
5146
5147 for (i = 0, section = section_headers;
5148 i < elf_header.e_shnum;
5149 i++, section++)
5150 {
5151 switch (section->sh_type)
5152 {
5153 case SHT_GNU_verdef:
5154 {
5155 Elf_External_Verdef *edefs;
5156 unsigned int idx;
5157 unsigned int cnt;
5158
5159 found = 1;
5160
5161 printf
5162 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5163 SECTION_NAME (section), section->sh_info);
5164
5165 printf (_(" Addr: 0x"));
5166 printf_vma (section->sh_addr);
5167 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5168 (unsigned long) section->sh_offset, section->sh_link,
5169 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5170
5171 edefs = ((Elf_External_Verdef *)
5172 get_data (NULL, file, section->sh_offset,
5173 section->sh_size,
5174 _("version definition section")));
5175 if (!edefs)
5176 break;
5177
5178 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5179 {
5180 char *vstart;
5181 Elf_External_Verdef *edef;
5182 Elf_Internal_Verdef ent;
5183 Elf_External_Verdaux *eaux;
5184 Elf_Internal_Verdaux aux;
5185 int j;
5186 int isum;
5187
5188 vstart = ((char *) edefs) + idx;
5189
5190 edef = (Elf_External_Verdef *) vstart;
5191
5192 ent.vd_version = BYTE_GET (edef->vd_version);
5193 ent.vd_flags = BYTE_GET (edef->vd_flags);
5194 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5195 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5196 ent.vd_hash = BYTE_GET (edef->vd_hash);
5197 ent.vd_aux = BYTE_GET (edef->vd_aux);
5198 ent.vd_next = BYTE_GET (edef->vd_next);
5199
5200 printf (_(" %#06x: Rev: %d Flags: %s"),
5201 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5202
5203 printf (_(" Index: %d Cnt: %d "),
5204 ent.vd_ndx, ent.vd_cnt);
5205
5206 vstart += ent.vd_aux;
5207
5208 eaux = (Elf_External_Verdaux *) vstart;
5209
5210 aux.vda_name = BYTE_GET (eaux->vda_name);
5211 aux.vda_next = BYTE_GET (eaux->vda_next);
5212
5213 if (dynamic_strings)
5214 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5215 else
5216 printf (_("Name index: %ld\n"), aux.vda_name);
5217
5218 isum = idx + ent.vd_aux;
5219
5220 for (j = 1; j < ent.vd_cnt; j++)
5221 {
5222 isum += aux.vda_next;
5223 vstart += aux.vda_next;
5224
5225 eaux = (Elf_External_Verdaux *) vstart;
5226
5227 aux.vda_name = BYTE_GET (eaux->vda_name);
5228 aux.vda_next = BYTE_GET (eaux->vda_next);
5229
5230 if (dynamic_strings)
5231 printf (_(" %#06x: Parent %d: %s\n"),
5232 isum, j, dynamic_strings + aux.vda_name);
5233 else
5234 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5235 isum, j, aux.vda_name);
5236 }
5237
5238 idx += ent.vd_next;
5239 }
5240
5241 free (edefs);
5242 }
5243 break;
5244
5245 case SHT_GNU_verneed:
5246 {
5247 Elf_External_Verneed *eneed;
5248 unsigned int idx;
5249 unsigned int cnt;
5250
5251 found = 1;
5252
5253 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5254 SECTION_NAME (section), section->sh_info);
5255
5256 printf (_(" Addr: 0x"));
5257 printf_vma (section->sh_addr);
5258 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5259 (unsigned long) section->sh_offset, section->sh_link,
5260 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5261
5262 eneed = ((Elf_External_Verneed *)
5263 get_data (NULL, file, section->sh_offset,
5264 section->sh_size, _("version need section")));
5265 if (!eneed)
5266 break;
5267
5268 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5269 {
5270 Elf_External_Verneed *entry;
5271 Elf_Internal_Verneed ent;
5272 int j;
5273 int isum;
5274 char *vstart;
5275
5276 vstart = ((char *) eneed) + idx;
5277
5278 entry = (Elf_External_Verneed *) vstart;
5279
5280 ent.vn_version = BYTE_GET (entry->vn_version);
5281 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5282 ent.vn_file = BYTE_GET (entry->vn_file);
5283 ent.vn_aux = BYTE_GET (entry->vn_aux);
5284 ent.vn_next = BYTE_GET (entry->vn_next);
5285
5286 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5287
5288 if (dynamic_strings)
5289 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5290 else
5291 printf (_(" File: %lx"), ent.vn_file);
5292
5293 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5294
5295 vstart += ent.vn_aux;
5296
5297 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5298 {
5299 Elf_External_Vernaux *eaux;
5300 Elf_Internal_Vernaux aux;
5301
5302 eaux = (Elf_External_Vernaux *) vstart;
5303
5304 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5305 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5306 aux.vna_other = BYTE_GET (eaux->vna_other);
5307 aux.vna_name = BYTE_GET (eaux->vna_name);
5308 aux.vna_next = BYTE_GET (eaux->vna_next);
5309
5310 if (dynamic_strings)
5311 printf (_(" %#06x: Name: %s"),
5312 isum, dynamic_strings + aux.vna_name);
5313 else
5314 printf (_(" %#06x: Name index: %lx"),
5315 isum, aux.vna_name);
5316
5317 printf (_(" Flags: %s Version: %d\n"),
5318 get_ver_flags (aux.vna_flags), aux.vna_other);
5319
5320 isum += aux.vna_next;
5321 vstart += aux.vna_next;
5322 }
5323
5324 idx += ent.vn_next;
5325 }
5326
5327 free (eneed);
5328 }
5329 break;
5330
5331 case SHT_GNU_versym:
5332 {
5333 Elf_Internal_Shdr *link_section;
5334 int total;
5335 int cnt;
5336 unsigned char *edata;
5337 unsigned short *data;
5338 char *strtab;
5339 Elf_Internal_Sym *symbols;
5340 Elf_Internal_Shdr *string_sec;
5341
5342 link_section = SECTION_HEADER (section->sh_link);
5343 total = section->sh_size / section->sh_entsize;
5344
5345 found = 1;
5346
5347 symbols = GET_ELF_SYMBOLS (file, link_section);
5348
5349 string_sec = SECTION_HEADER (link_section->sh_link);
5350
5351 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5352 string_sec->sh_size,
5353 _("version string table"));
5354 if (!strtab)
5355 break;
5356
5357 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5358 SECTION_NAME (section), total);
5359
5360 printf (_(" Addr: "));
5361 printf_vma (section->sh_addr);
5362 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5363 (unsigned long) section->sh_offset, section->sh_link,
5364 SECTION_NAME (link_section));
5365
5366 edata =
5367 ((unsigned char *)
5368 get_data (NULL, file,
5369 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
5370 total * sizeof (short), _("version symbol data")));
5371 if (!edata)
5372 {
5373 free (strtab);
5374 break;
5375 }
5376
5377 data = (unsigned short *) malloc (total * sizeof (short));
5378
5379 for (cnt = total; cnt --;)
5380 data[cnt] = byte_get (edata + cnt * sizeof (short),
5381 sizeof (short));
5382
5383 free (edata);
5384
5385 for (cnt = 0; cnt < total; cnt += 4)
5386 {
5387 int j, nn;
5388 int check_def, check_need;
5389 char *name;
5390
5391 printf (" %03x:", cnt);
5392
5393 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5394 switch (data[cnt + j])
5395 {
5396 case 0:
5397 fputs (_(" 0 (*local*) "), stdout);
5398 break;
5399
5400 case 1:
5401 fputs (_(" 1 (*global*) "), stdout);
5402 break;
5403
5404 default:
5405 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
5406 data[cnt + j] & 0x8000 ? 'h' : ' ');
5407
5408 check_def = 1;
5409 check_need = 1;
5410 if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
5411 != SHT_NOBITS)
5412 {
5413 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
5414 check_def = 0;
5415 else
5416 check_need = 0;
5417 }
5418
5419 if (check_need
5420 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
5421 {
5422 Elf_Internal_Verneed ivn;
5423 unsigned long offset;
5424
5425 offset = version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5426 - loadaddr;
5427
5428 do
5429 {
5430 Elf_Internal_Vernaux ivna;
5431 Elf_External_Verneed evn;
5432 Elf_External_Vernaux evna;
5433 unsigned long a_off;
5434
5435 get_data (&evn, file, offset, sizeof (evn),
5436 _("version need"));
5437
5438 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5439 ivn.vn_next = BYTE_GET (evn.vn_next);
5440
5441 a_off = offset + ivn.vn_aux;
5442
5443 do
5444 {
5445 get_data (&evna, file, a_off, sizeof (evna),
5446 _("version need aux (2)"));
5447
5448 ivna.vna_next = BYTE_GET (evna.vna_next);
5449 ivna.vna_other = BYTE_GET (evna.vna_other);
5450
5451 a_off += ivna.vna_next;
5452 }
5453 while (ivna.vna_other != data[cnt + j]
5454 && ivna.vna_next != 0);
5455
5456 if (ivna.vna_other == data[cnt + j])
5457 {
5458 ivna.vna_name = BYTE_GET (evna.vna_name);
5459
5460 name = strtab + ivna.vna_name;
5461 nn += printf ("(%s%-*s",
5462 name,
5463 12 - (int) strlen (name),
5464 ")");
5465 check_def = 0;
5466 break;
5467 }
5468
5469 offset += ivn.vn_next;
5470 }
5471 while (ivn.vn_next);
5472 }
5473
5474 if (check_def && data[cnt + j] != 0x8001
5475 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5476 {
5477 Elf_Internal_Verdef ivd;
5478 Elf_External_Verdef evd;
5479 unsigned long offset;
5480
5481 offset = (version_info[DT_VERSIONTAGIDX (DT_VERDEF)]
5482 - loadaddr);
5483
5484 do
5485 {
5486 get_data (&evd, file, offset, sizeof (evd),
5487 _("version def"));
5488
5489 ivd.vd_next = BYTE_GET (evd.vd_next);
5490 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5491
5492 offset += ivd.vd_next;
5493 }
5494 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
5495 && ivd.vd_next != 0);
5496
5497 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
5498 {
5499 Elf_External_Verdaux evda;
5500 Elf_Internal_Verdaux ivda;
5501
5502 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5503
5504 get_data (&evda, file,
5505 offset - ivd.vd_next + ivd.vd_aux,
5506 sizeof (evda), _("version def aux"));
5507
5508 ivda.vda_name = BYTE_GET (evda.vda_name);
5509
5510 name = strtab + ivda.vda_name;
5511 nn += printf ("(%s%-*s",
5512 name,
5513 12 - (int) strlen (name),
5514 ")");
5515 }
5516 }
5517
5518 if (nn < 18)
5519 printf ("%*c", 18 - nn, ' ');
5520 }
5521
5522 putchar ('\n');
5523 }
5524
5525 free (data);
5526 free (strtab);
5527 free (symbols);
5528 }
5529 break;
5530
5531 default:
5532 break;
5533 }
5534 }
5535
5536 if (! found)
5537 printf (_("\nNo version information found in this file.\n"));
5538
5539 return 1;
5540 }
5541
5542 static const char *
5543 get_symbol_binding (binding)
5544 unsigned int binding;
5545 {
5546 static char buff[32];
5547
5548 switch (binding)
5549 {
5550 case STB_LOCAL: return "LOCAL";
5551 case STB_GLOBAL: return "GLOBAL";
5552 case STB_WEAK: return "WEAK";
5553 default:
5554 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5555 sprintf (buff, _("<processor specific>: %d"), binding);
5556 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5557 sprintf (buff, _("<OS specific>: %d"), binding);
5558 else
5559 sprintf (buff, _("<unknown>: %d"), binding);
5560 return buff;
5561 }
5562 }
5563
5564 static const char *
5565 get_symbol_type (type)
5566 unsigned int type;
5567 {
5568 static char buff[32];
5569
5570 switch (type)
5571 {
5572 case STT_NOTYPE: return "NOTYPE";
5573 case STT_OBJECT: return "OBJECT";
5574 case STT_FUNC: return "FUNC";
5575 case STT_SECTION: return "SECTION";
5576 case STT_FILE: return "FILE";
5577 case STT_COMMON: return "COMMON";
5578 case STT_TLS: return "TLS";
5579 default:
5580 if (type >= STT_LOPROC && type <= STT_HIPROC)
5581 {
5582 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5583 return "THUMB_FUNC";
5584
5585 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5586 return "REGISTER";
5587
5588 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5589 return "PARISC_MILLI";
5590
5591 sprintf (buff, _("<processor specific>: %d"), type);
5592 }
5593 else if (type >= STT_LOOS && type <= STT_HIOS)
5594 {
5595 if (elf_header.e_machine == EM_PARISC)
5596 {
5597 if (type == STT_HP_OPAQUE)
5598 return "HP_OPAQUE";
5599 if (type == STT_HP_STUB)
5600 return "HP_STUB";
5601 }
5602
5603 sprintf (buff, _("<OS specific>: %d"), type);
5604 }
5605 else
5606 sprintf (buff, _("<unknown>: %d"), type);
5607 return buff;
5608 }
5609 }
5610
5611 static const char *
5612 get_symbol_visibility (visibility)
5613 unsigned int visibility;
5614 {
5615 switch (visibility)
5616 {
5617 case STV_DEFAULT: return "DEFAULT";
5618 case STV_INTERNAL: return "INTERNAL";
5619 case STV_HIDDEN: return "HIDDEN";
5620 case STV_PROTECTED: return "PROTECTED";
5621 default: abort ();
5622 }
5623 }
5624
5625 static const char *
5626 get_symbol_index_type (type)
5627 unsigned int type;
5628 {
5629 static char buff[32];
5630
5631 switch (type)
5632 {
5633 case SHN_UNDEF: return "UND";
5634 case SHN_ABS: return "ABS";
5635 case SHN_COMMON: return "COM";
5636 default:
5637 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5638 sprintf (buff, "PRC[0x%04x]", type);
5639 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5640 sprintf (buff, "OS [0x%04x]", type);
5641 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5642 sprintf (buff, "RSV[0x%04x]", type);
5643 else
5644 sprintf (buff, "%3d", type);
5645 break;
5646 }
5647
5648 return buff;
5649 }
5650
5651 static int *
5652 get_dynamic_data (file, number)
5653 FILE *file;
5654 unsigned int number;
5655 {
5656 unsigned char *e_data;
5657 int *i_data;
5658
5659 e_data = (unsigned char *) malloc (number * 4);
5660
5661 if (e_data == NULL)
5662 {
5663 error (_("Out of memory\n"));
5664 return NULL;
5665 }
5666
5667 if (fread (e_data, 4, number, file) != number)
5668 {
5669 error (_("Unable to read in dynamic data\n"));
5670 return NULL;
5671 }
5672
5673 i_data = (int *) malloc (number * sizeof (*i_data));
5674
5675 if (i_data == NULL)
5676 {
5677 error (_("Out of memory\n"));
5678 free (e_data);
5679 return NULL;
5680 }
5681
5682 while (number--)
5683 i_data[number] = byte_get (e_data + number * 4, 4);
5684
5685 free (e_data);
5686
5687 return i_data;
5688 }
5689
5690 /* Dump the symbol table. */
5691 static int
5692 process_symbol_table (file)
5693 FILE *file;
5694 {
5695 Elf_Internal_Shdr *section;
5696 unsigned char nb[4];
5697 unsigned char nc[4];
5698 int nbuckets = 0;
5699 int nchains = 0;
5700 int *buckets = NULL;
5701 int *chains = NULL;
5702
5703 if (! do_syms && !do_histogram)
5704 return 1;
5705
5706 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5707 || do_histogram))
5708 {
5709 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5710 {
5711 error (_("Unable to seek to start of dynamic information"));
5712 return 0;
5713 }
5714
5715 if (fread (nb, sizeof (nb), 1, file) != 1)
5716 {
5717 error (_("Failed to read in number of buckets\n"));
5718 return 0;
5719 }
5720
5721 if (fread (nc, sizeof (nc), 1, file) != 1)
5722 {
5723 error (_("Failed to read in number of chains\n"));
5724 return 0;
5725 }
5726
5727 nbuckets = byte_get (nb, 4);
5728 nchains = byte_get (nc, 4);
5729
5730 buckets = get_dynamic_data (file, nbuckets);
5731 chains = get_dynamic_data (file, nchains);
5732
5733 if (buckets == NULL || chains == NULL)
5734 return 0;
5735 }
5736
5737 if (do_syms
5738 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5739 {
5740 int hn;
5741 int si;
5742
5743 printf (_("\nSymbol table for image:\n"));
5744 if (is_32bit_elf)
5745 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5746 else
5747 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5748
5749 for (hn = 0; hn < nbuckets; hn++)
5750 {
5751 if (! buckets[hn])
5752 continue;
5753
5754 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
5755 {
5756 Elf_Internal_Sym *psym;
5757
5758 psym = dynamic_symbols + si;
5759
5760 printf (" %3d %3d: ", si, hn);
5761 print_vma (psym->st_value, LONG_HEX);
5762 putchar (' ' );
5763 print_vma (psym->st_size, DEC_5);
5764
5765 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5766 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5767 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5768 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5769 print_symbol (25, dynamic_strings + psym->st_name);
5770 putchar ('\n');
5771 }
5772 }
5773 }
5774 else if (do_syms && !do_using_dynamic)
5775 {
5776 unsigned int i;
5777
5778 for (i = 0, section = section_headers;
5779 i < elf_header.e_shnum;
5780 i++, section++)
5781 {
5782 unsigned int si;
5783 char *strtab;
5784 Elf_Internal_Sym *symtab;
5785 Elf_Internal_Sym *psym;
5786
5787
5788 if ( section->sh_type != SHT_SYMTAB
5789 && section->sh_type != SHT_DYNSYM)
5790 continue;
5791
5792 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5793 SECTION_NAME (section),
5794 (unsigned long) (section->sh_size / section->sh_entsize));
5795 if (is_32bit_elf)
5796 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5797 else
5798 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5799
5800 symtab = GET_ELF_SYMBOLS (file, section);
5801 if (symtab == NULL)
5802 continue;
5803
5804 if (section->sh_link == elf_header.e_shstrndx)
5805 strtab = string_table;
5806 else
5807 {
5808 Elf_Internal_Shdr *string_sec;
5809
5810 string_sec = SECTION_HEADER (section->sh_link);
5811
5812 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5813 string_sec->sh_size,
5814 _("string table"));
5815 }
5816
5817 for (si = 0, psym = symtab;
5818 si < section->sh_size / section->sh_entsize;
5819 si++, psym++)
5820 {
5821 printf ("%6d: ", si);
5822 print_vma (psym->st_value, LONG_HEX);
5823 putchar (' ');
5824 print_vma (psym->st_size, DEC_5);
5825 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5826 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5827 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5828 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5829 print_symbol (25, strtab + psym->st_name);
5830
5831 if (section->sh_type == SHT_DYNSYM &&
5832 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5833 {
5834 unsigned char data[2];
5835 unsigned short vers_data;
5836 unsigned long offset;
5837 int is_nobits;
5838 int check_def;
5839
5840 offset = version_info[DT_VERSIONTAGIDX (DT_VERSYM)]
5841 - loadaddr;
5842
5843 get_data (&data, file, offset + si * sizeof (vers_data),
5844 sizeof (data), _("version data"));
5845
5846 vers_data = byte_get (data, 2);
5847
5848 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5849 == SHT_NOBITS);
5850
5851 check_def = (psym->st_shndx != SHN_UNDEF);
5852
5853 if ((vers_data & 0x8000) || vers_data > 1)
5854 {
5855 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5856 && (is_nobits || ! check_def))
5857 {
5858 Elf_External_Verneed evn;
5859 Elf_Internal_Verneed ivn;
5860 Elf_Internal_Vernaux ivna;
5861
5862 /* We must test both. */
5863 offset = (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5864 - loadaddr);
5865
5866 do
5867 {
5868 unsigned long vna_off;
5869
5870 get_data (&evn, file, offset, sizeof (evn),
5871 _("version need"));
5872
5873 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5874 ivn.vn_next = BYTE_GET (evn.vn_next);
5875
5876 vna_off = offset + ivn.vn_aux;
5877
5878 do
5879 {
5880 Elf_External_Vernaux evna;
5881
5882 get_data (&evna, file, vna_off,
5883 sizeof (evna),
5884 _("version need aux (3)"));
5885
5886 ivna.vna_other = BYTE_GET (evna.vna_other);
5887 ivna.vna_next = BYTE_GET (evna.vna_next);
5888 ivna.vna_name = BYTE_GET (evna.vna_name);
5889
5890 vna_off += ivna.vna_next;
5891 }
5892 while (ivna.vna_other != vers_data
5893 && ivna.vna_next != 0);
5894
5895 if (ivna.vna_other == vers_data)
5896 break;
5897
5898 offset += ivn.vn_next;
5899 }
5900 while (ivn.vn_next != 0);
5901
5902 if (ivna.vna_other == vers_data)
5903 {
5904 printf ("@%s (%d)",
5905 strtab + ivna.vna_name, ivna.vna_other);
5906 check_def = 0;
5907 }
5908 else if (! is_nobits)
5909 error (_("bad dynamic symbol"));
5910 else
5911 check_def = 1;
5912 }
5913
5914 if (check_def)
5915 {
5916 if (vers_data != 0x8001
5917 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5918 {
5919 Elf_Internal_Verdef ivd;
5920 Elf_Internal_Verdaux ivda;
5921 Elf_External_Verdaux evda;
5922 unsigned long offset;
5923
5924 offset
5925 = (version_info[DT_VERSIONTAGIDX (DT_VERDEF)]
5926 - loadaddr);
5927
5928 do
5929 {
5930 Elf_External_Verdef evd;
5931
5932 get_data (&evd, file, offset, sizeof (evd),
5933 _("version def"));
5934
5935 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5936 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5937 ivd.vd_next = BYTE_GET (evd.vd_next);
5938
5939 offset += ivd.vd_next;
5940 }
5941 while (ivd.vd_ndx != (vers_data & 0x7fff)
5942 && ivd.vd_next != 0);
5943
5944 offset -= ivd.vd_next;
5945 offset += ivd.vd_aux;
5946
5947 get_data (&evda, file, offset, sizeof (evda),
5948 _("version def aux"));
5949
5950 ivda.vda_name = BYTE_GET (evda.vda_name);
5951
5952 if (psym->st_name != ivda.vda_name)
5953 printf ((vers_data & 0x8000)
5954 ? "@%s" : "@@%s",
5955 strtab + ivda.vda_name);
5956 }
5957 }
5958 }
5959 }
5960
5961 putchar ('\n');
5962 }
5963
5964 free (symtab);
5965 if (strtab != string_table)
5966 free (strtab);
5967 }
5968 }
5969 else if (do_syms)
5970 printf
5971 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5972
5973 if (do_histogram && buckets != NULL)
5974 {
5975 int *lengths;
5976 int *counts;
5977 int hn;
5978 int si;
5979 int maxlength = 0;
5980 int nzero_counts = 0;
5981 int nsyms = 0;
5982
5983 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5984 nbuckets);
5985 printf (_(" Length Number %% of total Coverage\n"));
5986
5987 lengths = (int *) calloc (nbuckets, sizeof (int));
5988 if (lengths == NULL)
5989 {
5990 error (_("Out of memory"));
5991 return 0;
5992 }
5993 for (hn = 0; hn < nbuckets; ++hn)
5994 {
5995 if (! buckets[hn])
5996 continue;
5997
5998 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5999 {
6000 ++nsyms;
6001 if (maxlength < ++lengths[hn])
6002 ++maxlength;
6003 }
6004 }
6005
6006 counts = (int *) calloc (maxlength + 1, sizeof (int));
6007 if (counts == NULL)
6008 {
6009 error (_("Out of memory"));
6010 return 0;
6011 }
6012
6013 for (hn = 0; hn < nbuckets; ++hn)
6014 ++counts[lengths[hn]];
6015
6016 if (nbuckets > 0)
6017 {
6018 printf (" 0 %-10d (%5.1f%%)\n",
6019 counts[0], (counts[0] * 100.0) / nbuckets);
6020 for (si = 1; si <= maxlength; ++si)
6021 {
6022 nzero_counts += counts[si] * si;
6023 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6024 si, counts[si], (counts[si] * 100.0) / nbuckets,
6025 (nzero_counts * 100.0) / nsyms);
6026 }
6027 }
6028
6029 free (counts);
6030 free (lengths);
6031 }
6032
6033 if (buckets != NULL)
6034 {
6035 free (buckets);
6036 free (chains);
6037 }
6038
6039 return 1;
6040 }
6041
6042 static int
6043 process_syminfo (file)
6044 FILE *file ATTRIBUTE_UNUSED;
6045 {
6046 unsigned int i;
6047
6048 if (dynamic_syminfo == NULL
6049 || !do_dynamic)
6050 /* No syminfo, this is ok. */
6051 return 1;
6052
6053 /* There better should be a dynamic symbol section. */
6054 if (dynamic_symbols == NULL || dynamic_strings == NULL)
6055 return 0;
6056
6057 if (dynamic_addr)
6058 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6059 dynamic_syminfo_offset, dynamic_syminfo_nent);
6060
6061 printf (_(" Num: Name BoundTo Flags\n"));
6062 for (i = 0; i < dynamic_syminfo_nent; ++i)
6063 {
6064 unsigned short int flags = dynamic_syminfo[i].si_flags;
6065
6066 printf ("%4d: ", i);
6067 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
6068 putchar (' ');
6069
6070 switch (dynamic_syminfo[i].si_boundto)
6071 {
6072 case SYMINFO_BT_SELF:
6073 fputs ("SELF ", stdout);
6074 break;
6075 case SYMINFO_BT_PARENT:
6076 fputs ("PARENT ", stdout);
6077 break;
6078 default:
6079 if (dynamic_syminfo[i].si_boundto > 0
6080 && dynamic_syminfo[i].si_boundto < dynamic_size)
6081 {
6082 print_symbol (10,
6083 dynamic_strings
6084 + (dynamic_segment
6085 [dynamic_syminfo[i].si_boundto].d_un.d_val));
6086 putchar (' ' );
6087 }
6088 else
6089 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
6090 break;
6091 }
6092
6093 if (flags & SYMINFO_FLG_DIRECT)
6094 printf (" DIRECT");
6095 if (flags & SYMINFO_FLG_PASSTHRU)
6096 printf (" PASSTHRU");
6097 if (flags & SYMINFO_FLG_COPY)
6098 printf (" COPY");
6099 if (flags & SYMINFO_FLG_LAZYLOAD)
6100 printf (" LAZYLOAD");
6101
6102 puts ("");
6103 }
6104
6105 return 1;
6106 }
6107
6108 #ifdef SUPPORT_DISASSEMBLY
6109 static void
6110 disassemble_section (section, file)
6111 Elf_Internal_Shdr *section;
6112 FILE *file;
6113 {
6114 printf (_("\nAssembly dump of section %s\n"),
6115 SECTION_NAME (section));
6116
6117 /* XXX -- to be done --- XXX */
6118
6119 return 1;
6120 }
6121 #endif
6122
6123 static int
6124 dump_section (section, file)
6125 Elf_Internal_Shdr *section;
6126 FILE *file;
6127 {
6128 bfd_size_type bytes;
6129 bfd_vma addr;
6130 unsigned char *data;
6131 unsigned char *start;
6132
6133 bytes = section->sh_size;
6134
6135 if (bytes == 0)
6136 {
6137 printf (_("\nSection '%s' has no data to dump.\n"),
6138 SECTION_NAME (section));
6139 return 0;
6140 }
6141 else
6142 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6143
6144 addr = section->sh_addr;
6145
6146 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
6147 _("section data"));
6148 if (!start)
6149 return 0;
6150
6151 data = start;
6152
6153 while (bytes)
6154 {
6155 int j;
6156 int k;
6157 int lbytes;
6158
6159 lbytes = (bytes > 16 ? 16 : bytes);
6160
6161 printf (" 0x%8.8lx ", (unsigned long) addr);
6162
6163 switch (elf_header.e_ident[EI_DATA])
6164 {
6165 default:
6166 case ELFDATA2LSB:
6167 for (j = 15; j >= 0; j --)
6168 {
6169 if (j < lbytes)
6170 printf ("%2.2x", data[j]);
6171 else
6172 printf (" ");
6173
6174 if (!(j & 0x3))
6175 printf (" ");
6176 }
6177 break;
6178
6179 case ELFDATA2MSB:
6180 for (j = 0; j < 16; j++)
6181 {
6182 if (j < lbytes)
6183 printf ("%2.2x", data[j]);
6184 else
6185 printf (" ");
6186
6187 if ((j & 3) == 3)
6188 printf (" ");
6189 }
6190 break;
6191 }
6192
6193 for (j = 0; j < lbytes; j++)
6194 {
6195 k = data[j];
6196 if (k >= ' ' && k < 0x80)
6197 printf ("%c", k);
6198 else
6199 printf (".");
6200 }
6201
6202 putchar ('\n');
6203
6204 data += lbytes;
6205 addr += lbytes;
6206 bytes -= lbytes;
6207 }
6208
6209 free (start);
6210
6211 return 1;
6212 }
6213
6214
6215 static unsigned long int
6216 read_leb128 (data, length_return, sign)
6217 unsigned char *data;
6218 int *length_return;
6219 int sign;
6220 {
6221 unsigned long int result = 0;
6222 unsigned int num_read = 0;
6223 int shift = 0;
6224 unsigned char byte;
6225
6226 do
6227 {
6228 byte = *data++;
6229 num_read++;
6230
6231 result |= (byte & 0x7f) << shift;
6232
6233 shift += 7;
6234
6235 }
6236 while (byte & 0x80);
6237
6238 if (length_return != NULL)
6239 *length_return = num_read;
6240
6241 if (sign && (shift < 32) && (byte & 0x40))
6242 result |= -1 << shift;
6243
6244 return result;
6245 }
6246
6247 typedef struct State_Machine_Registers
6248 {
6249 unsigned long address;
6250 unsigned int file;
6251 unsigned int line;
6252 unsigned int column;
6253 int is_stmt;
6254 int basic_block;
6255 int end_sequence;
6256 /* This variable hold the number of the last entry seen
6257 in the File Table. */
6258 unsigned int last_file_entry;
6259 } SMR;
6260
6261 static SMR state_machine_regs;
6262
6263 static void
6264 reset_state_machine (is_stmt)
6265 int is_stmt;
6266 {
6267 state_machine_regs.address = 0;
6268 state_machine_regs.file = 1;
6269 state_machine_regs.line = 1;
6270 state_machine_regs.column = 0;
6271 state_machine_regs.is_stmt = is_stmt;
6272 state_machine_regs.basic_block = 0;
6273 state_machine_regs.end_sequence = 0;
6274 state_machine_regs.last_file_entry = 0;
6275 }
6276
6277 /* Handled an extend line op. Returns true if this is the end
6278 of sequence. */
6279 static int
6280 process_extended_line_op (data, is_stmt, pointer_size)
6281 unsigned char *data;
6282 int is_stmt;
6283 int pointer_size;
6284 {
6285 unsigned char op_code;
6286 int bytes_read;
6287 unsigned int len;
6288 unsigned char *name;
6289 unsigned long adr;
6290
6291 len = read_leb128 (data, & bytes_read, 0);
6292 data += bytes_read;
6293
6294 if (len == 0)
6295 {
6296 warn (_("badly formed extended line op encountered!\n"));
6297 return bytes_read;
6298 }
6299
6300 len += bytes_read;
6301 op_code = *data++;
6302
6303 printf (_(" Extended opcode %d: "), op_code);
6304
6305 switch (op_code)
6306 {
6307 case DW_LNE_end_sequence:
6308 printf (_("End of Sequence\n\n"));
6309 reset_state_machine (is_stmt);
6310 break;
6311
6312 case DW_LNE_set_address:
6313 adr = byte_get (data, pointer_size);
6314 printf (_("set Address to 0x%lx\n"), adr);
6315 state_machine_regs.address = adr;
6316 break;
6317
6318 case DW_LNE_define_file:
6319 printf (_(" define new File Table entry\n"));
6320 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6321
6322 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6323 name = data;
6324 data += strlen ((char *) data) + 1;
6325 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6326 data += bytes_read;
6327 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6328 data += bytes_read;
6329 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6330 printf (_("%s\n\n"), name);
6331 break;
6332
6333 default:
6334 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6335 break;
6336 }
6337
6338 return len;
6339 }
6340
6341 /* Size of pointers in the .debug_line section. This information is not
6342 really present in that section. It's obtained before dumping the debug
6343 sections by doing some pre-scan of the .debug_info section. */
6344 static int debug_line_pointer_size = 4;
6345
6346 static int
6347 display_debug_lines (section, start, file)
6348 Elf_Internal_Shdr *section;
6349 unsigned char * start;
6350 FILE *file ATTRIBUTE_UNUSED;
6351 {
6352 DWARF2_External_LineInfo *external;
6353 DWARF2_Internal_LineInfo info;
6354 unsigned char *standard_opcodes;
6355 unsigned char *data = start;
6356 unsigned char *end = start + section->sh_size;
6357 unsigned char *end_of_sequence;
6358 int i;
6359
6360 printf (_("\nDump of debug contents of section %s:\n\n"),
6361 SECTION_NAME (section));
6362
6363 while (data < end)
6364 {
6365 external = (DWARF2_External_LineInfo *) data;
6366
6367 /* Check the length of the block. */
6368 info.li_length = BYTE_GET (external->li_length);
6369
6370 if (info.li_length == 0xffffffff)
6371 {
6372 warn (_("64-bit DWARF line info is not supported yet.\n"));
6373 break;
6374 }
6375
6376 if (info.li_length + sizeof (external->li_length) > section->sh_size)
6377 {
6378 warn
6379 (_("The line info appears to be corrupt - the section is too small\n"));
6380 return 0;
6381 }
6382
6383 /* Check its version number. */
6384 info.li_version = BYTE_GET (external->li_version);
6385 if (info.li_version != 2)
6386 {
6387 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6388 return 0;
6389 }
6390
6391 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
6392 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
6393 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
6394 info.li_line_base = BYTE_GET (external->li_line_base);
6395 info.li_line_range = BYTE_GET (external->li_line_range);
6396 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
6397
6398 /* Sign extend the line base field. */
6399 info.li_line_base <<= 24;
6400 info.li_line_base >>= 24;
6401
6402 printf (_(" Length: %ld\n"), info.li_length);
6403 printf (_(" DWARF Version: %d\n"), info.li_version);
6404 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6405 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6406 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6407 printf (_(" Line Base: %d\n"), info.li_line_base);
6408 printf (_(" Line Range: %d\n"), info.li_line_range);
6409 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6410
6411 end_of_sequence = data + info.li_length + sizeof (external->li_length);
6412
6413 reset_state_machine (info.li_default_is_stmt);
6414
6415 /* Display the contents of the Opcodes table. */
6416 standard_opcodes = data + sizeof (*external);
6417
6418 printf (_("\n Opcodes:\n"));
6419
6420 for (i = 1; i < info.li_opcode_base; i++)
6421 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6422
6423 /* Display the contents of the Directory table. */
6424 data = standard_opcodes + info.li_opcode_base - 1;
6425
6426 if (*data == 0)
6427 printf (_("\n The Directory Table is empty.\n"));
6428 else
6429 {
6430 printf (_("\n The Directory Table:\n"));
6431
6432 while (*data != 0)
6433 {
6434 printf (_(" %s\n"), data);
6435
6436 data += strlen ((char *) data) + 1;
6437 }
6438 }
6439
6440 /* Skip the NUL at the end of the table. */
6441 data++;
6442
6443 /* Display the contents of the File Name table. */
6444 if (*data == 0)
6445 printf (_("\n The File Name Table is empty.\n"));
6446 else
6447 {
6448 printf (_("\n The File Name Table:\n"));
6449 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6450
6451 while (*data != 0)
6452 {
6453 unsigned char *name;
6454 int bytes_read;
6455
6456 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6457 name = data;
6458
6459 data += strlen ((char *) data) + 1;
6460
6461 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6462 data += bytes_read;
6463 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6464 data += bytes_read;
6465 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6466 data += bytes_read;
6467 printf (_("%s\n"), name);
6468 }
6469 }
6470
6471 /* Skip the NUL at the end of the table. */
6472 data++;
6473
6474 /* Now display the statements. */
6475 printf (_("\n Line Number Statements:\n"));
6476
6477
6478 while (data < end_of_sequence)
6479 {
6480 unsigned char op_code;
6481 int adv;
6482 int bytes_read;
6483
6484 op_code = *data++;
6485
6486 if (op_code >= info.li_opcode_base)
6487 {
6488 op_code -= info.li_opcode_base;
6489 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6490 state_machine_regs.address += adv;
6491 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6492 op_code, adv, state_machine_regs.address);
6493 adv = (op_code % info.li_line_range) + info.li_line_base;
6494 state_machine_regs.line += adv;
6495 printf (_(" and Line by %d to %d\n"),
6496 adv, state_machine_regs.line);
6497 }
6498 else switch (op_code)
6499 {
6500 case DW_LNS_extended_op:
6501 data += process_extended_line_op (data, info.li_default_is_stmt,
6502 debug_line_pointer_size);
6503 break;
6504
6505 case DW_LNS_copy:
6506 printf (_(" Copy\n"));
6507 break;
6508
6509 case DW_LNS_advance_pc:
6510 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6511 data += bytes_read;
6512 state_machine_regs.address += adv;
6513 printf (_(" Advance PC by %d to %lx\n"), adv,
6514 state_machine_regs.address);
6515 break;
6516
6517 case DW_LNS_advance_line:
6518 adv = read_leb128 (data, & bytes_read, 1);
6519 data += bytes_read;
6520 state_machine_regs.line += adv;
6521 printf (_(" Advance Line by %d to %d\n"), adv,
6522 state_machine_regs.line);
6523 break;
6524
6525 case DW_LNS_set_file:
6526 adv = read_leb128 (data, & bytes_read, 0);
6527 data += bytes_read;
6528 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6529 adv);
6530 state_machine_regs.file = adv;
6531 break;
6532
6533 case DW_LNS_set_column:
6534 adv = read_leb128 (data, & bytes_read, 0);
6535 data += bytes_read;
6536 printf (_(" Set column to %d\n"), adv);
6537 state_machine_regs.column = adv;
6538 break;
6539
6540 case DW_LNS_negate_stmt:
6541 adv = state_machine_regs.is_stmt;
6542 adv = ! adv;
6543 printf (_(" Set is_stmt to %d\n"), adv);
6544 state_machine_regs.is_stmt = adv;
6545 break;
6546
6547 case DW_LNS_set_basic_block:
6548 printf (_(" Set basic block\n"));
6549 state_machine_regs.basic_block = 1;
6550 break;
6551
6552 case DW_LNS_const_add_pc:
6553 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6554 * info.li_min_insn_length);
6555 state_machine_regs.address += adv;
6556 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6557 state_machine_regs.address);
6558 break;
6559
6560 case DW_LNS_fixed_advance_pc:
6561 adv = byte_get (data, 2);
6562 data += 2;
6563 state_machine_regs.address += adv;
6564 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6565 adv, state_machine_regs.address);
6566 break;
6567
6568 case DW_LNS_set_prologue_end:
6569 printf (_(" Set prologue_end to true\n"));
6570 break;
6571
6572 case DW_LNS_set_epilogue_begin:
6573 printf (_(" Set epilogue_begin to true\n"));
6574 break;
6575
6576 case DW_LNS_set_isa:
6577 adv = read_leb128 (data, & bytes_read, 0);
6578 data += bytes_read;
6579 printf (_(" Set ISA to %d\n"), adv);
6580 break;
6581
6582 default:
6583 printf (_(" Unknown opcode %d with operands: "), op_code);
6584 {
6585 int i;
6586 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6587 {
6588 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6589 i == 1 ? "" : ", ");
6590 data += bytes_read;
6591 }
6592 putchar ('\n');
6593 }
6594 break;
6595 }
6596 }
6597 putchar ('\n');
6598 }
6599
6600 return 1;
6601 }
6602
6603 static int
6604 display_debug_pubnames (section, start, file)
6605 Elf_Internal_Shdr *section;
6606 unsigned char *start;
6607 FILE *file ATTRIBUTE_UNUSED;
6608 {
6609 DWARF2_External_PubNames *external;
6610 DWARF2_Internal_PubNames pubnames;
6611 unsigned char *end;
6612
6613 end = start + section->sh_size;
6614
6615 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6616
6617 while (start < end)
6618 {
6619 unsigned char *data;
6620 unsigned long offset;
6621
6622 external = (DWARF2_External_PubNames *) start;
6623
6624 pubnames.pn_length = BYTE_GET (external->pn_length);
6625 pubnames.pn_version = BYTE_GET (external->pn_version);
6626 pubnames.pn_offset = BYTE_GET (external->pn_offset);
6627 pubnames.pn_size = BYTE_GET (external->pn_size);
6628
6629 data = start + sizeof (*external);
6630 start += pubnames.pn_length + sizeof (external->pn_length);
6631
6632 if (pubnames.pn_length == 0xffffffff)
6633 {
6634 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6635 break;
6636 }
6637
6638 if (pubnames.pn_version != 2)
6639 {
6640 static int warned = 0;
6641
6642 if (! warned)
6643 {
6644 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6645 warned = 1;
6646 }
6647
6648 continue;
6649 }
6650
6651 printf (_(" Length: %ld\n"),
6652 pubnames.pn_length);
6653 printf (_(" Version: %d\n"),
6654 pubnames.pn_version);
6655 printf (_(" Offset into .debug_info section: %ld\n"),
6656 pubnames.pn_offset);
6657 printf (_(" Size of area in .debug_info section: %ld\n"),
6658 pubnames.pn_size);
6659
6660 printf (_("\n Offset\tName\n"));
6661
6662 do
6663 {
6664 offset = byte_get (data, 4);
6665
6666 if (offset != 0)
6667 {
6668 data += 4;
6669 printf (" %ld\t\t%s\n", offset, data);
6670 data += strlen ((char *) data) + 1;
6671 }
6672 }
6673 while (offset != 0);
6674 }
6675
6676 printf ("\n");
6677 return 1;
6678 }
6679
6680 static char *
6681 get_TAG_name (tag)
6682 unsigned long tag;
6683 {
6684 switch (tag)
6685 {
6686 case DW_TAG_padding: return "DW_TAG_padding";
6687 case DW_TAG_array_type: return "DW_TAG_array_type";
6688 case DW_TAG_class_type: return "DW_TAG_class_type";
6689 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6690 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6691 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6692 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6693 case DW_TAG_label: return "DW_TAG_label";
6694 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6695 case DW_TAG_member: return "DW_TAG_member";
6696 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6697 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6698 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6699 case DW_TAG_string_type: return "DW_TAG_string_type";
6700 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6701 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6702 case DW_TAG_typedef: return "DW_TAG_typedef";
6703 case DW_TAG_union_type: return "DW_TAG_union_type";
6704 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6705 case DW_TAG_variant: return "DW_TAG_variant";
6706 case DW_TAG_common_block: return "DW_TAG_common_block";
6707 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6708 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6709 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6710 case DW_TAG_module: return "DW_TAG_module";
6711 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6712 case DW_TAG_set_type: return "DW_TAG_set_type";
6713 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6714 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6715 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6716 case DW_TAG_base_type: return "DW_TAG_base_type";
6717 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6718 case DW_TAG_const_type: return "DW_TAG_const_type";
6719 case DW_TAG_constant: return "DW_TAG_constant";
6720 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6721 case DW_TAG_file_type: return "DW_TAG_file_type";
6722 case DW_TAG_friend: return "DW_TAG_friend";
6723 case DW_TAG_namelist: return "DW_TAG_namelist";
6724 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6725 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6726 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6727 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6728 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6729 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6730 case DW_TAG_try_block: return "DW_TAG_try_block";
6731 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6732 case DW_TAG_variable: return "DW_TAG_variable";
6733 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6734 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6735 case DW_TAG_format_label: return "DW_TAG_format_label";
6736 case DW_TAG_function_template: return "DW_TAG_function_template";
6737 case DW_TAG_class_template: return "DW_TAG_class_template";
6738 /* DWARF 2.1 values. */
6739 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6740 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6741 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6742 case DW_TAG_namespace: return "DW_TAG_namespace";
6743 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6744 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6745 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6746 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6747 /* UPC values. */
6748 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
6749 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
6750 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
6751 default:
6752 {
6753 static char buffer[100];
6754
6755 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6756 return buffer;
6757 }
6758 }
6759 }
6760
6761 static char *
6762 get_AT_name (attribute)
6763 unsigned long attribute;
6764 {
6765 switch (attribute)
6766 {
6767 case DW_AT_sibling: return "DW_AT_sibling";
6768 case DW_AT_location: return "DW_AT_location";
6769 case DW_AT_name: return "DW_AT_name";
6770 case DW_AT_ordering: return "DW_AT_ordering";
6771 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6772 case DW_AT_byte_size: return "DW_AT_byte_size";
6773 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6774 case DW_AT_bit_size: return "DW_AT_bit_size";
6775 case DW_AT_element_list: return "DW_AT_element_list";
6776 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6777 case DW_AT_low_pc: return "DW_AT_low_pc";
6778 case DW_AT_high_pc: return "DW_AT_high_pc";
6779 case DW_AT_language: return "DW_AT_language";
6780 case DW_AT_member: return "DW_AT_member";
6781 case DW_AT_discr: return "DW_AT_discr";
6782 case DW_AT_discr_value: return "DW_AT_discr_value";
6783 case DW_AT_visibility: return "DW_AT_visibility";
6784 case DW_AT_import: return "DW_AT_import";
6785 case DW_AT_string_length: return "DW_AT_string_length";
6786 case DW_AT_common_reference: return "DW_AT_common_reference";
6787 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6788 case DW_AT_const_value: return "DW_AT_const_value";
6789 case DW_AT_containing_type: return "DW_AT_containing_type";
6790 case DW_AT_default_value: return "DW_AT_default_value";
6791 case DW_AT_inline: return "DW_AT_inline";
6792 case DW_AT_is_optional: return "DW_AT_is_optional";
6793 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6794 case DW_AT_producer: return "DW_AT_producer";
6795 case DW_AT_prototyped: return "DW_AT_prototyped";
6796 case DW_AT_return_addr: return "DW_AT_return_addr";
6797 case DW_AT_start_scope: return "DW_AT_start_scope";
6798 case DW_AT_stride_size: return "DW_AT_stride_size";
6799 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6800 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6801 case DW_AT_accessibility: return "DW_AT_accessibility";
6802 case DW_AT_address_class: return "DW_AT_address_class";
6803 case DW_AT_artificial: return "DW_AT_artificial";
6804 case DW_AT_base_types: return "DW_AT_base_types";
6805 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6806 case DW_AT_count: return "DW_AT_count";
6807 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6808 case DW_AT_decl_column: return "DW_AT_decl_column";
6809 case DW_AT_decl_file: return "DW_AT_decl_file";
6810 case DW_AT_decl_line: return "DW_AT_decl_line";
6811 case DW_AT_declaration: return "DW_AT_declaration";
6812 case DW_AT_discr_list: return "DW_AT_discr_list";
6813 case DW_AT_encoding: return "DW_AT_encoding";
6814 case DW_AT_external: return "DW_AT_external";
6815 case DW_AT_frame_base: return "DW_AT_frame_base";
6816 case DW_AT_friend: return "DW_AT_friend";
6817 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6818 case DW_AT_macro_info: return "DW_AT_macro_info";
6819 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6820 case DW_AT_priority: return "DW_AT_priority";
6821 case DW_AT_segment: return "DW_AT_segment";
6822 case DW_AT_specification: return "DW_AT_specification";
6823 case DW_AT_static_link: return "DW_AT_static_link";
6824 case DW_AT_type: return "DW_AT_type";
6825 case DW_AT_use_location: return "DW_AT_use_location";
6826 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6827 case DW_AT_virtuality: return "DW_AT_virtuality";
6828 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6829 /* DWARF 2.1 values. */
6830 case DW_AT_allocated: return "DW_AT_allocated";
6831 case DW_AT_associated: return "DW_AT_associated";
6832 case DW_AT_data_location: return "DW_AT_data_location";
6833 case DW_AT_stride: return "DW_AT_stride";
6834 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6835 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6836 case DW_AT_extension: return "DW_AT_extension";
6837 case DW_AT_ranges: return "DW_AT_ranges";
6838 case DW_AT_trampoline: return "DW_AT_trampoline";
6839 case DW_AT_call_column: return "DW_AT_call_column";
6840 case DW_AT_call_file: return "DW_AT_call_file";
6841 case DW_AT_call_line: return "DW_AT_call_line";
6842 /* SGI/MIPS extensions. */
6843 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6844 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6845 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6846 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6847 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6848 case DW_AT_MIPS_software_pipeline_depth:
6849 return "DW_AT_MIPS_software_pipeline_depth";
6850 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6851 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6852 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6853 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6854 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6855 /* GNU extensions. */
6856 case DW_AT_sf_names: return "DW_AT_sf_names";
6857 case DW_AT_src_info: return "DW_AT_src_info";
6858 case DW_AT_mac_info: return "DW_AT_mac_info";
6859 case DW_AT_src_coords: return "DW_AT_src_coords";
6860 case DW_AT_body_begin: return "DW_AT_body_begin";
6861 case DW_AT_body_end: return "DW_AT_body_end";
6862 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6863 /* UPC extension. */
6864 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
6865 default:
6866 {
6867 static char buffer[100];
6868
6869 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6870 return buffer;
6871 }
6872 }
6873 }
6874
6875 static char *
6876 get_FORM_name (form)
6877 unsigned long form;
6878 {
6879 switch (form)
6880 {
6881 case DW_FORM_addr: return "DW_FORM_addr";
6882 case DW_FORM_block2: return "DW_FORM_block2";
6883 case DW_FORM_block4: return "DW_FORM_block4";
6884 case DW_FORM_data2: return "DW_FORM_data2";
6885 case DW_FORM_data4: return "DW_FORM_data4";
6886 case DW_FORM_data8: return "DW_FORM_data8";
6887 case DW_FORM_string: return "DW_FORM_string";
6888 case DW_FORM_block: return "DW_FORM_block";
6889 case DW_FORM_block1: return "DW_FORM_block1";
6890 case DW_FORM_data1: return "DW_FORM_data1";
6891 case DW_FORM_flag: return "DW_FORM_flag";
6892 case DW_FORM_sdata: return "DW_FORM_sdata";
6893 case DW_FORM_strp: return "DW_FORM_strp";
6894 case DW_FORM_udata: return "DW_FORM_udata";
6895 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6896 case DW_FORM_ref1: return "DW_FORM_ref1";
6897 case DW_FORM_ref2: return "DW_FORM_ref2";
6898 case DW_FORM_ref4: return "DW_FORM_ref4";
6899 case DW_FORM_ref8: return "DW_FORM_ref8";
6900 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6901 case DW_FORM_indirect: return "DW_FORM_indirect";
6902 default:
6903 {
6904 static char buffer[100];
6905
6906 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6907 return buffer;
6908 }
6909 }
6910 }
6911
6912 /* FIXME: There are better and more effiecint ways to handle
6913 these structures. For now though, I just want something that
6914 is simple to implement. */
6915 typedef struct abbrev_attr
6916 {
6917 unsigned long attribute;
6918 unsigned long form;
6919 struct abbrev_attr *next;
6920 }
6921 abbrev_attr;
6922
6923 typedef struct abbrev_entry
6924 {
6925 unsigned long entry;
6926 unsigned long tag;
6927 int children;
6928 struct abbrev_attr *first_attr;
6929 struct abbrev_attr *last_attr;
6930 struct abbrev_entry *next;
6931 }
6932 abbrev_entry;
6933
6934 static abbrev_entry *first_abbrev = NULL;
6935 static abbrev_entry *last_abbrev = NULL;
6936
6937 static void
6938 free_abbrevs ()
6939 {
6940 abbrev_entry *abbrev;
6941
6942 for (abbrev = first_abbrev; abbrev;)
6943 {
6944 abbrev_entry *next = abbrev->next;
6945 abbrev_attr *attr;
6946
6947 for (attr = abbrev->first_attr; attr;)
6948 {
6949 abbrev_attr *next = attr->next;
6950
6951 free (attr);
6952 attr = next;
6953 }
6954
6955 free (abbrev);
6956 abbrev = next;
6957 }
6958
6959 last_abbrev = first_abbrev = NULL;
6960 }
6961
6962 static void
6963 add_abbrev (number, tag, children)
6964 unsigned long number;
6965 unsigned long tag;
6966 int children;
6967 {
6968 abbrev_entry *entry;
6969
6970 entry = (abbrev_entry *) malloc (sizeof (*entry));
6971
6972 if (entry == NULL)
6973 /* ugg */
6974 return;
6975
6976 entry->entry = number;
6977 entry->tag = tag;
6978 entry->children = children;
6979 entry->first_attr = NULL;
6980 entry->last_attr = NULL;
6981 entry->next = NULL;
6982
6983 if (first_abbrev == NULL)
6984 first_abbrev = entry;
6985 else
6986 last_abbrev->next = entry;
6987
6988 last_abbrev = entry;
6989 }
6990
6991 static void
6992 add_abbrev_attr (attribute, form)
6993 unsigned long attribute;
6994 unsigned long form;
6995 {
6996 abbrev_attr *attr;
6997
6998 attr = (abbrev_attr *) malloc (sizeof (*attr));
6999
7000 if (attr == NULL)
7001 /* ugg */
7002 return;
7003
7004 attr->attribute = attribute;
7005 attr->form = form;
7006 attr->next = NULL;
7007
7008 if (last_abbrev->first_attr == NULL)
7009 last_abbrev->first_attr = attr;
7010 else
7011 last_abbrev->last_attr->next = attr;
7012
7013 last_abbrev->last_attr = attr;
7014 }
7015
7016 /* Processes the (partial) contents of a .debug_abbrev section.
7017 Returns NULL if the end of the section was encountered.
7018 Returns the address after the last byte read if the end of
7019 an abbreviation set was found. */
7020
7021 static unsigned char *
7022 process_abbrev_section (start, end)
7023 unsigned char *start;
7024 unsigned char *end;
7025 {
7026 if (first_abbrev != NULL)
7027 return NULL;
7028
7029 while (start < end)
7030 {
7031 int bytes_read;
7032 unsigned long entry;
7033 unsigned long tag;
7034 unsigned long attribute;
7035 int children;
7036
7037 entry = read_leb128 (start, & bytes_read, 0);
7038 start += bytes_read;
7039
7040 /* A single zero is supposed to end the section according
7041 to the standard. If there's more, then signal that to
7042 the caller. */
7043 if (entry == 0)
7044 return start == end ? NULL : start;
7045
7046 tag = read_leb128 (start, & bytes_read, 0);
7047 start += bytes_read;
7048
7049 children = *start++;
7050
7051 add_abbrev (entry, tag, children);
7052
7053 do
7054 {
7055 unsigned long form;
7056
7057 attribute = read_leb128 (start, & bytes_read, 0);
7058 start += bytes_read;
7059
7060 form = read_leb128 (start, & bytes_read, 0);
7061 start += bytes_read;
7062
7063 if (attribute != 0)
7064 add_abbrev_attr (attribute, form);
7065 }
7066 while (attribute != 0);
7067 }
7068
7069 return NULL;
7070 }
7071
7072
7073 static int
7074 display_debug_macinfo (section, start, file)
7075 Elf_Internal_Shdr *section;
7076 unsigned char *start;
7077 FILE *file ATTRIBUTE_UNUSED;
7078 {
7079 unsigned char *end = start + section->sh_size;
7080 unsigned char *curr = start;
7081 unsigned int bytes_read;
7082 enum dwarf_macinfo_record_type op;
7083
7084 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7085
7086 while (curr < end)
7087 {
7088 unsigned int lineno;
7089 const char *string;
7090
7091 op = *curr;
7092 curr++;
7093
7094 switch (op)
7095 {
7096 case DW_MACINFO_start_file:
7097 {
7098 unsigned int filenum;
7099
7100 lineno = read_leb128 (curr, & bytes_read, 0);
7101 curr += bytes_read;
7102 filenum = read_leb128 (curr, & bytes_read, 0);
7103 curr += bytes_read;
7104
7105 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
7106 }
7107 break;
7108
7109 case DW_MACINFO_end_file:
7110 printf (_(" DW_MACINFO_end_file\n"));
7111 break;
7112
7113 case DW_MACINFO_define:
7114 lineno = read_leb128 (curr, & bytes_read, 0);
7115 curr += bytes_read;
7116 string = curr;
7117 curr += strlen (string) + 1;
7118 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
7119 break;
7120
7121 case DW_MACINFO_undef:
7122 lineno = read_leb128 (curr, & bytes_read, 0);
7123 curr += bytes_read;
7124 string = curr;
7125 curr += strlen (string) + 1;
7126 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
7127 break;
7128
7129 case DW_MACINFO_vendor_ext:
7130 {
7131 unsigned int constant;
7132
7133 constant = read_leb128 (curr, & bytes_read, 0);
7134 curr += bytes_read;
7135 string = curr;
7136 curr += strlen (string) + 1;
7137 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
7138 }
7139 break;
7140 }
7141 }
7142
7143 return 1;
7144 }
7145
7146
7147 static int
7148 display_debug_abbrev (section, start, file)
7149 Elf_Internal_Shdr *section;
7150 unsigned char *start;
7151 FILE *file ATTRIBUTE_UNUSED;
7152 {
7153 abbrev_entry *entry;
7154 unsigned char *end = start + section->sh_size;
7155
7156 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7157
7158 do
7159 {
7160 start = process_abbrev_section (start, end);
7161
7162 if (first_abbrev == NULL)
7163 continue;
7164
7165 printf (_(" Number TAG\n"));
7166
7167 for (entry = first_abbrev; entry; entry = entry->next)
7168 {
7169 abbrev_attr *attr;
7170
7171 printf (_(" %ld %s [%s]\n"),
7172 entry->entry,
7173 get_TAG_name (entry->tag),
7174 entry->children ? _("has children") : _("no children"));
7175
7176 for (attr = entry->first_attr; attr; attr = attr->next)
7177 {
7178 printf (_(" %-18s %s\n"),
7179 get_AT_name (attr->attribute),
7180 get_FORM_name (attr->form));
7181 }
7182 }
7183
7184 free_abbrevs ();
7185 }
7186 while (start);
7187
7188 printf ("\n");
7189
7190 return 1;
7191 }
7192
7193
7194 static unsigned char *
7195 display_block (data, length)
7196 unsigned char *data;
7197 unsigned long length;
7198 {
7199 printf (_(" %lu byte block: "), length);
7200
7201 while (length --)
7202 printf ("%lx ", (unsigned long) byte_get (data++, 1));
7203
7204 return data;
7205 }
7206
7207 static void
7208 decode_location_expression (data, pointer_size, length)
7209 unsigned char * data;
7210 unsigned int pointer_size;
7211 unsigned long length;
7212 {
7213 unsigned op;
7214 int bytes_read;
7215 unsigned long uvalue;
7216 unsigned char *end = data + length;
7217
7218 while (data < end)
7219 {
7220 op = *data++;
7221
7222 switch (op)
7223 {
7224 case DW_OP_addr:
7225 printf ("DW_OP_addr: %lx",
7226 (unsigned long) byte_get (data, pointer_size));
7227 data += pointer_size;
7228 break;
7229 case DW_OP_deref:
7230 printf ("DW_OP_deref");
7231 break;
7232 case DW_OP_const1u:
7233 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7234 break;
7235 case DW_OP_const1s:
7236 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7237 break;
7238 case DW_OP_const2u:
7239 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7240 data += 2;
7241 break;
7242 case DW_OP_const2s:
7243 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7244 data += 2;
7245 break;
7246 case DW_OP_const4u:
7247 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7248 data += 4;
7249 break;
7250 case DW_OP_const4s:
7251 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7252 data += 4;
7253 break;
7254 case DW_OP_const8u:
7255 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7256 (unsigned long) byte_get (data + 4, 4));
7257 data += 8;
7258 break;
7259 case DW_OP_const8s:
7260 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7261 (long) byte_get (data + 4, 4));
7262 data += 8;
7263 break;
7264 case DW_OP_constu:
7265 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7266 data += bytes_read;
7267 break;
7268 case DW_OP_consts:
7269 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7270 data += bytes_read;
7271 break;
7272 case DW_OP_dup:
7273 printf ("DW_OP_dup");
7274 break;
7275 case DW_OP_drop:
7276 printf ("DW_OP_drop");
7277 break;
7278 case DW_OP_over:
7279 printf ("DW_OP_over");
7280 break;
7281 case DW_OP_pick:
7282 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7283 break;
7284 case DW_OP_swap:
7285 printf ("DW_OP_swap");
7286 break;
7287 case DW_OP_rot:
7288 printf ("DW_OP_rot");
7289 break;
7290 case DW_OP_xderef:
7291 printf ("DW_OP_xderef");
7292 break;
7293 case DW_OP_abs:
7294 printf ("DW_OP_abs");
7295 break;
7296 case DW_OP_and:
7297 printf ("DW_OP_and");
7298 break;
7299 case DW_OP_div:
7300 printf ("DW_OP_div");
7301 break;
7302 case DW_OP_minus:
7303 printf ("DW_OP_minus");
7304 break;
7305 case DW_OP_mod:
7306 printf ("DW_OP_mod");
7307 break;
7308 case DW_OP_mul:
7309 printf ("DW_OP_mul");
7310 break;
7311 case DW_OP_neg:
7312 printf ("DW_OP_neg");
7313 break;
7314 case DW_OP_not:
7315 printf ("DW_OP_not");
7316 break;
7317 case DW_OP_or:
7318 printf ("DW_OP_or");
7319 break;
7320 case DW_OP_plus:
7321 printf ("DW_OP_plus");
7322 break;
7323 case DW_OP_plus_uconst:
7324 printf ("DW_OP_plus_uconst: %lu",
7325 read_leb128 (data, &bytes_read, 0));
7326 data += bytes_read;
7327 break;
7328 case DW_OP_shl:
7329 printf ("DW_OP_shl");
7330 break;
7331 case DW_OP_shr:
7332 printf ("DW_OP_shr");
7333 break;
7334 case DW_OP_shra:
7335 printf ("DW_OP_shra");
7336 break;
7337 case DW_OP_xor:
7338 printf ("DW_OP_xor");
7339 break;
7340 case DW_OP_bra:
7341 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7342 data += 2;
7343 break;
7344 case DW_OP_eq:
7345 printf ("DW_OP_eq");
7346 break;
7347 case DW_OP_ge:
7348 printf ("DW_OP_ge");
7349 break;
7350 case DW_OP_gt:
7351 printf ("DW_OP_gt");
7352 break;
7353 case DW_OP_le:
7354 printf ("DW_OP_le");
7355 break;
7356 case DW_OP_lt:
7357 printf ("DW_OP_lt");
7358 break;
7359 case DW_OP_ne:
7360 printf ("DW_OP_ne");
7361 break;
7362 case DW_OP_skip:
7363 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7364 data += 2;
7365 break;
7366
7367 case DW_OP_lit0:
7368 case DW_OP_lit1:
7369 case DW_OP_lit2:
7370 case DW_OP_lit3:
7371 case DW_OP_lit4:
7372 case DW_OP_lit5:
7373 case DW_OP_lit6:
7374 case DW_OP_lit7:
7375 case DW_OP_lit8:
7376 case DW_OP_lit9:
7377 case DW_OP_lit10:
7378 case DW_OP_lit11:
7379 case DW_OP_lit12:
7380 case DW_OP_lit13:
7381 case DW_OP_lit14:
7382 case DW_OP_lit15:
7383 case DW_OP_lit16:
7384 case DW_OP_lit17:
7385 case DW_OP_lit18:
7386 case DW_OP_lit19:
7387 case DW_OP_lit20:
7388 case DW_OP_lit21:
7389 case DW_OP_lit22:
7390 case DW_OP_lit23:
7391 case DW_OP_lit24:
7392 case DW_OP_lit25:
7393 case DW_OP_lit26:
7394 case DW_OP_lit27:
7395 case DW_OP_lit28:
7396 case DW_OP_lit29:
7397 case DW_OP_lit30:
7398 case DW_OP_lit31:
7399 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7400 break;
7401
7402 case DW_OP_reg0:
7403 case DW_OP_reg1:
7404 case DW_OP_reg2:
7405 case DW_OP_reg3:
7406 case DW_OP_reg4:
7407 case DW_OP_reg5:
7408 case DW_OP_reg6:
7409 case DW_OP_reg7:
7410 case DW_OP_reg8:
7411 case DW_OP_reg9:
7412 case DW_OP_reg10:
7413 case DW_OP_reg11:
7414 case DW_OP_reg12:
7415 case DW_OP_reg13:
7416 case DW_OP_reg14:
7417 case DW_OP_reg15:
7418 case DW_OP_reg16:
7419 case DW_OP_reg17:
7420 case DW_OP_reg18:
7421 case DW_OP_reg19:
7422 case DW_OP_reg20:
7423 case DW_OP_reg21:
7424 case DW_OP_reg22:
7425 case DW_OP_reg23:
7426 case DW_OP_reg24:
7427 case DW_OP_reg25:
7428 case DW_OP_reg26:
7429 case DW_OP_reg27:
7430 case DW_OP_reg28:
7431 case DW_OP_reg29:
7432 case DW_OP_reg30:
7433 case DW_OP_reg31:
7434 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7435 break;
7436
7437 case DW_OP_breg0:
7438 case DW_OP_breg1:
7439 case DW_OP_breg2:
7440 case DW_OP_breg3:
7441 case DW_OP_breg4:
7442 case DW_OP_breg5:
7443 case DW_OP_breg6:
7444 case DW_OP_breg7:
7445 case DW_OP_breg8:
7446 case DW_OP_breg9:
7447 case DW_OP_breg10:
7448 case DW_OP_breg11:
7449 case DW_OP_breg12:
7450 case DW_OP_breg13:
7451 case DW_OP_breg14:
7452 case DW_OP_breg15:
7453 case DW_OP_breg16:
7454 case DW_OP_breg17:
7455 case DW_OP_breg18:
7456 case DW_OP_breg19:
7457 case DW_OP_breg20:
7458 case DW_OP_breg21:
7459 case DW_OP_breg22:
7460 case DW_OP_breg23:
7461 case DW_OP_breg24:
7462 case DW_OP_breg25:
7463 case DW_OP_breg26:
7464 case DW_OP_breg27:
7465 case DW_OP_breg28:
7466 case DW_OP_breg29:
7467 case DW_OP_breg30:
7468 case DW_OP_breg31:
7469 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7470 read_leb128 (data, &bytes_read, 1));
7471 data += bytes_read;
7472 break;
7473
7474 case DW_OP_regx:
7475 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7476 data += bytes_read;
7477 break;
7478 case DW_OP_fbreg:
7479 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7480 data += bytes_read;
7481 break;
7482 case DW_OP_bregx:
7483 uvalue = read_leb128 (data, &bytes_read, 0);
7484 data += bytes_read;
7485 printf ("DW_OP_bregx: %lu %ld", uvalue,
7486 read_leb128 (data, &bytes_read, 1));
7487 data += bytes_read;
7488 break;
7489 case DW_OP_piece:
7490 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7491 data += bytes_read;
7492 break;
7493 case DW_OP_deref_size:
7494 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7495 break;
7496 case DW_OP_xderef_size:
7497 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7498 break;
7499 case DW_OP_nop:
7500 printf ("DW_OP_nop");
7501 break;
7502
7503 /* DWARF 3 extensions. */
7504 case DW_OP_push_object_address:
7505 printf ("DW_OP_push_object_address");
7506 break;
7507 case DW_OP_call2:
7508 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7509 data += 2;
7510 break;
7511 case DW_OP_call4:
7512 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7513 data += 4;
7514 break;
7515 case DW_OP_call_ref:
7516 printf ("DW_OP_call_ref");
7517 break;
7518
7519 /* GNU extensions. */
7520 case DW_OP_GNU_push_tls_address:
7521 printf ("DW_OP_GNU_push_tls_address");
7522 break;
7523
7524 default:
7525 if (op >= DW_OP_lo_user
7526 && op <= DW_OP_hi_user)
7527 printf (_("(User defined location op)"));
7528 else
7529 printf (_("(Unknown location op)"));
7530 /* No way to tell where the next op is, so just bail. */
7531 return;
7532 }
7533
7534 /* Separate the ops. */
7535 printf ("; ");
7536 }
7537 }
7538
7539 static const char *debug_loc_contents;
7540 static bfd_vma debug_loc_size;
7541
7542 static void
7543 load_debug_loc (file)
7544 FILE *file;
7545 {
7546 Elf_Internal_Shdr *sec;
7547 unsigned int i;
7548
7549 /* If it is already loaded, do nothing. */
7550 if (debug_loc_contents != NULL)
7551 return;
7552
7553 /* Locate the .debug_loc section. */
7554 for (i = 0, sec = section_headers;
7555 i < elf_header.e_shnum;
7556 i++, sec++)
7557 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7558 break;
7559
7560 if (i == elf_header.e_shnum || sec->sh_size == 0)
7561 return;
7562
7563 debug_loc_size = sec->sh_size;
7564
7565 debug_loc_contents = ((char *)
7566 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7567 _("debug_loc section data")));
7568 }
7569
7570 static void
7571 free_debug_loc ()
7572 {
7573 if (debug_loc_contents == NULL)
7574 return;
7575
7576 free ((char *) debug_loc_contents);
7577 debug_loc_contents = NULL;
7578 debug_loc_size = 0;
7579 }
7580
7581
7582 static int
7583 display_debug_loc (section, start, file)
7584 Elf_Internal_Shdr *section;
7585 unsigned char *start;
7586 FILE *file ATTRIBUTE_UNUSED;
7587 {
7588 unsigned char *section_end;
7589 unsigned long bytes;
7590 unsigned char *section_begin = start;
7591 bfd_vma addr;
7592
7593 addr = section->sh_addr;
7594 bytes = section->sh_size;
7595 section_end = start + bytes;
7596
7597 if (bytes == 0)
7598 {
7599 printf (_("\nThe .debug_loc section is empty.\n"));
7600 return 0;
7601 }
7602
7603 printf (_("Contents of the .debug_loc section:\n\n"));
7604 printf (_("\n Offset Begin End Expression\n"));
7605
7606 while (start < section_end)
7607 {
7608 unsigned long begin;
7609 unsigned long end;
7610 unsigned short length;
7611 unsigned long offset;
7612
7613 offset = start - section_begin;
7614
7615 while (1)
7616 {
7617 /* Normally, the lists in the debug_loc section are related to a
7618 given compilation unit, and thus, we would use the
7619 pointer size of that compilation unit. However, since we are
7620 displaying it seperately here, we either have to store
7621 pointer sizes of all compilation units, or assume they don't
7622 change. We assume, like the debug_line display, that
7623 it doesn't change. */
7624 begin = byte_get (start, debug_line_pointer_size);
7625 start += debug_line_pointer_size;
7626 end = byte_get (start, debug_line_pointer_size);
7627 start += debug_line_pointer_size;
7628
7629 if (begin == 0 && end == 0)
7630 break;
7631
7632 begin += addr;
7633 end += addr;
7634
7635 length = byte_get (start, 2);
7636 start += 2;
7637
7638 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7639 decode_location_expression (start, debug_line_pointer_size, length);
7640 printf (")\n");
7641
7642 start += length;
7643 }
7644 printf ("\n");
7645 }
7646 return 1;
7647 }
7648
7649 static const char *debug_str_contents;
7650 static bfd_vma debug_str_size;
7651
7652 static void
7653 load_debug_str (file)
7654 FILE *file;
7655 {
7656 Elf_Internal_Shdr *sec;
7657 unsigned int i;
7658
7659 /* If it is already loaded, do nothing. */
7660 if (debug_str_contents != NULL)
7661 return;
7662
7663 /* Locate the .debug_str section. */
7664 for (i = 0, sec = section_headers;
7665 i < elf_header.e_shnum;
7666 i++, sec++)
7667 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7668 break;
7669
7670 if (i == elf_header.e_shnum || sec->sh_size == 0)
7671 return;
7672
7673 debug_str_size = sec->sh_size;
7674
7675 debug_str_contents = ((char *)
7676 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7677 _("debug_str section data")));
7678 }
7679
7680 static void
7681 free_debug_str ()
7682 {
7683 if (debug_str_contents == NULL)
7684 return;
7685
7686 free ((char *) debug_str_contents);
7687 debug_str_contents = NULL;
7688 debug_str_size = 0;
7689 }
7690
7691 static const char *
7692 fetch_indirect_string (offset)
7693 unsigned long offset;
7694 {
7695 if (debug_str_contents == NULL)
7696 return _("<no .debug_str section>");
7697
7698 if (offset > debug_str_size)
7699 return _("<offset is too big>");
7700
7701 return debug_str_contents + offset;
7702 }
7703
7704 static int
7705 display_debug_str (section, start, file)
7706 Elf_Internal_Shdr *section;
7707 unsigned char *start;
7708 FILE *file ATTRIBUTE_UNUSED;
7709 {
7710 unsigned long bytes;
7711 bfd_vma addr;
7712
7713 addr = section->sh_addr;
7714 bytes = section->sh_size;
7715
7716 if (bytes == 0)
7717 {
7718 printf (_("\nThe .debug_str section is empty.\n"));
7719 return 0;
7720 }
7721
7722 printf (_("Contents of the .debug_str section:\n\n"));
7723
7724 while (bytes)
7725 {
7726 int j;
7727 int k;
7728 int lbytes;
7729
7730 lbytes = (bytes > 16 ? 16 : bytes);
7731
7732 printf (" 0x%8.8lx ", (unsigned long) addr);
7733
7734 for (j = 0; j < 16; j++)
7735 {
7736 if (j < lbytes)
7737 printf ("%2.2x", start[j]);
7738 else
7739 printf (" ");
7740
7741 if ((j & 3) == 3)
7742 printf (" ");
7743 }
7744
7745 for (j = 0; j < lbytes; j++)
7746 {
7747 k = start[j];
7748 if (k >= ' ' && k < 0x80)
7749 printf ("%c", k);
7750 else
7751 printf (".");
7752 }
7753
7754 putchar ('\n');
7755
7756 start += lbytes;
7757 addr += lbytes;
7758 bytes -= lbytes;
7759 }
7760
7761 return 1;
7762 }
7763
7764 static unsigned char *
7765 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7766 unsigned long attribute;
7767 unsigned long form;
7768 unsigned char *data;
7769 unsigned long cu_offset;
7770 unsigned long pointer_size;
7771 {
7772 unsigned long uvalue = 0;
7773 unsigned char *block_start = NULL;
7774 int bytes_read;
7775
7776 switch (form)
7777 {
7778 default:
7779 break;
7780
7781 case DW_FORM_ref_addr:
7782 case DW_FORM_addr:
7783 uvalue = byte_get (data, pointer_size);
7784 data += pointer_size;
7785 break;
7786
7787 case DW_FORM_strp:
7788 uvalue = byte_get (data, /* offset_size */ 4);
7789 data += /* offset_size */ 4;
7790 break;
7791
7792 case DW_FORM_ref1:
7793 case DW_FORM_flag:
7794 case DW_FORM_data1:
7795 uvalue = byte_get (data++, 1);
7796 break;
7797
7798 case DW_FORM_ref2:
7799 case DW_FORM_data2:
7800 uvalue = byte_get (data, 2);
7801 data += 2;
7802 break;
7803
7804 case DW_FORM_ref4:
7805 case DW_FORM_data4:
7806 uvalue = byte_get (data, 4);
7807 data += 4;
7808 break;
7809
7810 case DW_FORM_sdata:
7811 uvalue = read_leb128 (data, & bytes_read, 1);
7812 data += bytes_read;
7813 break;
7814
7815 case DW_FORM_ref_udata:
7816 case DW_FORM_udata:
7817 uvalue = read_leb128 (data, & bytes_read, 0);
7818 data += bytes_read;
7819 break;
7820
7821 case DW_FORM_indirect:
7822 form = read_leb128 (data, & bytes_read, 0);
7823 data += bytes_read;
7824 printf (" %s", get_FORM_name (form));
7825 return read_and_display_attr_value (attribute, form, data, cu_offset,
7826 pointer_size);
7827 }
7828
7829 switch (form)
7830 {
7831 case DW_FORM_ref_addr:
7832 printf (" <#%lx>", uvalue);
7833 break;
7834
7835 case DW_FORM_ref1:
7836 case DW_FORM_ref2:
7837 case DW_FORM_ref4:
7838 case DW_FORM_ref_udata:
7839 printf (" <%lx>", uvalue + cu_offset);
7840 break;
7841
7842 case DW_FORM_addr:
7843 printf (" %#lx", uvalue);
7844
7845 case DW_FORM_flag:
7846 case DW_FORM_data1:
7847 case DW_FORM_data2:
7848 case DW_FORM_data4:
7849 case DW_FORM_sdata:
7850 case DW_FORM_udata:
7851 printf (" %ld", uvalue);
7852 break;
7853
7854 case DW_FORM_ref8:
7855 case DW_FORM_data8:
7856 uvalue = byte_get (data, 4);
7857 printf (" %lx", uvalue);
7858 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7859 data += 8;
7860 break;
7861
7862 case DW_FORM_string:
7863 printf (" %s", data);
7864 data += strlen ((char *) data) + 1;
7865 break;
7866
7867 case DW_FORM_block:
7868 uvalue = read_leb128 (data, & bytes_read, 0);
7869 block_start = data + bytes_read;
7870 data = display_block (block_start, uvalue);
7871 break;
7872
7873 case DW_FORM_block1:
7874 uvalue = byte_get (data, 1);
7875 block_start = data + 1;
7876 data = display_block (block_start, uvalue);
7877 break;
7878
7879 case DW_FORM_block2:
7880 uvalue = byte_get (data, 2);
7881 block_start = data + 2;
7882 data = display_block (block_start, uvalue);
7883 break;
7884
7885 case DW_FORM_block4:
7886 uvalue = byte_get (data, 4);
7887 block_start = data + 4;
7888 data = display_block (block_start, uvalue);
7889 break;
7890
7891 case DW_FORM_strp:
7892 printf (_(" (indirect string, offset: 0x%lx): %s"),
7893 uvalue, fetch_indirect_string (uvalue));
7894 break;
7895
7896 case DW_FORM_indirect:
7897 /* Handled above. */
7898 break;
7899
7900 default:
7901 warn (_("Unrecognized form: %d\n"), form);
7902 break;
7903 }
7904
7905 /* For some attributes we can display futher information. */
7906
7907 printf ("\t");
7908
7909 switch (attribute)
7910 {
7911 case DW_AT_inline:
7912 switch (uvalue)
7913 {
7914 case DW_INL_not_inlined:
7915 printf (_("(not inlined)"));
7916 break;
7917 case DW_INL_inlined:
7918 printf (_("(inlined)"));
7919 break;
7920 case DW_INL_declared_not_inlined:
7921 printf (_("(declared as inline but ignored)"));
7922 break;
7923 case DW_INL_declared_inlined:
7924 printf (_("(declared as inline and inlined)"));
7925 break;
7926 default:
7927 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
7928 break;
7929 }
7930 break;
7931
7932 case DW_AT_language:
7933 switch (uvalue)
7934 {
7935 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7936 case DW_LANG_C89: printf ("(ANSI C)"); break;
7937 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7938 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7939 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7940 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7941 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7942 case DW_LANG_Ada83: printf ("(Ada)"); break;
7943 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7944 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7945 /* DWARF 2.1 values. */
7946 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7947 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7948 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7949 /* MIPS extension. */
7950 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7951 /* UPC extension. */
7952 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
7953 default:
7954 printf ("(Unknown: %lx)", uvalue);
7955 break;
7956 }
7957 break;
7958
7959 case DW_AT_encoding:
7960 switch (uvalue)
7961 {
7962 case DW_ATE_void: printf ("(void)"); break;
7963 case DW_ATE_address: printf ("(machine address)"); break;
7964 case DW_ATE_boolean: printf ("(boolean)"); break;
7965 case DW_ATE_complex_float: printf ("(complex float)"); break;
7966 case DW_ATE_float: printf ("(float)"); break;
7967 case DW_ATE_signed: printf ("(signed)"); break;
7968 case DW_ATE_signed_char: printf ("(signed char)"); break;
7969 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7970 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7971 /* DWARF 2.1 value. */
7972 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7973 default:
7974 if (uvalue >= DW_ATE_lo_user
7975 && uvalue <= DW_ATE_hi_user)
7976 printf ("(user defined type)");
7977 else
7978 printf ("(unknown type)");
7979 break;
7980 }
7981 break;
7982
7983 case DW_AT_accessibility:
7984 switch (uvalue)
7985 {
7986 case DW_ACCESS_public: printf ("(public)"); break;
7987 case DW_ACCESS_protected: printf ("(protected)"); break;
7988 case DW_ACCESS_private: printf ("(private)"); break;
7989 default:
7990 printf ("(unknown accessibility)");
7991 break;
7992 }
7993 break;
7994
7995 case DW_AT_visibility:
7996 switch (uvalue)
7997 {
7998 case DW_VIS_local: printf ("(local)"); break;
7999 case DW_VIS_exported: printf ("(exported)"); break;
8000 case DW_VIS_qualified: printf ("(qualified)"); break;
8001 default: printf ("(unknown visibility)"); break;
8002 }
8003 break;
8004
8005 case DW_AT_virtuality:
8006 switch (uvalue)
8007 {
8008 case DW_VIRTUALITY_none: printf ("(none)"); break;
8009 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
8010 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
8011 default: printf ("(unknown virtuality)"); break;
8012 }
8013 break;
8014
8015 case DW_AT_identifier_case:
8016 switch (uvalue)
8017 {
8018 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
8019 case DW_ID_up_case: printf ("(up_case)"); break;
8020 case DW_ID_down_case: printf ("(down_case)"); break;
8021 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
8022 default: printf ("(unknown case)"); break;
8023 }
8024 break;
8025
8026 case DW_AT_calling_convention:
8027 switch (uvalue)
8028 {
8029 case DW_CC_normal: printf ("(normal)"); break;
8030 case DW_CC_program: printf ("(program)"); break;
8031 case DW_CC_nocall: printf ("(nocall)"); break;
8032 default:
8033 if (uvalue >= DW_CC_lo_user
8034 && uvalue <= DW_CC_hi_user)
8035 printf ("(user defined)");
8036 else
8037 printf ("(unknown convention)");
8038 }
8039 break;
8040
8041 case DW_AT_ordering:
8042 switch (uvalue)
8043 {
8044 case -1: printf ("(undefined)"); break;
8045 case 0: printf ("(row major)"); break;
8046 case 1: printf ("(column major)"); break;
8047 }
8048 break;
8049
8050 case DW_AT_frame_base:
8051 case DW_AT_location:
8052 case DW_AT_data_member_location:
8053 case DW_AT_vtable_elem_location:
8054 case DW_AT_allocated:
8055 case DW_AT_associated:
8056 case DW_AT_data_location:
8057 case DW_AT_stride:
8058 case DW_AT_upper_bound:
8059 case DW_AT_lower_bound:
8060 if (block_start)
8061 {
8062 printf ("(");
8063 decode_location_expression (block_start, pointer_size, uvalue);
8064 printf (")");
8065 }
8066 else if (form == DW_FORM_data4)
8067 {
8068 printf ("(");
8069 printf ("location list");
8070 printf (")");
8071 }
8072 break;
8073
8074 default:
8075 break;
8076 }
8077
8078 return data;
8079 }
8080
8081 static unsigned char *
8082 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
8083 unsigned long attribute;
8084 unsigned long form;
8085 unsigned char *data;
8086 unsigned long cu_offset;
8087 unsigned long pointer_size;
8088 {
8089 printf (" %-18s:", get_AT_name (attribute));
8090 data = read_and_display_attr_value (attribute, form, data, cu_offset,
8091 pointer_size);
8092 printf ("\n");
8093 return data;
8094 }
8095
8096 static int
8097 display_debug_info (section, start, file)
8098 Elf_Internal_Shdr *section;
8099 unsigned char *start;
8100 FILE *file;
8101 {
8102 unsigned char *end = start + section->sh_size;
8103 unsigned char *section_begin = start;
8104
8105 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8106
8107 load_debug_str (file);
8108 load_debug_loc (file);
8109
8110 while (start < end)
8111 {
8112 DWARF2_External_CompUnit *external;
8113 DWARF2_Internal_CompUnit compunit;
8114 Elf_Internal_Shdr *relsec;
8115 unsigned char *tags;
8116 unsigned int i;
8117 int level;
8118 unsigned long cu_offset;
8119
8120 external = (DWARF2_External_CompUnit *) start;
8121
8122 compunit.cu_length = BYTE_GET (external->cu_length);
8123 compunit.cu_version = BYTE_GET (external->cu_version);
8124 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
8125 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
8126
8127 if (compunit.cu_length == 0xffffffff)
8128 {
8129 warn (_("64-bit DWARF debug info is not supported yet.\n"));
8130 break;
8131 }
8132
8133 /* Check for RELA relocations in the
8134 abbrev_offset address, and apply them. */
8135 for (relsec = section_headers;
8136 relsec < section_headers + elf_header.e_shnum;
8137 ++relsec)
8138 {
8139 unsigned long nrelas;
8140 Elf_Internal_Rela *rela, *rp;
8141 Elf_Internal_Shdr *symsec;
8142 Elf_Internal_Sym *symtab;
8143 Elf_Internal_Sym *sym;
8144
8145 if (relsec->sh_type != SHT_RELA
8146 || SECTION_HEADER (relsec->sh_info) != section
8147 || relsec->sh_size == 0)
8148 continue;
8149
8150 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8151 & rela, & nrelas))
8152 return 0;
8153
8154 symsec = SECTION_HEADER (relsec->sh_link);
8155 symtab = GET_ELF_SYMBOLS (file, symsec);
8156
8157 for (rp = rela; rp < rela + nrelas; ++rp)
8158 {
8159 if (rp->r_offset
8160 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
8161 - section_begin))
8162 continue;
8163
8164 if (is_32bit_elf)
8165 {
8166 sym = symtab + ELF32_R_SYM (rp->r_info);
8167
8168 if (ELF32_R_SYM (rp->r_info) != 0
8169 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
8170 {
8171 warn (_("Skipping unexpected symbol type %u\n"),
8172 ELF32_ST_TYPE (sym->st_info));
8173 continue;
8174 }
8175 }
8176 else
8177 {
8178 sym = symtab + ELF64_R_SYM (rp->r_info);
8179
8180 if (ELF64_R_SYM (rp->r_info) != 0
8181 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8182 {
8183 warn (_("Skipping unexpected symbol type %u\n"),
8184 ELF64_ST_TYPE (sym->st_info));
8185 continue;
8186 }
8187 }
8188
8189 compunit.cu_abbrev_offset = rp->r_addend;
8190 break;
8191 }
8192
8193 free (rela);
8194 break;
8195 }
8196
8197 tags = start + sizeof (*external);
8198 cu_offset = start - section_begin;
8199 start += compunit.cu_length + sizeof (external->cu_length);
8200
8201 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8202 printf (_(" Length: %ld\n"), compunit.cu_length);
8203 printf (_(" Version: %d\n"), compunit.cu_version);
8204 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8205 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8206
8207 if (compunit.cu_version != 2)
8208 {
8209 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8210 continue;
8211 }
8212
8213 free_abbrevs ();
8214
8215 /* Read in the abbrevs used by this compilation unit. */
8216 {
8217 Elf_Internal_Shdr *sec;
8218 unsigned char *begin;
8219
8220 /* Locate the .debug_abbrev section and process it. */
8221 for (i = 0, sec = section_headers;
8222 i < elf_header.e_shnum;
8223 i++, sec++)
8224 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
8225 break;
8226
8227 if (i == elf_header.e_shnum || sec->sh_size == 0)
8228 {
8229 warn (_("Unable to locate .debug_abbrev section!\n"));
8230 return 0;
8231 }
8232
8233 begin = ((unsigned char *)
8234 get_data (NULL, file, sec->sh_offset, sec->sh_size,
8235 _("debug_abbrev section data")));
8236 if (!begin)
8237 return 0;
8238
8239 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8240 begin + sec->sh_size);
8241
8242 free (begin);
8243 }
8244
8245 level = 0;
8246 while (tags < start)
8247 {
8248 int bytes_read;
8249 unsigned long abbrev_number;
8250 abbrev_entry *entry;
8251 abbrev_attr *attr;
8252
8253 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8254 tags += bytes_read;
8255
8256 /* A null DIE marks the end of a list of children. */
8257 if (abbrev_number == 0)
8258 {
8259 --level;
8260 continue;
8261 }
8262
8263 /* Scan through the abbreviation list until we reach the
8264 correct entry. */
8265 for (entry = first_abbrev;
8266 entry && entry->entry != abbrev_number;
8267 entry = entry->next)
8268 continue;
8269
8270 if (entry == NULL)
8271 {
8272 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8273 abbrev_number);
8274 return 0;
8275 }
8276
8277 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8278 level,
8279 (unsigned long) (tags - section_begin - bytes_read),
8280 abbrev_number,
8281 get_TAG_name (entry->tag));
8282
8283 for (attr = entry->first_attr; attr; attr = attr->next)
8284 tags = read_and_display_attr (attr->attribute,
8285 attr->form,
8286 tags, cu_offset,
8287 compunit.cu_pointer_size);
8288
8289 if (entry->children)
8290 ++level;
8291 }
8292 }
8293
8294 free_debug_str ();
8295 free_debug_loc ();
8296
8297 printf ("\n");
8298
8299 return 1;
8300 }
8301
8302 static int
8303 display_debug_aranges (section, start, file)
8304 Elf_Internal_Shdr *section;
8305 unsigned char *start;
8306 FILE *file ATTRIBUTE_UNUSED;
8307 {
8308 unsigned char *end = start + section->sh_size;
8309
8310 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8311
8312 while (start < end)
8313 {
8314 DWARF2_External_ARange *external;
8315 DWARF2_Internal_ARange arange;
8316 unsigned char *ranges;
8317 unsigned long length;
8318 unsigned long address;
8319 int excess;
8320
8321 external = (DWARF2_External_ARange *) start;
8322
8323 arange.ar_length = BYTE_GET (external->ar_length);
8324 arange.ar_version = BYTE_GET (external->ar_version);
8325 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
8326 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
8327 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
8328
8329 if (arange.ar_length == 0xffffffff)
8330 {
8331 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8332 break;
8333 }
8334
8335 if (arange.ar_version != 2)
8336 {
8337 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8338 break;
8339 }
8340
8341 printf (_(" Length: %ld\n"), arange.ar_length);
8342 printf (_(" Version: %d\n"), arange.ar_version);
8343 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8344 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8345 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8346
8347 printf (_("\n Address Length\n"));
8348
8349 ranges = start + sizeof (*external);
8350
8351 /* Must pad to an alignment boundary that is twice the pointer size. */
8352 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
8353 if (excess)
8354 ranges += (2 * arange.ar_pointer_size) - excess;
8355
8356 for (;;)
8357 {
8358 address = byte_get (ranges, arange.ar_pointer_size);
8359
8360 ranges += arange.ar_pointer_size;
8361
8362 length = byte_get (ranges, arange.ar_pointer_size);
8363
8364 ranges += arange.ar_pointer_size;
8365
8366 /* A pair of zeros marks the end of the list. */
8367 if (address == 0 && length == 0)
8368 break;
8369
8370 printf (" %8.8lx %lu\n", address, length);
8371 }
8372
8373 start += arange.ar_length + sizeof (external->ar_length);
8374 }
8375
8376 printf ("\n");
8377
8378 return 1;
8379 }
8380
8381 typedef struct Frame_Chunk
8382 {
8383 struct Frame_Chunk *next;
8384 unsigned char *chunk_start;
8385 int ncols;
8386 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8387 short int *col_type;
8388 int *col_offset;
8389 char *augmentation;
8390 unsigned int code_factor;
8391 int data_factor;
8392 unsigned long pc_begin;
8393 unsigned long pc_range;
8394 int cfa_reg;
8395 int cfa_offset;
8396 int ra;
8397 unsigned char fde_encoding;
8398 }
8399 Frame_Chunk;
8400
8401 /* A marker for a col_type that means this column was never referenced
8402 in the frame info. */
8403 #define DW_CFA_unreferenced (-1)
8404
8405 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8406 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8407 static int size_of_encoded_value PARAMS ((int));
8408
8409 static void
8410 frame_need_space (fc, reg)
8411 Frame_Chunk *fc;
8412 int reg;
8413 {
8414 int prev = fc->ncols;
8415
8416 if (reg < fc->ncols)
8417 return;
8418
8419 fc->ncols = reg + 1;
8420 fc->col_type = (short int *) xrealloc (fc->col_type,
8421 fc->ncols * sizeof (short int));
8422 fc->col_offset = (int *) xrealloc (fc->col_offset,
8423 fc->ncols * sizeof (int));
8424
8425 while (prev < fc->ncols)
8426 {
8427 fc->col_type[prev] = DW_CFA_unreferenced;
8428 fc->col_offset[prev] = 0;
8429 prev++;
8430 }
8431 }
8432
8433 static void
8434 frame_display_row (fc, need_col_headers, max_regs)
8435 Frame_Chunk *fc;
8436 int *need_col_headers;
8437 int *max_regs;
8438 {
8439 int r;
8440 char tmp[100];
8441
8442 if (*max_regs < fc->ncols)
8443 *max_regs = fc->ncols;
8444
8445 if (*need_col_headers)
8446 {
8447 *need_col_headers = 0;
8448
8449 printf (" LOC CFA ");
8450
8451 for (r = 0; r < *max_regs; r++)
8452 if (fc->col_type[r] != DW_CFA_unreferenced)
8453 {
8454 if (r == fc->ra)
8455 printf ("ra ");
8456 else
8457 printf ("r%-4d", r);
8458 }
8459
8460 printf ("\n");
8461 }
8462
8463 printf ("%08lx ", fc->pc_begin);
8464 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8465 printf ("%-8s ", tmp);
8466
8467 for (r = 0; r < fc->ncols; r++)
8468 {
8469 if (fc->col_type[r] != DW_CFA_unreferenced)
8470 {
8471 switch (fc->col_type[r])
8472 {
8473 case DW_CFA_undefined:
8474 strcpy (tmp, "u");
8475 break;
8476 case DW_CFA_same_value:
8477 strcpy (tmp, "s");
8478 break;
8479 case DW_CFA_offset:
8480 sprintf (tmp, "c%+d", fc->col_offset[r]);
8481 break;
8482 case DW_CFA_register:
8483 sprintf (tmp, "r%d", fc->col_offset[r]);
8484 break;
8485 default:
8486 strcpy (tmp, "n/a");
8487 break;
8488 }
8489 printf ("%-5s", tmp);
8490 }
8491 }
8492 printf ("\n");
8493 }
8494
8495 static int
8496 size_of_encoded_value (encoding)
8497 int encoding;
8498 {
8499 switch (encoding & 0x7)
8500 {
8501 default: /* ??? */
8502 case 0: return is_32bit_elf ? 4 : 8;
8503 case 2: return 2;
8504 case 3: return 4;
8505 case 4: return 8;
8506 }
8507 }
8508
8509 #define GET(N) byte_get (start, N); start += N
8510 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8511 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8512
8513 static int
8514 display_debug_frames (section, start, file)
8515 Elf_Internal_Shdr *section;
8516 unsigned char *start;
8517 FILE *file ATTRIBUTE_UNUSED;
8518 {
8519 unsigned char *end = start + section->sh_size;
8520 unsigned char *section_start = start;
8521 Frame_Chunk *chunks = 0;
8522 Frame_Chunk *remembered_state = 0;
8523 Frame_Chunk *rs;
8524 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8525 int length_return;
8526 int max_regs = 0;
8527 int addr_size = is_32bit_elf ? 4 : 8;
8528
8529 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8530
8531 while (start < end)
8532 {
8533 unsigned char *saved_start;
8534 unsigned char *block_end;
8535 unsigned long length;
8536 unsigned long cie_id;
8537 Frame_Chunk *fc;
8538 Frame_Chunk *cie;
8539 int need_col_headers = 1;
8540 unsigned char *augmentation_data = NULL;
8541 unsigned long augmentation_data_len = 0;
8542 int encoded_ptr_size = addr_size;
8543
8544 saved_start = start;
8545 length = byte_get (start, 4); start += 4;
8546
8547 if (length == 0)
8548 {
8549 printf ("\n%08lx ZERO terminator\n\n",
8550 (unsigned long)(saved_start - section_start));
8551 return 1;
8552 }
8553
8554 if (length == 0xffffffff)
8555 {
8556 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8557 break;
8558 }
8559
8560 block_end = saved_start + length + 4;
8561 cie_id = byte_get (start, 4); start += 4;
8562
8563 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8564 {
8565 int version;
8566
8567 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8568 memset (fc, 0, sizeof (Frame_Chunk));
8569
8570 fc->next = chunks;
8571 chunks = fc;
8572 fc->chunk_start = saved_start;
8573 fc->ncols = 0;
8574 fc->col_type = (short int *) xmalloc (sizeof (short int));
8575 fc->col_offset = (int *) xmalloc (sizeof (int));
8576 frame_need_space (fc, max_regs-1);
8577
8578 version = *start++;
8579
8580 fc->augmentation = start;
8581 start = strchr (start, '\0') + 1;
8582
8583 if (fc->augmentation[0] == 'z')
8584 {
8585 fc->code_factor = LEB ();
8586 fc->data_factor = SLEB ();
8587 fc->ra = byte_get (start, 1); start += 1;
8588 augmentation_data_len = LEB ();
8589 augmentation_data = start;
8590 start += augmentation_data_len;
8591 }
8592 else if (strcmp (fc->augmentation, "eh") == 0)
8593 {
8594 start += addr_size;
8595 fc->code_factor = LEB ();
8596 fc->data_factor = SLEB ();
8597 fc->ra = byte_get (start, 1); start += 1;
8598 }
8599 else
8600 {
8601 fc->code_factor = LEB ();
8602 fc->data_factor = SLEB ();
8603 fc->ra = byte_get (start, 1); start += 1;
8604 }
8605 cie = fc;
8606
8607 if (do_debug_frames_interp)
8608 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8609 (unsigned long)(saved_start - section_start), length, cie_id,
8610 fc->augmentation, fc->code_factor, fc->data_factor,
8611 fc->ra);
8612 else
8613 {
8614 printf ("\n%08lx %08lx %08lx CIE\n",
8615 (unsigned long)(saved_start - section_start), length, cie_id);
8616 printf (" Version: %d\n", version);
8617 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8618 printf (" Code alignment factor: %u\n", fc->code_factor);
8619 printf (" Data alignment factor: %d\n", fc->data_factor);
8620 printf (" Return address column: %d\n", fc->ra);
8621
8622 if (augmentation_data_len)
8623 {
8624 unsigned long i;
8625 printf (" Augmentation data: ");
8626 for (i = 0; i < augmentation_data_len; ++i)
8627 printf (" %02x", augmentation_data[i]);
8628 putchar ('\n');
8629 }
8630 putchar ('\n');
8631 }
8632
8633 if (augmentation_data_len)
8634 {
8635 unsigned char *p, *q;
8636 p = fc->augmentation + 1;
8637 q = augmentation_data;
8638
8639 while (1)
8640 {
8641 if (*p == 'L')
8642 q++;
8643 else if (*p == 'P')
8644 q += 1 + size_of_encoded_value (*q);
8645 else if (*p == 'R')
8646 fc->fde_encoding = *q++;
8647 else
8648 break;
8649 p++;
8650 }
8651
8652 if (fc->fde_encoding)
8653 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8654 }
8655
8656 frame_need_space (fc, fc->ra);
8657 }
8658 else
8659 {
8660 unsigned char *look_for;
8661 static Frame_Chunk fde_fc;
8662
8663 fc = & fde_fc;
8664 memset (fc, 0, sizeof (Frame_Chunk));
8665
8666 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8667
8668 for (cie = chunks; cie ; cie = cie->next)
8669 if (cie->chunk_start == look_for)
8670 break;
8671
8672 if (!cie)
8673 {
8674 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8675 cie_id, saved_start);
8676 start = block_end;
8677 fc->ncols = 0;
8678 fc->col_type = (short int *) xmalloc (sizeof (short int));
8679 fc->col_offset = (int *) xmalloc (sizeof (int));
8680 frame_need_space (fc, max_regs - 1);
8681 cie = fc;
8682 fc->augmentation = "";
8683 fc->fde_encoding = 0;
8684 }
8685 else
8686 {
8687 fc->ncols = cie->ncols;
8688 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8689 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8690 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8691 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8692 fc->augmentation = cie->augmentation;
8693 fc->code_factor = cie->code_factor;
8694 fc->data_factor = cie->data_factor;
8695 fc->cfa_reg = cie->cfa_reg;
8696 fc->cfa_offset = cie->cfa_offset;
8697 fc->ra = cie->ra;
8698 frame_need_space (fc, max_regs-1);
8699 fc->fde_encoding = cie->fde_encoding;
8700 }
8701
8702 if (fc->fde_encoding)
8703 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8704
8705 fc->pc_begin = byte_get (start, encoded_ptr_size);
8706 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8707 fc->pc_begin += section->sh_addr + (start - section_start);
8708 start += encoded_ptr_size;
8709 fc->pc_range = byte_get (start, encoded_ptr_size);
8710 start += encoded_ptr_size;
8711
8712 if (cie->augmentation[0] == 'z')
8713 {
8714 augmentation_data_len = LEB ();
8715 augmentation_data = start;
8716 start += augmentation_data_len;
8717 }
8718
8719 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8720 (unsigned long)(saved_start - section_start), length, cie_id,
8721 (unsigned long)(cie->chunk_start - section_start),
8722 fc->pc_begin, fc->pc_begin + fc->pc_range);
8723 if (! do_debug_frames_interp && augmentation_data_len)
8724 {
8725 unsigned long i;
8726 printf (" Augmentation data: ");
8727 for (i = 0; i < augmentation_data_len; ++i)
8728 printf (" %02x", augmentation_data[i]);
8729 putchar ('\n');
8730 putchar ('\n');
8731 }
8732 }
8733
8734 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8735 about to interpret instructions for the chunk. */
8736
8737 if (do_debug_frames_interp)
8738 {
8739 /* Start by making a pass over the chunk, allocating storage
8740 and taking note of what registers are used. */
8741 unsigned char *tmp = start;
8742
8743 while (start < block_end)
8744 {
8745 unsigned op, opa;
8746 unsigned long reg;
8747
8748 op = *start++;
8749 opa = op & 0x3f;
8750 if (op & 0xc0)
8751 op &= 0xc0;
8752
8753 /* Warning: if you add any more cases to this switch, be
8754 sure to add them to the corresponding switch below. */
8755 switch (op)
8756 {
8757 case DW_CFA_advance_loc:
8758 break;
8759 case DW_CFA_offset:
8760 LEB ();
8761 frame_need_space (fc, opa);
8762 fc->col_type[opa] = DW_CFA_undefined;
8763 break;
8764 case DW_CFA_restore:
8765 frame_need_space (fc, opa);
8766 fc->col_type[opa] = DW_CFA_undefined;
8767 break;
8768 case DW_CFA_set_loc:
8769 start += encoded_ptr_size;
8770 break;
8771 case DW_CFA_advance_loc1:
8772 start += 1;
8773 break;
8774 case DW_CFA_advance_loc2:
8775 start += 2;
8776 break;
8777 case DW_CFA_advance_loc4:
8778 start += 4;
8779 break;
8780 case DW_CFA_offset_extended:
8781 reg = LEB (); LEB ();
8782 frame_need_space (fc, reg);
8783 fc->col_type[reg] = DW_CFA_undefined;
8784 break;
8785 case DW_CFA_restore_extended:
8786 reg = LEB ();
8787 frame_need_space (fc, reg);
8788 fc->col_type[reg] = DW_CFA_undefined;
8789 break;
8790 case DW_CFA_undefined:
8791 reg = LEB ();
8792 frame_need_space (fc, reg);
8793 fc->col_type[reg] = DW_CFA_undefined;
8794 break;
8795 case DW_CFA_same_value:
8796 reg = LEB ();
8797 frame_need_space (fc, reg);
8798 fc->col_type[reg] = DW_CFA_undefined;
8799 break;
8800 case DW_CFA_register:
8801 reg = LEB (); LEB ();
8802 frame_need_space (fc, reg);
8803 fc->col_type[reg] = DW_CFA_undefined;
8804 break;
8805 case DW_CFA_def_cfa:
8806 LEB (); LEB ();
8807 break;
8808 case DW_CFA_def_cfa_register:
8809 LEB ();
8810 break;
8811 case DW_CFA_def_cfa_offset:
8812 LEB ();
8813 break;
8814 case DW_CFA_offset_extended_sf:
8815 reg = LEB (); SLEB ();
8816 frame_need_space (fc, reg);
8817 fc->col_type[reg] = DW_CFA_undefined;
8818 break;
8819 case DW_CFA_def_cfa_sf:
8820 LEB (); SLEB ();
8821 break;
8822 case DW_CFA_def_cfa_offset_sf:
8823 SLEB ();
8824 break;
8825 case DW_CFA_GNU_args_size:
8826 LEB ();
8827 break;
8828 case DW_CFA_GNU_negative_offset_extended:
8829 reg = LEB (); LEB ();
8830 frame_need_space (fc, reg);
8831 fc->col_type[reg] = DW_CFA_undefined;
8832
8833 default:
8834 break;
8835 }
8836 }
8837 start = tmp;
8838 }
8839
8840 /* Now we know what registers are used, make a second pass over
8841 the chunk, this time actually printing out the info. */
8842
8843 while (start < block_end)
8844 {
8845 unsigned op, opa;
8846 unsigned long ul, reg, roffs;
8847 long l, ofs;
8848 bfd_vma vma;
8849
8850 op = *start++;
8851 opa = op & 0x3f;
8852 if (op & 0xc0)
8853 op &= 0xc0;
8854
8855 /* Warning: if you add any more cases to this switch, be
8856 sure to add them to the corresponding switch above. */
8857 switch (op)
8858 {
8859 case DW_CFA_advance_loc:
8860 if (do_debug_frames_interp)
8861 frame_display_row (fc, &need_col_headers, &max_regs);
8862 else
8863 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8864 opa * fc->code_factor,
8865 fc->pc_begin + opa * fc->code_factor);
8866 fc->pc_begin += opa * fc->code_factor;
8867 break;
8868
8869 case DW_CFA_offset:
8870 roffs = LEB ();
8871 if (! do_debug_frames_interp)
8872 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8873 opa, roffs * fc->data_factor);
8874 fc->col_type[opa] = DW_CFA_offset;
8875 fc->col_offset[opa] = roffs * fc->data_factor;
8876 break;
8877
8878 case DW_CFA_restore:
8879 if (! do_debug_frames_interp)
8880 printf (" DW_CFA_restore: r%d\n", opa);
8881 fc->col_type[opa] = cie->col_type[opa];
8882 fc->col_offset[opa] = cie->col_offset[opa];
8883 break;
8884
8885 case DW_CFA_set_loc:
8886 vma = byte_get (start, encoded_ptr_size);
8887 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8888 vma += section->sh_addr + (start - section_start);
8889 start += encoded_ptr_size;
8890 if (do_debug_frames_interp)
8891 frame_display_row (fc, &need_col_headers, &max_regs);
8892 else
8893 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8894 fc->pc_begin = vma;
8895 break;
8896
8897 case DW_CFA_advance_loc1:
8898 ofs = byte_get (start, 1); start += 1;
8899 if (do_debug_frames_interp)
8900 frame_display_row (fc, &need_col_headers, &max_regs);
8901 else
8902 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8903 ofs * fc->code_factor,
8904 fc->pc_begin + ofs * fc->code_factor);
8905 fc->pc_begin += ofs * fc->code_factor;
8906 break;
8907
8908 case DW_CFA_advance_loc2:
8909 ofs = byte_get (start, 2); start += 2;
8910 if (do_debug_frames_interp)
8911 frame_display_row (fc, &need_col_headers, &max_regs);
8912 else
8913 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8914 ofs * fc->code_factor,
8915 fc->pc_begin + ofs * fc->code_factor);
8916 fc->pc_begin += ofs * fc->code_factor;
8917 break;
8918
8919 case DW_CFA_advance_loc4:
8920 ofs = byte_get (start, 4); start += 4;
8921 if (do_debug_frames_interp)
8922 frame_display_row (fc, &need_col_headers, &max_regs);
8923 else
8924 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8925 ofs * fc->code_factor,
8926 fc->pc_begin + ofs * fc->code_factor);
8927 fc->pc_begin += ofs * fc->code_factor;
8928 break;
8929
8930 case DW_CFA_offset_extended:
8931 reg = LEB ();
8932 roffs = LEB ();
8933 if (! do_debug_frames_interp)
8934 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8935 reg, roffs * fc->data_factor);
8936 fc->col_type[reg] = DW_CFA_offset;
8937 fc->col_offset[reg] = roffs * fc->data_factor;
8938 break;
8939
8940 case DW_CFA_restore_extended:
8941 reg = LEB ();
8942 if (! do_debug_frames_interp)
8943 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8944 fc->col_type[reg] = cie->col_type[reg];
8945 fc->col_offset[reg] = cie->col_offset[reg];
8946 break;
8947
8948 case DW_CFA_undefined:
8949 reg = LEB ();
8950 if (! do_debug_frames_interp)
8951 printf (" DW_CFA_undefined: r%ld\n", reg);
8952 fc->col_type[reg] = DW_CFA_undefined;
8953 fc->col_offset[reg] = 0;
8954 break;
8955
8956 case DW_CFA_same_value:
8957 reg = LEB ();
8958 if (! do_debug_frames_interp)
8959 printf (" DW_CFA_same_value: r%ld\n", reg);
8960 fc->col_type[reg] = DW_CFA_same_value;
8961 fc->col_offset[reg] = 0;
8962 break;
8963
8964 case DW_CFA_register:
8965 reg = LEB ();
8966 roffs = LEB ();
8967 if (! do_debug_frames_interp)
8968 printf (" DW_CFA_register: r%ld\n", reg);
8969 fc->col_type[reg] = DW_CFA_register;
8970 fc->col_offset[reg] = roffs;
8971 break;
8972
8973 case DW_CFA_remember_state:
8974 if (! do_debug_frames_interp)
8975 printf (" DW_CFA_remember_state\n");
8976 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8977 rs->ncols = fc->ncols;
8978 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8979 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8980 memcpy (rs->col_type, fc->col_type, rs->ncols);
8981 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8982 rs->next = remembered_state;
8983 remembered_state = rs;
8984 break;
8985
8986 case DW_CFA_restore_state:
8987 if (! do_debug_frames_interp)
8988 printf (" DW_CFA_restore_state\n");
8989 rs = remembered_state;
8990 remembered_state = rs->next;
8991 frame_need_space (fc, rs->ncols-1);
8992 memcpy (fc->col_type, rs->col_type, rs->ncols);
8993 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8994 free (rs->col_type);
8995 free (rs->col_offset);
8996 free (rs);
8997 break;
8998
8999 case DW_CFA_def_cfa:
9000 fc->cfa_reg = LEB ();
9001 fc->cfa_offset = LEB ();
9002 if (! do_debug_frames_interp)
9003 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9004 fc->cfa_reg, fc->cfa_offset);
9005 break;
9006
9007 case DW_CFA_def_cfa_register:
9008 fc->cfa_reg = LEB ();
9009 if (! do_debug_frames_interp)
9010 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
9011 break;
9012
9013 case DW_CFA_def_cfa_offset:
9014 fc->cfa_offset = LEB ();
9015 if (! do_debug_frames_interp)
9016 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
9017 break;
9018
9019 case DW_CFA_nop:
9020 if (! do_debug_frames_interp)
9021 printf (" DW_CFA_nop\n");
9022 break;
9023
9024 case DW_CFA_offset_extended_sf:
9025 reg = LEB ();
9026 l = SLEB ();
9027 frame_need_space (fc, reg);
9028 if (! do_debug_frames_interp)
9029 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9030 reg, l * fc->data_factor);
9031 fc->col_type[reg] = DW_CFA_offset;
9032 fc->col_offset[reg] = l * fc->data_factor;
9033 break;
9034
9035 case DW_CFA_def_cfa_sf:
9036 fc->cfa_reg = LEB ();
9037 fc->cfa_offset = SLEB ();
9038 if (! do_debug_frames_interp)
9039 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9040 fc->cfa_reg, fc->cfa_offset);
9041 break;
9042
9043 case DW_CFA_def_cfa_offset_sf:
9044 fc->cfa_offset = SLEB ();
9045 if (! do_debug_frames_interp)
9046 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
9047 break;
9048
9049 case DW_CFA_GNU_window_save:
9050 if (! do_debug_frames_interp)
9051 printf (" DW_CFA_GNU_window_save\n");
9052 break;
9053
9054 case DW_CFA_GNU_args_size:
9055 ul = LEB ();
9056 if (! do_debug_frames_interp)
9057 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
9058 break;
9059
9060 case DW_CFA_GNU_negative_offset_extended:
9061 reg = LEB ();
9062 l = - LEB ();
9063 frame_need_space (fc, reg);
9064 if (! do_debug_frames_interp)
9065 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9066 reg, l * fc->data_factor);
9067 fc->col_type[reg] = DW_CFA_offset;
9068 fc->col_offset[reg] = l * fc->data_factor;
9069 break;
9070
9071 /* FIXME: How do we handle these? */
9072 case DW_CFA_def_cfa_expression:
9073 fprintf (stderr, "unsupported DW_CFA_def_cfa_expression\n");
9074 start = block_end;
9075 break;
9076
9077 case DW_CFA_expression:
9078 fprintf (stderr, "unsupported DW_CFA_expression\n");
9079 start = block_end;
9080 break;
9081
9082 default:
9083 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
9084 start = block_end;
9085 }
9086 }
9087
9088 if (do_debug_frames_interp)
9089 frame_display_row (fc, &need_col_headers, &max_regs);
9090
9091 start = block_end;
9092 }
9093
9094 printf ("\n");
9095
9096 return 1;
9097 }
9098
9099 #undef GET
9100 #undef LEB
9101 #undef SLEB
9102
9103 static int
9104 display_debug_not_supported (section, start, file)
9105 Elf_Internal_Shdr *section;
9106 unsigned char *start ATTRIBUTE_UNUSED;
9107 FILE *file ATTRIBUTE_UNUSED;
9108 {
9109 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9110 SECTION_NAME (section));
9111
9112 return 1;
9113 }
9114
9115 /* Pre-scan the .debug_info section to record the size of address.
9116 When dumping the .debug_line, we use that size information, assuming
9117 that all compilation units have the same address size. */
9118 static int
9119 prescan_debug_info (section, start, file)
9120 Elf_Internal_Shdr *section ATTRIBUTE_UNUSED;
9121 unsigned char *start;
9122 FILE *file ATTRIBUTE_UNUSED;
9123 {
9124 DWARF2_External_CompUnit *external;
9125
9126 external = (DWARF2_External_CompUnit *) start;
9127
9128 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
9129 return 0;
9130 }
9131
9132 /* A structure containing the name of a debug section and a pointer
9133 to a function that can decode it. The third field is a prescan
9134 function to be run over the section before displaying any of the
9135 sections. */
9136 struct
9137 {
9138 const char *const name;
9139 int (*display) PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
9140 int (*prescan) PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
9141 }
9142 debug_displays[] =
9143 {
9144 { ".debug_abbrev", display_debug_abbrev, NULL },
9145 { ".debug_aranges", display_debug_aranges, NULL },
9146 { ".debug_frame", display_debug_frames, NULL },
9147 { ".debug_info", display_debug_info, prescan_debug_info },
9148 { ".debug_line", display_debug_lines, NULL },
9149 { ".debug_pubnames", display_debug_pubnames, NULL },
9150 { ".eh_frame", display_debug_frames, NULL },
9151 { ".debug_macinfo", display_debug_macinfo, NULL },
9152 { ".debug_str", display_debug_str, NULL },
9153 { ".debug_loc", display_debug_loc, NULL },
9154 { ".debug_pubtypes", display_debug_not_supported, NULL },
9155 { ".debug_ranges", display_debug_not_supported, NULL },
9156 { ".debug_static_func", display_debug_not_supported, NULL },
9157 { ".debug_static_vars", display_debug_not_supported, NULL },
9158 { ".debug_types", display_debug_not_supported, NULL },
9159 { ".debug_weaknames", display_debug_not_supported, NULL }
9160 };
9161
9162 static int
9163 display_debug_section (section, file)
9164 Elf_Internal_Shdr *section;
9165 FILE *file;
9166 {
9167 char *name = SECTION_NAME (section);
9168 bfd_size_type length;
9169 unsigned char *start;
9170 int i;
9171
9172 length = section->sh_size;
9173 if (length == 0)
9174 {
9175 printf (_("\nSection '%s' has no debugging data.\n"), name);
9176 return 0;
9177 }
9178
9179 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
9180 _("debug section data"));
9181 if (!start)
9182 return 0;
9183
9184 /* See if we know how to display the contents of this section. */
9185 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9186 name = ".debug_info";
9187
9188 for (i = NUM_ELEM (debug_displays); i--;)
9189 if (strcmp (debug_displays[i].name, name) == 0)
9190 {
9191 debug_displays[i].display (section, start, file);
9192 break;
9193 }
9194
9195 if (i == -1)
9196 printf (_("Unrecognized debug section: %s\n"), name);
9197
9198 free (start);
9199
9200 /* If we loaded in the abbrev section at some point,
9201 we must release it here. */
9202 free_abbrevs ();
9203
9204 return 1;
9205 }
9206
9207 static int
9208 process_section_contents (file)
9209 FILE *file;
9210 {
9211 Elf_Internal_Shdr *section;
9212 unsigned int i;
9213
9214 if (! do_dump)
9215 return 1;
9216
9217 /* Pre-scan the debug sections to find some debug information not
9218 present in some of them. For the .debug_line, we must find out the
9219 size of address (specified in .debug_info and .debug_aranges). */
9220 for (i = 0, section = section_headers;
9221 i < elf_header.e_shnum && i < num_dump_sects;
9222 i++, section++)
9223 {
9224 char *name = SECTION_NAME (section);
9225 int j;
9226
9227 if (section->sh_size == 0)
9228 continue;
9229
9230 /* See if there is some pre-scan operation for this section. */
9231 for (j = NUM_ELEM (debug_displays); j--;)
9232 if (strcmp (debug_displays[j].name, name) == 0)
9233 {
9234 if (debug_displays[j].prescan != NULL)
9235 {
9236 bfd_size_type length;
9237 unsigned char *start;
9238
9239 length = section->sh_size;
9240 start = ((unsigned char *)
9241 get_data (NULL, file, section->sh_offset, length,
9242 _("debug section data")));
9243 if (!start)
9244 return 0;
9245
9246 debug_displays[j].prescan (section, start, file);
9247 free (start);
9248 }
9249
9250 break;
9251 }
9252 }
9253
9254 for (i = 0, section = section_headers;
9255 i < elf_header.e_shnum && i < num_dump_sects;
9256 i++, section++)
9257 {
9258 #ifdef SUPPORT_DISASSEMBLY
9259 if (dump_sects[i] & DISASS_DUMP)
9260 disassemble_section (section, file);
9261 #endif
9262 if (dump_sects[i] & HEX_DUMP)
9263 dump_section (section, file);
9264
9265 if (dump_sects[i] & DEBUG_DUMP)
9266 display_debug_section (section, file);
9267 }
9268
9269 if (i < num_dump_sects)
9270 warn (_("Some sections were not dumped because they do not exist!\n"));
9271
9272 return 1;
9273 }
9274
9275 static void
9276 process_mips_fpe_exception (mask)
9277 int mask;
9278 {
9279 if (mask)
9280 {
9281 int first = 1;
9282 if (mask & OEX_FPU_INEX)
9283 fputs ("INEX", stdout), first = 0;
9284 if (mask & OEX_FPU_UFLO)
9285 printf ("%sUFLO", first ? "" : "|"), first = 0;
9286 if (mask & OEX_FPU_OFLO)
9287 printf ("%sOFLO", first ? "" : "|"), first = 0;
9288 if (mask & OEX_FPU_DIV0)
9289 printf ("%sDIV0", first ? "" : "|"), first = 0;
9290 if (mask & OEX_FPU_INVAL)
9291 printf ("%sINVAL", first ? "" : "|");
9292 }
9293 else
9294 fputs ("0", stdout);
9295 }
9296
9297 static int
9298 process_mips_specific (file)
9299 FILE *file;
9300 {
9301 Elf_Internal_Dyn *entry;
9302 size_t liblist_offset = 0;
9303 size_t liblistno = 0;
9304 size_t conflictsno = 0;
9305 size_t options_offset = 0;
9306 size_t conflicts_offset = 0;
9307
9308 /* We have a lot of special sections. Thanks SGI! */
9309 if (dynamic_segment == NULL)
9310 /* No information available. */
9311 return 0;
9312
9313 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9314 switch (entry->d_tag)
9315 {
9316 case DT_MIPS_LIBLIST:
9317 liblist_offset = entry->d_un.d_val - loadaddr;
9318 break;
9319 case DT_MIPS_LIBLISTNO:
9320 liblistno = entry->d_un.d_val;
9321 break;
9322 case DT_MIPS_OPTIONS:
9323 options_offset = entry->d_un.d_val - loadaddr;
9324 break;
9325 case DT_MIPS_CONFLICT:
9326 conflicts_offset = entry->d_un.d_val - loadaddr;
9327 break;
9328 case DT_MIPS_CONFLICTNO:
9329 conflictsno = entry->d_un.d_val;
9330 break;
9331 default:
9332 break;
9333 }
9334
9335 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9336 {
9337 Elf32_External_Lib *elib;
9338 size_t cnt;
9339
9340 elib = ((Elf32_External_Lib *)
9341 get_data (NULL, file, liblist_offset,
9342 liblistno * sizeof (Elf32_External_Lib),
9343 _("liblist")));
9344 if (elib)
9345 {
9346 printf ("\nSection '.liblist' contains %lu entries:\n",
9347 (unsigned long) liblistno);
9348 fputs (" Library Time Stamp Checksum Version Flags\n",
9349 stdout);
9350
9351 for (cnt = 0; cnt < liblistno; ++cnt)
9352 {
9353 Elf32_Lib liblist;
9354 time_t time;
9355 char timebuf[20];
9356 struct tm *tmp;
9357
9358 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9359 time = BYTE_GET (elib[cnt].l_time_stamp);
9360 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9361 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9362 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9363
9364 tmp = gmtime (&time);
9365 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9366 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9367 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9368
9369 printf ("%3lu: ", (unsigned long) cnt);
9370 print_symbol (20, dynamic_strings + liblist.l_name);
9371 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9372 liblist.l_version);
9373
9374 if (liblist.l_flags == 0)
9375 puts (" NONE");
9376 else
9377 {
9378 static const struct
9379 {
9380 const char *name;
9381 int bit;
9382 }
9383 l_flags_vals[] =
9384 {
9385 { " EXACT_MATCH", LL_EXACT_MATCH },
9386 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9387 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9388 { " EXPORTS", LL_EXPORTS },
9389 { " DELAY_LOAD", LL_DELAY_LOAD },
9390 { " DELTA", LL_DELTA }
9391 };
9392 int flags = liblist.l_flags;
9393 size_t fcnt;
9394
9395 for (fcnt = 0;
9396 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9397 ++fcnt)
9398 if ((flags & l_flags_vals[fcnt].bit) != 0)
9399 {
9400 fputs (l_flags_vals[fcnt].name, stdout);
9401 flags ^= l_flags_vals[fcnt].bit;
9402 }
9403 if (flags != 0)
9404 printf (" %#x", (unsigned int) flags);
9405
9406 puts ("");
9407 }
9408 }
9409
9410 free (elib);
9411 }
9412 }
9413
9414 if (options_offset != 0)
9415 {
9416 Elf_External_Options *eopt;
9417 Elf_Internal_Shdr *sect = section_headers;
9418 Elf_Internal_Options *iopt;
9419 Elf_Internal_Options *option;
9420 size_t offset;
9421 int cnt;
9422
9423 /* Find the section header so that we get the size. */
9424 while (sect->sh_type != SHT_MIPS_OPTIONS)
9425 ++sect;
9426
9427 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9428 sect->sh_size, _("options"));
9429 if (eopt)
9430 {
9431 iopt = ((Elf_Internal_Options *)
9432 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt)));
9433 if (iopt == NULL)
9434 {
9435 error (_("Out of memory"));
9436 return 0;
9437 }
9438
9439 offset = cnt = 0;
9440 option = iopt;
9441
9442 while (offset < sect->sh_size)
9443 {
9444 Elf_External_Options *eoption;
9445
9446 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9447
9448 option->kind = BYTE_GET (eoption->kind);
9449 option->size = BYTE_GET (eoption->size);
9450 option->section = BYTE_GET (eoption->section);
9451 option->info = BYTE_GET (eoption->info);
9452
9453 offset += option->size;
9454
9455 ++option;
9456 ++cnt;
9457 }
9458
9459 printf (_("\nSection '%s' contains %d entries:\n"),
9460 SECTION_NAME (sect), cnt);
9461
9462 option = iopt;
9463
9464 while (cnt-- > 0)
9465 {
9466 size_t len;
9467
9468 switch (option->kind)
9469 {
9470 case ODK_NULL:
9471 /* This shouldn't happen. */
9472 printf (" NULL %d %lx", option->section, option->info);
9473 break;
9474 case ODK_REGINFO:
9475 printf (" REGINFO ");
9476 if (elf_header.e_machine == EM_MIPS)
9477 {
9478 /* 32bit form. */
9479 Elf32_External_RegInfo *ereg;
9480 Elf32_RegInfo reginfo;
9481
9482 ereg = (Elf32_External_RegInfo *) (option + 1);
9483 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9484 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9485 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9486 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9487 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9488 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9489
9490 printf ("GPR %08lx GP 0x%lx\n",
9491 reginfo.ri_gprmask,
9492 (unsigned long) reginfo.ri_gp_value);
9493 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9494 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9495 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9496 }
9497 else
9498 {
9499 /* 64 bit form. */
9500 Elf64_External_RegInfo *ereg;
9501 Elf64_Internal_RegInfo reginfo;
9502
9503 ereg = (Elf64_External_RegInfo *) (option + 1);
9504 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9505 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9506 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9507 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9508 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9509 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9510
9511 printf ("GPR %08lx GP 0x",
9512 reginfo.ri_gprmask);
9513 printf_vma (reginfo.ri_gp_value);
9514 printf ("\n");
9515
9516 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9517 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9518 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9519 }
9520 ++option;
9521 continue;
9522 case ODK_EXCEPTIONS:
9523 fputs (" EXCEPTIONS fpe_min(", stdout);
9524 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9525 fputs (") fpe_max(", stdout);
9526 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9527 fputs (")", stdout);
9528
9529 if (option->info & OEX_PAGE0)
9530 fputs (" PAGE0", stdout);
9531 if (option->info & OEX_SMM)
9532 fputs (" SMM", stdout);
9533 if (option->info & OEX_FPDBUG)
9534 fputs (" FPDBUG", stdout);
9535 if (option->info & OEX_DISMISS)
9536 fputs (" DISMISS", stdout);
9537 break;
9538 case ODK_PAD:
9539 fputs (" PAD ", stdout);
9540 if (option->info & OPAD_PREFIX)
9541 fputs (" PREFIX", stdout);
9542 if (option->info & OPAD_POSTFIX)
9543 fputs (" POSTFIX", stdout);
9544 if (option->info & OPAD_SYMBOL)
9545 fputs (" SYMBOL", stdout);
9546 break;
9547 case ODK_HWPATCH:
9548 fputs (" HWPATCH ", stdout);
9549 if (option->info & OHW_R4KEOP)
9550 fputs (" R4KEOP", stdout);
9551 if (option->info & OHW_R8KPFETCH)
9552 fputs (" R8KPFETCH", stdout);
9553 if (option->info & OHW_R5KEOP)
9554 fputs (" R5KEOP", stdout);
9555 if (option->info & OHW_R5KCVTL)
9556 fputs (" R5KCVTL", stdout);
9557 break;
9558 case ODK_FILL:
9559 fputs (" FILL ", stdout);
9560 /* XXX Print content of info word? */
9561 break;
9562 case ODK_TAGS:
9563 fputs (" TAGS ", stdout);
9564 /* XXX Print content of info word? */
9565 break;
9566 case ODK_HWAND:
9567 fputs (" HWAND ", stdout);
9568 if (option->info & OHWA0_R4KEOP_CHECKED)
9569 fputs (" R4KEOP_CHECKED", stdout);
9570 if (option->info & OHWA0_R4KEOP_CLEAN)
9571 fputs (" R4KEOP_CLEAN", stdout);
9572 break;
9573 case ODK_HWOR:
9574 fputs (" HWOR ", stdout);
9575 if (option->info & OHWA0_R4KEOP_CHECKED)
9576 fputs (" R4KEOP_CHECKED", stdout);
9577 if (option->info & OHWA0_R4KEOP_CLEAN)
9578 fputs (" R4KEOP_CLEAN", stdout);
9579 break;
9580 case ODK_GP_GROUP:
9581 printf (" GP_GROUP %#06lx self-contained %#06lx",
9582 option->info & OGP_GROUP,
9583 (option->info & OGP_SELF) >> 16);
9584 break;
9585 case ODK_IDENT:
9586 printf (" IDENT %#06lx self-contained %#06lx",
9587 option->info & OGP_GROUP,
9588 (option->info & OGP_SELF) >> 16);
9589 break;
9590 default:
9591 /* This shouldn't happen. */
9592 printf (" %3d ??? %d %lx",
9593 option->kind, option->section, option->info);
9594 break;
9595 }
9596
9597 len = sizeof (*eopt);
9598 while (len < option->size)
9599 if (((char *) option)[len] >= ' '
9600 && ((char *) option)[len] < 0x7f)
9601 printf ("%c", ((char *) option)[len++]);
9602 else
9603 printf ("\\%03o", ((char *) option)[len++]);
9604
9605 fputs ("\n", stdout);
9606 ++option;
9607 }
9608
9609 free (eopt);
9610 }
9611 }
9612
9613 if (conflicts_offset != 0 && conflictsno != 0)
9614 {
9615 Elf32_Conflict *iconf;
9616 size_t cnt;
9617
9618 if (dynamic_symbols == NULL)
9619 {
9620 error (_("conflict list found without a dynamic symbol table"));
9621 return 0;
9622 }
9623
9624 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
9625 if (iconf == NULL)
9626 {
9627 error (_("Out of memory"));
9628 return 0;
9629 }
9630
9631 if (is_32bit_elf)
9632 {
9633 Elf32_External_Conflict *econf32;
9634
9635 econf32 = ((Elf32_External_Conflict *)
9636 get_data (NULL, file, conflicts_offset,
9637 conflictsno * sizeof (*econf32),
9638 _("conflict")));
9639 if (!econf32)
9640 return 0;
9641
9642 for (cnt = 0; cnt < conflictsno; ++cnt)
9643 iconf[cnt] = BYTE_GET (econf32[cnt]);
9644
9645 free (econf32);
9646 }
9647 else
9648 {
9649 Elf64_External_Conflict *econf64;
9650
9651 econf64 = ((Elf64_External_Conflict *)
9652 get_data (NULL, file, conflicts_offset,
9653 conflictsno * sizeof (*econf64),
9654 _("conflict")));
9655 if (!econf64)
9656 return 0;
9657
9658 for (cnt = 0; cnt < conflictsno; ++cnt)
9659 iconf[cnt] = BYTE_GET (econf64[cnt]);
9660
9661 free (econf64);
9662 }
9663
9664 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9665 (long) conflictsno);
9666 puts (_(" Num: Index Value Name"));
9667
9668 for (cnt = 0; cnt < conflictsno; ++cnt)
9669 {
9670 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9671
9672 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9673 print_vma (psym->st_value, FULL_HEX);
9674 putchar (' ');
9675 print_symbol (25, dynamic_strings + psym->st_name);
9676 putchar ('\n');
9677 }
9678
9679 free (iconf);
9680 }
9681
9682 return 1;
9683 }
9684
9685 static int
9686 process_gnu_liblist (file)
9687 FILE *file;
9688 {
9689 Elf_Internal_Shdr *section, *string_sec;
9690 Elf32_External_Lib *elib;
9691 char *strtab;
9692 size_t cnt;
9693 unsigned i;
9694
9695 if (! do_arch)
9696 return 0;
9697
9698 for (i = 0, section = section_headers;
9699 i < elf_header.e_shnum;
9700 i++, section++)
9701 {
9702 switch (section->sh_type)
9703 {
9704 case SHT_GNU_LIBLIST:
9705 elib = ((Elf32_External_Lib *)
9706 get_data (NULL, file, section->sh_offset, section->sh_size,
9707 _("liblist")));
9708
9709 if (elib == NULL)
9710 break;
9711 string_sec = SECTION_HEADER (section->sh_link);
9712
9713 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9714 string_sec->sh_size,
9715 _("liblist string table"));
9716
9717 if (strtab == NULL
9718 || section->sh_entsize != sizeof (Elf32_External_Lib))
9719 {
9720 free (elib);
9721 break;
9722 }
9723
9724 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9725 SECTION_NAME (section),
9726 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9727
9728 puts (" Library Time Stamp Checksum Version Flags");
9729
9730 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9731 ++cnt)
9732 {
9733 Elf32_Lib liblist;
9734 time_t time;
9735 char timebuf[20];
9736 struct tm *tmp;
9737
9738 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9739 time = BYTE_GET (elib[cnt].l_time_stamp);
9740 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9741 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9742 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9743
9744 tmp = gmtime (&time);
9745 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9746 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9747 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9748
9749 printf ("%3lu: ", (unsigned long) cnt);
9750 if (do_wide)
9751 printf ("%-20s", strtab + liblist.l_name);
9752 else
9753 printf ("%-20.20s", strtab + liblist.l_name);
9754 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9755 liblist.l_version, liblist.l_flags);
9756 }
9757
9758 free (elib);
9759 }
9760 }
9761
9762 return 1;
9763 }
9764
9765 static const char *
9766 get_note_type (e_type)
9767 unsigned e_type;
9768 {
9769 static char buff[64];
9770
9771 switch (e_type)
9772 {
9773 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9774 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9775 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9776 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9777 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9778 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9779 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9780 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9781 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9782 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9783 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9784 default:
9785 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9786 return buff;
9787 }
9788 }
9789
9790 static const char *
9791 get_netbsd_elfcore_note_type (e_type)
9792 unsigned e_type;
9793 {
9794 static char buff[64];
9795
9796 if (e_type == NT_NETBSDCORE_PROCINFO)
9797 {
9798 /* NetBSD core "procinfo" structure. */
9799 return _("NetBSD procinfo structure");
9800 }
9801
9802 /* As of Jan 2002 there are no other machine-independent notes
9803 defined for NetBSD core files. If the note type is less
9804 than the start of the machine-dependent note types, we don't
9805 understand it. */
9806
9807 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9808 {
9809 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9810 return buff;
9811 }
9812
9813 switch (elf_header.e_machine)
9814 {
9815 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9816 and PT_GETFPREGS == mach+2. */
9817
9818 case EM_OLD_ALPHA:
9819 case EM_ALPHA:
9820 case EM_SPARC:
9821 case EM_SPARC32PLUS:
9822 case EM_SPARCV9:
9823 switch (e_type)
9824 {
9825 case NT_NETBSDCORE_FIRSTMACH+0:
9826 return _("PT_GETREGS (reg structure)");
9827 case NT_NETBSDCORE_FIRSTMACH+2:
9828 return _("PT_GETFPREGS (fpreg structure)");
9829 default:
9830 break;
9831 }
9832 break;
9833
9834 /* On all other arch's, PT_GETREGS == mach+1 and
9835 PT_GETFPREGS == mach+3. */
9836 default:
9837 switch (e_type)
9838 {
9839 case NT_NETBSDCORE_FIRSTMACH+1:
9840 return _("PT_GETREGS (reg structure)");
9841 case NT_NETBSDCORE_FIRSTMACH+3:
9842 return _("PT_GETFPREGS (fpreg structure)");
9843 default:
9844 break;
9845 }
9846 }
9847
9848 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9849 return buff;
9850 }
9851
9852 /* Note that by the ELF standard, the name field is already null byte
9853 terminated, and namesz includes the terminating null byte.
9854 I.E. the value of namesz for the name "FSF" is 4.
9855
9856 If the value of namesz is zero, there is no name present. */
9857 static int
9858 process_note (pnote)
9859 Elf_Internal_Note *pnote;
9860 {
9861 const char *nt;
9862
9863 if (pnote->namesz == 0)
9864 {
9865 /* If there is no note name, then use the default set of
9866 note type strings. */
9867 nt = get_note_type (pnote->type);
9868 }
9869 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9870 {
9871 /* NetBSD-specific core file notes. */
9872 nt = get_netbsd_elfcore_note_type (pnote->type);
9873 }
9874 else
9875 {
9876 /* Don't recognize this note name; just use the default set of
9877 note type strings. */
9878 nt = get_note_type (pnote->type);
9879 }
9880
9881 printf (" %s\t\t0x%08lx\t%s\n",
9882 pnote->namesz ? pnote->namedata : "(NONE)",
9883 pnote->descsz, nt);
9884 return 1;
9885 }
9886
9887
9888 static int
9889 process_corefile_note_segment (file, offset, length)
9890 FILE *file;
9891 bfd_vma offset;
9892 bfd_vma length;
9893 {
9894 Elf_External_Note *pnotes;
9895 Elf_External_Note *external;
9896 int res = 1;
9897
9898 if (length <= 0)
9899 return 0;
9900
9901 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9902 _("notes"));
9903 if (!pnotes)
9904 return 0;
9905
9906 external = pnotes;
9907
9908 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9909 (unsigned long) offset, (unsigned long) length);
9910 printf (_(" Owner\t\tData size\tDescription\n"));
9911
9912 while (external < (Elf_External_Note *)((char *) pnotes + length))
9913 {
9914 Elf_External_Note *next;
9915 Elf_Internal_Note inote;
9916 char *temp = NULL;
9917
9918 inote.type = BYTE_GET (external->type);
9919 inote.namesz = BYTE_GET (external->namesz);
9920 inote.namedata = external->name;
9921 inote.descsz = BYTE_GET (external->descsz);
9922 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9923 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9924
9925 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9926
9927 if (((char *) next) > (((char *) pnotes) + length))
9928 {
9929 warn (_("corrupt note found at offset %x into core notes\n"),
9930 ((char *) external) - ((char *) pnotes));
9931 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9932 inote.type, inote.namesz, inote.descsz);
9933 break;
9934 }
9935
9936 external = next;
9937
9938 /* Verify that name is null terminated. It appears that at least
9939 one version of Linux (RedHat 6.0) generates corefiles that don't
9940 comply with the ELF spec by failing to include the null byte in
9941 namesz. */
9942 if (inote.namedata[inote.namesz] != '\0')
9943 {
9944 temp = malloc (inote.namesz + 1);
9945
9946 if (temp == NULL)
9947 {
9948 error (_("Out of memory\n"));
9949 res = 0;
9950 break;
9951 }
9952
9953 strncpy (temp, inote.namedata, inote.namesz);
9954 temp[inote.namesz] = 0;
9955
9956 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9957 inote.namedata = temp;
9958 }
9959
9960 res &= process_note (& inote);
9961
9962 if (temp != NULL)
9963 {
9964 free (temp);
9965 temp = NULL;
9966 }
9967 }
9968
9969 free (pnotes);
9970
9971 return res;
9972 }
9973
9974 static int
9975 process_corefile_note_segments (file)
9976 FILE *file;
9977 {
9978 Elf_Internal_Phdr *program_headers;
9979 Elf_Internal_Phdr *segment;
9980 unsigned int i;
9981 int res = 1;
9982
9983 program_headers = (Elf_Internal_Phdr *) malloc
9984 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9985
9986 if (program_headers == NULL)
9987 {
9988 error (_("Out of memory\n"));
9989 return 0;
9990 }
9991
9992 if (is_32bit_elf)
9993 i = get_32bit_program_headers (file, program_headers);
9994 else
9995 i = get_64bit_program_headers (file, program_headers);
9996
9997 if (i == 0)
9998 {
9999 free (program_headers);
10000 return 0;
10001 }
10002
10003 for (i = 0, segment = program_headers;
10004 i < elf_header.e_phnum;
10005 i++, segment++)
10006 {
10007 if (segment->p_type == PT_NOTE)
10008 res &= process_corefile_note_segment (file,
10009 (bfd_vma) segment->p_offset,
10010 (bfd_vma) segment->p_filesz);
10011 }
10012
10013 free (program_headers);
10014
10015 return res;
10016 }
10017
10018 static int
10019 process_corefile_contents (file)
10020 FILE *file;
10021 {
10022 /* If we have not been asked to display the notes then do nothing. */
10023 if (! do_notes)
10024 return 1;
10025
10026 /* If file is not a core file then exit. */
10027 if (elf_header.e_type != ET_CORE)
10028 return 1;
10029
10030 /* No program headers means no NOTE segment. */
10031 if (elf_header.e_phnum == 0)
10032 {
10033 printf (_("No note segments present in the core file.\n"));
10034 return 1;
10035 }
10036
10037 return process_corefile_note_segments (file);
10038 }
10039
10040 static int
10041 process_arch_specific (file)
10042 FILE *file;
10043 {
10044 if (! do_arch)
10045 return 1;
10046
10047 switch (elf_header.e_machine)
10048 {
10049 case EM_MIPS:
10050 case EM_MIPS_RS3_LE:
10051 return process_mips_specific (file);
10052 break;
10053 default:
10054 break;
10055 }
10056 return 1;
10057 }
10058
10059 static int
10060 get_file_header (file)
10061 FILE *file;
10062 {
10063 /* Read in the identity array. */
10064 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10065 return 0;
10066
10067 /* Determine how to read the rest of the header. */
10068 switch (elf_header.e_ident[EI_DATA])
10069 {
10070 default: /* fall through */
10071 case ELFDATANONE: /* fall through */
10072 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
10073 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
10074 }
10075
10076 /* For now we only support 32 bit and 64 bit ELF files. */
10077 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10078
10079 /* Read in the rest of the header. */
10080 if (is_32bit_elf)
10081 {
10082 Elf32_External_Ehdr ehdr32;
10083
10084 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10085 return 0;
10086
10087 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10088 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10089 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10090 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10091 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10092 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10093 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10094 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10095 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10096 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10097 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10098 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10099 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10100 }
10101 else
10102 {
10103 Elf64_External_Ehdr ehdr64;
10104
10105 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10106 we will not be able to cope with the 64bit data found in
10107 64 ELF files. Detect this now and abort before we start
10108 overwritting things. */
10109 if (sizeof (bfd_vma) < 8)
10110 {
10111 error (_("This instance of readelf has been built without support for a\n\
10112 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10113 return 0;
10114 }
10115
10116 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10117 return 0;
10118
10119 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10120 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10121 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10122 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
10123 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
10124 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
10125 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10126 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10127 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10128 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10129 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10130 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10131 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10132 }
10133
10134 if (elf_header.e_shoff)
10135 {
10136 /* There may be some extensions in the first section header. Don't
10137 bomb if we can't read it. */
10138 if (is_32bit_elf)
10139 get_32bit_section_headers (file, 1);
10140 else
10141 get_64bit_section_headers (file, 1);
10142 }
10143
10144 return 1;
10145 }
10146
10147 static int
10148 process_file (file_name)
10149 char *file_name;
10150 {
10151 FILE *file;
10152 struct stat statbuf;
10153 unsigned int i;
10154
10155 if (stat (file_name, & statbuf) < 0)
10156 {
10157 error (_("Cannot stat input file %s.\n"), file_name);
10158 return 1;
10159 }
10160
10161 file = fopen (file_name, "rb");
10162 if (file == NULL)
10163 {
10164 error (_("Input file %s not found.\n"), file_name);
10165 return 1;
10166 }
10167
10168 if (! get_file_header (file))
10169 {
10170 error (_("%s: Failed to read file header\n"), file_name);
10171 fclose (file);
10172 return 1;
10173 }
10174
10175 /* Initialise per file variables. */
10176 for (i = NUM_ELEM (version_info); i--;)
10177 version_info[i] = 0;
10178
10179 for (i = NUM_ELEM (dynamic_info); i--;)
10180 dynamic_info[i] = 0;
10181
10182 /* Process the file. */
10183 if (show_name)
10184 printf (_("\nFile: %s\n"), file_name);
10185
10186 if (! process_file_header ())
10187 {
10188 fclose (file);
10189 return 1;
10190 }
10191
10192 if (! process_section_headers (file))
10193 {
10194 /* Without loaded section headers we
10195 cannot process lots of things. */
10196 do_unwind = do_version = do_dump = do_arch = 0;
10197
10198 if (! do_using_dynamic)
10199 do_syms = do_reloc = 0;
10200 }
10201
10202 if (process_program_headers (file))
10203 process_dynamic_segment (file);
10204
10205 process_relocs (file);
10206
10207 process_unwind (file);
10208
10209 process_symbol_table (file);
10210
10211 process_syminfo (file);
10212
10213 process_version_sections (file);
10214
10215 process_section_contents (file);
10216
10217 process_corefile_contents (file);
10218
10219 process_gnu_liblist (file);
10220
10221 process_arch_specific (file);
10222
10223 fclose (file);
10224
10225 if (section_headers)
10226 {
10227 free (section_headers);
10228 section_headers = NULL;
10229 }
10230
10231 if (string_table)
10232 {
10233 free (string_table);
10234 string_table = NULL;
10235 string_table_length = 0;
10236 }
10237
10238 if (dynamic_strings)
10239 {
10240 free (dynamic_strings);
10241 dynamic_strings = NULL;
10242 }
10243
10244 if (dynamic_symbols)
10245 {
10246 free (dynamic_symbols);
10247 dynamic_symbols = NULL;
10248 num_dynamic_syms = 0;
10249 }
10250
10251 if (dynamic_syminfo)
10252 {
10253 free (dynamic_syminfo);
10254 dynamic_syminfo = NULL;
10255 }
10256
10257 return 0;
10258 }
10259
10260 #ifdef SUPPORT_DISASSEMBLY
10261 /* Needed by the i386 disassembler. For extra credit, someone could
10262 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10263 symbols. */
10264
10265 void
10266 print_address (unsigned int addr, FILE *outfile)
10267 {
10268 fprintf (outfile,"0x%8.8x", addr);
10269 }
10270
10271 /* Needed by the i386 disassembler. */
10272 void
10273 db_task_printsym (unsigned int addr)
10274 {
10275 print_address (addr, stderr);
10276 }
10277 #endif
10278
10279 int main PARAMS ((int, char **));
10280
10281 int
10282 main (argc, argv)
10283 int argc;
10284 char **argv;
10285 {
10286 int err;
10287 char *cmdline_dump_sects = NULL;
10288 unsigned num_cmdline_dump_sects = 0;
10289
10290 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10291 setlocale (LC_MESSAGES, "");
10292 #endif
10293 #if defined (HAVE_SETLOCALE)
10294 setlocale (LC_CTYPE, "");
10295 #endif
10296 bindtextdomain (PACKAGE, LOCALEDIR);
10297 textdomain (PACKAGE);
10298
10299 parse_args (argc, argv);
10300
10301 if (optind < (argc - 1))
10302 show_name = 1;
10303
10304 /* When processing more than one file remember the dump requests
10305 issued on command line to reset them after each file. */
10306 if (optind + 1 < argc && dump_sects != NULL)
10307 {
10308 cmdline_dump_sects = malloc (num_dump_sects);
10309 if (cmdline_dump_sects == NULL)
10310 error (_("Out of memory allocating dump request table."));
10311 else
10312 {
10313 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
10314 num_cmdline_dump_sects = num_dump_sects;
10315 }
10316 }
10317
10318 err = 0;
10319 while (optind < argc)
10320 {
10321 err |= process_file (argv[optind++]);
10322
10323 /* Reset dump requests. */
10324 if (optind < argc && dump_sects != NULL)
10325 {
10326 num_dump_sects = num_cmdline_dump_sects;
10327 if (num_cmdline_dump_sects > 0)
10328 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
10329 }
10330 }
10331
10332 if (dump_sects != NULL)
10333 free (dump_sects);
10334 if (cmdline_dump_sects != NULL)
10335 free (cmdline_dump_sects);
10336
10337 return err;
10338 }
A mirror of the official binutils-gdb repository