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