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