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