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