projects / binutils-gdb.git / blob
? search:


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