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