projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* bucomm.c (fatal): Define using VPARAMS, VA_OPEN, VA_FIXEDARG,
[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, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
2003 }
2004 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2005 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
2006 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2007 sprintf (buff, "SHT_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 do_debugging = 0;
2206 switch (optarg[0])
2207 {
2208 case 'i':
2209 case 'I':
2210 do_debug_info = 1;
2211 break;
2212
2213 case 'a':
2214 case 'A':
2215 do_debug_abbrevs = 1;
2216 break;
2217
2218 case 'l':
2219 case 'L':
2220 do_debug_lines = 1;
2221 break;
2222
2223 case 'p':
2224 case 'P':
2225 do_debug_pubnames = 1;
2226 break;
2227
2228 case 'r':
2229 case 'R':
2230 do_debug_aranges = 1;
2231 break;
2232
2233 case 'F':
2234 do_debug_frames_interp = 1;
2235 case 'f':
2236 do_debug_frames = 1;
2237 break;
2238
2239 case 'm':
2240 case 'M':
2241 do_debug_macinfo = 1;
2242 break;
2243
2244 default:
2245 warn (_("Unrecognised debug option '%s'\n"), optarg);
2246 break;
2247 }
2248 }
2249 break;
2250 #ifdef SUPPORT_DISASSEMBLY
2251 case 'i':
2252 do_dump ++;
2253 section = strtoul (optarg, & cp, 0);
2254 if (! * cp && section >= 0)
2255 {
2256 request_dump (section, DISASS_DUMP);
2257 break;
2258 }
2259 goto oops;
2260 #endif
2261 case 'v':
2262 print_version (program_name);
2263 break;
2264 case 'V':
2265 do_version ++;
2266 break;
2267 case 'W':
2268 do_wide ++;
2269 break;
2270 default:
2271 oops:
2272 /* xgettext:c-format */
2273 error (_("Invalid option '-%c'\n"), c);
2274 /* Drop through. */
2275 case '?':
2276 usage ();
2277 }
2278 }
2279
2280 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2281 && !do_segments && !do_header && !do_dump && !do_version
2282 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2283 usage ();
2284 else if (argc < 3)
2285 {
2286 warn (_("Nothing to do.\n"));
2287 usage();
2288 }
2289 }
2290
2291 static const char *
2292 get_elf_class (elf_class)
2293 unsigned char elf_class;
2294 {
2295 static char buff [32];
2296
2297 switch (elf_class)
2298 {
2299 case ELFCLASSNONE: return _("none");
2300 case ELFCLASS32: return _("ELF32");
2301 case ELFCLASS64: return _("ELF64");
2302 default:
2303 sprintf (buff, _("<unknown: %x>"), elf_class);
2304 return buff;
2305 }
2306 }
2307
2308 static const char *
2309 get_data_encoding (encoding)
2310 unsigned char encoding;
2311 {
2312 static char buff [32];
2313
2314 switch (encoding)
2315 {
2316 case ELFDATANONE: return _("none");
2317 case ELFDATA2LSB: return _("2's complement, little endian");
2318 case ELFDATA2MSB: return _("2's complement, big endian");
2319 default:
2320 sprintf (buff, _("<unknown: %x>"), encoding);
2321 return buff;
2322 }
2323 }
2324
2325 static const char *
2326 get_osabi_name (osabi)
2327 unsigned char osabi;
2328 {
2329 static char buff [32];
2330
2331 switch (osabi)
2332 {
2333 case ELFOSABI_NONE: return _("UNIX - System V");
2334 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2335 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2336 case ELFOSABI_LINUX: return _("UNIX - Linux");
2337 case ELFOSABI_HURD: return _("GNU/Hurd");
2338 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2339 case ELFOSABI_AIX: return _("UNIX - AIX");
2340 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2341 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2342 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2343 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2344 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2345 case ELFOSABI_STANDALONE: return _("Standalone App");
2346 case ELFOSABI_ARM: return _("ARM");
2347 default:
2348 sprintf (buff, _("<unknown: %x>"), osabi);
2349 return buff;
2350 }
2351 }
2352
2353 /* Decode the data held in 'elf_header'. */
2354 static int
2355 process_file_header ()
2356 {
2357 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2358 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2359 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2360 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2361 {
2362 error
2363 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2364 return 0;
2365 }
2366
2367 if (do_header)
2368 {
2369 int i;
2370
2371 printf (_("ELF Header:\n"));
2372 printf (_(" Magic: "));
2373 for (i = 0; i < EI_NIDENT; i ++)
2374 printf ("%2.2x ", elf_header.e_ident [i]);
2375 printf ("\n");
2376 printf (_(" Class: %s\n"),
2377 get_elf_class (elf_header.e_ident [EI_CLASS]));
2378 printf (_(" Data: %s\n"),
2379 get_data_encoding (elf_header.e_ident [EI_DATA]));
2380 printf (_(" Version: %d %s\n"),
2381 elf_header.e_ident [EI_VERSION],
2382 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2383 ? "(current)"
2384 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2385 ? "<unknown: %lx>"
2386 : "")));
2387 printf (_(" OS/ABI: %s\n"),
2388 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2389 printf (_(" ABI Version: %d\n"),
2390 elf_header.e_ident [EI_ABIVERSION]);
2391 printf (_(" Type: %s\n"),
2392 get_file_type (elf_header.e_type));
2393 printf (_(" Machine: %s\n"),
2394 get_machine_name (elf_header.e_machine));
2395 printf (_(" Version: 0x%lx\n"),
2396 (unsigned long) elf_header.e_version);
2397
2398 printf (_(" Entry point address: "));
2399 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2400 printf (_("\n Start of program headers: "));
2401 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2402 printf (_(" (bytes into file)\n Start of section headers: "));
2403 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2404 printf (_(" (bytes into file)\n"));
2405
2406 printf (_(" Flags: 0x%lx%s\n"),
2407 (unsigned long) elf_header.e_flags,
2408 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2409 printf (_(" Size of this header: %ld (bytes)\n"),
2410 (long) elf_header.e_ehsize);
2411 printf (_(" Size of program headers: %ld (bytes)\n"),
2412 (long) elf_header.e_phentsize);
2413 printf (_(" Number of program headers: %ld\n"),
2414 (long) elf_header.e_phnum);
2415 printf (_(" Size of section headers: %ld (bytes)\n"),
2416 (long) elf_header.e_shentsize);
2417 printf (_(" Number of section headers: %ld\n"),
2418 (long) elf_header.e_shnum);
2419 printf (_(" Section header string table index: %ld\n"),
2420 (long) elf_header.e_shstrndx);
2421 }
2422
2423 return 1;
2424 }
2425
2426
2427 static int
2428 get_32bit_program_headers (file, program_headers)
2429 FILE * file;
2430 Elf_Internal_Phdr * program_headers;
2431 {
2432 Elf32_External_Phdr * phdrs;
2433 Elf32_External_Phdr * external;
2434 Elf32_Internal_Phdr * internal;
2435 unsigned int i;
2436
2437 phdrs = ((Elf32_External_Phdr *)
2438 get_data (NULL, file, elf_header.e_phoff,
2439 elf_header.e_phentsize * elf_header.e_phnum,
2440 _("program headers")));
2441 if (!phdrs)
2442 return 0;
2443
2444 for (i = 0, internal = program_headers, external = phdrs;
2445 i < elf_header.e_phnum;
2446 i ++, internal ++, external ++)
2447 {
2448 internal->p_type = BYTE_GET (external->p_type);
2449 internal->p_offset = BYTE_GET (external->p_offset);
2450 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2451 internal->p_paddr = BYTE_GET (external->p_paddr);
2452 internal->p_filesz = BYTE_GET (external->p_filesz);
2453 internal->p_memsz = BYTE_GET (external->p_memsz);
2454 internal->p_flags = BYTE_GET (external->p_flags);
2455 internal->p_align = BYTE_GET (external->p_align);
2456 }
2457
2458 free (phdrs);
2459
2460 return 1;
2461 }
2462
2463 static int
2464 get_64bit_program_headers (file, program_headers)
2465 FILE * file;
2466 Elf_Internal_Phdr * program_headers;
2467 {
2468 Elf64_External_Phdr * phdrs;
2469 Elf64_External_Phdr * external;
2470 Elf64_Internal_Phdr * internal;
2471 unsigned int i;
2472
2473 phdrs = ((Elf64_External_Phdr *)
2474 get_data (NULL, file, elf_header.e_phoff,
2475 elf_header.e_phentsize * elf_header.e_phnum,
2476 _("program headers")));
2477 if (!phdrs)
2478 return 0;
2479
2480 for (i = 0, internal = program_headers, external = phdrs;
2481 i < elf_header.e_phnum;
2482 i ++, internal ++, external ++)
2483 {
2484 internal->p_type = BYTE_GET (external->p_type);
2485 internal->p_flags = BYTE_GET (external->p_flags);
2486 internal->p_offset = BYTE_GET8 (external->p_offset);
2487 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2488 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2489 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2490 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2491 internal->p_align = BYTE_GET8 (external->p_align);
2492 }
2493
2494 free (phdrs);
2495
2496 return 1;
2497 }
2498
2499 static int
2500 process_program_headers (file)
2501 FILE * file;
2502 {
2503 Elf_Internal_Phdr * program_headers;
2504 Elf_Internal_Phdr * segment;
2505 unsigned int i;
2506
2507 if (elf_header.e_phnum == 0)
2508 {
2509 if (do_segments)
2510 printf (_("\nThere are no program headers in this file.\n"));
2511 return 1;
2512 }
2513
2514 if (do_segments && !do_header)
2515 {
2516 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2517 printf (_("Entry point "));
2518 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2519 printf (_("\nThere are %d program headers, starting at offset "),
2520 elf_header.e_phnum);
2521 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2522 printf ("\n");
2523 }
2524
2525 program_headers = (Elf_Internal_Phdr *) malloc
2526 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2527
2528 if (program_headers == NULL)
2529 {
2530 error (_("Out of memory\n"));
2531 return 0;
2532 }
2533
2534 if (is_32bit_elf)
2535 i = get_32bit_program_headers (file, program_headers);
2536 else
2537 i = get_64bit_program_headers (file, program_headers);
2538
2539 if (i == 0)
2540 {
2541 free (program_headers);
2542 return 0;
2543 }
2544
2545 if (do_segments)
2546 {
2547 printf
2548 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2549
2550 if (is_32bit_elf)
2551 printf
2552 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2553 else if (do_wide)
2554 printf
2555 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2556 else
2557 {
2558 printf
2559 (_(" Type Offset VirtAddr PhysAddr\n"));
2560 printf
2561 (_(" FileSiz MemSiz Flags Align\n"));
2562 }
2563 }
2564
2565 loadaddr = -1;
2566 dynamic_addr = 0;
2567 dynamic_size = 0;
2568
2569 for (i = 0, segment = program_headers;
2570 i < elf_header.e_phnum;
2571 i ++, segment ++)
2572 {
2573 if (do_segments)
2574 {
2575 printf (" %-14.14s ", get_segment_type (segment->p_type));
2576
2577 if (is_32bit_elf)
2578 {
2579 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2580 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2581 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2582 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2583 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2584 printf ("%c%c%c ",
2585 (segment->p_flags & PF_R ? 'R' : ' '),
2586 (segment->p_flags & PF_W ? 'W' : ' '),
2587 (segment->p_flags & PF_X ? 'E' : ' '));
2588 printf ("%#lx", (unsigned long) segment->p_align);
2589 }
2590 else if (do_wide)
2591 {
2592 if ((unsigned long) segment->p_offset == segment->p_offset)
2593 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2594 else
2595 {
2596 print_vma (segment->p_offset, FULL_HEX);
2597 putchar (' ');
2598 }
2599
2600 print_vma (segment->p_vaddr, FULL_HEX);
2601 putchar (' ');
2602 print_vma (segment->p_paddr, FULL_HEX);
2603 putchar (' ');
2604
2605 if ((unsigned long) segment->p_filesz == segment->p_filesz)
2606 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2607 else
2608 {
2609 print_vma (segment->p_filesz, FULL_HEX);
2610 putchar (' ');
2611 }
2612
2613 if ((unsigned long) segment->p_memsz == segment->p_memsz)
2614 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2615 else
2616 {
2617 print_vma (segment->p_offset, FULL_HEX);
2618 }
2619
2620 printf (" %c%c%c ",
2621 (segment->p_flags & PF_R ? 'R' : ' '),
2622 (segment->p_flags & PF_W ? 'W' : ' '),
2623 (segment->p_flags & PF_X ? 'E' : ' '));
2624
2625 if ((unsigned long) segment->p_align == segment->p_align)
2626 printf ("%#lx", (unsigned long) segment->p_align);
2627 else
2628 {
2629 print_vma (segment->p_align, PREFIX_HEX);
2630 }
2631 }
2632 else
2633 {
2634 print_vma (segment->p_offset, FULL_HEX);
2635 putchar (' ');
2636 print_vma (segment->p_vaddr, FULL_HEX);
2637 putchar (' ');
2638 print_vma (segment->p_paddr, FULL_HEX);
2639 printf ("\n ");
2640 print_vma (segment->p_filesz, FULL_HEX);
2641 putchar (' ');
2642 print_vma (segment->p_memsz, FULL_HEX);
2643 printf (" %c%c%c ",
2644 (segment->p_flags & PF_R ? 'R' : ' '),
2645 (segment->p_flags & PF_W ? 'W' : ' '),
2646 (segment->p_flags & PF_X ? 'E' : ' '));
2647 print_vma (segment->p_align, HEX);
2648 }
2649 }
2650
2651 switch (segment->p_type)
2652 {
2653 case PT_LOAD:
2654 if (loadaddr == -1)
2655 loadaddr = (segment->p_vaddr & 0xfffff000)
2656 - (segment->p_offset & 0xfffff000);
2657 break;
2658
2659 case PT_DYNAMIC:
2660 if (dynamic_addr)
2661 error (_("more than one dynamic segment\n"));
2662
2663 dynamic_addr = segment->p_offset;
2664 dynamic_size = segment->p_filesz;
2665 break;
2666
2667 case PT_INTERP:
2668 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2669 error (_("Unable to find program interpreter name\n"));
2670 else
2671 {
2672 program_interpreter[0] = 0;
2673 fscanf (file, "%63s", program_interpreter);
2674
2675 if (do_segments)
2676 printf (_("\n [Requesting program interpreter: %s]"),
2677 program_interpreter);
2678 }
2679 break;
2680 }
2681
2682 if (do_segments)
2683 putc ('\n', stdout);
2684 }
2685
2686 if (loadaddr == -1)
2687 {
2688 /* Very strange. */
2689 loadaddr = 0;
2690 }
2691
2692 if (do_segments && section_headers != NULL)
2693 {
2694 printf (_("\n Section to Segment mapping:\n"));
2695 printf (_(" Segment Sections...\n"));
2696
2697 assert (string_table != NULL);
2698
2699 for (i = 0; i < elf_header.e_phnum; i++)
2700 {
2701 int j;
2702 Elf_Internal_Shdr * section;
2703
2704 segment = program_headers + i;
2705 section = section_headers;
2706
2707 printf (" %2.2d ", i);
2708
2709 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2710 {
2711 if (section->sh_size > 0
2712 /* Compare allocated sections by VMA, unallocated
2713 sections by file offset. */
2714 && (section->sh_flags & SHF_ALLOC
2715 ? (section->sh_addr >= segment->p_vaddr
2716 && section->sh_addr + section->sh_size
2717 <= segment->p_vaddr + segment->p_memsz)
2718 : ((bfd_vma) section->sh_offset >= segment->p_offset
2719 && (section->sh_offset + section->sh_size
2720 <= segment->p_offset + segment->p_filesz))))
2721 printf ("%s ", SECTION_NAME (section));
2722 }
2723
2724 putc ('\n',stdout);
2725 }
2726 }
2727
2728 free (program_headers);
2729
2730 return 1;
2731 }
2732
2733
2734 static int
2735 get_32bit_section_headers (file)
2736 FILE * file;
2737 {
2738 Elf32_External_Shdr * shdrs;
2739 Elf32_Internal_Shdr * internal;
2740 unsigned int i;
2741
2742 shdrs = ((Elf32_External_Shdr *)
2743 get_data (NULL, file, elf_header.e_shoff,
2744 elf_header.e_shentsize * elf_header.e_shnum,
2745 _("section headers")));
2746 if (!shdrs)
2747 return 0;
2748
2749 section_headers = (Elf_Internal_Shdr *) malloc
2750 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2751
2752 if (section_headers == NULL)
2753 {
2754 error (_("Out of memory\n"));
2755 return 0;
2756 }
2757
2758 for (i = 0, internal = section_headers;
2759 i < elf_header.e_shnum;
2760 i ++, internal ++)
2761 {
2762 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2763 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2764 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2765 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2766 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2767 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2768 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2769 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2770 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2771 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2772 }
2773
2774 free (shdrs);
2775
2776 return 1;
2777 }
2778
2779 static int
2780 get_64bit_section_headers (file)
2781 FILE * file;
2782 {
2783 Elf64_External_Shdr * shdrs;
2784 Elf64_Internal_Shdr * internal;
2785 unsigned int i;
2786
2787 shdrs = ((Elf64_External_Shdr *)
2788 get_data (NULL, file, elf_header.e_shoff,
2789 elf_header.e_shentsize * elf_header.e_shnum,
2790 _("section headers")));
2791 if (!shdrs)
2792 return 0;
2793
2794 section_headers = (Elf_Internal_Shdr *) malloc
2795 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2796
2797 if (section_headers == NULL)
2798 {
2799 error (_("Out of memory\n"));
2800 return 0;
2801 }
2802
2803 for (i = 0, internal = section_headers;
2804 i < elf_header.e_shnum;
2805 i ++, internal ++)
2806 {
2807 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2808 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2809 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2810 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2811 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2812 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2813 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2814 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2815 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2816 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2817 }
2818
2819 free (shdrs);
2820
2821 return 1;
2822 }
2823
2824 static Elf_Internal_Sym *
2825 get_32bit_elf_symbols (file, offset, number)
2826 FILE * file;
2827 unsigned long offset;
2828 unsigned long number;
2829 {
2830 Elf32_External_Sym * esyms;
2831 Elf_Internal_Sym * isyms;
2832 Elf_Internal_Sym * psym;
2833 unsigned int j;
2834
2835 esyms = ((Elf32_External_Sym *)
2836 get_data (NULL, file, offset,
2837 number * sizeof (Elf32_External_Sym), _("symbols")));
2838 if (!esyms)
2839 return NULL;
2840
2841 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2842
2843 if (isyms == NULL)
2844 {
2845 error (_("Out of memory\n"));
2846 free (esyms);
2847
2848 return NULL;
2849 }
2850
2851 for (j = 0, psym = isyms;
2852 j < number;
2853 j ++, psym ++)
2854 {
2855 psym->st_name = BYTE_GET (esyms[j].st_name);
2856 psym->st_value = BYTE_GET (esyms[j].st_value);
2857 psym->st_size = BYTE_GET (esyms[j].st_size);
2858 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2859 psym->st_info = BYTE_GET (esyms[j].st_info);
2860 psym->st_other = BYTE_GET (esyms[j].st_other);
2861 }
2862
2863 free (esyms);
2864
2865 return isyms;
2866 }
2867
2868 static Elf_Internal_Sym *
2869 get_64bit_elf_symbols (file, offset, number)
2870 FILE * file;
2871 unsigned long offset;
2872 unsigned long number;
2873 {
2874 Elf64_External_Sym * esyms;
2875 Elf_Internal_Sym * isyms;
2876 Elf_Internal_Sym * psym;
2877 unsigned int j;
2878
2879 esyms = ((Elf64_External_Sym *)
2880 get_data (NULL, file, offset,
2881 number * sizeof (Elf64_External_Sym), _("symbols")));
2882 if (!esyms)
2883 return NULL;
2884
2885 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2886
2887 if (isyms == NULL)
2888 {
2889 error (_("Out of memory\n"));
2890 free (esyms);
2891
2892 return NULL;
2893 }
2894
2895 for (j = 0, psym = isyms;
2896 j < number;
2897 j ++, psym ++)
2898 {
2899 psym->st_name = BYTE_GET (esyms[j].st_name);
2900 psym->st_info = BYTE_GET (esyms[j].st_info);
2901 psym->st_other = BYTE_GET (esyms[j].st_other);
2902 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2903 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2904 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2905 }
2906
2907 free (esyms);
2908
2909 return isyms;
2910 }
2911
2912 static const char *
2913 get_elf_section_flags (sh_flags)
2914 bfd_vma sh_flags;
2915 {
2916 static char buff [32];
2917
2918 * buff = 0;
2919
2920 while (sh_flags)
2921 {
2922 bfd_vma flag;
2923
2924 flag = sh_flags & - sh_flags;
2925 sh_flags &= ~ flag;
2926
2927 switch (flag)
2928 {
2929 case SHF_WRITE: strcat (buff, "W"); break;
2930 case SHF_ALLOC: strcat (buff, "A"); break;
2931 case SHF_EXECINSTR: strcat (buff, "X"); break;
2932 case SHF_MERGE: strcat (buff, "M"); break;
2933 case SHF_STRINGS: strcat (buff, "S"); break;
2934 case SHF_INFO_LINK: strcat (buff, "I"); break;
2935 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2936 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2937 case SHF_GROUP: strcat (buff, "G"); break;
2938
2939 default:
2940 if (flag & SHF_MASKOS)
2941 {
2942 strcat (buff, "o");
2943 sh_flags &= ~ SHF_MASKOS;
2944 }
2945 else if (flag & SHF_MASKPROC)
2946 {
2947 strcat (buff, "p");
2948 sh_flags &= ~ SHF_MASKPROC;
2949 }
2950 else
2951 strcat (buff, "x");
2952 break;
2953 }
2954 }
2955
2956 return buff;
2957 }
2958
2959 static int
2960 process_section_headers (file)
2961 FILE * file;
2962 {
2963 Elf_Internal_Shdr * section;
2964 int i;
2965
2966 section_headers = NULL;
2967
2968 if (elf_header.e_shnum == 0)
2969 {
2970 if (do_sections)
2971 printf (_("\nThere are no sections in this file.\n"));
2972
2973 return 1;
2974 }
2975
2976 if (do_sections && !do_header)
2977 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2978 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2979
2980 if (is_32bit_elf)
2981 {
2982 if (! get_32bit_section_headers (file))
2983 return 0;
2984 }
2985 else if (! get_64bit_section_headers (file))
2986 return 0;
2987
2988 /* Read in the string table, so that we have names to display. */
2989 section = section_headers + elf_header.e_shstrndx;
2990
2991 if (section->sh_size != 0)
2992 {
2993 string_table = (char *) get_data (NULL, file, section->sh_offset,
2994 section->sh_size, _("string table"));
2995
2996 string_table_length = section->sh_size;
2997 }
2998
2999 /* Scan the sections for the dynamic symbol table
3000 and dynamic string table and debug sections. */
3001 dynamic_symbols = NULL;
3002 dynamic_strings = NULL;
3003 dynamic_syminfo = NULL;
3004
3005 for (i = 0, section = section_headers;
3006 i < elf_header.e_shnum;
3007 i ++, section ++)
3008 {
3009 char * name = SECTION_NAME (section);
3010
3011 if (section->sh_type == SHT_DYNSYM)
3012 {
3013 if (dynamic_symbols != NULL)
3014 {
3015 error (_("File contains multiple dynamic symbol tables\n"));
3016 continue;
3017 }
3018
3019 num_dynamic_syms = section->sh_size / section->sh_entsize;
3020 dynamic_symbols =
3021 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
3022 }
3023 else if (section->sh_type == SHT_STRTAB
3024 && strcmp (name, ".dynstr") == 0)
3025 {
3026 if (dynamic_strings != NULL)
3027 {
3028 error (_("File contains multiple dynamic string tables\n"));
3029 continue;
3030 }
3031
3032 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3033 section->sh_size,
3034 _("dynamic strings"));
3035 }
3036 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3037 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3038 || do_debug_frames || do_debug_macinfo)
3039 && strncmp (name, ".debug_", 7) == 0)
3040 {
3041 name += 7;
3042
3043 if (do_debugging
3044 || (do_debug_info && (strcmp (name, "info") == 0))
3045 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3046 || (do_debug_lines && (strcmp (name, "line") == 0))
3047 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3048 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3049 || (do_debug_frames && (strcmp (name, "frame") == 0))
3050 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3051 )
3052 request_dump (i, DEBUG_DUMP);
3053 }
3054 /* linkonce section to be combined with .debug_info at link time. */
3055 else if ((do_debugging || do_debug_info)
3056 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3057 request_dump (i, DEBUG_DUMP);
3058 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3059 request_dump (i, DEBUG_DUMP);
3060 }
3061
3062 if (! do_sections)
3063 return 1;
3064
3065 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
3066
3067 if (is_32bit_elf)
3068 printf
3069 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3070 else if (do_wide)
3071 printf
3072 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3073 else
3074 {
3075 printf (_(" [Nr] Name Type Address Offset\n"));
3076 printf (_(" Size EntSize Flags Link Info Align\n"));
3077 }
3078
3079 for (i = 0, section = section_headers;
3080 i < elf_header.e_shnum;
3081 i ++, section ++)
3082 {
3083 printf (" [%2d] %-17.17s %-15.15s ",
3084 i,
3085 SECTION_NAME (section),
3086 get_section_type_name (section->sh_type));
3087
3088 if (is_32bit_elf)
3089 {
3090 print_vma (section->sh_addr, LONG_HEX);
3091
3092 printf ( " %6.6lx %6.6lx %2.2lx",
3093 (unsigned long) section->sh_offset,
3094 (unsigned long) section->sh_size,
3095 (unsigned long) section->sh_entsize);
3096
3097 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3098
3099 printf ("%2ld %3lx %2ld\n",
3100 (unsigned long) section->sh_link,
3101 (unsigned long) section->sh_info,
3102 (unsigned long) section->sh_addralign);
3103 }
3104 else if (do_wide)
3105 {
3106 print_vma (section->sh_addr, LONG_HEX);
3107
3108 if ((long) section->sh_offset == section->sh_offset)
3109 printf (" %6.6lx", (unsigned long) section->sh_offset);
3110 else
3111 {
3112 putchar (' ');
3113 print_vma (section->sh_offset, LONG_HEX);
3114 }
3115
3116 if ((unsigned long) section->sh_size == section->sh_size)
3117 printf (" %6.6lx", (unsigned long) section->sh_size);
3118 else
3119 {
3120 putchar (' ');
3121 print_vma (section->sh_size, LONG_HEX);
3122 }
3123
3124 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3125 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3126 else
3127 {
3128 putchar (' ');
3129 print_vma (section->sh_entsize, LONG_HEX);
3130 }
3131
3132 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3133
3134 printf ("%2ld %3lx ",
3135 (unsigned long) section->sh_link,
3136 (unsigned long) section->sh_info);
3137
3138 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3139 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3140 else
3141 {
3142 print_vma (section->sh_addralign, DEC);
3143 putchar ('\n');
3144 }
3145 }
3146 else
3147 {
3148 putchar (' ');
3149 print_vma (section->sh_addr, LONG_HEX);
3150 if ((long) section->sh_offset == section->sh_offset)
3151 printf (" %8.8lx", (unsigned long) section->sh_offset);
3152 else
3153 {
3154 printf (" ");
3155 print_vma (section->sh_offset, LONG_HEX);
3156 }
3157 printf ("\n ");
3158 print_vma (section->sh_size, LONG_HEX);
3159 printf (" ");
3160 print_vma (section->sh_entsize, LONG_HEX);
3161
3162 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3163
3164 printf (" %2ld %3lx %ld\n",
3165 (unsigned long) section->sh_link,
3166 (unsigned long) section->sh_info,
3167 (unsigned long) section->sh_addralign);
3168 }
3169 }
3170
3171 printf (_("Key to Flags:\n"));
3172 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3173 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
3174 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3175
3176 return 1;
3177 }
3178
3179 /* Process the reloc section. */
3180 static int
3181 process_relocs (file)
3182 FILE * file;
3183 {
3184 unsigned long rel_size;
3185 unsigned long rel_offset;
3186
3187
3188 if (!do_reloc)
3189 return 1;
3190
3191 if (do_using_dynamic)
3192 {
3193 int is_rela = FALSE;
3194
3195 rel_size = 0;
3196 rel_offset = 0;
3197
3198 if (dynamic_info[DT_REL])
3199 {
3200 rel_offset = dynamic_info[DT_REL];
3201 rel_size = dynamic_info[DT_RELSZ];
3202 is_rela = FALSE;
3203 }
3204 else if (dynamic_info [DT_RELA])
3205 {
3206 rel_offset = dynamic_info[DT_RELA];
3207 rel_size = dynamic_info[DT_RELASZ];
3208 is_rela = TRUE;
3209 }
3210 else if (dynamic_info[DT_JMPREL])
3211 {
3212 rel_offset = dynamic_info[DT_JMPREL];
3213 rel_size = dynamic_info[DT_PLTRELSZ];
3214
3215 switch (dynamic_info[DT_PLTREL])
3216 {
3217 case DT_REL:
3218 is_rela = FALSE;
3219 break;
3220 case DT_RELA:
3221 is_rela = TRUE;
3222 break;
3223 default:
3224 is_rela = UNKNOWN;
3225 break;
3226 }
3227 }
3228
3229 if (rel_size)
3230 {
3231 printf
3232 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3233 rel_offset, rel_size);
3234
3235 dump_relocations (file, rel_offset - loadaddr, rel_size,
3236 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3237 }
3238 else
3239 printf (_("\nThere are no dynamic relocations in this file.\n"));
3240 }
3241 else
3242 {
3243 Elf32_Internal_Shdr * section;
3244 unsigned long i;
3245 int found = 0;
3246
3247 for (i = 0, section = section_headers;
3248 i < elf_header.e_shnum;
3249 i++, section ++)
3250 {
3251 if ( section->sh_type != SHT_RELA
3252 && section->sh_type != SHT_REL)
3253 continue;
3254
3255 rel_offset = section->sh_offset;
3256 rel_size = section->sh_size;
3257
3258 if (rel_size)
3259 {
3260 Elf32_Internal_Shdr * strsec;
3261 Elf_Internal_Sym * symtab;
3262 char * strtab;
3263 int is_rela;
3264 unsigned long nsyms;
3265
3266 printf (_("\nRelocation section "));
3267
3268 if (string_table == NULL)
3269 printf ("%d", section->sh_name);
3270 else
3271 printf ("'%s'", SECTION_NAME (section));
3272
3273 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3274 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3275
3276 symtab = NULL;
3277 strtab = NULL;
3278 nsyms = 0;
3279 if (section->sh_link)
3280 {
3281 Elf32_Internal_Shdr * symsec;
3282
3283 symsec = section_headers + section->sh_link;
3284 nsyms = symsec->sh_size / symsec->sh_entsize;
3285 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3286
3287 if (symtab == NULL)
3288 continue;
3289
3290 strsec = section_headers + symsec->sh_link;
3291
3292 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3293 strsec->sh_size,
3294 _("string table"));
3295 }
3296 is_rela = section->sh_type == SHT_RELA;
3297
3298 dump_relocations (file, rel_offset, rel_size,
3299 symtab, nsyms, strtab, is_rela);
3300
3301 if (strtab)
3302 free (strtab);
3303 if (symtab)
3304 free (symtab);
3305
3306 found = 1;
3307 }
3308 }
3309
3310 if (! found)
3311 printf (_("\nThere are no relocations in this file.\n"));
3312 }
3313
3314 return 1;
3315 }
3316
3317 #include "unwind-ia64.h"
3318
3319 /* An absolute address consists of a section and an offset. If the
3320 section is NULL, the offset itself is the address, otherwise, the
3321 address equals to LOAD_ADDRESS(section) + offset. */
3322
3323 struct absaddr
3324 {
3325 unsigned short section;
3326 bfd_vma offset;
3327 };
3328
3329 struct unw_aux_info
3330 {
3331 struct unw_table_entry
3332 {
3333 struct absaddr start;
3334 struct absaddr end;
3335 struct absaddr info;
3336 }
3337 *table; /* Unwind table. */
3338 unsigned long table_len; /* Length of unwind table. */
3339 unsigned char * info; /* Unwind info. */
3340 unsigned long info_size; /* Size of unwind info. */
3341 bfd_vma info_addr; /* starting address of unwind info. */
3342 bfd_vma seg_base; /* Starting address of segment. */
3343 Elf_Internal_Sym * symtab; /* The symbol table. */
3344 unsigned long nsyms; /* Number of symbols. */
3345 char * strtab; /* The string table. */
3346 unsigned long strtab_size; /* Size of string table. */
3347 };
3348
3349 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3350 struct absaddr, const char **,
3351 bfd_vma *));
3352 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3353 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3354 Elf32_Internal_Shdr *));
3355
3356 static void
3357 find_symbol_for_address (aux, addr, symname, offset)
3358 struct unw_aux_info *aux;
3359 struct absaddr addr;
3360 const char **symname;
3361 bfd_vma *offset;
3362 {
3363 bfd_vma dist = (bfd_vma) 0x100000;
3364 Elf_Internal_Sym *sym, *best = NULL;
3365 unsigned long i;
3366
3367 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3368 {
3369 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3370 && sym->st_name != 0
3371 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3372 && addr.offset >= sym->st_value
3373 && addr.offset - sym->st_value < dist)
3374 {
3375 best = sym;
3376 dist = addr.offset - sym->st_value;
3377 if (!dist)
3378 break;
3379 }
3380 }
3381 if (best)
3382 {
3383 *symname = (best->st_name >= aux->strtab_size
3384 ? "<corrupt>" : aux->strtab + best->st_name);
3385 *offset = dist;
3386 return;
3387 }
3388 *symname = NULL;
3389 *offset = addr.offset;
3390 }
3391
3392 static void
3393 dump_ia64_unwind (aux)
3394 struct unw_aux_info *aux;
3395 {
3396 bfd_vma addr_size;
3397 struct unw_table_entry * tp;
3398 int in_body;
3399
3400 addr_size = is_32bit_elf ? 4 : 8;
3401
3402 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3403 {
3404 bfd_vma stamp;
3405 bfd_vma offset;
3406 const unsigned char * dp;
3407 const unsigned char * head;
3408 const char * procname;
3409
3410 find_symbol_for_address (aux, tp->start, &procname, &offset);
3411
3412 fputs ("\n<", stdout);
3413
3414 if (procname)
3415 {
3416 fputs (procname, stdout);
3417
3418 if (offset)
3419 printf ("+%lx", (unsigned long) offset);
3420 }
3421
3422 fputs (">: [", stdout);
3423 print_vma (tp->start.offset, PREFIX_HEX);
3424 fputc ('-', stdout);
3425 print_vma (tp->end.offset, PREFIX_HEX);
3426 printf ("), info at +0x%lx\n",
3427 (unsigned long) (tp->info.offset - aux->seg_base));
3428
3429 head = aux->info + (tp->info.offset - aux->info_addr);
3430 stamp = BYTE_GET8 ((unsigned char *) head);
3431
3432 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3433 (unsigned) UNW_VER (stamp),
3434 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3435 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3436 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3437 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3438
3439 if (UNW_VER (stamp) != 1)
3440 {
3441 printf ("\tUnknown version.\n");
3442 continue;
3443 }
3444
3445 in_body = 0;
3446 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3447 dp = unw_decode (dp, in_body, & in_body);
3448 }
3449 }
3450
3451 static int
3452 slurp_ia64_unwind_table (file, aux, sec)
3453 FILE *file;
3454 struct unw_aux_info *aux;
3455 Elf32_Internal_Shdr *sec;
3456 {
3457 unsigned long size, addr_size, nrelas, i;
3458 Elf_Internal_Phdr *prog_hdrs, *seg;
3459 struct unw_table_entry *tep;
3460 Elf32_Internal_Shdr *relsec;
3461 Elf_Internal_Rela *rela, *rp;
3462 unsigned char *table, *tp;
3463 Elf_Internal_Sym *sym;
3464 const char *relname;
3465 int result;
3466
3467 addr_size = is_32bit_elf ? 4 : 8;
3468
3469 /* First, find the starting address of the segment that includes
3470 this section: */
3471
3472 if (elf_header.e_phnum)
3473 {
3474 prog_hdrs = (Elf_Internal_Phdr *)
3475 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3476
3477 if (is_32bit_elf)
3478 result = get_32bit_program_headers (file, prog_hdrs);
3479 else
3480 result = get_64bit_program_headers (file, prog_hdrs);
3481
3482 if (!result)
3483 {
3484 free (prog_hdrs);
3485 return 0;
3486 }
3487
3488 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3489 {
3490 if (seg->p_type != PT_LOAD)
3491 continue;
3492
3493 if (sec->sh_addr >= seg->p_vaddr
3494 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3495 {
3496 aux->seg_base = seg->p_vaddr;
3497 break;
3498 }
3499 }
3500
3501 free (prog_hdrs);
3502 }
3503
3504 /* Second, build the unwind table from the contents of the unwind section: */
3505 size = sec->sh_size;
3506 table = (char *) get_data (NULL, file, sec->sh_offset,
3507 size, _("unwind table"));
3508 if (!table)
3509 return 0;
3510
3511 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3512 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3513 {
3514 tep->start.section = SHN_UNDEF;
3515 tep->end.section = SHN_UNDEF;
3516 tep->info.section = SHN_UNDEF;
3517 if (is_32bit_elf)
3518 {
3519 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3520 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3521 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3522 }
3523 else
3524 {
3525 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3526 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3527 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3528 }
3529 tep->start.offset += aux->seg_base;
3530 tep->end.offset += aux->seg_base;
3531 tep->info.offset += aux->seg_base;
3532 }
3533 free (table);
3534
3535 /* Third, apply any relocations to the unwind table: */
3536
3537 for (relsec = section_headers;
3538 relsec < section_headers + elf_header.e_shnum;
3539 ++relsec)
3540 {
3541 if (relsec->sh_type != SHT_RELA
3542 || section_headers + relsec->sh_info != sec)
3543 continue;
3544
3545 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3546 & rela, & nrelas))
3547 return 0;
3548
3549 for (rp = rela; rp < rela + nrelas; ++rp)
3550 {
3551 if (is_32bit_elf)
3552 {
3553 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3554 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3555
3556 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3557 {
3558 warn (_("Skipping unexpected symbol type %u"),
3559 ELF32_ST_TYPE (sym->st_info));
3560 continue;
3561 }
3562 }
3563 else
3564 {
3565 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3566 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3567
3568 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3569 {
3570 warn (_("Skipping unexpected symbol type %u"),
3571 ELF64_ST_TYPE (sym->st_info));
3572 continue;
3573 }
3574 }
3575
3576 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3577 {
3578 warn (_("Skipping unexpected relocation type %s"), relname);
3579 continue;
3580 }
3581
3582 i = rp->r_offset / (3 * addr_size);
3583
3584 switch (rp->r_offset/addr_size % 3)
3585 {
3586 case 0:
3587 aux->table[i].start.section = sym->st_shndx;
3588 aux->table[i].start.offset += rp->r_addend;
3589 break;
3590 case 1:
3591 aux->table[i].end.section = sym->st_shndx;
3592 aux->table[i].end.offset += rp->r_addend;
3593 break;
3594 case 2:
3595 aux->table[i].info.section = sym->st_shndx;
3596 aux->table[i].info.offset += rp->r_addend;
3597 break;
3598 default:
3599 break;
3600 }
3601 }
3602
3603 free (rela);
3604 }
3605
3606 aux->table_len = size / (3 * addr_size);
3607 return 1;
3608 }
3609
3610 static int
3611 process_unwind (file)
3612 FILE * file;
3613 {
3614 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3615 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
3616 struct unw_aux_info aux;
3617
3618 if (!do_unwind)
3619 return 1;
3620
3621 if (elf_header.e_machine != EM_IA_64)
3622 {
3623 printf (_("\nThere are no unwind sections in this file.\n"));
3624 return 1;
3625 }
3626
3627 memset (& aux, 0, sizeof (aux));
3628
3629 addr_size = is_32bit_elf ? 4 : 8;
3630
3631 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3632 {
3633 if (sec->sh_type == SHT_SYMTAB)
3634 {
3635 aux.nsyms = sec->sh_size / sec->sh_entsize;
3636 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3637
3638 strsec = section_headers + sec->sh_link;
3639 aux.strtab_size = strsec->sh_size;
3640 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3641 aux.strtab_size, _("string table"));
3642 }
3643 else if (sec->sh_type == SHT_IA_64_UNWIND)
3644 unwcount++;
3645 }
3646
3647 if (!unwcount)
3648 printf (_("\nThere are no unwind sections in this file.\n"));
3649
3650 while (unwcount-- > 0)
3651 {
3652 char *suffix;
3653 size_t len, len2;
3654
3655 for (i = unwstart, sec = section_headers + unwstart;
3656 i < elf_header.e_shnum; ++i, ++sec)
3657 if (sec->sh_type == SHT_IA_64_UNWIND)
3658 {
3659 unwsec = sec;
3660 break;
3661 }
3662
3663 unwstart = i + 1;
3664 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
3665
3666 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
3667 len) == 0)
3668 {
3669 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3670 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
3671 suffix = SECTION_NAME (unwsec) + len;
3672 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3673 ++i, ++sec)
3674 if (strncmp (SECTION_NAME (sec),
3675 ELF_STRING_ia64_unwind_info_once, len2) == 0
3676 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3677 break;
3678 }
3679 else
3680 {
3681 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3682 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3683 len = sizeof (ELF_STRING_ia64_unwind) - 1;
3684 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
3685 suffix = "";
3686 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
3687 len) == 0)
3688 suffix = SECTION_NAME (unwsec) + len;
3689 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3690 ++i, ++sec)
3691 if (strncmp (SECTION_NAME (sec),
3692 ELF_STRING_ia64_unwind_info, len2) == 0
3693 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3694 break;
3695 }
3696
3697 if (i == elf_header.e_shnum)
3698 {
3699 printf (_("\nCould not find unwind info section for "));
3700
3701 if (string_table == NULL)
3702 printf ("%d", unwsec->sh_name);
3703 else
3704 printf ("'%s'", SECTION_NAME (unwsec));
3705 }
3706 else
3707 {
3708 aux.info_size = sec->sh_size;
3709 aux.info_addr = sec->sh_addr;
3710 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
3711 aux.info_size, _("unwind info"));
3712
3713 printf (_("\nUnwind section "));
3714
3715 if (string_table == NULL)
3716 printf ("%d", unwsec->sh_name);
3717 else
3718 printf ("'%s'", SECTION_NAME (unwsec));
3719
3720 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3721 (unsigned long) unwsec->sh_offset,
3722 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3723
3724 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3725
3726 if (aux.table_len > 0)
3727 dump_ia64_unwind (& aux);
3728
3729 if (aux.table)
3730 free ((char *) aux.table);
3731 if (aux.info)
3732 free ((char *) aux.info);
3733 aux.table = NULL;
3734 aux.info = NULL;
3735 }
3736 }
3737
3738 if (aux.symtab)
3739 free (aux.symtab);
3740 if (aux.strtab)
3741 free ((char *) aux.strtab);
3742
3743 return 1;
3744 }
3745
3746 static void
3747 dynamic_segment_mips_val (entry)
3748 Elf_Internal_Dyn * entry;
3749 {
3750 switch (entry->d_tag)
3751 {
3752 case DT_MIPS_FLAGS:
3753 if (entry->d_un.d_val == 0)
3754 printf ("NONE\n");
3755 else
3756 {
3757 static const char * opts[] =
3758 {
3759 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3760 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3761 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3762 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3763 "RLD_ORDER_SAFE"
3764 };
3765 unsigned int cnt;
3766 int first = 1;
3767 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3768 if (entry->d_un.d_val & (1 << cnt))
3769 {
3770 printf ("%s%s", first ? "" : " ", opts[cnt]);
3771 first = 0;
3772 }
3773 puts ("");
3774 }
3775 break;
3776
3777 case DT_MIPS_IVERSION:
3778 if (dynamic_strings != NULL)
3779 printf ("Interface Version: %s\n",
3780 dynamic_strings + entry->d_un.d_val);
3781 else
3782 printf ("%ld\n", (long) entry->d_un.d_ptr);
3783 break;
3784
3785 case DT_MIPS_TIME_STAMP:
3786 {
3787 char timebuf[20];
3788 struct tm * tmp;
3789
3790 time_t time = entry->d_un.d_val;
3791 tmp = gmtime (&time);
3792 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3793 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3794 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3795 printf ("Time Stamp: %s\n", timebuf);
3796 }
3797 break;
3798
3799 case DT_MIPS_RLD_VERSION:
3800 case DT_MIPS_LOCAL_GOTNO:
3801 case DT_MIPS_CONFLICTNO:
3802 case DT_MIPS_LIBLISTNO:
3803 case DT_MIPS_SYMTABNO:
3804 case DT_MIPS_UNREFEXTNO:
3805 case DT_MIPS_HIPAGENO:
3806 case DT_MIPS_DELTA_CLASS_NO:
3807 case DT_MIPS_DELTA_INSTANCE_NO:
3808 case DT_MIPS_DELTA_RELOC_NO:
3809 case DT_MIPS_DELTA_SYM_NO:
3810 case DT_MIPS_DELTA_CLASSSYM_NO:
3811 case DT_MIPS_COMPACT_SIZE:
3812 printf ("%ld\n", (long) entry->d_un.d_ptr);
3813 break;
3814
3815 default:
3816 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3817 }
3818 }
3819
3820
3821 static void
3822 dynamic_segment_parisc_val (entry)
3823 Elf_Internal_Dyn * entry;
3824 {
3825 switch (entry->d_tag)
3826 {
3827 case DT_HP_DLD_FLAGS:
3828 {
3829 static struct
3830 {
3831 long int bit;
3832 const char * str;
3833 }
3834 flags[] =
3835 {
3836 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3837 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3838 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3839 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3840 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3841 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3842 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3843 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3844 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3845 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3846 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3847 };
3848 int first = 1;
3849 size_t cnt;
3850 bfd_vma val = entry->d_un.d_val;
3851
3852 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3853 if (val & flags[cnt].bit)
3854 {
3855 if (! first)
3856 putchar (' ');
3857 fputs (flags[cnt].str, stdout);
3858 first = 0;
3859 val ^= flags[cnt].bit;
3860 }
3861
3862 if (val != 0 || first)
3863 {
3864 if (! first)
3865 putchar (' ');
3866 print_vma (val, HEX);
3867 }
3868 }
3869 break;
3870
3871 default:
3872 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3873 break;
3874 }
3875 }
3876
3877 static int
3878 get_32bit_dynamic_segment (file)
3879 FILE * file;
3880 {
3881 Elf32_External_Dyn * edyn;
3882 Elf_Internal_Dyn * entry;
3883 bfd_size_type i;
3884
3885 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
3886 dynamic_size, _("dynamic segment"));
3887 if (!edyn)
3888 return 0;
3889
3890 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3891 how large this .dynamic is now. We can do this even before the byte
3892 swapping since the DT_NULL tag is recognizable. */
3893 dynamic_size = 0;
3894 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3895 ;
3896
3897 dynamic_segment = (Elf_Internal_Dyn *)
3898 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3899
3900 if (dynamic_segment == NULL)
3901 {
3902 error (_("Out of memory\n"));
3903 free (edyn);
3904 return 0;
3905 }
3906
3907 for (i = 0, entry = dynamic_segment;
3908 i < dynamic_size;
3909 i ++, entry ++)
3910 {
3911 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3912 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3913 }
3914
3915 free (edyn);
3916
3917 return 1;
3918 }
3919
3920 static int
3921 get_64bit_dynamic_segment (file)
3922 FILE * file;
3923 {
3924 Elf64_External_Dyn * edyn;
3925 Elf_Internal_Dyn * entry;
3926 bfd_size_type i;
3927
3928 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
3929 dynamic_size, _("dynamic segment"));
3930 if (!edyn)
3931 return 0;
3932
3933 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3934 how large this .dynamic is now. We can do this even before the byte
3935 swapping since the DT_NULL tag is recognizable. */
3936 dynamic_size = 0;
3937 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3938 ;
3939
3940 dynamic_segment = (Elf_Internal_Dyn *)
3941 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3942
3943 if (dynamic_segment == NULL)
3944 {
3945 error (_("Out of memory\n"));
3946 free (edyn);
3947 return 0;
3948 }
3949
3950 for (i = 0, entry = dynamic_segment;
3951 i < dynamic_size;
3952 i ++, entry ++)
3953 {
3954 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3955 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3956 }
3957
3958 free (edyn);
3959
3960 return 1;
3961 }
3962
3963 static const char *
3964 get_dynamic_flags (flags)
3965 bfd_vma flags;
3966 {
3967 static char buff [64];
3968 while (flags)
3969 {
3970 bfd_vma flag;
3971
3972 flag = flags & - flags;
3973 flags &= ~ flag;
3974
3975 switch (flag)
3976 {
3977 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3978 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3979 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3980 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3981 default: strcat (buff, "unknown "); break;
3982 }
3983 }
3984 return buff;
3985 }
3986
3987 /* Parse and display the contents of the dynamic segment. */
3988 static int
3989 process_dynamic_segment (file)
3990 FILE * file;
3991 {
3992 Elf_Internal_Dyn * entry;
3993 bfd_size_type i;
3994
3995 if (dynamic_size == 0)
3996 {
3997 if (do_dynamic)
3998 printf (_("\nThere is no dynamic segment in this file.\n"));
3999
4000 return 1;
4001 }
4002
4003 if (is_32bit_elf)
4004 {
4005 if (! get_32bit_dynamic_segment (file))
4006 return 0;
4007 }
4008 else if (! get_64bit_dynamic_segment (file))
4009 return 0;
4010
4011 /* Find the appropriate symbol table. */
4012 if (dynamic_symbols == NULL)
4013 {
4014 for (i = 0, entry = dynamic_segment;
4015 i < dynamic_size;
4016 ++i, ++ entry)
4017 {
4018 unsigned long offset;
4019
4020 if (entry->d_tag != DT_SYMTAB)
4021 continue;
4022
4023 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4024
4025 /* Since we do not know how big the symbol table is,
4026 we default to reading in the entire file (!) and
4027 processing that. This is overkill, I know, but it
4028 should work. */
4029 offset = entry->d_un.d_val - loadaddr;
4030
4031 if (fseek (file, 0, SEEK_END))
4032 error (_("Unable to seek to end of file!"));
4033
4034 if (is_32bit_elf)
4035 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
4036 else
4037 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
4038
4039 if (num_dynamic_syms < 1)
4040 {
4041 error (_("Unable to determine the number of symbols to load\n"));
4042 continue;
4043 }
4044
4045 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
4046 }
4047 }
4048
4049 /* Similarly find a string table. */
4050 if (dynamic_strings == NULL)
4051 {
4052 for (i = 0, entry = dynamic_segment;
4053 i < dynamic_size;
4054 ++i, ++ entry)
4055 {
4056 unsigned long offset;
4057 long str_tab_len;
4058
4059 if (entry->d_tag != DT_STRTAB)
4060 continue;
4061
4062 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4063
4064 /* Since we do not know how big the string table is,
4065 we default to reading in the entire file (!) and
4066 processing that. This is overkill, I know, but it
4067 should work. */
4068
4069 offset = entry->d_un.d_val - loadaddr;
4070 if (fseek (file, 0, SEEK_END))
4071 error (_("Unable to seek to end of file\n"));
4072 str_tab_len = ftell (file) - offset;
4073
4074 if (str_tab_len < 1)
4075 {
4076 error
4077 (_("Unable to determine the length of the dynamic string table\n"));
4078 continue;
4079 }
4080
4081 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4082 _("dynamic string table"));
4083
4084 break;
4085 }
4086 }
4087
4088 /* And find the syminfo section if available. */
4089 if (dynamic_syminfo == NULL)
4090 {
4091 unsigned int syminsz = 0;
4092
4093 for (i = 0, entry = dynamic_segment;
4094 i < dynamic_size;
4095 ++i, ++ entry)
4096 {
4097 if (entry->d_tag == DT_SYMINENT)
4098 {
4099 /* Note: these braces are necessary to avoid a syntax
4100 error from the SunOS4 C compiler. */
4101 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4102 }
4103 else if (entry->d_tag == DT_SYMINSZ)
4104 syminsz = entry->d_un.d_val;
4105 else if (entry->d_tag == DT_SYMINFO)
4106 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4107 }
4108
4109 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4110 {
4111 Elf_External_Syminfo * extsyminfo;
4112 Elf_Internal_Syminfo * syminfo;
4113
4114 /* There is a syminfo section. Read the data. */
4115 extsyminfo = ((Elf_External_Syminfo *)
4116 get_data (NULL, file, dynamic_syminfo_offset,
4117 syminsz, _("symbol information")));
4118 if (!extsyminfo)
4119 return 0;
4120
4121 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4122 if (dynamic_syminfo == NULL)
4123 {
4124 error (_("Out of memory\n"));
4125 return 0;
4126 }
4127
4128 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4129 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4130 ++i, ++syminfo)
4131 {
4132 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4133 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4134 }
4135
4136 free (extsyminfo);
4137 }
4138 }
4139
4140 if (do_dynamic && dynamic_addr)
4141 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4142 dynamic_addr, (long) dynamic_size);
4143 if (do_dynamic)
4144 printf (_(" Tag Type Name/Value\n"));
4145
4146 for (i = 0, entry = dynamic_segment;
4147 i < dynamic_size;
4148 i++, entry ++)
4149 {
4150 if (do_dynamic)
4151 {
4152 const char * dtype;
4153
4154 putchar (' ');
4155 print_vma (entry->d_tag, FULL_HEX);
4156 dtype = get_dynamic_type (entry->d_tag);
4157 printf (" (%s)%*s", dtype,
4158 ((is_32bit_elf ? 27 : 19)
4159 - (int) strlen (dtype)),
4160 " ");
4161 }
4162
4163 switch (entry->d_tag)
4164 {
4165 case DT_FLAGS:
4166 if (do_dynamic)
4167 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
4168 break;
4169
4170 case DT_AUXILIARY:
4171 case DT_FILTER:
4172 case DT_CONFIG:
4173 case DT_DEPAUDIT:
4174 case DT_AUDIT:
4175 if (do_dynamic)
4176 {
4177 switch (entry->d_tag)
4178 {
4179 case DT_AUXILIARY:
4180 printf (_("Auxiliary library"));
4181 break;
4182
4183 case DT_FILTER:
4184 printf (_("Filter library"));
4185 break;
4186
4187 case DT_CONFIG:
4188 printf (_("Configuration file"));
4189 break;
4190
4191 case DT_DEPAUDIT:
4192 printf (_("Dependency audit library"));
4193 break;
4194
4195 case DT_AUDIT:
4196 printf (_("Audit library"));
4197 break;
4198 }
4199
4200 if (dynamic_strings)
4201 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4202 else
4203 {
4204 printf (": ");
4205 print_vma (entry->d_un.d_val, PREFIX_HEX);
4206 putchar ('\n');
4207 }
4208 }
4209 break;
4210
4211 case DT_FEATURE:
4212 if (do_dynamic)
4213 {
4214 printf (_("Flags:"));
4215 if (entry->d_un.d_val == 0)
4216 printf (_(" None\n"));
4217 else
4218 {
4219 unsigned long int val = entry->d_un.d_val;
4220 if (val & DTF_1_PARINIT)
4221 {
4222 printf (" PARINIT");
4223 val ^= DTF_1_PARINIT;
4224 }
4225 if (val & DTF_1_CONFEXP)
4226 {
4227 printf (" CONFEXP");
4228 val ^= DTF_1_CONFEXP;
4229 }
4230 if (val != 0)
4231 printf (" %lx", val);
4232 puts ("");
4233 }
4234 }
4235 break;
4236
4237 case DT_POSFLAG_1:
4238 if (do_dynamic)
4239 {
4240 printf (_("Flags:"));
4241 if (entry->d_un.d_val == 0)
4242 printf (_(" None\n"));
4243 else
4244 {
4245 unsigned long int val = entry->d_un.d_val;
4246 if (val & DF_P1_LAZYLOAD)
4247 {
4248 printf (" LAZYLOAD");
4249 val ^= DF_P1_LAZYLOAD;
4250 }
4251 if (val & DF_P1_GROUPPERM)
4252 {
4253 printf (" GROUPPERM");
4254 val ^= DF_P1_GROUPPERM;
4255 }
4256 if (val != 0)
4257 printf (" %lx", val);
4258 puts ("");
4259 }
4260 }
4261 break;
4262
4263 case DT_FLAGS_1:
4264 if (do_dynamic)
4265 {
4266 printf (_("Flags:"));
4267 if (entry->d_un.d_val == 0)
4268 printf (_(" None\n"));
4269 else
4270 {
4271 unsigned long int val = entry->d_un.d_val;
4272 if (val & DF_1_NOW)
4273 {
4274 printf (" NOW");
4275 val ^= DF_1_NOW;
4276 }
4277 if (val & DF_1_GLOBAL)
4278 {
4279 printf (" GLOBAL");
4280 val ^= DF_1_GLOBAL;
4281 }
4282 if (val & DF_1_GROUP)
4283 {
4284 printf (" GROUP");
4285 val ^= DF_1_GROUP;
4286 }
4287 if (val & DF_1_NODELETE)
4288 {
4289 printf (" NODELETE");
4290 val ^= DF_1_NODELETE;
4291 }
4292 if (val & DF_1_LOADFLTR)
4293 {
4294 printf (" LOADFLTR");
4295 val ^= DF_1_LOADFLTR;
4296 }
4297 if (val & DF_1_INITFIRST)
4298 {
4299 printf (" INITFIRST");
4300 val ^= DF_1_INITFIRST;
4301 }
4302 if (val & DF_1_NOOPEN)
4303 {
4304 printf (" NOOPEN");
4305 val ^= DF_1_NOOPEN;
4306 }
4307 if (val & DF_1_ORIGIN)
4308 {
4309 printf (" ORIGIN");
4310 val ^= DF_1_ORIGIN;
4311 }
4312 if (val & DF_1_DIRECT)
4313 {
4314 printf (" DIRECT");
4315 val ^= DF_1_DIRECT;
4316 }
4317 if (val & DF_1_TRANS)
4318 {
4319 printf (" TRANS");
4320 val ^= DF_1_TRANS;
4321 }
4322 if (val & DF_1_INTERPOSE)
4323 {
4324 printf (" INTERPOSE");
4325 val ^= DF_1_INTERPOSE;
4326 }
4327 if (val & DF_1_NODEFLIB)
4328 {
4329 printf (" NODEFLIB");
4330 val ^= DF_1_NODEFLIB;
4331 }
4332 if (val & DF_1_NODUMP)
4333 {
4334 printf (" NODUMP");
4335 val ^= DF_1_NODUMP;
4336 }
4337 if (val & DF_1_CONLFAT)
4338 {
4339 printf (" CONLFAT");
4340 val ^= DF_1_CONLFAT;
4341 }
4342 if (val != 0)
4343 printf (" %lx", val);
4344 puts ("");
4345 }
4346 }
4347 break;
4348
4349 case DT_PLTREL:
4350 if (do_dynamic)
4351 puts (get_dynamic_type (entry->d_un.d_val));
4352 break;
4353
4354 case DT_NULL :
4355 case DT_NEEDED :
4356 case DT_PLTGOT :
4357 case DT_HASH :
4358 case DT_STRTAB :
4359 case DT_SYMTAB :
4360 case DT_RELA :
4361 case DT_INIT :
4362 case DT_FINI :
4363 case DT_SONAME :
4364 case DT_RPATH :
4365 case DT_SYMBOLIC:
4366 case DT_REL :
4367 case DT_DEBUG :
4368 case DT_TEXTREL :
4369 case DT_JMPREL :
4370 case DT_RUNPATH :
4371 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4372
4373 if (do_dynamic)
4374 {
4375 char * name;
4376
4377 if (dynamic_strings == NULL)
4378 name = NULL;
4379 else
4380 name = dynamic_strings + entry->d_un.d_val;
4381
4382 if (name)
4383 {
4384 switch (entry->d_tag)
4385 {
4386 case DT_NEEDED:
4387 printf (_("Shared library: [%s]"), name);
4388
4389 if (strcmp (name, program_interpreter) == 0)
4390 printf (_(" program interpreter"));
4391 break;
4392
4393 case DT_SONAME:
4394 printf (_("Library soname: [%s]"), name);
4395 break;
4396
4397 case DT_RPATH:
4398 printf (_("Library rpath: [%s]"), name);
4399 break;
4400
4401 case DT_RUNPATH:
4402 printf (_("Library runpath: [%s]"), name);
4403 break;
4404
4405 default:
4406 print_vma (entry->d_un.d_val, PREFIX_HEX);
4407 break;
4408 }
4409 }
4410 else
4411 print_vma (entry->d_un.d_val, PREFIX_HEX);
4412
4413 putchar ('\n');
4414 }
4415 break;
4416
4417 case DT_PLTRELSZ:
4418 case DT_RELASZ :
4419 case DT_STRSZ :
4420 case DT_RELSZ :
4421 case DT_RELAENT :
4422 case DT_SYMENT :
4423 case DT_RELENT :
4424 case DT_PLTPADSZ:
4425 case DT_MOVEENT :
4426 case DT_MOVESZ :
4427 case DT_INIT_ARRAYSZ:
4428 case DT_FINI_ARRAYSZ:
4429 if (do_dynamic)
4430 {
4431 print_vma (entry->d_un.d_val, UNSIGNED);
4432 printf (" (bytes)\n");
4433 }
4434 break;
4435
4436 case DT_VERDEFNUM:
4437 case DT_VERNEEDNUM:
4438 case DT_RELACOUNT:
4439 case DT_RELCOUNT:
4440 if (do_dynamic)
4441 {
4442 print_vma (entry->d_un.d_val, UNSIGNED);
4443 putchar ('\n');
4444 }
4445 break;
4446
4447 case DT_SYMINSZ:
4448 case DT_SYMINENT:
4449 case DT_SYMINFO:
4450 case DT_USED:
4451 case DT_INIT_ARRAY:
4452 case DT_FINI_ARRAY:
4453 if (do_dynamic)
4454 {
4455 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4456 {
4457 char * name;
4458
4459 name = dynamic_strings + entry->d_un.d_val;
4460
4461 if (* name)
4462 {
4463 printf (_("Not needed object: [%s]\n"), name);
4464 break;
4465 }
4466 }
4467
4468 print_vma (entry->d_un.d_val, PREFIX_HEX);
4469 putchar ('\n');
4470 }
4471 break;
4472
4473 case DT_BIND_NOW:
4474 /* The value of this entry is ignored. */
4475 break;
4476
4477 default:
4478 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4479 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4480 entry->d_un.d_val;
4481
4482 if (do_dynamic)
4483 {
4484 switch (elf_header.e_machine)
4485 {
4486 case EM_MIPS:
4487 case EM_MIPS_RS3_LE:
4488 dynamic_segment_mips_val (entry);
4489 break;
4490 case EM_PARISC:
4491 dynamic_segment_parisc_val (entry);
4492 break;
4493 default:
4494 print_vma (entry->d_un.d_val, PREFIX_HEX);
4495 putchar ('\n');
4496 }
4497 }
4498 break;
4499 }
4500 }
4501
4502 return 1;
4503 }
4504
4505 static char *
4506 get_ver_flags (flags)
4507 unsigned int flags;
4508 {
4509 static char buff [32];
4510
4511 buff[0] = 0;
4512
4513 if (flags == 0)
4514 return _("none");
4515
4516 if (flags & VER_FLG_BASE)
4517 strcat (buff, "BASE ");
4518
4519 if (flags & VER_FLG_WEAK)
4520 {
4521 if (flags & VER_FLG_BASE)
4522 strcat (buff, "| ");
4523
4524 strcat (buff, "WEAK ");
4525 }
4526
4527 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4528 strcat (buff, "| <unknown>");
4529
4530 return buff;
4531 }
4532
4533 /* Display the contents of the version sections. */
4534 static int
4535 process_version_sections (file)
4536 FILE * file;
4537 {
4538 Elf32_Internal_Shdr * section;
4539 unsigned i;
4540 int found = 0;
4541
4542 if (! do_version)
4543 return 1;
4544
4545 for (i = 0, section = section_headers;
4546 i < elf_header.e_shnum;
4547 i++, section ++)
4548 {
4549 switch (section->sh_type)
4550 {
4551 case SHT_GNU_verdef:
4552 {
4553 Elf_External_Verdef * edefs;
4554 unsigned int idx;
4555 unsigned int cnt;
4556
4557 found = 1;
4558
4559 printf
4560 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4561 SECTION_NAME (section), section->sh_info);
4562
4563 printf (_(" Addr: 0x"));
4564 printf_vma (section->sh_addr);
4565 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4566 (unsigned long) section->sh_offset, section->sh_link,
4567 SECTION_NAME (section_headers + section->sh_link));
4568
4569 edefs = ((Elf_External_Verdef *)
4570 get_data (NULL, file, section->sh_offset,
4571 section->sh_size,
4572 _("version definition section")));
4573 if (!edefs)
4574 break;
4575
4576 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4577 {
4578 char * vstart;
4579 Elf_External_Verdef * edef;
4580 Elf_Internal_Verdef ent;
4581 Elf_External_Verdaux * eaux;
4582 Elf_Internal_Verdaux aux;
4583 int j;
4584 int isum;
4585
4586 vstart = ((char *) edefs) + idx;
4587
4588 edef = (Elf_External_Verdef *) vstart;
4589
4590 ent.vd_version = BYTE_GET (edef->vd_version);
4591 ent.vd_flags = BYTE_GET (edef->vd_flags);
4592 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4593 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4594 ent.vd_hash = BYTE_GET (edef->vd_hash);
4595 ent.vd_aux = BYTE_GET (edef->vd_aux);
4596 ent.vd_next = BYTE_GET (edef->vd_next);
4597
4598 printf (_(" %#06x: Rev: %d Flags: %s"),
4599 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4600
4601 printf (_(" Index: %d Cnt: %d "),
4602 ent.vd_ndx, ent.vd_cnt);
4603
4604 vstart += ent.vd_aux;
4605
4606 eaux = (Elf_External_Verdaux *) vstart;
4607
4608 aux.vda_name = BYTE_GET (eaux->vda_name);
4609 aux.vda_next = BYTE_GET (eaux->vda_next);
4610
4611 if (dynamic_strings)
4612 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4613 else
4614 printf (_("Name index: %ld\n"), aux.vda_name);
4615
4616 isum = idx + ent.vd_aux;
4617
4618 for (j = 1; j < ent.vd_cnt; j ++)
4619 {
4620 isum += aux.vda_next;
4621 vstart += aux.vda_next;
4622
4623 eaux = (Elf_External_Verdaux *) vstart;
4624
4625 aux.vda_name = BYTE_GET (eaux->vda_name);
4626 aux.vda_next = BYTE_GET (eaux->vda_next);
4627
4628 if (dynamic_strings)
4629 printf (_(" %#06x: Parent %d: %s\n"),
4630 isum, j, dynamic_strings + aux.vda_name);
4631 else
4632 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4633 isum, j, aux.vda_name);
4634 }
4635
4636 idx += ent.vd_next;
4637 }
4638
4639 free (edefs);
4640 }
4641 break;
4642
4643 case SHT_GNU_verneed:
4644 {
4645 Elf_External_Verneed * eneed;
4646 unsigned int idx;
4647 unsigned int cnt;
4648
4649 found = 1;
4650
4651 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4652 SECTION_NAME (section), section->sh_info);
4653
4654 printf (_(" Addr: 0x"));
4655 printf_vma (section->sh_addr);
4656 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4657 (unsigned long) section->sh_offset, section->sh_link,
4658 SECTION_NAME (section_headers + section->sh_link));
4659
4660 eneed = ((Elf_External_Verneed *)
4661 get_data (NULL, file, section->sh_offset,
4662 section->sh_size, _("version need section")));
4663 if (!eneed)
4664 break;
4665
4666 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4667 {
4668 Elf_External_Verneed * entry;
4669 Elf_Internal_Verneed ent;
4670 int j;
4671 int isum;
4672 char * vstart;
4673
4674 vstart = ((char *) eneed) + idx;
4675
4676 entry = (Elf_External_Verneed *) vstart;
4677
4678 ent.vn_version = BYTE_GET (entry->vn_version);
4679 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4680 ent.vn_file = BYTE_GET (entry->vn_file);
4681 ent.vn_aux = BYTE_GET (entry->vn_aux);
4682 ent.vn_next = BYTE_GET (entry->vn_next);
4683
4684 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4685
4686 if (dynamic_strings)
4687 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4688 else
4689 printf (_(" File: %lx"), ent.vn_file);
4690
4691 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4692
4693 vstart += ent.vn_aux;
4694
4695 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4696 {
4697 Elf_External_Vernaux * eaux;
4698 Elf_Internal_Vernaux aux;
4699
4700 eaux = (Elf_External_Vernaux *) vstart;
4701
4702 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4703 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4704 aux.vna_other = BYTE_GET (eaux->vna_other);
4705 aux.vna_name = BYTE_GET (eaux->vna_name);
4706 aux.vna_next = BYTE_GET (eaux->vna_next);
4707
4708 if (dynamic_strings)
4709 printf (_(" %#06x: Name: %s"),
4710 isum, dynamic_strings + aux.vna_name);
4711 else
4712 printf (_(" %#06x: Name index: %lx"),
4713 isum, aux.vna_name);
4714
4715 printf (_(" Flags: %s Version: %d\n"),
4716 get_ver_flags (aux.vna_flags), aux.vna_other);
4717
4718 isum += aux.vna_next;
4719 vstart += aux.vna_next;
4720 }
4721
4722 idx += ent.vn_next;
4723 }
4724
4725 free (eneed);
4726 }
4727 break;
4728
4729 case SHT_GNU_versym:
4730 {
4731 Elf32_Internal_Shdr * link_section;
4732 int total;
4733 int cnt;
4734 unsigned char * edata;
4735 unsigned short * data;
4736 char * strtab;
4737 Elf_Internal_Sym * symbols;
4738 Elf32_Internal_Shdr * string_sec;
4739
4740 link_section = section_headers + section->sh_link;
4741 total = section->sh_size / section->sh_entsize;
4742
4743 found = 1;
4744
4745 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4746 link_section->sh_size / link_section->sh_entsize);
4747
4748 string_sec = section_headers + link_section->sh_link;
4749
4750 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
4751 string_sec->sh_size,
4752 _("version string table"));
4753 if (!strtab)
4754 break;
4755
4756 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4757 SECTION_NAME (section), total);
4758
4759 printf (_(" Addr: "));
4760 printf_vma (section->sh_addr);
4761 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4762 (unsigned long) section->sh_offset, section->sh_link,
4763 SECTION_NAME (link_section));
4764
4765 edata =
4766 ((unsigned char *)
4767 get_data (NULL, file,
4768 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
4769 total * sizeof (short), _("version symbol data")));
4770 if (!edata)
4771 {
4772 free (strtab);
4773 break;
4774 }
4775
4776 data = (unsigned short *) malloc (total * sizeof (short));
4777
4778 for (cnt = total; cnt --;)
4779 data [cnt] = byte_get (edata + cnt * sizeof (short),
4780 sizeof (short));
4781
4782 free (edata);
4783
4784 for (cnt = 0; cnt < total; cnt += 4)
4785 {
4786 int j, nn;
4787 int check_def, check_need;
4788 char * name;
4789
4790 printf (" %03x:", cnt);
4791
4792 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4793 switch (data [cnt + j])
4794 {
4795 case 0:
4796 fputs (_(" 0 (*local*) "), stdout);
4797 break;
4798
4799 case 1:
4800 fputs (_(" 1 (*global*) "), stdout);
4801 break;
4802
4803 default:
4804 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4805 data [cnt + j] & 0x8000 ? 'h' : ' ');
4806
4807 check_def = 1;
4808 check_need = 1;
4809 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4810 || section_headers[symbols [cnt + j].st_shndx].sh_type
4811 != SHT_NOBITS)
4812 {
4813 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4814 check_def = 0;
4815 else
4816 check_need = 0;
4817 }
4818
4819 if (check_need
4820 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4821 {
4822 Elf_Internal_Verneed ivn;
4823 unsigned long offset;
4824
4825 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4826 - loadaddr;
4827
4828 do
4829 {
4830 Elf_Internal_Vernaux ivna;
4831 Elf_External_Verneed evn;
4832 Elf_External_Vernaux evna;
4833 unsigned long a_off;
4834
4835 get_data (&evn, file, offset, sizeof (evn),
4836 _("version need"));
4837
4838 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4839 ivn.vn_next = BYTE_GET (evn.vn_next);
4840
4841 a_off = offset + ivn.vn_aux;
4842
4843 do
4844 {
4845 get_data (&evna, file, a_off, sizeof (evna),
4846 _("version need aux (2)"));
4847
4848 ivna.vna_next = BYTE_GET (evna.vna_next);
4849 ivna.vna_other = BYTE_GET (evna.vna_other);
4850
4851 a_off += ivna.vna_next;
4852 }
4853 while (ivna.vna_other != data [cnt + j]
4854 && ivna.vna_next != 0);
4855
4856 if (ivna.vna_other == data [cnt + j])
4857 {
4858 ivna.vna_name = BYTE_GET (evna.vna_name);
4859
4860 name = strtab + ivna.vna_name;
4861 nn += printf ("(%s%-*s",
4862 name,
4863 12 - (int) strlen (name),
4864 ")");
4865 check_def = 0;
4866 break;
4867 }
4868
4869 offset += ivn.vn_next;
4870 }
4871 while (ivn.vn_next);
4872 }
4873
4874 if (check_def && data [cnt + j] != 0x8001
4875 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4876 {
4877 Elf_Internal_Verdef ivd;
4878 Elf_External_Verdef evd;
4879 unsigned long offset;
4880
4881 offset = version_info
4882 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4883
4884 do
4885 {
4886 get_data (&evd, file, offset, sizeof (evd),
4887 _("version def"));
4888
4889 ivd.vd_next = BYTE_GET (evd.vd_next);
4890 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4891
4892 offset += ivd.vd_next;
4893 }
4894 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4895 && ivd.vd_next != 0);
4896
4897 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4898 {
4899 Elf_External_Verdaux evda;
4900 Elf_Internal_Verdaux ivda;
4901
4902 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4903
4904 get_data (&evda, file,
4905 offset - ivd.vd_next + ivd.vd_aux,
4906 sizeof (evda), _("version def aux"));
4907
4908 ivda.vda_name = BYTE_GET (evda.vda_name);
4909
4910 name = strtab + ivda.vda_name;
4911 nn += printf ("(%s%-*s",
4912 name,
4913 12 - (int) strlen (name),
4914 ")");
4915 }
4916 }
4917
4918 if (nn < 18)
4919 printf ("%*c", 18 - nn, ' ');
4920 }
4921
4922 putchar ('\n');
4923 }
4924
4925 free (data);
4926 free (strtab);
4927 free (symbols);
4928 }
4929 break;
4930
4931 default:
4932 break;
4933 }
4934 }
4935
4936 if (! found)
4937 printf (_("\nNo version information found in this file.\n"));
4938
4939 return 1;
4940 }
4941
4942 static const char *
4943 get_symbol_binding (binding)
4944 unsigned int binding;
4945 {
4946 static char buff [32];
4947
4948 switch (binding)
4949 {
4950 case STB_LOCAL: return "LOCAL";
4951 case STB_GLOBAL: return "GLOBAL";
4952 case STB_WEAK: return "WEAK";
4953 default:
4954 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4955 sprintf (buff, _("<processor specific>: %d"), binding);
4956 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4957 sprintf (buff, _("<OS specific>: %d"), binding);
4958 else
4959 sprintf (buff, _("<unknown>: %d"), binding);
4960 return buff;
4961 }
4962 }
4963
4964 static const char *
4965 get_symbol_type (type)
4966 unsigned int type;
4967 {
4968 static char buff [32];
4969
4970 switch (type)
4971 {
4972 case STT_NOTYPE: return "NOTYPE";
4973 case STT_OBJECT: return "OBJECT";
4974 case STT_FUNC: return "FUNC";
4975 case STT_SECTION: return "SECTION";
4976 case STT_FILE: return "FILE";
4977 case STT_COMMON: return "COMMON";
4978 default:
4979 if (type >= STT_LOPROC && type <= STT_HIPROC)
4980 {
4981 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4982 return "THUMB_FUNC";
4983
4984 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4985 return "REGISTER";
4986
4987 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4988 return "PARISC_MILLI";
4989
4990 sprintf (buff, _("<processor specific>: %d"), type);
4991 }
4992 else if (type >= STT_LOOS && type <= STT_HIOS)
4993 {
4994 if (elf_header.e_machine == EM_PARISC)
4995 {
4996 if (type == STT_HP_OPAQUE)
4997 return "HP_OPAQUE";
4998 if (type == STT_HP_STUB)
4999 return "HP_STUB";
5000 }
5001
5002 sprintf (buff, _("<OS specific>: %d"), type);
5003 }
5004 else
5005 sprintf (buff, _("<unknown>: %d"), type);
5006 return buff;
5007 }
5008 }
5009
5010 static const char *
5011 get_symbol_visibility (visibility)
5012 unsigned int visibility;
5013 {
5014 switch (visibility)
5015 {
5016 case STV_DEFAULT: return "DEFAULT";
5017 case STV_INTERNAL: return "INTERNAL";
5018 case STV_HIDDEN: return "HIDDEN";
5019 case STV_PROTECTED: return "PROTECTED";
5020 default: abort ();
5021 }
5022 }
5023
5024 static const char *
5025 get_symbol_index_type (type)
5026 unsigned int type;
5027 {
5028 switch (type)
5029 {
5030 case SHN_UNDEF: return "UND";
5031 case SHN_ABS: return "ABS";
5032 case SHN_COMMON: return "COM";
5033 default:
5034 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5035 return "PRC";
5036 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5037 return "RSV";
5038 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5039 return "OS ";
5040 else
5041 {
5042 static char buff [32];
5043
5044 sprintf (buff, "%3d", type);
5045 return buff;
5046 }
5047 }
5048 }
5049
5050 static int *
5051 get_dynamic_data (file, number)
5052 FILE * file;
5053 unsigned int number;
5054 {
5055 unsigned char * e_data;
5056 int * i_data;
5057
5058 e_data = (unsigned char *) malloc (number * 4);
5059
5060 if (e_data == NULL)
5061 {
5062 error (_("Out of memory\n"));
5063 return NULL;
5064 }
5065
5066 if (fread (e_data, 4, number, file) != number)
5067 {
5068 error (_("Unable to read in dynamic data\n"));
5069 return NULL;
5070 }
5071
5072 i_data = (int *) malloc (number * sizeof (* i_data));
5073
5074 if (i_data == NULL)
5075 {
5076 error (_("Out of memory\n"));
5077 free (e_data);
5078 return NULL;
5079 }
5080
5081 while (number--)
5082 i_data [number] = byte_get (e_data + number * 4, 4);
5083
5084 free (e_data);
5085
5086 return i_data;
5087 }
5088
5089 /* Dump the symbol table */
5090 static int
5091 process_symbol_table (file)
5092 FILE * file;
5093 {
5094 Elf32_Internal_Shdr * section;
5095 unsigned char nb [4];
5096 unsigned char nc [4];
5097 int nbuckets = 0;
5098 int nchains = 0;
5099 int * buckets = NULL;
5100 int * chains = NULL;
5101
5102 if (! do_syms && !do_histogram)
5103 return 1;
5104
5105 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5106 || do_histogram))
5107 {
5108 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5109 {
5110 error (_("Unable to seek to start of dynamic information"));
5111 return 0;
5112 }
5113
5114 if (fread (nb, sizeof (nb), 1, file) != 1)
5115 {
5116 error (_("Failed to read in number of buckets\n"));
5117 return 0;
5118 }
5119
5120 if (fread (nc, sizeof (nc), 1, file) != 1)
5121 {
5122 error (_("Failed to read in number of chains\n"));
5123 return 0;
5124 }
5125
5126 nbuckets = byte_get (nb, 4);
5127 nchains = byte_get (nc, 4);
5128
5129 buckets = get_dynamic_data (file, nbuckets);
5130 chains = get_dynamic_data (file, nchains);
5131
5132 if (buckets == NULL || chains == NULL)
5133 return 0;
5134 }
5135
5136 if (do_syms
5137 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5138 {
5139 int hn;
5140 int si;
5141
5142 printf (_("\nSymbol table for image:\n"));
5143 if (is_32bit_elf)
5144 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5145 else
5146 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5147
5148 for (hn = 0; hn < nbuckets; hn++)
5149 {
5150 if (! buckets [hn])
5151 continue;
5152
5153 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5154 {
5155 Elf_Internal_Sym * psym;
5156
5157 psym = dynamic_symbols + si;
5158
5159 printf (" %3d %3d: ", si, hn);
5160 print_vma (psym->st_value, LONG_HEX);
5161 putchar (' ' );
5162 print_vma (psym->st_size, DEC_5);
5163
5164 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5165 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5166 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5167 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
5168 printf (" %s\n", dynamic_strings + psym->st_name);
5169 }
5170 }
5171 }
5172 else if (do_syms && !do_using_dynamic)
5173 {
5174 unsigned int i;
5175
5176 for (i = 0, section = section_headers;
5177 i < elf_header.e_shnum;
5178 i++, section++)
5179 {
5180 unsigned int si;
5181 char * strtab;
5182 Elf_Internal_Sym * symtab;
5183 Elf_Internal_Sym * psym;
5184
5185
5186 if ( section->sh_type != SHT_SYMTAB
5187 && section->sh_type != SHT_DYNSYM)
5188 continue;
5189
5190 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5191 SECTION_NAME (section),
5192 (unsigned long) (section->sh_size / section->sh_entsize));
5193 if (is_32bit_elf)
5194 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5195 else
5196 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5197
5198 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
5199 section->sh_size / section->sh_entsize);
5200 if (symtab == NULL)
5201 continue;
5202
5203 if (section->sh_link == elf_header.e_shstrndx)
5204 strtab = string_table;
5205 else
5206 {
5207 Elf32_Internal_Shdr * string_sec;
5208
5209 string_sec = section_headers + section->sh_link;
5210
5211 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5212 string_sec->sh_size,
5213 _("string table"));
5214 }
5215
5216 for (si = 0, psym = symtab;
5217 si < section->sh_size / section->sh_entsize;
5218 si ++, psym ++)
5219 {
5220 printf ("%6d: ", si);
5221 print_vma (psym->st_value, LONG_HEX);
5222 putchar (' ');
5223 print_vma (psym->st_size, DEC_5);
5224 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5225 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5226 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5227 printf (" %4s", get_symbol_index_type (psym->st_shndx));
5228 printf (" %s", strtab + psym->st_name);
5229
5230 if (section->sh_type == SHT_DYNSYM &&
5231 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5232 {
5233 unsigned char data[2];
5234 unsigned short vers_data;
5235 unsigned long offset;
5236 int is_nobits;
5237 int check_def;
5238
5239 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5240 - loadaddr;
5241
5242 get_data (&data, file, offset + si * sizeof (vers_data),
5243 sizeof (data), _("version data"));
5244
5245 vers_data = byte_get (data, 2);
5246
5247 is_nobits = psym->st_shndx < SHN_LORESERVE ?
5248 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
5249 : 0;
5250
5251 check_def = (psym->st_shndx != SHN_UNDEF);
5252
5253 if ((vers_data & 0x8000) || vers_data > 1)
5254 {
5255 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5256 && (is_nobits || ! check_def))
5257 {
5258 Elf_External_Verneed evn;
5259 Elf_Internal_Verneed ivn;
5260 Elf_Internal_Vernaux ivna;
5261
5262 /* We must test both. */
5263 offset = version_info
5264 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5265
5266 do
5267 {
5268 unsigned long vna_off;
5269
5270 get_data (&evn, file, offset, sizeof (evn),
5271 _("version need"));
5272
5273 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5274 ivn.vn_next = BYTE_GET (evn.vn_next);
5275
5276 vna_off = offset + ivn.vn_aux;
5277
5278 do
5279 {
5280 Elf_External_Vernaux evna;
5281
5282 get_data (&evna, file, vna_off,
5283 sizeof (evna),
5284 _("version need aux (3)"));
5285
5286 ivna.vna_other = BYTE_GET (evna.vna_other);
5287 ivna.vna_next = BYTE_GET (evna.vna_next);
5288 ivna.vna_name = BYTE_GET (evna.vna_name);
5289
5290 vna_off += ivna.vna_next;
5291 }
5292 while (ivna.vna_other != vers_data
5293 && ivna.vna_next != 0);
5294
5295 if (ivna.vna_other == vers_data)
5296 break;
5297
5298 offset += ivn.vn_next;
5299 }
5300 while (ivn.vn_next != 0);
5301
5302 if (ivna.vna_other == vers_data)
5303 {
5304 printf ("@%s (%d)",
5305 strtab + ivna.vna_name, ivna.vna_other);
5306 check_def = 0;
5307 }
5308 else if (! is_nobits)
5309 error (_("bad dynamic symbol"));
5310 else
5311 check_def = 1;
5312 }
5313
5314 if (check_def)
5315 {
5316 if (vers_data != 0x8001
5317 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5318 {
5319 Elf_Internal_Verdef ivd;
5320 Elf_Internal_Verdaux ivda;
5321 Elf_External_Verdaux evda;
5322 unsigned long offset;
5323
5324 offset =
5325 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5326 - loadaddr;
5327
5328 do
5329 {
5330 Elf_External_Verdef evd;
5331
5332 get_data (&evd, file, offset, sizeof (evd),
5333 _("version def"));
5334
5335 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5336 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5337 ivd.vd_next = BYTE_GET (evd.vd_next);
5338
5339 offset += ivd.vd_next;
5340 }
5341 while (ivd.vd_ndx != (vers_data & 0x7fff)
5342 && ivd.vd_next != 0);
5343
5344 offset -= ivd.vd_next;
5345 offset += ivd.vd_aux;
5346
5347 get_data (&evda, file, offset, sizeof (evda),
5348 _("version def aux"));
5349
5350 ivda.vda_name = BYTE_GET (evda.vda_name);
5351
5352 if (psym->st_name != ivda.vda_name)
5353 printf ((vers_data & 0x8000)
5354 ? "@%s" : "@@%s",
5355 strtab + ivda.vda_name);
5356 }
5357 }
5358 }
5359 }
5360
5361 putchar ('\n');
5362 }
5363
5364 free (symtab);
5365 if (strtab != string_table)
5366 free (strtab);
5367 }
5368 }
5369 else if (do_syms)
5370 printf
5371 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5372
5373 if (do_histogram && buckets != NULL)
5374 {
5375 int * lengths;
5376 int * counts;
5377 int hn;
5378 int si;
5379 int maxlength = 0;
5380 int nzero_counts = 0;
5381 int nsyms = 0;
5382
5383 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5384 nbuckets);
5385 printf (_(" Length Number %% of total Coverage\n"));
5386
5387 lengths = (int *) calloc (nbuckets, sizeof (int));
5388 if (lengths == NULL)
5389 {
5390 error (_("Out of memory"));
5391 return 0;
5392 }
5393 for (hn = 0; hn < nbuckets; ++hn)
5394 {
5395 if (! buckets [hn])
5396 continue;
5397
5398 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5399 {
5400 ++ nsyms;
5401 if (maxlength < ++lengths[hn])
5402 ++ maxlength;
5403 }
5404 }
5405
5406 counts = (int *) calloc (maxlength + 1, sizeof (int));
5407 if (counts == NULL)
5408 {
5409 error (_("Out of memory"));
5410 return 0;
5411 }
5412
5413 for (hn = 0; hn < nbuckets; ++hn)
5414 ++ counts [lengths [hn]];
5415
5416 if (nbuckets > 0)
5417 {
5418 printf (" 0 %-10d (%5.1f%%)\n",
5419 counts[0], (counts[0] * 100.0) / nbuckets);
5420 for (si = 1; si <= maxlength; ++si)
5421 {
5422 nzero_counts += counts[si] * si;
5423 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5424 si, counts[si], (counts[si] * 100.0) / nbuckets,
5425 (nzero_counts * 100.0) / nsyms);
5426 }
5427 }
5428
5429 free (counts);
5430 free (lengths);
5431 }
5432
5433 if (buckets != NULL)
5434 {
5435 free (buckets);
5436 free (chains);
5437 }
5438
5439 return 1;
5440 }
5441
5442 static int
5443 process_syminfo (file)
5444 FILE * file ATTRIBUTE_UNUSED;
5445 {
5446 unsigned int i;
5447
5448 if (dynamic_syminfo == NULL
5449 || !do_dynamic)
5450 /* No syminfo, this is ok. */
5451 return 1;
5452
5453 /* There better should be a dynamic symbol section. */
5454 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5455 return 0;
5456
5457 if (dynamic_addr)
5458 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5459 dynamic_syminfo_offset, dynamic_syminfo_nent);
5460
5461 printf (_(" Num: Name BoundTo Flags\n"));
5462 for (i = 0; i < dynamic_syminfo_nent; ++i)
5463 {
5464 unsigned short int flags = dynamic_syminfo[i].si_flags;
5465
5466 printf ("%4d: %-30s ", i,
5467 dynamic_strings + dynamic_symbols[i].st_name);
5468
5469 switch (dynamic_syminfo[i].si_boundto)
5470 {
5471 case SYMINFO_BT_SELF:
5472 fputs ("SELF ", stdout);
5473 break;
5474 case SYMINFO_BT_PARENT:
5475 fputs ("PARENT ", stdout);
5476 break;
5477 default:
5478 if (dynamic_syminfo[i].si_boundto > 0
5479 && dynamic_syminfo[i].si_boundto < dynamic_size)
5480 printf ("%-10s ",
5481 dynamic_strings
5482 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5483 else
5484 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5485 break;
5486 }
5487
5488 if (flags & SYMINFO_FLG_DIRECT)
5489 printf (" DIRECT");
5490 if (flags & SYMINFO_FLG_PASSTHRU)
5491 printf (" PASSTHRU");
5492 if (flags & SYMINFO_FLG_COPY)
5493 printf (" COPY");
5494 if (flags & SYMINFO_FLG_LAZYLOAD)
5495 printf (" LAZYLOAD");
5496
5497 puts ("");
5498 }
5499
5500 return 1;
5501 }
5502
5503 #ifdef SUPPORT_DISASSEMBLY
5504 static void
5505 disassemble_section (section, file)
5506 Elf32_Internal_Shdr * section;
5507 FILE * file;
5508 {
5509 printf (_("\nAssembly dump of section %s\n"),
5510 SECTION_NAME (section));
5511
5512 /* XXX -- to be done --- XXX */
5513
5514 return 1;
5515 }
5516 #endif
5517
5518 static int
5519 dump_section (section, file)
5520 Elf32_Internal_Shdr * section;
5521 FILE * file;
5522 {
5523 bfd_size_type bytes;
5524 bfd_vma addr;
5525 unsigned char * data;
5526 unsigned char * start;
5527
5528 bytes = section->sh_size;
5529
5530 if (bytes == 0)
5531 {
5532 printf (_("\nSection '%s' has no data to dump.\n"),
5533 SECTION_NAME (section));
5534 return 0;
5535 }
5536 else
5537 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5538
5539 addr = section->sh_addr;
5540
5541 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
5542 _("section data"));
5543 if (!start)
5544 return 0;
5545
5546 data = start;
5547
5548 while (bytes)
5549 {
5550 int j;
5551 int k;
5552 int lbytes;
5553
5554 lbytes = (bytes > 16 ? 16 : bytes);
5555
5556 printf (" 0x%8.8lx ", (unsigned long) addr);
5557
5558 switch (elf_header.e_ident [EI_DATA])
5559 {
5560 default:
5561 case ELFDATA2LSB:
5562 for (j = 15; j >= 0; j --)
5563 {
5564 if (j < lbytes)
5565 printf ("%2.2x", data [j]);
5566 else
5567 printf (" ");
5568
5569 if (!(j & 0x3))
5570 printf (" ");
5571 }
5572 break;
5573
5574 case ELFDATA2MSB:
5575 for (j = 0; j < 16; j++)
5576 {
5577 if (j < lbytes)
5578 printf ("%2.2x", data [j]);
5579 else
5580 printf (" ");
5581
5582 if ((j & 3) == 3)
5583 printf (" ");
5584 }
5585 break;
5586 }
5587
5588 for (j = 0; j < lbytes; j++)
5589 {
5590 k = data [j];
5591 if (k >= ' ' && k < 0x80)
5592 printf ("%c", k);
5593 else
5594 printf (".");
5595 }
5596
5597 putchar ('\n');
5598
5599 data += lbytes;
5600 addr += lbytes;
5601 bytes -= lbytes;
5602 }
5603
5604 free (start);
5605
5606 return 1;
5607 }
5608
5609
5610 static unsigned long int
5611 read_leb128 (data, length_return, sign)
5612 unsigned char * data;
5613 int * length_return;
5614 int sign;
5615 {
5616 unsigned long int result = 0;
5617 unsigned int num_read = 0;
5618 int shift = 0;
5619 unsigned char byte;
5620
5621 do
5622 {
5623 byte = * data ++;
5624 num_read ++;
5625
5626 result |= (byte & 0x7f) << shift;
5627
5628 shift += 7;
5629
5630 }
5631 while (byte & 0x80);
5632
5633 if (length_return != NULL)
5634 * length_return = num_read;
5635
5636 if (sign && (shift < 32) && (byte & 0x40))
5637 result |= -1 << shift;
5638
5639 return result;
5640 }
5641
5642 typedef struct State_Machine_Registers
5643 {
5644 unsigned long address;
5645 unsigned int file;
5646 unsigned int line;
5647 unsigned int column;
5648 int is_stmt;
5649 int basic_block;
5650 int end_sequence;
5651 /* This variable hold the number of the last entry seen
5652 in the File Table. */
5653 unsigned int last_file_entry;
5654 } SMR;
5655
5656 static SMR state_machine_regs;
5657
5658 static void
5659 reset_state_machine (is_stmt)
5660 int is_stmt;
5661 {
5662 state_machine_regs.address = 0;
5663 state_machine_regs.file = 1;
5664 state_machine_regs.line = 1;
5665 state_machine_regs.column = 0;
5666 state_machine_regs.is_stmt = is_stmt;
5667 state_machine_regs.basic_block = 0;
5668 state_machine_regs.end_sequence = 0;
5669 state_machine_regs.last_file_entry = 0;
5670 }
5671
5672 /* Handled an extend line op. Returns true if this is the end
5673 of sequence. */
5674 static int
5675 process_extended_line_op (data, is_stmt, pointer_size)
5676 unsigned char * data;
5677 int is_stmt;
5678 int pointer_size;
5679 {
5680 unsigned char op_code;
5681 int bytes_read;
5682 unsigned int len;
5683 unsigned char * name;
5684 unsigned long adr;
5685
5686 len = read_leb128 (data, & bytes_read, 0);
5687 data += bytes_read;
5688
5689 if (len == 0)
5690 {
5691 warn (_("badly formed extended line op encountered!"));
5692 return bytes_read;
5693 }
5694
5695 len += bytes_read;
5696 op_code = * data ++;
5697
5698 printf (_(" Extended opcode %d: "), op_code);
5699
5700 switch (op_code)
5701 {
5702 case DW_LNE_end_sequence:
5703 printf (_("End of Sequence\n\n"));
5704 reset_state_machine (is_stmt);
5705 break;
5706
5707 case DW_LNE_set_address:
5708 adr = byte_get (data, pointer_size);
5709 printf (_("set Address to 0x%lx\n"), adr);
5710 state_machine_regs.address = adr;
5711 break;
5712
5713 case DW_LNE_define_file:
5714 printf (_(" define new File Table entry\n"));
5715 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5716
5717 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5718 name = data;
5719 data += strlen ((char *) data) + 1;
5720 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5721 data += bytes_read;
5722 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5723 data += bytes_read;
5724 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5725 printf (_("%s\n\n"), name);
5726 break;
5727
5728 default:
5729 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5730 break;
5731 }
5732
5733 return len;
5734 }
5735
5736 /* Size of pointers in the .debug_line section. This information is not
5737 really present in that section. It's obtained before dumping the debug
5738 sections by doing some pre-scan of the .debug_info section. */
5739 static int debug_line_pointer_size = 4;
5740
5741 static int
5742 display_debug_lines (section, start, file)
5743 Elf32_Internal_Shdr * section;
5744 unsigned char * start;
5745 FILE * file ATTRIBUTE_UNUSED;
5746 {
5747 DWARF2_External_LineInfo * external;
5748 DWARF2_Internal_LineInfo info;
5749 unsigned char * standard_opcodes;
5750 unsigned char * data = start;
5751 unsigned char * end = start + section->sh_size;
5752 unsigned char * end_of_sequence;
5753 int i;
5754
5755 printf (_("\nDump of debug contents of section %s:\n\n"),
5756 SECTION_NAME (section));
5757
5758 while (data < end)
5759 {
5760 external = (DWARF2_External_LineInfo *) data;
5761
5762 /* Check the length of the block. */
5763 info.li_length = BYTE_GET (external->li_length);
5764 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5765 {
5766 warn
5767 (_("The line info appears to be corrupt - the section is too small\n"));
5768 return 0;
5769 }
5770
5771 /* Check its version number. */
5772 info.li_version = BYTE_GET (external->li_version);
5773 if (info.li_version != 2)
5774 {
5775 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5776 return 0;
5777 }
5778
5779 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5780 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5781 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5782 info.li_line_base = BYTE_GET (external->li_line_base);
5783 info.li_line_range = BYTE_GET (external->li_line_range);
5784 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5785
5786 /* Sign extend the line base field. */
5787 info.li_line_base <<= 24;
5788 info.li_line_base >>= 24;
5789
5790 printf (_(" Length: %ld\n"), info.li_length);
5791 printf (_(" DWARF Version: %d\n"), info.li_version);
5792 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
5793 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5794 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5795 printf (_(" Line Base: %d\n"), info.li_line_base);
5796 printf (_(" Line Range: %d\n"), info.li_line_range);
5797 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5798
5799 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5800
5801 reset_state_machine (info.li_default_is_stmt);
5802
5803 /* Display the contents of the Opcodes table. */
5804 standard_opcodes = data + sizeof (* external);
5805
5806 printf (_("\n Opcodes:\n"));
5807
5808 for (i = 1; i < info.li_opcode_base; i++)
5809 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5810
5811 /* Display the contents of the Directory table. */
5812 data = standard_opcodes + info.li_opcode_base - 1;
5813
5814 if (* data == 0)
5815 printf (_("\n The Directory Table is empty.\n"));
5816 else
5817 {
5818 printf (_("\n The Directory Table:\n"));
5819
5820 while (* data != 0)
5821 {
5822 printf (_(" %s\n"), data);
5823
5824 data += strlen ((char *) data) + 1;
5825 }
5826 }
5827
5828 /* Skip the NUL at the end of the table. */
5829 data ++;
5830
5831 /* Display the contents of the File Name table. */
5832 if (* data == 0)
5833 printf (_("\n The File Name Table is empty.\n"));
5834 else
5835 {
5836 printf (_("\n The File Name Table:\n"));
5837 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5838
5839 while (* data != 0)
5840 {
5841 unsigned char * name;
5842 int bytes_read;
5843
5844 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5845 name = data;
5846
5847 data += strlen ((char *) data) + 1;
5848
5849 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5850 data += bytes_read;
5851 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5852 data += bytes_read;
5853 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5854 data += bytes_read;
5855 printf (_("%s\n"), name);
5856 }
5857 }
5858
5859 /* Skip the NUL at the end of the table. */
5860 data ++;
5861
5862 /* Now display the statements. */
5863 printf (_("\n Line Number Statements:\n"));
5864
5865
5866 while (data < end_of_sequence)
5867 {
5868 unsigned char op_code;
5869 int adv;
5870 int bytes_read;
5871
5872 op_code = * data ++;
5873
5874 switch (op_code)
5875 {
5876 case DW_LNS_extended_op:
5877 data += process_extended_line_op (data, info.li_default_is_stmt,
5878 debug_line_pointer_size);
5879 break;
5880
5881 case DW_LNS_copy:
5882 printf (_(" Copy\n"));
5883 break;
5884
5885 case DW_LNS_advance_pc:
5886 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5887 data += bytes_read;
5888 state_machine_regs.address += adv;
5889 printf (_(" Advance PC by %d to %lx\n"), adv,
5890 state_machine_regs.address);
5891 break;
5892
5893 case DW_LNS_advance_line:
5894 adv = read_leb128 (data, & bytes_read, 1);
5895 data += bytes_read;
5896 state_machine_regs.line += adv;
5897 printf (_(" Advance Line by %d to %d\n"), adv,
5898 state_machine_regs.line);
5899 break;
5900
5901 case DW_LNS_set_file:
5902 adv = read_leb128 (data, & bytes_read, 0);
5903 data += bytes_read;
5904 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5905 adv);
5906 state_machine_regs.file = adv;
5907 break;
5908
5909 case DW_LNS_set_column:
5910 adv = read_leb128 (data, & bytes_read, 0);
5911 data += bytes_read;
5912 printf (_(" Set column to %d\n"), adv);
5913 state_machine_regs.column = adv;
5914 break;
5915
5916 case DW_LNS_negate_stmt:
5917 adv = state_machine_regs.is_stmt;
5918 adv = ! adv;
5919 printf (_(" Set is_stmt to %d\n"), adv);
5920 state_machine_regs.is_stmt = adv;
5921 break;
5922
5923 case DW_LNS_set_basic_block:
5924 printf (_(" Set basic block\n"));
5925 state_machine_regs.basic_block = 1;
5926 break;
5927
5928 case DW_LNS_const_add_pc:
5929 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5930 * info.li_min_insn_length);
5931 state_machine_regs.address += adv;
5932 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5933 state_machine_regs.address);
5934 break;
5935
5936 case DW_LNS_fixed_advance_pc:
5937 adv = byte_get (data, 2);
5938 data += 2;
5939 state_machine_regs.address += adv;
5940 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5941 adv, state_machine_regs.address);
5942 break;
5943
5944 default:
5945 op_code -= info.li_opcode_base;
5946 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5947 state_machine_regs.address += adv;
5948 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5949 op_code, adv, state_machine_regs.address);
5950 adv = (op_code % info.li_line_range) + info.li_line_base;
5951 state_machine_regs.line += adv;
5952 printf (_(" and Line by %d to %d\n"),
5953 adv, state_machine_regs.line);
5954 break;
5955 }
5956 }
5957 printf ("\n");
5958 }
5959
5960 return 1;
5961 }
5962
5963 static int
5964 display_debug_pubnames (section, start, file)
5965 Elf32_Internal_Shdr * section;
5966 unsigned char * start;
5967 FILE * file ATTRIBUTE_UNUSED;
5968 {
5969 DWARF2_External_PubNames * external;
5970 DWARF2_Internal_PubNames pubnames;
5971 unsigned char * end;
5972
5973 end = start + section->sh_size;
5974
5975 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5976
5977 while (start < end)
5978 {
5979 unsigned char * data;
5980 unsigned long offset;
5981
5982 external = (DWARF2_External_PubNames *) start;
5983
5984 pubnames.pn_length = BYTE_GET (external->pn_length);
5985 pubnames.pn_version = BYTE_GET (external->pn_version);
5986 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5987 pubnames.pn_size = BYTE_GET (external->pn_size);
5988
5989 data = start + sizeof (* external);
5990 start += pubnames.pn_length + sizeof (external->pn_length);
5991
5992 if (pubnames.pn_version != 2)
5993 {
5994 static int warned = 0;
5995
5996 if (! warned)
5997 {
5998 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5999 warned = 1;
6000 }
6001
6002 continue;
6003 }
6004
6005 printf (_(" Length: %ld\n"),
6006 pubnames.pn_length);
6007 printf (_(" Version: %d\n"),
6008 pubnames.pn_version);
6009 printf (_(" Offset into .debug_info section: %ld\n"),
6010 pubnames.pn_offset);
6011 printf (_(" Size of area in .debug_info section: %ld\n"),
6012 pubnames.pn_size);
6013
6014 printf (_("\n Offset\tName\n"));
6015
6016 do
6017 {
6018 offset = byte_get (data, 4);
6019
6020 if (offset != 0)
6021 {
6022 data += 4;
6023 printf (" %ld\t\t%s\n", offset, data);
6024 data += strlen ((char *) data) + 1;
6025 }
6026 }
6027 while (offset != 0);
6028 }
6029
6030 printf ("\n");
6031 return 1;
6032 }
6033
6034 static char *
6035 get_TAG_name (tag)
6036 unsigned long tag;
6037 {
6038 switch (tag)
6039 {
6040 case DW_TAG_padding: return "DW_TAG_padding";
6041 case DW_TAG_array_type: return "DW_TAG_array_type";
6042 case DW_TAG_class_type: return "DW_TAG_class_type";
6043 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6044 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6045 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6046 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6047 case DW_TAG_label: return "DW_TAG_label";
6048 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6049 case DW_TAG_member: return "DW_TAG_member";
6050 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6051 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6052 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6053 case DW_TAG_string_type: return "DW_TAG_string_type";
6054 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6055 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6056 case DW_TAG_typedef: return "DW_TAG_typedef";
6057 case DW_TAG_union_type: return "DW_TAG_union_type";
6058 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6059 case DW_TAG_variant: return "DW_TAG_variant";
6060 case DW_TAG_common_block: return "DW_TAG_common_block";
6061 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6062 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6063 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6064 case DW_TAG_module: return "DW_TAG_module";
6065 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6066 case DW_TAG_set_type: return "DW_TAG_set_type";
6067 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6068 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6069 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6070 case DW_TAG_base_type: return "DW_TAG_base_type";
6071 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6072 case DW_TAG_const_type: return "DW_TAG_const_type";
6073 case DW_TAG_constant: return "DW_TAG_constant";
6074 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6075 case DW_TAG_file_type: return "DW_TAG_file_type";
6076 case DW_TAG_friend: return "DW_TAG_friend";
6077 case DW_TAG_namelist: return "DW_TAG_namelist";
6078 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6079 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6080 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6081 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6082 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6083 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6084 case DW_TAG_try_block: return "DW_TAG_try_block";
6085 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6086 case DW_TAG_variable: return "DW_TAG_variable";
6087 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6088 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6089 case DW_TAG_format_label: return "DW_TAG_format_label";
6090 case DW_TAG_function_template: return "DW_TAG_function_template";
6091 case DW_TAG_class_template: return "DW_TAG_class_template";
6092 /* DWARF 2.1 values. */
6093 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6094 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6095 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6096 case DW_TAG_namespace: return "DW_TAG_namespace";
6097 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6098 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6099 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6100 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6101 default:
6102 {
6103 static char buffer [100];
6104
6105 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6106 return buffer;
6107 }
6108 }
6109 }
6110
6111 static char *
6112 get_AT_name (attribute)
6113 unsigned long attribute;
6114 {
6115 switch (attribute)
6116 {
6117 case DW_AT_sibling: return "DW_AT_sibling";
6118 case DW_AT_location: return "DW_AT_location";
6119 case DW_AT_name: return "DW_AT_name";
6120 case DW_AT_ordering: return "DW_AT_ordering";
6121 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6122 case DW_AT_byte_size: return "DW_AT_byte_size";
6123 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6124 case DW_AT_bit_size: return "DW_AT_bit_size";
6125 case DW_AT_element_list: return "DW_AT_element_list";
6126 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6127 case DW_AT_low_pc: return "DW_AT_low_pc";
6128 case DW_AT_high_pc: return "DW_AT_high_pc";
6129 case DW_AT_language: return "DW_AT_language";
6130 case DW_AT_member: return "DW_AT_member";
6131 case DW_AT_discr: return "DW_AT_discr";
6132 case DW_AT_discr_value: return "DW_AT_discr_value";
6133 case DW_AT_visibility: return "DW_AT_visibility";
6134 case DW_AT_import: return "DW_AT_import";
6135 case DW_AT_string_length: return "DW_AT_string_length";
6136 case DW_AT_common_reference: return "DW_AT_common_reference";
6137 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6138 case DW_AT_const_value: return "DW_AT_const_value";
6139 case DW_AT_containing_type: return "DW_AT_containing_type";
6140 case DW_AT_default_value: return "DW_AT_default_value";
6141 case DW_AT_inline: return "DW_AT_inline";
6142 case DW_AT_is_optional: return "DW_AT_is_optional";
6143 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6144 case DW_AT_producer: return "DW_AT_producer";
6145 case DW_AT_prototyped: return "DW_AT_prototyped";
6146 case DW_AT_return_addr: return "DW_AT_return_addr";
6147 case DW_AT_start_scope: return "DW_AT_start_scope";
6148 case DW_AT_stride_size: return "DW_AT_stride_size";
6149 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6150 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6151 case DW_AT_accessibility: return "DW_AT_accessibility";
6152 case DW_AT_address_class: return "DW_AT_address_class";
6153 case DW_AT_artificial: return "DW_AT_artificial";
6154 case DW_AT_base_types: return "DW_AT_base_types";
6155 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6156 case DW_AT_count: return "DW_AT_count";
6157 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6158 case DW_AT_decl_column: return "DW_AT_decl_column";
6159 case DW_AT_decl_file: return "DW_AT_decl_file";
6160 case DW_AT_decl_line: return "DW_AT_decl_line";
6161 case DW_AT_declaration: return "DW_AT_declaration";
6162 case DW_AT_discr_list: return "DW_AT_discr_list";
6163 case DW_AT_encoding: return "DW_AT_encoding";
6164 case DW_AT_external: return "DW_AT_external";
6165 case DW_AT_frame_base: return "DW_AT_frame_base";
6166 case DW_AT_friend: return "DW_AT_friend";
6167 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6168 case DW_AT_macro_info: return "DW_AT_macro_info";
6169 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6170 case DW_AT_priority: return "DW_AT_priority";
6171 case DW_AT_segment: return "DW_AT_segment";
6172 case DW_AT_specification: return "DW_AT_specification";
6173 case DW_AT_static_link: return "DW_AT_static_link";
6174 case DW_AT_type: return "DW_AT_type";
6175 case DW_AT_use_location: return "DW_AT_use_location";
6176 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6177 case DW_AT_virtuality: return "DW_AT_virtuality";
6178 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6179 /* DWARF 2.1 values. */
6180 case DW_AT_allocated: return "DW_AT_allocated";
6181 case DW_AT_associated: return "DW_AT_associated";
6182 case DW_AT_data_location: return "DW_AT_data_location";
6183 case DW_AT_stride: return "DW_AT_stride";
6184 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6185 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6186 case DW_AT_extension: return "DW_AT_extension";
6187 case DW_AT_ranges: return "DW_AT_ranges";
6188 case DW_AT_trampoline: return "DW_AT_trampoline";
6189 case DW_AT_call_column: return "DW_AT_call_column";
6190 case DW_AT_call_file: return "DW_AT_call_file";
6191 case DW_AT_call_line: return "DW_AT_call_line";
6192 /* SGI/MIPS extensions. */
6193 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6194 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6195 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6196 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6197 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6198 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6199 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6200 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6201 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6202 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6203 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6204 /* GNU extensions. */
6205 case DW_AT_sf_names: return "DW_AT_sf_names";
6206 case DW_AT_src_info: return "DW_AT_src_info";
6207 case DW_AT_mac_info: return "DW_AT_mac_info";
6208 case DW_AT_src_coords: return "DW_AT_src_coords";
6209 case DW_AT_body_begin: return "DW_AT_body_begin";
6210 case DW_AT_body_end: return "DW_AT_body_end";
6211 default:
6212 {
6213 static char buffer [100];
6214
6215 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6216 return buffer;
6217 }
6218 }
6219 }
6220
6221 static char *
6222 get_FORM_name (form)
6223 unsigned long form;
6224 {
6225 switch (form)
6226 {
6227 case DW_FORM_addr: return "DW_FORM_addr";
6228 case DW_FORM_block2: return "DW_FORM_block2";
6229 case DW_FORM_block4: return "DW_FORM_block4";
6230 case DW_FORM_data2: return "DW_FORM_data2";
6231 case DW_FORM_data4: return "DW_FORM_data4";
6232 case DW_FORM_data8: return "DW_FORM_data8";
6233 case DW_FORM_string: return "DW_FORM_string";
6234 case DW_FORM_block: return "DW_FORM_block";
6235 case DW_FORM_block1: return "DW_FORM_block1";
6236 case DW_FORM_data1: return "DW_FORM_data1";
6237 case DW_FORM_flag: return "DW_FORM_flag";
6238 case DW_FORM_sdata: return "DW_FORM_sdata";
6239 case DW_FORM_strp: return "DW_FORM_strp";
6240 case DW_FORM_udata: return "DW_FORM_udata";
6241 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6242 case DW_FORM_ref1: return "DW_FORM_ref1";
6243 case DW_FORM_ref2: return "DW_FORM_ref2";
6244 case DW_FORM_ref4: return "DW_FORM_ref4";
6245 case DW_FORM_ref8: return "DW_FORM_ref8";
6246 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6247 case DW_FORM_indirect: return "DW_FORM_indirect";
6248 default:
6249 {
6250 static char buffer [100];
6251
6252 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6253 return buffer;
6254 }
6255 }
6256 }
6257
6258 /* FIXME: There are better and more effiecint ways to handle
6259 these structures. For now though, I just want something that
6260 is simple to implement. */
6261 typedef struct abbrev_attr
6262 {
6263 unsigned long attribute;
6264 unsigned long form;
6265 struct abbrev_attr * next;
6266 }
6267 abbrev_attr;
6268
6269 typedef struct abbrev_entry
6270 {
6271 unsigned long entry;
6272 unsigned long tag;
6273 int children;
6274 struct abbrev_attr * first_attr;
6275 struct abbrev_attr * last_attr;
6276 struct abbrev_entry * next;
6277 }
6278 abbrev_entry;
6279
6280 static abbrev_entry * first_abbrev = NULL;
6281 static abbrev_entry * last_abbrev = NULL;
6282
6283 static void
6284 free_abbrevs PARAMS ((void))
6285 {
6286 abbrev_entry * abbrev;
6287
6288 for (abbrev = first_abbrev; abbrev;)
6289 {
6290 abbrev_entry * next = abbrev->next;
6291 abbrev_attr * attr;
6292
6293 for (attr = abbrev->first_attr; attr;)
6294 {
6295 abbrev_attr * next = attr->next;
6296
6297 free (attr);
6298 attr = next;
6299 }
6300
6301 free (abbrev);
6302 abbrev = next;
6303 }
6304
6305 last_abbrev = first_abbrev = NULL;
6306 }
6307
6308 static void
6309 add_abbrev (number, tag, children)
6310 unsigned long number;
6311 unsigned long tag;
6312 int children;
6313 {
6314 abbrev_entry * entry;
6315
6316 entry = (abbrev_entry *) malloc (sizeof (* entry));
6317
6318 if (entry == NULL)
6319 /* ugg */
6320 return;
6321
6322 entry->entry = number;
6323 entry->tag = tag;
6324 entry->children = children;
6325 entry->first_attr = NULL;
6326 entry->last_attr = NULL;
6327 entry->next = NULL;
6328
6329 if (first_abbrev == NULL)
6330 first_abbrev = entry;
6331 else
6332 last_abbrev->next = entry;
6333
6334 last_abbrev = entry;
6335 }
6336
6337 static void
6338 add_abbrev_attr (attribute, form)
6339 unsigned long attribute;
6340 unsigned long form;
6341 {
6342 abbrev_attr * attr;
6343
6344 attr = (abbrev_attr *) malloc (sizeof (* attr));
6345
6346 if (attr == NULL)
6347 /* ugg */
6348 return;
6349
6350 attr->attribute = attribute;
6351 attr->form = form;
6352 attr->next = NULL;
6353
6354 if (last_abbrev->first_attr == NULL)
6355 last_abbrev->first_attr = attr;
6356 else
6357 last_abbrev->last_attr->next = attr;
6358
6359 last_abbrev->last_attr = attr;
6360 }
6361
6362 /* Processes the (partial) contents of a .debug_abbrev section.
6363 Returns NULL if the end of the section was encountered.
6364 Returns the address after the last byte read if the end of
6365 an abbreviation set was found. */
6366
6367 static unsigned char *
6368 process_abbrev_section (start, end)
6369 unsigned char * start;
6370 unsigned char * end;
6371 {
6372 if (first_abbrev != NULL)
6373 return NULL;
6374
6375 while (start < end)
6376 {
6377 int bytes_read;
6378 unsigned long entry;
6379 unsigned long tag;
6380 unsigned long attribute;
6381 int children;
6382
6383 entry = read_leb128 (start, & bytes_read, 0);
6384 start += bytes_read;
6385
6386 /* A single zero is supposed to end the section according
6387 to the standard. If there's more, then signal that to
6388 the caller. */
6389 if (entry == 0)
6390 return start == end ? NULL : start;
6391
6392 tag = read_leb128 (start, & bytes_read, 0);
6393 start += bytes_read;
6394
6395 children = * start ++;
6396
6397 add_abbrev (entry, tag, children);
6398
6399 do
6400 {
6401 unsigned long form;
6402
6403 attribute = read_leb128 (start, & bytes_read, 0);
6404 start += bytes_read;
6405
6406 form = read_leb128 (start, & bytes_read, 0);
6407 start += bytes_read;
6408
6409 if (attribute != 0)
6410 add_abbrev_attr (attribute, form);
6411 }
6412 while (attribute != 0);
6413 }
6414
6415 return NULL;
6416 }
6417
6418
6419 static int
6420 display_debug_macinfo (section, start, file)
6421 Elf32_Internal_Shdr * section;
6422 unsigned char * start;
6423 FILE * file ATTRIBUTE_UNUSED;
6424 {
6425 unsigned char * end = start + section->sh_size;
6426 unsigned char * curr = start;
6427 unsigned int bytes_read;
6428 enum dwarf_macinfo_record_type op;
6429
6430 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6431
6432 while (curr < end)
6433 {
6434 unsigned int lineno;
6435 const char * string;
6436
6437 op = * curr;
6438 curr ++;
6439
6440 switch (op)
6441 {
6442 case DW_MACINFO_start_file:
6443 {
6444 unsigned int filenum;
6445
6446 lineno = read_leb128 (curr, & bytes_read, 0);
6447 curr += bytes_read;
6448 filenum = read_leb128 (curr, & bytes_read, 0);
6449 curr += bytes_read;
6450
6451 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6452 }
6453 break;
6454
6455 case DW_MACINFO_end_file:
6456 printf (_(" DW_MACINFO_end_file\n"));
6457 break;
6458
6459 case DW_MACINFO_define:
6460 lineno = read_leb128 (curr, & bytes_read, 0);
6461 curr += bytes_read;
6462 string = curr;
6463 curr += strlen (string) + 1;
6464 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6465 break;
6466
6467 case DW_MACINFO_undef:
6468 lineno = read_leb128 (curr, & bytes_read, 0);
6469 curr += bytes_read;
6470 string = curr;
6471 curr += strlen (string) + 1;
6472 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6473 break;
6474
6475 case DW_MACINFO_vendor_ext:
6476 {
6477 unsigned int constant;
6478
6479 constant = read_leb128 (curr, & bytes_read, 0);
6480 curr += bytes_read;
6481 string = curr;
6482 curr += strlen (string) + 1;
6483 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6484 }
6485 break;
6486 }
6487 }
6488
6489 return 1;
6490 }
6491
6492
6493 static int
6494 display_debug_abbrev (section, start, file)
6495 Elf32_Internal_Shdr * section;
6496 unsigned char * start;
6497 FILE * file ATTRIBUTE_UNUSED;
6498 {
6499 abbrev_entry * entry;
6500 unsigned char * end = start + section->sh_size;
6501
6502 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6503
6504 do
6505 {
6506 start = process_abbrev_section (start, end);
6507
6508 printf (_(" Number TAG\n"));
6509
6510 for (entry = first_abbrev; entry; entry = entry->next)
6511 {
6512 abbrev_attr * attr;
6513
6514 printf (_(" %ld %s [%s]\n"),
6515 entry->entry,
6516 get_TAG_name (entry->tag),
6517 entry->children ? _("has children") : _("no children"));
6518
6519 for (attr = entry->first_attr; attr; attr = attr->next)
6520 {
6521 printf (_(" %-18s %s\n"),
6522 get_AT_name (attr->attribute),
6523 get_FORM_name (attr->form));
6524 }
6525 }
6526 }
6527 while (start);
6528
6529 printf ("\n");
6530
6531 return 1;
6532 }
6533
6534
6535 static unsigned char *
6536 display_block (data, length)
6537 unsigned char * data;
6538 unsigned long length;
6539 {
6540 printf (_(" %lu byte block: "), length);
6541
6542 while (length --)
6543 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6544
6545 return data;
6546 }
6547
6548 static void
6549 decode_location_expression (data, pointer_size, length)
6550 unsigned char * data;
6551 unsigned int pointer_size;
6552 unsigned long length;
6553 {
6554 unsigned op;
6555 int bytes_read;
6556 unsigned long uvalue;
6557 unsigned char * end = data + length;
6558
6559 while (data < end)
6560 {
6561 op = * data ++;
6562
6563 switch (op)
6564 {
6565 case DW_OP_addr:
6566 printf ("DW_OP_addr: %lx",
6567 (unsigned long) byte_get (data, pointer_size));
6568 data += pointer_size;
6569 break;
6570 case DW_OP_deref:
6571 printf ("DW_OP_deref");
6572 break;
6573 case DW_OP_const1u:
6574 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6575 break;
6576 case DW_OP_const1s:
6577 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6578 break;
6579 case DW_OP_const2u:
6580 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6581 data += 2;
6582 break;
6583 case DW_OP_const2s:
6584 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6585 data += 2;
6586 break;
6587 case DW_OP_const4u:
6588 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6589 data += 4;
6590 break;
6591 case DW_OP_const4s:
6592 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6593 data += 4;
6594 break;
6595 case DW_OP_const8u:
6596 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6597 (unsigned long) byte_get (data + 4, 4));
6598 data += 8;
6599 break;
6600 case DW_OP_const8s:
6601 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6602 (long) byte_get (data + 4, 4));
6603 data += 8;
6604 break;
6605 case DW_OP_constu:
6606 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6607 data += bytes_read;
6608 break;
6609 case DW_OP_consts:
6610 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6611 data += bytes_read;
6612 break;
6613 case DW_OP_dup:
6614 printf ("DW_OP_dup");
6615 break;
6616 case DW_OP_drop:
6617 printf ("DW_OP_drop");
6618 break;
6619 case DW_OP_over:
6620 printf ("DW_OP_over");
6621 break;
6622 case DW_OP_pick:
6623 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6624 break;
6625 case DW_OP_swap:
6626 printf ("DW_OP_swap");
6627 break;
6628 case DW_OP_rot:
6629 printf ("DW_OP_rot");
6630 break;
6631 case DW_OP_xderef:
6632 printf ("DW_OP_xderef");
6633 break;
6634 case DW_OP_abs:
6635 printf ("DW_OP_abs");
6636 break;
6637 case DW_OP_and:
6638 printf ("DW_OP_and");
6639 break;
6640 case DW_OP_div:
6641 printf ("DW_OP_div");
6642 break;
6643 case DW_OP_minus:
6644 printf ("DW_OP_minus");
6645 break;
6646 case DW_OP_mod:
6647 printf ("DW_OP_mod");
6648 break;
6649 case DW_OP_mul:
6650 printf ("DW_OP_mul");
6651 break;
6652 case DW_OP_neg:
6653 printf ("DW_OP_neg");
6654 break;
6655 case DW_OP_not:
6656 printf ("DW_OP_not");
6657 break;
6658 case DW_OP_or:
6659 printf ("DW_OP_or");
6660 break;
6661 case DW_OP_plus:
6662 printf ("DW_OP_plus");
6663 break;
6664 case DW_OP_plus_uconst:
6665 printf ("DW_OP_plus_uconst: %lu",
6666 read_leb128 (data, &bytes_read, 0));
6667 data += bytes_read;
6668 break;
6669 case DW_OP_shl:
6670 printf ("DW_OP_shl");
6671 break;
6672 case DW_OP_shr:
6673 printf ("DW_OP_shr");
6674 break;
6675 case DW_OP_shra:
6676 printf ("DW_OP_shra");
6677 break;
6678 case DW_OP_xor:
6679 printf ("DW_OP_xor");
6680 break;
6681 case DW_OP_bra:
6682 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6683 data += 2;
6684 break;
6685 case DW_OP_eq:
6686 printf ("DW_OP_eq");
6687 break;
6688 case DW_OP_ge:
6689 printf ("DW_OP_ge");
6690 break;
6691 case DW_OP_gt:
6692 printf ("DW_OP_gt");
6693 break;
6694 case DW_OP_le:
6695 printf ("DW_OP_le");
6696 break;
6697 case DW_OP_lt:
6698 printf ("DW_OP_lt");
6699 break;
6700 case DW_OP_ne:
6701 printf ("DW_OP_ne");
6702 break;
6703 case DW_OP_skip:
6704 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6705 data += 2;
6706 break;
6707
6708 case DW_OP_lit0:
6709 case DW_OP_lit1:
6710 case DW_OP_lit2:
6711 case DW_OP_lit3:
6712 case DW_OP_lit4:
6713 case DW_OP_lit5:
6714 case DW_OP_lit6:
6715 case DW_OP_lit7:
6716 case DW_OP_lit8:
6717 case DW_OP_lit9:
6718 case DW_OP_lit10:
6719 case DW_OP_lit11:
6720 case DW_OP_lit12:
6721 case DW_OP_lit13:
6722 case DW_OP_lit14:
6723 case DW_OP_lit15:
6724 case DW_OP_lit16:
6725 case DW_OP_lit17:
6726 case DW_OP_lit18:
6727 case DW_OP_lit19:
6728 case DW_OP_lit20:
6729 case DW_OP_lit21:
6730 case DW_OP_lit22:
6731 case DW_OP_lit23:
6732 case DW_OP_lit24:
6733 case DW_OP_lit25:
6734 case DW_OP_lit26:
6735 case DW_OP_lit27:
6736 case DW_OP_lit28:
6737 case DW_OP_lit29:
6738 case DW_OP_lit30:
6739 case DW_OP_lit31:
6740 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6741 break;
6742
6743 case DW_OP_reg0:
6744 case DW_OP_reg1:
6745 case DW_OP_reg2:
6746 case DW_OP_reg3:
6747 case DW_OP_reg4:
6748 case DW_OP_reg5:
6749 case DW_OP_reg6:
6750 case DW_OP_reg7:
6751 case DW_OP_reg8:
6752 case DW_OP_reg9:
6753 case DW_OP_reg10:
6754 case DW_OP_reg11:
6755 case DW_OP_reg12:
6756 case DW_OP_reg13:
6757 case DW_OP_reg14:
6758 case DW_OP_reg15:
6759 case DW_OP_reg16:
6760 case DW_OP_reg17:
6761 case DW_OP_reg18:
6762 case DW_OP_reg19:
6763 case DW_OP_reg20:
6764 case DW_OP_reg21:
6765 case DW_OP_reg22:
6766 case DW_OP_reg23:
6767 case DW_OP_reg24:
6768 case DW_OP_reg25:
6769 case DW_OP_reg26:
6770 case DW_OP_reg27:
6771 case DW_OP_reg28:
6772 case DW_OP_reg29:
6773 case DW_OP_reg30:
6774 case DW_OP_reg31:
6775 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6776 break;
6777
6778 case DW_OP_breg0:
6779 case DW_OP_breg1:
6780 case DW_OP_breg2:
6781 case DW_OP_breg3:
6782 case DW_OP_breg4:
6783 case DW_OP_breg5:
6784 case DW_OP_breg6:
6785 case DW_OP_breg7:
6786 case DW_OP_breg8:
6787 case DW_OP_breg9:
6788 case DW_OP_breg10:
6789 case DW_OP_breg11:
6790 case DW_OP_breg12:
6791 case DW_OP_breg13:
6792 case DW_OP_breg14:
6793 case DW_OP_breg15:
6794 case DW_OP_breg16:
6795 case DW_OP_breg17:
6796 case DW_OP_breg18:
6797 case DW_OP_breg19:
6798 case DW_OP_breg20:
6799 case DW_OP_breg21:
6800 case DW_OP_breg22:
6801 case DW_OP_breg23:
6802 case DW_OP_breg24:
6803 case DW_OP_breg25:
6804 case DW_OP_breg26:
6805 case DW_OP_breg27:
6806 case DW_OP_breg28:
6807 case DW_OP_breg29:
6808 case DW_OP_breg30:
6809 case DW_OP_breg31:
6810 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6811 read_leb128 (data, &bytes_read, 1));
6812 data += bytes_read;
6813 break;
6814
6815 case DW_OP_regx:
6816 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6817 data += bytes_read;
6818 break;
6819 case DW_OP_fbreg:
6820 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6821 data += bytes_read;
6822 break;
6823 case DW_OP_bregx:
6824 uvalue = read_leb128 (data, &bytes_read, 0);
6825 data += bytes_read;
6826 printf ("DW_OP_bregx: %lu %ld", uvalue,
6827 read_leb128 (data, &bytes_read, 1));
6828 data += bytes_read;
6829 break;
6830 case DW_OP_piece:
6831 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6832 data += bytes_read;
6833 break;
6834 case DW_OP_deref_size:
6835 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6836 break;
6837 case DW_OP_xderef_size:
6838 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6839 break;
6840 case DW_OP_nop:
6841 printf ("DW_OP_nop");
6842 break;
6843
6844 /* DWARF 2.1 extensions. */
6845 case DW_OP_push_object_address:
6846 printf ("DW_OP_push_object_address");
6847 break;
6848 case DW_OP_call2:
6849 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
6850 data += 2;
6851 break;
6852 case DW_OP_call4:
6853 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
6854 data += 4;
6855 break;
6856 case DW_OP_calli:
6857 printf ("DW_OP_calli");
6858 break;
6859
6860 default:
6861 if (op >= DW_OP_lo_user
6862 && op <= DW_OP_hi_user)
6863 printf (_("(User defined location op)"));
6864 else
6865 printf (_("(Unknown location op)"));
6866 /* No way to tell where the next op is, so just bail. */
6867 return;
6868 }
6869
6870 /* Separate the ops. */
6871 printf ("; ");
6872 }
6873 }
6874
6875
6876 static unsigned char *
6877 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6878 unsigned long attribute;
6879 unsigned long form;
6880 unsigned char * data;
6881 unsigned long cu_offset;
6882 unsigned long pointer_size;
6883 {
6884 unsigned long uvalue = 0;
6885 unsigned char * block_start = NULL;
6886 int bytes_read;
6887
6888 printf (" %-18s:", get_AT_name (attribute));
6889
6890 switch (form)
6891 {
6892 default:
6893 break;
6894
6895 case DW_FORM_ref_addr:
6896 case DW_FORM_addr:
6897 uvalue = byte_get (data, pointer_size);
6898 data += pointer_size;
6899 break;
6900
6901 case DW_FORM_ref1:
6902 case DW_FORM_flag:
6903 case DW_FORM_data1:
6904 uvalue = byte_get (data ++, 1);
6905 break;
6906
6907 case DW_FORM_ref2:
6908 case DW_FORM_data2:
6909 uvalue = byte_get (data, 2);
6910 data += 2;
6911 break;
6912
6913 case DW_FORM_ref4:
6914 case DW_FORM_data4:
6915 uvalue = byte_get (data, 4);
6916 data += 4;
6917 break;
6918
6919 case DW_FORM_sdata:
6920 uvalue = read_leb128 (data, & bytes_read, 1);
6921 data += bytes_read;
6922 break;
6923
6924 case DW_FORM_ref_udata:
6925 case DW_FORM_udata:
6926 uvalue = read_leb128 (data, & bytes_read, 0);
6927 data += bytes_read;
6928 break;
6929 }
6930
6931 switch (form)
6932 {
6933 case DW_FORM_ref_addr:
6934 printf (" <#%lx>", uvalue);
6935 break;
6936
6937 case DW_FORM_ref1:
6938 case DW_FORM_ref2:
6939 case DW_FORM_ref4:
6940 case DW_FORM_ref_udata:
6941 printf (" <%lx>", uvalue + cu_offset);
6942 break;
6943
6944 case DW_FORM_addr:
6945 printf (" %#lx", uvalue);
6946
6947 case DW_FORM_flag:
6948 case DW_FORM_data1:
6949 case DW_FORM_data2:
6950 case DW_FORM_data4:
6951 case DW_FORM_sdata:
6952 case DW_FORM_udata:
6953 printf (" %ld", uvalue);
6954 break;
6955
6956 case DW_FORM_ref8:
6957 case DW_FORM_data8:
6958 uvalue = byte_get (data, 4);
6959 printf (" %lx", uvalue);
6960 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6961 data += 8;
6962 break;
6963
6964 case DW_FORM_string:
6965 printf (" %s", data);
6966 data += strlen ((char *) data) + 1;
6967 break;
6968
6969 case DW_FORM_block:
6970 uvalue = read_leb128 (data, & bytes_read, 0);
6971 block_start = data + bytes_read;
6972 data = display_block (block_start, uvalue);
6973 break;
6974
6975 case DW_FORM_block1:
6976 uvalue = byte_get (data, 1);
6977 block_start = data + 1;
6978 data = display_block (block_start, uvalue);
6979 break;
6980
6981 case DW_FORM_block2:
6982 uvalue = byte_get (data, 2);
6983 block_start = data + 2;
6984 data = display_block (block_start, uvalue);
6985 break;
6986
6987 case DW_FORM_block4:
6988 uvalue = byte_get (data, 4);
6989 block_start = data + 4;
6990 data = display_block (block_start, uvalue);
6991 break;
6992
6993 case DW_FORM_strp:
6994 case DW_FORM_indirect:
6995 warn (_("Unable to handle FORM: %d"), form);
6996 break;
6997
6998 default:
6999 warn (_("Unrecognised form: %d"), form);
7000 break;
7001 }
7002
7003 /* For some attributes we can display futher information. */
7004
7005 printf ("\t");
7006
7007 switch (attribute)
7008 {
7009 case DW_AT_inline:
7010 switch (uvalue)
7011 {
7012 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7013 case DW_INL_inlined: printf (_("(inlined)")); break;
7014 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7015 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7016 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7017 }
7018 break;
7019
7020 case DW_AT_language:
7021 switch (uvalue)
7022 {
7023 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7024 case DW_LANG_C89: printf ("(ANSI C)"); break;
7025 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7026 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7027 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7028 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7029 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7030 case DW_LANG_Ada83: printf ("(Ada)"); break;
7031 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7032 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7033 /* DWARF 2.1 values. */
7034 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7035 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7036 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7037 /* MIPS extension. */
7038 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7039 default: printf ("(Unknown: %lx)", uvalue); break;
7040 }
7041 break;
7042
7043 case DW_AT_encoding:
7044 switch (uvalue)
7045 {
7046 case DW_ATE_void: printf ("(void)"); break;
7047 case DW_ATE_address: printf ("(machine address)"); break;
7048 case DW_ATE_boolean: printf ("(boolean)"); break;
7049 case DW_ATE_complex_float: printf ("(complex float)"); break;
7050 case DW_ATE_float: printf ("(float)"); break;
7051 case DW_ATE_signed: printf ("(signed)"); break;
7052 case DW_ATE_signed_char: printf ("(signed char)"); break;
7053 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7054 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7055 /* DWARF 2.1 value. */
7056 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7057 default:
7058 if (uvalue >= DW_ATE_lo_user
7059 && uvalue <= DW_ATE_hi_user)
7060 printf ("(user defined type)");
7061 else
7062 printf ("(unknown type)");
7063 break;
7064 }
7065 break;
7066
7067 case DW_AT_accessibility:
7068 switch (uvalue)
7069 {
7070 case DW_ACCESS_public: printf ("(public)"); break;
7071 case DW_ACCESS_protected: printf ("(protected)"); break;
7072 case DW_ACCESS_private: printf ("(private)"); break;
7073 default: printf ("(unknown accessibility)"); break;
7074 }
7075 break;
7076
7077 case DW_AT_visibility:
7078 switch (uvalue)
7079 {
7080 case DW_VIS_local: printf ("(local)"); break;
7081 case DW_VIS_exported: printf ("(exported)"); break;
7082 case DW_VIS_qualified: printf ("(qualified)"); break;
7083 default: printf ("(unknown visibility)"); break;
7084 }
7085 break;
7086
7087 case DW_AT_virtuality:
7088 switch (uvalue)
7089 {
7090 case DW_VIRTUALITY_none: printf ("(none)"); break;
7091 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7092 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7093 default: printf ("(unknown virtuality)"); break;
7094 }
7095 break;
7096
7097 case DW_AT_identifier_case:
7098 switch (uvalue)
7099 {
7100 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7101 case DW_ID_up_case: printf ("(up_case)"); break;
7102 case DW_ID_down_case: printf ("(down_case)"); break;
7103 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7104 default: printf ("(unknown case)"); break;
7105 }
7106 break;
7107
7108 case DW_AT_calling_convention:
7109 switch (uvalue)
7110 {
7111 case DW_CC_normal: printf ("(normal)"); break;
7112 case DW_CC_program: printf ("(program)"); break;
7113 case DW_CC_nocall: printf ("(nocall)"); break;
7114 default:
7115 if (uvalue >= DW_CC_lo_user
7116 && uvalue <= DW_CC_hi_user)
7117 printf ("(user defined)");
7118 else
7119 printf ("(unknown convention)");
7120 }
7121 break;
7122
7123 case DW_AT_ordering:
7124 switch (uvalue)
7125 {
7126 case -1: printf ("(undefined)"); break;
7127 case 0: printf ("(row major)"); break;
7128 case 1: printf ("(column major)"); break;
7129 }
7130 break;
7131
7132 case DW_AT_frame_base:
7133 case DW_AT_location:
7134 case DW_AT_data_member_location:
7135 case DW_AT_vtable_elem_location:
7136 case DW_AT_allocated:
7137 case DW_AT_associated:
7138 case DW_AT_data_location:
7139 case DW_AT_stride:
7140 case DW_AT_upper_bound:
7141 case DW_AT_lower_bound:
7142 if (block_start)
7143 {
7144 printf ("(");
7145 decode_location_expression (block_start, pointer_size, uvalue);
7146 printf (")");
7147 }
7148 break;
7149
7150 default:
7151 break;
7152 }
7153
7154 printf ("\n");
7155 return data;
7156 }
7157
7158 static int
7159 display_debug_info (section, start, file)
7160 Elf32_Internal_Shdr * section;
7161 unsigned char * start;
7162 FILE * file;
7163 {
7164 unsigned char * end = start + section->sh_size;
7165 unsigned char * section_begin = start;
7166
7167 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7168
7169 while (start < end)
7170 {
7171 DWARF2_External_CompUnit * external;
7172 DWARF2_Internal_CompUnit compunit;
7173 Elf32_Internal_Shdr * relsec;
7174 unsigned char * tags;
7175 int i;
7176 int level;
7177 unsigned long cu_offset;
7178
7179 external = (DWARF2_External_CompUnit *) start;
7180
7181 compunit.cu_length = BYTE_GET (external->cu_length);
7182 compunit.cu_version = BYTE_GET (external->cu_version);
7183 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7184 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7185
7186 /* Check for RELA relocations in the abbrev_offset address, and
7187 apply them. */
7188 for (relsec = section_headers;
7189 relsec < section_headers + elf_header.e_shnum;
7190 ++relsec)
7191 {
7192 unsigned long nrelas, nsyms;
7193 Elf_Internal_Rela *rela, *rp;
7194 Elf32_Internal_Shdr *symsec;
7195 Elf_Internal_Sym *symtab;
7196 Elf_Internal_Sym *sym;
7197
7198 if (relsec->sh_type != SHT_RELA
7199 || section_headers + relsec->sh_info != section)
7200 continue;
7201
7202 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7203 & rela, & nrelas))
7204 return 0;
7205
7206 symsec = section_headers + relsec->sh_link;
7207 nsyms = symsec->sh_size / symsec->sh_entsize;
7208 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
7209
7210 for (rp = rela; rp < rela + nrelas; ++rp)
7211 {
7212 if (rp->r_offset
7213 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7214 - section_begin))
7215 continue;
7216
7217 if (is_32bit_elf)
7218 {
7219 sym = symtab + ELF32_R_SYM (rp->r_info);
7220
7221 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7222 {
7223 warn (_("Skipping unexpected symbol type %u"),
7224 ELF32_ST_TYPE (sym->st_info));
7225 continue;
7226 }
7227 }
7228 else
7229 {
7230 sym = symtab + ELF64_R_SYM (rp->r_info);
7231
7232 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7233 {
7234 warn (_("Skipping unexpected symbol type %u"),
7235 ELF64_ST_TYPE (sym->st_info));
7236 continue;
7237 }
7238 }
7239
7240 compunit.cu_abbrev_offset += rp->r_addend;
7241 break;
7242 }
7243
7244 free (rela);
7245 break;
7246 }
7247
7248 tags = start + sizeof (* external);
7249 cu_offset = start - section_begin;
7250 start += compunit.cu_length + sizeof (external->cu_length);
7251
7252 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
7253 printf (_(" Length: %ld\n"), compunit.cu_length);
7254 printf (_(" Version: %d\n"), compunit.cu_version);
7255 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7256 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
7257
7258 if (compunit.cu_version != 2)
7259 {
7260 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7261 continue;
7262 }
7263
7264 if (first_abbrev != NULL)
7265 free_abbrevs ();
7266
7267 /* Read in the abbrevs used by this compilation unit. */
7268
7269 {
7270 Elf32_Internal_Shdr * sec;
7271 unsigned char * begin;
7272
7273 /* Locate the .debug_abbrev section and process it. */
7274 for (i = 0, sec = section_headers;
7275 i < elf_header.e_shnum;
7276 i ++, sec ++)
7277 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7278 break;
7279
7280 if (i == -1 || sec->sh_size == 0)
7281 {
7282 warn (_("Unable to locate .debug_abbrev section!\n"));
7283 return 0;
7284 }
7285
7286 begin = ((unsigned char *)
7287 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7288 _("debug_abbrev section data")));
7289 if (!begin)
7290 return 0;
7291
7292 process_abbrev_section (begin + compunit.cu_abbrev_offset,
7293 begin + sec->sh_size);
7294
7295 free (begin);
7296 }
7297
7298 level = 0;
7299 while (tags < start)
7300 {
7301 int bytes_read;
7302 unsigned long abbrev_number;
7303 abbrev_entry * entry;
7304 abbrev_attr * attr;
7305
7306 abbrev_number = read_leb128 (tags, & bytes_read, 0);
7307 tags += bytes_read;
7308
7309 /* A null DIE marks the end of a list of children. */
7310 if (abbrev_number == 0)
7311 {
7312 --level;
7313 continue;
7314 }
7315
7316 /* Scan through the abbreviation list until we reach the
7317 correct entry. */
7318 for (entry = first_abbrev;
7319 entry && entry->entry != abbrev_number;
7320 entry = entry->next)
7321 continue;
7322
7323 if (entry == NULL)
7324 {
7325 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7326 abbrev_number);
7327 return 0;
7328 }
7329
7330 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7331 level,
7332 (unsigned long) (tags - section_begin - bytes_read),
7333 abbrev_number,
7334 get_TAG_name (entry->tag));
7335
7336 for (attr = entry->first_attr; attr; attr = attr->next)
7337 tags = read_and_display_attr (attr->attribute,
7338 attr->form,
7339 tags, cu_offset,
7340 compunit.cu_pointer_size);
7341
7342 if (entry->children)
7343 ++level;
7344 }
7345 }
7346
7347 printf ("\n");
7348
7349 return 1;
7350 }
7351
7352 static int
7353 display_debug_aranges (section, start, file)
7354 Elf32_Internal_Shdr * section;
7355 unsigned char * start;
7356 FILE * file ATTRIBUTE_UNUSED;
7357 {
7358 unsigned char * end = start + section->sh_size;
7359
7360 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7361
7362 while (start < end)
7363 {
7364 DWARF2_External_ARange * external;
7365 DWARF2_Internal_ARange arange;
7366 unsigned char * ranges;
7367 unsigned long length;
7368 unsigned long address;
7369 int excess;
7370
7371 external = (DWARF2_External_ARange *) start;
7372
7373 arange.ar_length = BYTE_GET (external->ar_length);
7374 arange.ar_version = BYTE_GET (external->ar_version);
7375 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
7376 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7377 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7378
7379 if (arange.ar_version != 2)
7380 {
7381 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7382 break;
7383 }
7384
7385 printf (_(" Length: %ld\n"), arange.ar_length);
7386 printf (_(" Version: %d\n"), arange.ar_version);
7387 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
7388 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
7389 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
7390
7391 printf (_("\n Address Length\n"));
7392
7393 ranges = start + sizeof (* external);
7394
7395 /* Must pad to an alignment boundary that is twice the pointer size. */
7396 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7397 if (excess)
7398 ranges += (2 * arange.ar_pointer_size) - excess;
7399
7400 for (;;)
7401 {
7402 address = byte_get (ranges, arange.ar_pointer_size);
7403
7404 ranges += arange.ar_pointer_size;
7405
7406 length = byte_get (ranges, arange.ar_pointer_size);
7407
7408 ranges += arange.ar_pointer_size;
7409
7410 /* A pair of zeros marks the end of the list. */
7411 if (address == 0 && length == 0)
7412 break;
7413
7414 printf (" %8.8lx %lu\n", address, length);
7415 }
7416
7417 start += arange.ar_length + sizeof (external->ar_length);
7418 }
7419
7420 printf ("\n");
7421
7422 return 1;
7423 }
7424
7425 typedef struct Frame_Chunk
7426 {
7427 struct Frame_Chunk * next;
7428 unsigned char * chunk_start;
7429 int ncols;
7430 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7431 short int * col_type;
7432 int * col_offset;
7433 char * augmentation;
7434 unsigned int code_factor;
7435 int data_factor;
7436 unsigned long pc_begin;
7437 unsigned long pc_range;
7438 int cfa_reg;
7439 int cfa_offset;
7440 int ra;
7441 unsigned char fde_encoding;
7442 }
7443 Frame_Chunk;
7444
7445 /* A marker for a col_type that means this column was never referenced
7446 in the frame info. */
7447 #define DW_CFA_unreferenced (-1)
7448
7449 static void frame_need_space PARAMS ((Frame_Chunk *, int));
7450 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
7451 static int size_of_encoded_value PARAMS ((int));
7452
7453 static void
7454 frame_need_space (fc, reg)
7455 Frame_Chunk * fc;
7456 int reg;
7457 {
7458 int prev = fc->ncols;
7459
7460 if (reg < fc->ncols)
7461 return;
7462
7463 fc->ncols = reg + 1;
7464 fc->col_type = (short int *) xrealloc (fc->col_type,
7465 fc->ncols * sizeof (short int));
7466 fc->col_offset = (int *) xrealloc (fc->col_offset,
7467 fc->ncols * sizeof (int));
7468
7469 while (prev < fc->ncols)
7470 {
7471 fc->col_type[prev] = DW_CFA_unreferenced;
7472 fc->col_offset[prev] = 0;
7473 prev++;
7474 }
7475 }
7476
7477 static void
7478 frame_display_row (fc, need_col_headers, max_regs)
7479 Frame_Chunk * fc;
7480 int * need_col_headers;
7481 int * max_regs;
7482 {
7483 int r;
7484 char tmp[100];
7485
7486 if (* max_regs < fc->ncols)
7487 * max_regs = fc->ncols;
7488
7489 if (* need_col_headers)
7490 {
7491 * need_col_headers = 0;
7492
7493 printf (" LOC CFA ");
7494
7495 for (r = 0; r < * max_regs; r++)
7496 if (fc->col_type[r] != DW_CFA_unreferenced)
7497 {
7498 if (r == fc->ra)
7499 printf ("ra ");
7500 else
7501 printf ("r%-4d", r);
7502 }
7503
7504 printf ("\n");
7505 }
7506
7507 printf ("%08lx ", fc->pc_begin);
7508 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
7509 printf ("%-8s ", tmp);
7510
7511 for (r = 0; r < fc->ncols; r++)
7512 {
7513 if (fc->col_type[r] != DW_CFA_unreferenced)
7514 {
7515 switch (fc->col_type[r])
7516 {
7517 case DW_CFA_undefined:
7518 strcpy (tmp, "u");
7519 break;
7520 case DW_CFA_same_value:
7521 strcpy (tmp, "s");
7522 break;
7523 case DW_CFA_offset:
7524 sprintf (tmp, "c%+d", fc->col_offset[r]);
7525 break;
7526 case DW_CFA_register:
7527 sprintf (tmp, "r%d", fc->col_offset[r]);
7528 break;
7529 default:
7530 strcpy (tmp, "n/a");
7531 break;
7532 }
7533 printf ("%-5s", tmp);
7534 }
7535 }
7536 printf ("\n");
7537 }
7538
7539 static int
7540 size_of_encoded_value (encoding)
7541 int encoding;
7542 {
7543 switch (encoding & 0x7)
7544 {
7545 default: /* ??? */
7546 case 0: return is_32bit_elf ? 4 : 8;
7547 case 2: return 2;
7548 case 3: return 4;
7549 case 4: return 8;
7550 }
7551 }
7552
7553 #define GET(N) byte_get (start, N); start += N
7554 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7555 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7556
7557 static int
7558 display_debug_frames (section, start, file)
7559 Elf32_Internal_Shdr * section;
7560 unsigned char * start;
7561 FILE * file ATTRIBUTE_UNUSED;
7562 {
7563 unsigned char * end = start + section->sh_size;
7564 unsigned char * section_start = start;
7565 Frame_Chunk * chunks = 0;
7566 Frame_Chunk * remembered_state = 0;
7567 Frame_Chunk * rs;
7568 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7569 int length_return;
7570 int max_regs = 0;
7571 int addr_size = is_32bit_elf ? 4 : 8;
7572
7573 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7574
7575 while (start < end)
7576 {
7577 unsigned char * saved_start;
7578 unsigned char * block_end;
7579 unsigned long length;
7580 unsigned long cie_id;
7581 Frame_Chunk * fc;
7582 Frame_Chunk * cie;
7583 int need_col_headers = 1;
7584 unsigned char * augmentation_data = NULL;
7585 unsigned long augmentation_data_len = 0;
7586 int encoded_ptr_size = addr_size;
7587
7588 saved_start = start;
7589 length = byte_get (start, 4); start += 4;
7590
7591 if (length == 0)
7592 return 1;
7593
7594 block_end = saved_start + length + 4;
7595 cie_id = byte_get (start, 4); start += 4;
7596
7597 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7598 {
7599 int version;
7600
7601 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7602 memset (fc, 0, sizeof (Frame_Chunk));
7603
7604 fc->next = chunks;
7605 chunks = fc;
7606 fc->chunk_start = saved_start;
7607 fc->ncols = 0;
7608 fc->col_type = (short int *) xmalloc (sizeof (short int));
7609 fc->col_offset = (int *) xmalloc (sizeof (int));
7610 frame_need_space (fc, max_regs-1);
7611
7612 version = *start++;
7613
7614 fc->augmentation = start;
7615 start = strchr (start, '\0') + 1;
7616
7617 if (fc->augmentation[0] == 'z')
7618 {
7619 fc->code_factor = LEB ();
7620 fc->data_factor = SLEB ();
7621 fc->ra = byte_get (start, 1); start += 1;
7622 augmentation_data_len = LEB ();
7623 augmentation_data = start;
7624 start += augmentation_data_len;
7625 }
7626 else if (strcmp (fc->augmentation, "eh") == 0)
7627 {
7628 start += addr_size;
7629 fc->code_factor = LEB ();
7630 fc->data_factor = SLEB ();
7631 fc->ra = byte_get (start, 1); start += 1;
7632 }
7633 else
7634 {
7635 fc->code_factor = LEB ();
7636 fc->data_factor = SLEB ();
7637 fc->ra = byte_get (start, 1); start += 1;
7638 }
7639 cie = fc;
7640
7641 if (do_debug_frames_interp)
7642 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7643 (unsigned long)(saved_start - section_start), length, cie_id,
7644 fc->augmentation, fc->code_factor, fc->data_factor,
7645 fc->ra);
7646 else
7647 {
7648 printf ("\n%08lx %08lx %08lx CIE\n",
7649 (unsigned long)(saved_start - section_start), length, cie_id);
7650 printf (" Version: %d\n", version);
7651 printf (" Augmentation: \"%s\"\n", fc->augmentation);
7652 printf (" Code alignment factor: %u\n", fc->code_factor);
7653 printf (" Data alignment factor: %d\n", fc->data_factor);
7654 printf (" Return address column: %d\n", fc->ra);
7655
7656 if (augmentation_data_len)
7657 {
7658 unsigned long i;
7659 printf (" Augmentation data: ");
7660 for (i = 0; i < augmentation_data_len; ++i)
7661 printf (" %02x", augmentation_data[i]);
7662 putchar ('\n');
7663 }
7664 putchar ('\n');
7665 }
7666
7667 if (augmentation_data_len)
7668 {
7669 unsigned char *p, *q;
7670 p = fc->augmentation + 1;
7671 q = augmentation_data;
7672
7673 while (1)
7674 {
7675 if (*p == 'L')
7676 q++;
7677 else if (*p == 'P')
7678 q += 1 + size_of_encoded_value (*q);
7679 else if (*p == 'R')
7680 fc->fde_encoding = *q++;
7681 else
7682 break;
7683 p++;
7684 }
7685
7686 if (fc->fde_encoding)
7687 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7688 }
7689
7690 frame_need_space (fc, fc->ra);
7691 }
7692 else
7693 {
7694 unsigned char * look_for;
7695 static Frame_Chunk fde_fc;
7696
7697 fc = & fde_fc;
7698 memset (fc, 0, sizeof (Frame_Chunk));
7699
7700 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
7701
7702 for (cie=chunks; cie ; cie = cie->next)
7703 if (cie->chunk_start == look_for)
7704 break;
7705
7706 if (!cie)
7707 {
7708 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7709 cie_id, saved_start);
7710 start = block_end;
7711 fc->ncols = 0;
7712 fc->col_type = (short int *) xmalloc (sizeof (short int));
7713 fc->col_offset = (int *) xmalloc (sizeof (int));
7714 frame_need_space (fc, max_regs - 1);
7715 cie = fc;
7716 fc->augmentation = "";
7717 fc->fde_encoding = 0;
7718 }
7719 else
7720 {
7721 fc->ncols = cie->ncols;
7722 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7723 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7724 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7725 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7726 fc->augmentation = cie->augmentation;
7727 fc->code_factor = cie->code_factor;
7728 fc->data_factor = cie->data_factor;
7729 fc->cfa_reg = cie->cfa_reg;
7730 fc->cfa_offset = cie->cfa_offset;
7731 fc->ra = cie->ra;
7732 frame_need_space (fc, max_regs-1);
7733 fc->fde_encoding = cie->fde_encoding;
7734 }
7735
7736 if (fc->fde_encoding)
7737 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7738
7739 fc->pc_begin = byte_get (start, encoded_ptr_size);
7740 start += encoded_ptr_size;
7741 fc->pc_range = byte_get (start, encoded_ptr_size);
7742 start += encoded_ptr_size;
7743
7744 if (cie->augmentation[0] == 'z')
7745 {
7746 augmentation_data_len = LEB ();
7747 augmentation_data = start;
7748 start += augmentation_data_len;
7749 }
7750
7751 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7752 (unsigned long)(saved_start - section_start), length, cie_id,
7753 (unsigned long)(cie->chunk_start - section_start),
7754 fc->pc_begin, fc->pc_begin + fc->pc_range);
7755 if (! do_debug_frames_interp && augmentation_data_len)
7756 {
7757 unsigned long i;
7758 printf (" Augmentation data: ");
7759 for (i = 0; i < augmentation_data_len; ++i)
7760 printf (" %02x", augmentation_data[i]);
7761 putchar ('\n');
7762 putchar ('\n');
7763 }
7764 }
7765
7766 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7767 about to interpret instructions for the chunk. */
7768
7769 if (do_debug_frames_interp)
7770 {
7771 /* Start by making a pass over the chunk, allocating storage
7772 and taking note of what registers are used. */
7773 unsigned char * tmp = start;
7774
7775 while (start < block_end)
7776 {
7777 unsigned op, opa;
7778 unsigned long reg;
7779
7780 op = * start ++;
7781 opa = op & 0x3f;
7782 if (op & 0xc0)
7783 op &= 0xc0;
7784
7785 /* Warning: if you add any more cases to this switch, be
7786 sure to add them to the corresponding switch below. */
7787 switch (op)
7788 {
7789 case DW_CFA_advance_loc:
7790 break;
7791 case DW_CFA_offset:
7792 LEB ();
7793 frame_need_space (fc, opa);
7794 fc->col_type[opa] = DW_CFA_undefined;
7795 break;
7796 case DW_CFA_restore:
7797 frame_need_space (fc, opa);
7798 fc->col_type[opa] = DW_CFA_undefined;
7799 break;
7800 case DW_CFA_set_loc:
7801 start += encoded_ptr_size;
7802 break;
7803 case DW_CFA_advance_loc1:
7804 start += 1;
7805 break;
7806 case DW_CFA_advance_loc2:
7807 start += 2;
7808 break;
7809 case DW_CFA_advance_loc4:
7810 start += 4;
7811 break;
7812 case DW_CFA_offset_extended:
7813 reg = LEB (); LEB ();
7814 frame_need_space (fc, reg);
7815 fc->col_type[reg] = DW_CFA_undefined;
7816 break;
7817 case DW_CFA_restore_extended:
7818 reg = LEB ();
7819 frame_need_space (fc, reg);
7820 fc->col_type[reg] = DW_CFA_undefined;
7821 break;
7822 case DW_CFA_undefined:
7823 reg = LEB ();
7824 frame_need_space (fc, reg);
7825 fc->col_type[reg] = DW_CFA_undefined;
7826 break;
7827 case DW_CFA_same_value:
7828 reg = LEB ();
7829 frame_need_space (fc, reg);
7830 fc->col_type[reg] = DW_CFA_undefined;
7831 break;
7832 case DW_CFA_register:
7833 reg = LEB (); LEB ();
7834 frame_need_space (fc, reg);
7835 fc->col_type[reg] = DW_CFA_undefined;
7836 break;
7837 case DW_CFA_def_cfa:
7838 LEB (); LEB ();
7839 break;
7840 case DW_CFA_def_cfa_register:
7841 LEB ();
7842 break;
7843 case DW_CFA_def_cfa_offset:
7844 LEB ();
7845 break;
7846 #ifndef DW_CFA_GNU_args_size
7847 #define DW_CFA_GNU_args_size 0x2e
7848 #endif
7849 case DW_CFA_GNU_args_size:
7850 LEB ();
7851 break;
7852 #ifndef DW_CFA_GNU_negative_offset_extended
7853 #define DW_CFA_GNU_negative_offset_extended 0x2f
7854 #endif
7855 case DW_CFA_GNU_negative_offset_extended:
7856 reg = LEB (); LEB ();
7857 frame_need_space (fc, reg);
7858 fc->col_type[reg] = DW_CFA_undefined;
7859
7860 default:
7861 break;
7862 }
7863 }
7864 start = tmp;
7865 }
7866
7867 /* Now we know what registers are used, make a second pass over
7868 the chunk, this time actually printing out the info. */
7869
7870 while (start < block_end)
7871 {
7872 unsigned op, opa;
7873 unsigned long ul, reg, roffs;
7874 long l, ofs;
7875 bfd_vma vma;
7876
7877 op = * start ++;
7878 opa = op & 0x3f;
7879 if (op & 0xc0)
7880 op &= 0xc0;
7881
7882 /* Warning: if you add any more cases to this switch, be
7883 sure to add them to the corresponding switch above. */
7884 switch (op)
7885 {
7886 case DW_CFA_advance_loc:
7887 if (do_debug_frames_interp)
7888 frame_display_row (fc, &need_col_headers, &max_regs);
7889 else
7890 printf (" DW_CFA_advance_loc: %d to %08lx\n",
7891 opa * fc->code_factor,
7892 fc->pc_begin + opa * fc->code_factor);
7893 fc->pc_begin += opa * fc->code_factor;
7894 break;
7895
7896 case DW_CFA_offset:
7897 roffs = LEB ();
7898 if (! do_debug_frames_interp)
7899 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
7900 opa, roffs * fc->data_factor);
7901 fc->col_type[opa] = DW_CFA_offset;
7902 fc->col_offset[opa] = roffs * fc->data_factor;
7903 break;
7904
7905 case DW_CFA_restore:
7906 if (! do_debug_frames_interp)
7907 printf (" DW_CFA_restore: r%d\n", opa);
7908 fc->col_type[opa] = cie->col_type[opa];
7909 fc->col_offset[opa] = cie->col_offset[opa];
7910 break;
7911
7912 case DW_CFA_set_loc:
7913 vma = byte_get (start, encoded_ptr_size);
7914 start += encoded_ptr_size;
7915 if (do_debug_frames_interp)
7916 frame_display_row (fc, &need_col_headers, &max_regs);
7917 else
7918 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
7919 fc->pc_begin = vma;
7920 break;
7921
7922 case DW_CFA_advance_loc1:
7923 ofs = byte_get (start, 1); start += 1;
7924 if (do_debug_frames_interp)
7925 frame_display_row (fc, &need_col_headers, &max_regs);
7926 else
7927 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
7928 ofs * fc->code_factor,
7929 fc->pc_begin + ofs * fc->code_factor);
7930 fc->pc_begin += ofs * fc->code_factor;
7931 break;
7932
7933 case DW_CFA_advance_loc2:
7934 ofs = byte_get (start, 2); start += 2;
7935 if (do_debug_frames_interp)
7936 frame_display_row (fc, &need_col_headers, &max_regs);
7937 else
7938 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
7939 ofs * fc->code_factor,
7940 fc->pc_begin + ofs * fc->code_factor);
7941 fc->pc_begin += ofs * fc->code_factor;
7942 break;
7943
7944 case DW_CFA_advance_loc4:
7945 ofs = byte_get (start, 4); start += 4;
7946 if (do_debug_frames_interp)
7947 frame_display_row (fc, &need_col_headers, &max_regs);
7948 else
7949 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
7950 ofs * fc->code_factor,
7951 fc->pc_begin + ofs * fc->code_factor);
7952 fc->pc_begin += ofs * fc->code_factor;
7953 break;
7954
7955 case DW_CFA_offset_extended:
7956 reg = LEB ();
7957 roffs = LEB ();
7958 if (! do_debug_frames_interp)
7959 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
7960 reg, roffs * fc->data_factor);
7961 fc->col_type[reg] = DW_CFA_offset;
7962 fc->col_offset[reg] = roffs * fc->data_factor;
7963 break;
7964
7965 case DW_CFA_restore_extended:
7966 reg = LEB ();
7967 if (! do_debug_frames_interp)
7968 printf (" DW_CFA_restore_extended: r%ld\n", reg);
7969 fc->col_type[reg] = cie->col_type[reg];
7970 fc->col_offset[reg] = cie->col_offset[reg];
7971 break;
7972
7973 case DW_CFA_undefined:
7974 reg = LEB ();
7975 if (! do_debug_frames_interp)
7976 printf (" DW_CFA_undefined: r%ld\n", reg);
7977 fc->col_type[reg] = DW_CFA_undefined;
7978 fc->col_offset[reg] = 0;
7979 break;
7980
7981 case DW_CFA_same_value:
7982 reg = LEB ();
7983 if (! do_debug_frames_interp)
7984 printf (" DW_CFA_same_value: r%ld\n", reg);
7985 fc->col_type[reg] = DW_CFA_same_value;
7986 fc->col_offset[reg] = 0;
7987 break;
7988
7989 case DW_CFA_register:
7990 reg = LEB ();
7991 roffs = LEB ();
7992 if (! do_debug_frames_interp)
7993 printf (" DW_CFA_register: r%ld\n", reg);
7994 fc->col_type[reg] = DW_CFA_register;
7995 fc->col_offset[reg] = roffs;
7996 break;
7997
7998 case DW_CFA_remember_state:
7999 if (! do_debug_frames_interp)
8000 printf (" DW_CFA_remember_state\n");
8001 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8002 rs->ncols = fc->ncols;
8003 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8004 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8005 memcpy (rs->col_type, fc->col_type, rs->ncols);
8006 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8007 rs->next = remembered_state;
8008 remembered_state = rs;
8009 break;
8010
8011 case DW_CFA_restore_state:
8012 if (! do_debug_frames_interp)
8013 printf (" DW_CFA_restore_state\n");
8014 rs = remembered_state;
8015 remembered_state = rs->next;
8016 frame_need_space (fc, rs->ncols-1);
8017 memcpy (fc->col_type, rs->col_type, rs->ncols);
8018 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8019 free (rs->col_type);
8020 free (rs->col_offset);
8021 free (rs);
8022 break;
8023
8024 case DW_CFA_def_cfa:
8025 fc->cfa_reg = LEB ();
8026 fc->cfa_offset = LEB ();
8027 if (! do_debug_frames_interp)
8028 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8029 fc->cfa_reg, fc->cfa_offset);
8030 break;
8031
8032 case DW_CFA_def_cfa_register:
8033 fc->cfa_reg = LEB ();
8034 if (! do_debug_frames_interp)
8035 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8036 break;
8037
8038 case DW_CFA_def_cfa_offset:
8039 fc->cfa_offset = LEB ();
8040 if (! do_debug_frames_interp)
8041 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8042 break;
8043
8044 case DW_CFA_nop:
8045 if (! do_debug_frames_interp)
8046 printf (" DW_CFA_nop\n");
8047 break;
8048
8049 #ifndef DW_CFA_GNU_window_save
8050 #define DW_CFA_GNU_window_save 0x2d
8051 #endif
8052 case DW_CFA_GNU_window_save:
8053 if (! do_debug_frames_interp)
8054 printf (" DW_CFA_GNU_window_save\n");
8055 break;
8056
8057 case DW_CFA_GNU_args_size:
8058 ul = LEB ();
8059 if (! do_debug_frames_interp)
8060 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8061 break;
8062
8063 case DW_CFA_GNU_negative_offset_extended:
8064 reg = LEB ();
8065 l = - LEB ();
8066 frame_need_space (fc, reg);
8067 if (! do_debug_frames_interp)
8068 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8069 reg, l * fc->data_factor);
8070 fc->col_type[reg] = DW_CFA_offset;
8071 fc->col_offset[reg] = l * fc->data_factor;
8072 break;
8073
8074 default:
8075 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8076 start = block_end;
8077 }
8078 }
8079
8080 if (do_debug_frames_interp)
8081 frame_display_row (fc, &need_col_headers, &max_regs);
8082
8083 start = block_end;
8084 }
8085
8086 printf ("\n");
8087
8088 return 1;
8089 }
8090
8091 #undef GET
8092 #undef LEB
8093 #undef SLEB
8094
8095 static int
8096 display_debug_not_supported (section, start, file)
8097 Elf32_Internal_Shdr * section;
8098 unsigned char * start ATTRIBUTE_UNUSED;
8099 FILE * file ATTRIBUTE_UNUSED;
8100 {
8101 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8102 SECTION_NAME (section));
8103
8104 return 1;
8105 }
8106
8107 /* Pre-scan the .debug_info section to record the size of address.
8108 When dumping the .debug_line, we use that size information, assuming
8109 that all compilation units have the same address size. */
8110 static int
8111 prescan_debug_info (section, start, file)
8112 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8113 unsigned char * start;
8114 FILE * file ATTRIBUTE_UNUSED;
8115 {
8116 DWARF2_External_CompUnit * external;
8117
8118 external = (DWARF2_External_CompUnit *) start;
8119
8120 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8121 return 0;
8122 }
8123
8124 /* A structure containing the name of a debug section and a pointer
8125 to a function that can decode it. The third field is a prescan
8126 function to be run over the section before displaying any of the
8127 sections. */
8128 struct
8129 {
8130 char * name;
8131 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8132 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8133 }
8134 debug_displays[] =
8135 {
8136 { ".debug_info", display_debug_info, prescan_debug_info },
8137 { ".debug_abbrev", display_debug_abbrev, NULL },
8138 { ".debug_line", display_debug_lines, NULL },
8139 { ".debug_aranges", display_debug_aranges, NULL },
8140 { ".debug_pubnames", display_debug_pubnames, NULL },
8141 { ".debug_frame", display_debug_frames, NULL },
8142 { ".eh_frame", display_debug_frames, NULL },
8143 { ".debug_macinfo", display_debug_macinfo, NULL },
8144 { ".debug_str", display_debug_not_supported, NULL },
8145 { ".debug_static_func", display_debug_not_supported, NULL },
8146 { ".debug_static_vars", display_debug_not_supported, NULL },
8147 { ".debug_types", display_debug_not_supported, NULL },
8148 { ".debug_weaknames", display_debug_not_supported, NULL }
8149 };
8150
8151 static int
8152 display_debug_section (section, file)
8153 Elf32_Internal_Shdr * section;
8154 FILE * file;
8155 {
8156 char * name = SECTION_NAME (section);
8157 bfd_size_type length;
8158 unsigned char * start;
8159 int i;
8160
8161 length = section->sh_size;
8162 if (length == 0)
8163 {
8164 printf (_("\nSection '%s' has no debugging data.\n"), name);
8165 return 0;
8166 }
8167
8168 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8169 _("debug section data"));
8170 if (!start)
8171 return 0;
8172
8173 /* See if we know how to display the contents of this section. */
8174 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8175 name = ".debug_info";
8176
8177 for (i = NUM_ELEM (debug_displays); i--;)
8178 if (strcmp (debug_displays[i].name, name) == 0)
8179 {
8180 debug_displays[i].display (section, start, file);
8181 break;
8182 }
8183
8184 if (i == -1)
8185 printf (_("Unrecognised debug section: %s\n"), name);
8186
8187 free (start);
8188
8189 /* If we loaded in the abbrev section at some point,
8190 we must release it here. */
8191 if (first_abbrev != NULL)
8192 free_abbrevs ();
8193
8194 return 1;
8195 }
8196
8197 static int
8198 process_section_contents (file)
8199 FILE * file;
8200 {
8201 Elf32_Internal_Shdr * section;
8202 unsigned int i;
8203
8204 if (! do_dump)
8205 return 1;
8206
8207 /* Pre-scan the debug sections to find some debug information not
8208 present in some of them. For the .debug_line, we must find out the
8209 size of address (specified in .debug_info and .debug_aranges). */
8210 for (i = 0, section = section_headers;
8211 i < elf_header.e_shnum && i < num_dump_sects;
8212 i ++, section ++)
8213 {
8214 char * name = SECTION_NAME (section);
8215 int j;
8216
8217 if (section->sh_size == 0)
8218 continue;
8219
8220 /* See if there is some pre-scan operation for this section. */
8221 for (j = NUM_ELEM (debug_displays); j--;)
8222 if (strcmp (debug_displays[j].name, name) == 0)
8223 {
8224 if (debug_displays[j].prescan != NULL)
8225 {
8226 bfd_size_type length;
8227 unsigned char * start;
8228
8229 length = section->sh_size;
8230 start = ((unsigned char *)
8231 get_data (NULL, file, section->sh_offset, length,
8232 _("debug section data")));
8233 if (!start)
8234 return 0;
8235
8236 debug_displays[j].prescan (section, start, file);
8237 free (start);
8238 }
8239
8240 break;
8241 }
8242 }
8243
8244 for (i = 0, section = section_headers;
8245 i < elf_header.e_shnum && i < num_dump_sects;
8246 i ++, section ++)
8247 {
8248 #ifdef SUPPORT_DISASSEMBLY
8249 if (dump_sects[i] & DISASS_DUMP)
8250 disassemble_section (section, file);
8251 #endif
8252 if (dump_sects[i] & HEX_DUMP)
8253 dump_section (section, file);
8254
8255 if (dump_sects[i] & DEBUG_DUMP)
8256 display_debug_section (section, file);
8257 }
8258
8259 if (i < num_dump_sects)
8260 warn (_("Some sections were not dumped because they do not exist!\n"));
8261
8262 return 1;
8263 }
8264
8265 static void
8266 process_mips_fpe_exception (mask)
8267 int mask;
8268 {
8269 if (mask)
8270 {
8271 int first = 1;
8272 if (mask & OEX_FPU_INEX)
8273 fputs ("INEX", stdout), first = 0;
8274 if (mask & OEX_FPU_UFLO)
8275 printf ("%sUFLO", first ? "" : "|"), first = 0;
8276 if (mask & OEX_FPU_OFLO)
8277 printf ("%sOFLO", first ? "" : "|"), first = 0;
8278 if (mask & OEX_FPU_DIV0)
8279 printf ("%sDIV0", first ? "" : "|"), first = 0;
8280 if (mask & OEX_FPU_INVAL)
8281 printf ("%sINVAL", first ? "" : "|");
8282 }
8283 else
8284 fputs ("0", stdout);
8285 }
8286
8287 static int
8288 process_mips_specific (file)
8289 FILE * file;
8290 {
8291 Elf_Internal_Dyn * entry;
8292 size_t liblist_offset = 0;
8293 size_t liblistno = 0;
8294 size_t conflictsno = 0;
8295 size_t options_offset = 0;
8296 size_t conflicts_offset = 0;
8297
8298 /* We have a lot of special sections. Thanks SGI! */
8299 if (dynamic_segment == NULL)
8300 /* No information available. */
8301 return 0;
8302
8303 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8304 switch (entry->d_tag)
8305 {
8306 case DT_MIPS_LIBLIST:
8307 liblist_offset = entry->d_un.d_val - loadaddr;
8308 break;
8309 case DT_MIPS_LIBLISTNO:
8310 liblistno = entry->d_un.d_val;
8311 break;
8312 case DT_MIPS_OPTIONS:
8313 options_offset = entry->d_un.d_val - loadaddr;
8314 break;
8315 case DT_MIPS_CONFLICT:
8316 conflicts_offset = entry->d_un.d_val - loadaddr;
8317 break;
8318 case DT_MIPS_CONFLICTNO:
8319 conflictsno = entry->d_un.d_val;
8320 break;
8321 default:
8322 break;
8323 }
8324
8325 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8326 {
8327 Elf32_External_Lib * elib;
8328 size_t cnt;
8329
8330 elib = ((Elf32_External_Lib *)
8331 get_data (NULL, file, liblist_offset,
8332 liblistno * sizeof (Elf32_External_Lib),
8333 _("liblist")));
8334 if (elib)
8335 {
8336 printf ("\nSection '.liblist' contains %lu entries:\n",
8337 (unsigned long) liblistno);
8338 fputs (" Library Time Stamp Checksum Version Flags\n",
8339 stdout);
8340
8341 for (cnt = 0; cnt < liblistno; ++cnt)
8342 {
8343 Elf32_Lib liblist;
8344 time_t time;
8345 char timebuf[20];
8346 struct tm * tmp;
8347
8348 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8349 time = BYTE_GET (elib[cnt].l_time_stamp);
8350 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8351 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8352 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8353
8354 tmp = gmtime (&time);
8355 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8356 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8357 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8358
8359 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
8360 dynamic_strings + liblist.l_name, timebuf,
8361 liblist.l_checksum, liblist.l_version);
8362
8363 if (liblist.l_flags == 0)
8364 puts (" NONE");
8365 else
8366 {
8367 static const struct
8368 {
8369 const char * name;
8370 int bit;
8371 }
8372 l_flags_vals[] =
8373 {
8374 { " EXACT_MATCH", LL_EXACT_MATCH },
8375 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8376 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8377 { " EXPORTS", LL_EXPORTS },
8378 { " DELAY_LOAD", LL_DELAY_LOAD },
8379 { " DELTA", LL_DELTA }
8380 };
8381 int flags = liblist.l_flags;
8382 size_t fcnt;
8383
8384 for (fcnt = 0;
8385 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8386 ++fcnt)
8387 if ((flags & l_flags_vals[fcnt].bit) != 0)
8388 {
8389 fputs (l_flags_vals[fcnt].name, stdout);
8390 flags ^= l_flags_vals[fcnt].bit;
8391 }
8392 if (flags != 0)
8393 printf (" %#x", (unsigned int) flags);
8394
8395 puts ("");
8396 }
8397 }
8398
8399 free (elib);
8400 }
8401 }
8402
8403 if (options_offset != 0)
8404 {
8405 Elf_External_Options * eopt;
8406 Elf_Internal_Shdr * sect = section_headers;
8407 Elf_Internal_Options * iopt;
8408 Elf_Internal_Options * option;
8409 size_t offset;
8410 int cnt;
8411
8412 /* Find the section header so that we get the size. */
8413 while (sect->sh_type != SHT_MIPS_OPTIONS)
8414 ++ sect;
8415
8416 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
8417 sect->sh_size, _("options"));
8418 if (eopt)
8419 {
8420 iopt = ((Elf_Internal_Options *)
8421 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
8422 if (iopt == NULL)
8423 {
8424 error (_("Out of memory"));
8425 return 0;
8426 }
8427
8428 offset = cnt = 0;
8429 option = iopt;
8430
8431 while (offset < sect->sh_size)
8432 {
8433 Elf_External_Options * eoption;
8434
8435 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8436
8437 option->kind = BYTE_GET (eoption->kind);
8438 option->size = BYTE_GET (eoption->size);
8439 option->section = BYTE_GET (eoption->section);
8440 option->info = BYTE_GET (eoption->info);
8441
8442 offset += option->size;
8443
8444 ++option;
8445 ++cnt;
8446 }
8447
8448 printf (_("\nSection '%s' contains %d entries:\n"),
8449 SECTION_NAME (sect), cnt);
8450
8451 option = iopt;
8452
8453 while (cnt-- > 0)
8454 {
8455 size_t len;
8456
8457 switch (option->kind)
8458 {
8459 case ODK_NULL:
8460 /* This shouldn't happen. */
8461 printf (" NULL %d %lx", option->section, option->info);
8462 break;
8463 case ODK_REGINFO:
8464 printf (" REGINFO ");
8465 if (elf_header.e_machine == EM_MIPS)
8466 {
8467 /* 32bit form. */
8468 Elf32_External_RegInfo * ereg;
8469 Elf32_RegInfo reginfo;
8470
8471 ereg = (Elf32_External_RegInfo *) (option + 1);
8472 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8473 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8474 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8475 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8476 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8477 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8478
8479 printf ("GPR %08lx GP 0x%lx\n",
8480 reginfo.ri_gprmask,
8481 (unsigned long) reginfo.ri_gp_value);
8482 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8483 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8484 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8485 }
8486 else
8487 {
8488 /* 64 bit form. */
8489 Elf64_External_RegInfo * ereg;
8490 Elf64_Internal_RegInfo reginfo;
8491
8492 ereg = (Elf64_External_RegInfo *) (option + 1);
8493 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8494 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8495 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8496 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8497 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8498 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
8499
8500 printf ("GPR %08lx GP 0x",
8501 reginfo.ri_gprmask);
8502 printf_vma (reginfo.ri_gp_value);
8503 printf ("\n");
8504
8505 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8506 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8507 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8508 }
8509 ++option;
8510 continue;
8511 case ODK_EXCEPTIONS:
8512 fputs (" EXCEPTIONS fpe_min(", stdout);
8513 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8514 fputs (") fpe_max(", stdout);
8515 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8516 fputs (")", stdout);
8517
8518 if (option->info & OEX_PAGE0)
8519 fputs (" PAGE0", stdout);
8520 if (option->info & OEX_SMM)
8521 fputs (" SMM", stdout);
8522 if (option->info & OEX_FPDBUG)
8523 fputs (" FPDBUG", stdout);
8524 if (option->info & OEX_DISMISS)
8525 fputs (" DISMISS", stdout);
8526 break;
8527 case ODK_PAD:
8528 fputs (" PAD ", stdout);
8529 if (option->info & OPAD_PREFIX)
8530 fputs (" PREFIX", stdout);
8531 if (option->info & OPAD_POSTFIX)
8532 fputs (" POSTFIX", stdout);
8533 if (option->info & OPAD_SYMBOL)
8534 fputs (" SYMBOL", stdout);
8535 break;
8536 case ODK_HWPATCH:
8537 fputs (" HWPATCH ", stdout);
8538 if (option->info & OHW_R4KEOP)
8539 fputs (" R4KEOP", stdout);
8540 if (option->info & OHW_R8KPFETCH)
8541 fputs (" R8KPFETCH", stdout);
8542 if (option->info & OHW_R5KEOP)
8543 fputs (" R5KEOP", stdout);
8544 if (option->info & OHW_R5KCVTL)
8545 fputs (" R5KCVTL", stdout);
8546 break;
8547 case ODK_FILL:
8548 fputs (" FILL ", stdout);
8549 /* XXX Print content of info word? */
8550 break;
8551 case ODK_TAGS:
8552 fputs (" TAGS ", stdout);
8553 /* XXX Print content of info word? */
8554 break;
8555 case ODK_HWAND:
8556 fputs (" HWAND ", stdout);
8557 if (option->info & OHWA0_R4KEOP_CHECKED)
8558 fputs (" R4KEOP_CHECKED", stdout);
8559 if (option->info & OHWA0_R4KEOP_CLEAN)
8560 fputs (" R4KEOP_CLEAN", stdout);
8561 break;
8562 case ODK_HWOR:
8563 fputs (" HWOR ", stdout);
8564 if (option->info & OHWA0_R4KEOP_CHECKED)
8565 fputs (" R4KEOP_CHECKED", stdout);
8566 if (option->info & OHWA0_R4KEOP_CLEAN)
8567 fputs (" R4KEOP_CLEAN", stdout);
8568 break;
8569 case ODK_GP_GROUP:
8570 printf (" GP_GROUP %#06lx self-contained %#06lx",
8571 option->info & OGP_GROUP,
8572 (option->info & OGP_SELF) >> 16);
8573 break;
8574 case ODK_IDENT:
8575 printf (" IDENT %#06lx self-contained %#06lx",
8576 option->info & OGP_GROUP,
8577 (option->info & OGP_SELF) >> 16);
8578 break;
8579 default:
8580 /* This shouldn't happen. */
8581 printf (" %3d ??? %d %lx",
8582 option->kind, option->section, option->info);
8583 break;
8584 }
8585
8586 len = sizeof (* eopt);
8587 while (len < option->size)
8588 if (((char *) option)[len] >= ' '
8589 && ((char *) option)[len] < 0x7f)
8590 printf ("%c", ((char *) option)[len++]);
8591 else
8592 printf ("\\%03o", ((char *) option)[len++]);
8593
8594 fputs ("\n", stdout);
8595 ++option;
8596 }
8597
8598 free (eopt);
8599 }
8600 }
8601
8602 if (conflicts_offset != 0 && conflictsno != 0)
8603 {
8604 Elf32_Conflict * iconf;
8605 size_t cnt;
8606
8607 if (dynamic_symbols == NULL)
8608 {
8609 error (_("conflict list with without table"));
8610 return 0;
8611 }
8612
8613 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8614 if (iconf == NULL)
8615 {
8616 error (_("Out of memory"));
8617 return 0;
8618 }
8619
8620 if (is_32bit_elf)
8621 {
8622 Elf32_External_Conflict * econf32;
8623
8624 econf32 = ((Elf32_External_Conflict *)
8625 get_data (NULL, file, conflicts_offset,
8626 conflictsno * sizeof (* econf32),
8627 _("conflict")));
8628 if (!econf32)
8629 return 0;
8630
8631 for (cnt = 0; cnt < conflictsno; ++cnt)
8632 iconf[cnt] = BYTE_GET (econf32[cnt]);
8633
8634 free (econf32);
8635 }
8636 else
8637 {
8638 Elf64_External_Conflict * econf64;
8639
8640 econf64 = ((Elf64_External_Conflict *)
8641 get_data (NULL, file, conflicts_offset,
8642 conflictsno * sizeof (* econf64),
8643 _("conflict")));
8644 if (!econf64)
8645 return 0;
8646
8647 for (cnt = 0; cnt < conflictsno; ++cnt)
8648 iconf[cnt] = BYTE_GET (econf64[cnt]);
8649
8650 free (econf64);
8651 }
8652
8653 printf (_("\nSection '.conflict' contains %ld entries:\n"),
8654 (long) conflictsno);
8655 puts (_(" Num: Index Value Name"));
8656
8657 for (cnt = 0; cnt < conflictsno; ++cnt)
8658 {
8659 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8660
8661 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8662 print_vma (psym->st_value, FULL_HEX);
8663 printf (" %s\n", dynamic_strings + psym->st_name);
8664 }
8665
8666 free (iconf);
8667 }
8668
8669 return 1;
8670 }
8671
8672 static char *
8673 get_note_type (e_type)
8674 unsigned e_type;
8675 {
8676 static char buff[64];
8677
8678 switch (e_type)
8679 {
8680 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8681 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8682 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8683 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8684 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8685 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8686 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8687 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8688 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8689 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8690 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8691 default:
8692 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8693 return buff;
8694 }
8695 }
8696
8697 /* Note that by the ELF standard, the name field is already null byte
8698 terminated, and namesz includes the terminating null byte.
8699 I.E. the value of namesz for the name "FSF" is 4.
8700
8701 If the value of namesz is zero, there is no name present. */
8702 static int
8703 process_note (pnote)
8704 Elf32_Internal_Note * pnote;
8705 {
8706 printf (" %s\t\t0x%08lx\t%s\n",
8707 pnote->namesz ? pnote->namedata : "(NONE)",
8708 pnote->descsz, get_note_type (pnote->type));
8709 return 1;
8710 }
8711
8712
8713 static int
8714 process_corefile_note_segment (file, offset, length)
8715 FILE * file;
8716 bfd_vma offset;
8717 bfd_vma length;
8718 {
8719 Elf_External_Note * pnotes;
8720 Elf_External_Note * external;
8721 int res = 1;
8722
8723 if (length <= 0)
8724 return 0;
8725
8726 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
8727 _("notes"));
8728 if (!pnotes)
8729 return 0;
8730
8731 external = pnotes;
8732
8733 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8734 (unsigned long) offset, (unsigned long) length);
8735 printf (_(" Owner\t\tData size\tDescription\n"));
8736
8737 while (external < (Elf_External_Note *)((char *) pnotes + length))
8738 {
8739 Elf32_Internal_Note inote;
8740 char * temp = NULL;
8741
8742 inote.type = BYTE_GET (external->type);
8743 inote.namesz = BYTE_GET (external->namesz);
8744 inote.namedata = external->name;
8745 inote.descsz = BYTE_GET (external->descsz);
8746 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8747 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8748
8749 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8750
8751 /* Verify that name is null terminated. It appears that at least
8752 one version of Linux (RedHat 6.0) generates corefiles that don't
8753 comply with the ELF spec by failing to include the null byte in
8754 namesz. */
8755 if (inote.namedata[inote.namesz] != '\0')
8756 {
8757 temp = malloc (inote.namesz + 1);
8758
8759 if (temp == NULL)
8760 {
8761 error (_("Out of memory\n"));
8762 res = 0;
8763 break;
8764 }
8765
8766 strncpy (temp, inote.namedata, inote.namesz);
8767 temp[inote.namesz] = 0;
8768
8769 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8770 inote.namedata = temp;
8771 }
8772
8773 res &= process_note (& inote);
8774
8775 if (temp != NULL)
8776 {
8777 free (temp);
8778 temp = NULL;
8779 }
8780 }
8781
8782 free (pnotes);
8783
8784 return res;
8785 }
8786
8787 static int
8788 process_corefile_note_segments (file)
8789 FILE * file;
8790 {
8791 Elf_Internal_Phdr * program_headers;
8792 Elf_Internal_Phdr * segment;
8793 unsigned int i;
8794 int res = 1;
8795
8796 program_headers = (Elf_Internal_Phdr *) malloc
8797 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8798
8799 if (program_headers == NULL)
8800 {
8801 error (_("Out of memory\n"));
8802 return 0;
8803 }
8804
8805 if (is_32bit_elf)
8806 i = get_32bit_program_headers (file, program_headers);
8807 else
8808 i = get_64bit_program_headers (file, program_headers);
8809
8810 if (i == 0)
8811 {
8812 free (program_headers);
8813 return 0;
8814 }
8815
8816 for (i = 0, segment = program_headers;
8817 i < elf_header.e_phnum;
8818 i ++, segment ++)
8819 {
8820 if (segment->p_type == PT_NOTE)
8821 res &= process_corefile_note_segment (file,
8822 (bfd_vma) segment->p_offset,
8823 (bfd_vma) segment->p_filesz);
8824 }
8825
8826 free (program_headers);
8827
8828 return res;
8829 }
8830
8831 static int
8832 process_corefile_contents (file)
8833 FILE * file;
8834 {
8835 /* If we have not been asked to display the notes then do nothing. */
8836 if (! do_notes)
8837 return 1;
8838
8839 /* If file is not a core file then exit. */
8840 if (elf_header.e_type != ET_CORE)
8841 return 1;
8842
8843 /* No program headers means no NOTE segment. */
8844 if (elf_header.e_phnum == 0)
8845 {
8846 printf (_("No note segments present in the core file.\n"));
8847 return 1;
8848 }
8849
8850 return process_corefile_note_segments (file);
8851 }
8852
8853 static int
8854 process_arch_specific (file)
8855 FILE * file;
8856 {
8857 if (! do_arch)
8858 return 1;
8859
8860 switch (elf_header.e_machine)
8861 {
8862 case EM_MIPS:
8863 case EM_MIPS_RS3_LE:
8864 return process_mips_specific (file);
8865 break;
8866 default:
8867 break;
8868 }
8869 return 1;
8870 }
8871
8872 static int
8873 get_file_header (file)
8874 FILE * file;
8875 {
8876 /* Read in the identity array. */
8877 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8878 return 0;
8879
8880 /* Determine how to read the rest of the header. */
8881 switch (elf_header.e_ident [EI_DATA])
8882 {
8883 default: /* fall through */
8884 case ELFDATANONE: /* fall through */
8885 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8886 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8887 }
8888
8889 /* For now we only support 32 bit and 64 bit ELF files. */
8890 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8891
8892 /* Read in the rest of the header. */
8893 if (is_32bit_elf)
8894 {
8895 Elf32_External_Ehdr ehdr32;
8896
8897 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8898 return 0;
8899
8900 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8901 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8902 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8903 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8904 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8905 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8906 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8907 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8908 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8909 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8910 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8911 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8912 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8913 }
8914 else
8915 {
8916 Elf64_External_Ehdr ehdr64;
8917
8918 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8919 we will not be able to cope with the 64bit data found in
8920 64 ELF files. Detect this now and abort before we start
8921 overwritting things. */
8922 if (sizeof (bfd_vma) < 8)
8923 {
8924 error (_("This instance of readelf has been built without support for a\n"));
8925 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8926 return 0;
8927 }
8928
8929 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8930 return 0;
8931
8932 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8933 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8934 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8935 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8936 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8937 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8938 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8939 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8940 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8941 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8942 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8943 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8944 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8945 }
8946
8947 return 1;
8948 }
8949
8950 static int
8951 process_file (file_name)
8952 char * file_name;
8953 {
8954 FILE * file;
8955 struct stat statbuf;
8956 unsigned int i;
8957
8958 if (stat (file_name, & statbuf) < 0)
8959 {
8960 error (_("Cannot stat input file %s.\n"), file_name);
8961 return 1;
8962 }
8963
8964 file = fopen (file_name, "rb");
8965 if (file == NULL)
8966 {
8967 error (_("Input file %s not found.\n"), file_name);
8968 return 1;
8969 }
8970
8971 if (! get_file_header (file))
8972 {
8973 error (_("%s: Failed to read file header\n"), file_name);
8974 fclose (file);
8975 return 1;
8976 }
8977
8978 /* Initialise per file variables. */
8979 for (i = NUM_ELEM (version_info); i--;)
8980 version_info[i] = 0;
8981
8982 for (i = NUM_ELEM (dynamic_info); i--;)
8983 dynamic_info[i] = 0;
8984
8985 /* Process the file. */
8986 if (show_name)
8987 printf (_("\nFile: %s\n"), file_name);
8988
8989 if (! process_file_header ())
8990 {
8991 fclose (file);
8992 return 1;
8993 }
8994
8995 process_section_headers (file);
8996
8997 process_program_headers (file);
8998
8999 process_dynamic_segment (file);
9000
9001 process_relocs (file);
9002
9003 process_unwind (file);
9004
9005 process_symbol_table (file);
9006
9007 process_syminfo (file);
9008
9009 process_version_sections (file);
9010
9011 process_section_contents (file);
9012
9013 process_corefile_contents (file);
9014
9015 process_arch_specific (file);
9016
9017 fclose (file);
9018
9019 if (section_headers)
9020 {
9021 free (section_headers);
9022 section_headers = NULL;
9023 }
9024
9025 if (string_table)
9026 {
9027 free (string_table);
9028 string_table = NULL;
9029 string_table_length = 0;
9030 }
9031
9032 if (dynamic_strings)
9033 {
9034 free (dynamic_strings);
9035 dynamic_strings = NULL;
9036 }
9037
9038 if (dynamic_symbols)
9039 {
9040 free (dynamic_symbols);
9041 dynamic_symbols = NULL;
9042 num_dynamic_syms = 0;
9043 }
9044
9045 if (dynamic_syminfo)
9046 {
9047 free (dynamic_syminfo);
9048 dynamic_syminfo = NULL;
9049 }
9050
9051 return 0;
9052 }
9053
9054 #ifdef SUPPORT_DISASSEMBLY
9055 /* Needed by the i386 disassembler. For extra credit, someone could
9056 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9057 symbols */
9058
9059 void
9060 print_address (unsigned int addr, FILE * outfile)
9061 {
9062 fprintf (outfile,"0x%8.8x", addr);
9063 }
9064
9065 /* Needed by the i386 disassembler. */
9066 void
9067 db_task_printsym (unsigned int addr)
9068 {
9069 print_address (addr, stderr);
9070 }
9071 #endif
9072
9073 int
9074 main (argc, argv)
9075 int argc;
9076 char ** argv;
9077 {
9078 int err;
9079
9080 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9081 setlocale (LC_MESSAGES, "");
9082 #endif
9083 #if defined (HAVE_SETLOCALE)
9084 setlocale (LC_CTYPE, "");
9085 #endif
9086 bindtextdomain (PACKAGE, LOCALEDIR);
9087 textdomain (PACKAGE);
9088
9089 parse_args (argc, argv);
9090
9091 if (optind < (argc - 1))
9092 show_name = 1;
9093
9094 err = 0;
9095 while (optind < argc)
9096 err |= process_file (argv [optind ++]);
9097
9098 if (dump_sects != NULL)
9099 free (dump_sects);
9100
9101 return err;
9102 }
GDB Binutils - Deliverables
This page took 0.235038 seconds and 4 git commands to generate.