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