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