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