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