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