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