?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf64-alpha.c (elf64_alpha_relocate_section): Force relative relocs
[binutils.git] / binutils / readelf.c
blob77694cb80773b1ba47ce566e83db60627d225a65
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 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6533 default:
6534 {
6535 static char buffer [100];
6536
6537 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6538 return buffer;
6539 }
6540 }
6541 }
6542
6543 static char *
6544 get_FORM_name (form)
6545 unsigned long form;
6546 {
6547 switch (form)
6548 {
6549 case DW_FORM_addr: return "DW_FORM_addr";
6550 case DW_FORM_block2: return "DW_FORM_block2";
6551 case DW_FORM_block4: return "DW_FORM_block4";
6552 case DW_FORM_data2: return "DW_FORM_data2";
6553 case DW_FORM_data4: return "DW_FORM_data4";
6554 case DW_FORM_data8: return "DW_FORM_data8";
6555 case DW_FORM_string: return "DW_FORM_string";
6556 case DW_FORM_block: return "DW_FORM_block";
6557 case DW_FORM_block1: return "DW_FORM_block1";
6558 case DW_FORM_data1: return "DW_FORM_data1";
6559 case DW_FORM_flag: return "DW_FORM_flag";
6560 case DW_FORM_sdata: return "DW_FORM_sdata";
6561 case DW_FORM_strp: return "DW_FORM_strp";
6562 case DW_FORM_udata: return "DW_FORM_udata";
6563 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6564 case DW_FORM_ref1: return "DW_FORM_ref1";
6565 case DW_FORM_ref2: return "DW_FORM_ref2";
6566 case DW_FORM_ref4: return "DW_FORM_ref4";
6567 case DW_FORM_ref8: return "DW_FORM_ref8";
6568 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6569 case DW_FORM_indirect: return "DW_FORM_indirect";
6570 default:
6571 {
6572 static char buffer [100];
6573
6574 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6575 return buffer;
6576 }
6577 }
6578 }
6579
6580 /* FIXME: There are better and more effiecint ways to handle
6581 these structures. For now though, I just want something that
6582 is simple to implement. */
6583 typedef struct abbrev_attr
6584 {
6585 unsigned long attribute;
6586 unsigned long form;
6587 struct abbrev_attr * next;
6588 }
6589 abbrev_attr;
6590
6591 typedef struct abbrev_entry
6592 {
6593 unsigned long entry;
6594 unsigned long tag;
6595 int children;
6596 struct abbrev_attr * first_attr;
6597 struct abbrev_attr * last_attr;
6598 struct abbrev_entry * next;
6599 }
6600 abbrev_entry;
6601
6602 static abbrev_entry * first_abbrev = NULL;
6603 static abbrev_entry * last_abbrev = NULL;
6604
6605 static void
6606 free_abbrevs PARAMS ((void))
6607 {
6608 abbrev_entry * abbrev;
6609
6610 for (abbrev = first_abbrev; abbrev;)
6611 {
6612 abbrev_entry * next = abbrev->next;
6613 abbrev_attr * attr;
6614
6615 for (attr = abbrev->first_attr; attr;)
6616 {
6617 abbrev_attr * next = attr->next;
6618
6619 free (attr);
6620 attr = next;
6621 }
6622
6623 free (abbrev);
6624 abbrev = next;
6625 }
6626
6627 last_abbrev = first_abbrev = NULL;
6628 }
6629
6630 static void
6631 add_abbrev (number, tag, children)
6632 unsigned long number;
6633 unsigned long tag;
6634 int children;
6635 {
6636 abbrev_entry * entry;
6637
6638 entry = (abbrev_entry *) malloc (sizeof (* entry));
6639
6640 if (entry == NULL)
6641 /* ugg */
6642 return;
6643
6644 entry->entry = number;
6645 entry->tag = tag;
6646 entry->children = children;
6647 entry->first_attr = NULL;
6648 entry->last_attr = NULL;
6649 entry->next = NULL;
6650
6651 if (first_abbrev == NULL)
6652 first_abbrev = entry;
6653 else
6654 last_abbrev->next = entry;
6655
6656 last_abbrev = entry;
6657 }
6658
6659 static void
6660 add_abbrev_attr (attribute, form)
6661 unsigned long attribute;
6662 unsigned long form;
6663 {
6664 abbrev_attr * attr;
6665
6666 attr = (abbrev_attr *) malloc (sizeof (* attr));
6667
6668 if (attr == NULL)
6669 /* ugg */
6670 return;
6671
6672 attr->attribute = attribute;
6673 attr->form = form;
6674 attr->next = NULL;
6675
6676 if (last_abbrev->first_attr == NULL)
6677 last_abbrev->first_attr = attr;
6678 else
6679 last_abbrev->last_attr->next = attr;
6680
6681 last_abbrev->last_attr = attr;
6682 }
6683
6684 /* Processes the (partial) contents of a .debug_abbrev section.
6685 Returns NULL if the end of the section was encountered.
6686 Returns the address after the last byte read if the end of
6687 an abbreviation set was found. */
6688
6689 static unsigned char *
6690 process_abbrev_section (start, end)
6691 unsigned char * start;
6692 unsigned char * end;
6693 {
6694 if (first_abbrev != NULL)
6695 return NULL;
6696
6697 while (start < end)
6698 {
6699 int bytes_read;
6700 unsigned long entry;
6701 unsigned long tag;
6702 unsigned long attribute;
6703 int children;
6704
6705 entry = read_leb128 (start, & bytes_read, 0);
6706 start += bytes_read;
6707
6708 /* A single zero is supposed to end the section according
6709 to the standard. If there's more, then signal that to
6710 the caller. */
6711 if (entry == 0)
6712 return start == end ? NULL : start;
6713
6714 tag = read_leb128 (start, & bytes_read, 0);
6715 start += bytes_read;
6716
6717 children = * start ++;
6718
6719 add_abbrev (entry, tag, children);
6720
6721 do
6722 {
6723 unsigned long form;
6724
6725 attribute = read_leb128 (start, & bytes_read, 0);
6726 start += bytes_read;
6727
6728 form = read_leb128 (start, & bytes_read, 0);
6729 start += bytes_read;
6730
6731 if (attribute != 0)
6732 add_abbrev_attr (attribute, form);
6733 }
6734 while (attribute != 0);
6735 }
6736
6737 return NULL;
6738 }
6739
6740
6741 static int
6742 display_debug_macinfo (section, start, file)
6743 Elf32_Internal_Shdr * section;
6744 unsigned char * start;
6745 FILE * file ATTRIBUTE_UNUSED;
6746 {
6747 unsigned char * end = start + section->sh_size;
6748 unsigned char * curr = start;
6749 unsigned int bytes_read;
6750 enum dwarf_macinfo_record_type op;
6751
6752 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6753
6754 while (curr < end)
6755 {
6756 unsigned int lineno;
6757 const char * string;
6758
6759 op = * curr;
6760 curr ++;
6761
6762 switch (op)
6763 {
6764 case DW_MACINFO_start_file:
6765 {
6766 unsigned int filenum;
6767
6768 lineno = read_leb128 (curr, & bytes_read, 0);
6769 curr += bytes_read;
6770 filenum = read_leb128 (curr, & bytes_read, 0);
6771 curr += bytes_read;
6772
6773 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6774 }
6775 break;
6776
6777 case DW_MACINFO_end_file:
6778 printf (_(" DW_MACINFO_end_file\n"));
6779 break;
6780
6781 case DW_MACINFO_define:
6782 lineno = read_leb128 (curr, & bytes_read, 0);
6783 curr += bytes_read;
6784 string = curr;
6785 curr += strlen (string) + 1;
6786 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6787 break;
6788
6789 case DW_MACINFO_undef:
6790 lineno = read_leb128 (curr, & bytes_read, 0);
6791 curr += bytes_read;
6792 string = curr;
6793 curr += strlen (string) + 1;
6794 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6795 break;
6796
6797 case DW_MACINFO_vendor_ext:
6798 {
6799 unsigned int constant;
6800
6801 constant = read_leb128 (curr, & bytes_read, 0);
6802 curr += bytes_read;
6803 string = curr;
6804 curr += strlen (string) + 1;
6805 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6806 }
6807 break;
6808 }
6809 }
6810
6811 return 1;
6812 }
6813
6814
6815 static int
6816 display_debug_abbrev (section, start, file)
6817 Elf32_Internal_Shdr * section;
6818 unsigned char * start;
6819 FILE * file ATTRIBUTE_UNUSED;
6820 {
6821 abbrev_entry * entry;
6822 unsigned char * end = start + section->sh_size;
6823
6824 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6825
6826 do
6827 {
6828 start = process_abbrev_section (start, end);
6829
6830 if (first_abbrev == NULL)
6831 continue;
6832
6833 printf (_(" Number TAG\n"));
6834
6835 for (entry = first_abbrev; entry; entry = entry->next)
6836 {
6837 abbrev_attr * attr;
6838
6839 printf (_(" %ld %s [%s]\n"),
6840 entry->entry,
6841 get_TAG_name (entry->tag),
6842 entry->children ? _("has children") : _("no children"));
6843
6844 for (attr = entry->first_attr; attr; attr = attr->next)
6845 {
6846 printf (_(" %-18s %s\n"),
6847 get_AT_name (attr->attribute),
6848 get_FORM_name (attr->form));
6849 }
6850 }
6851
6852 free_abbrevs ();
6853 }
6854 while (start);
6855
6856 printf ("\n");
6857
6858 return 1;
6859 }
6860
6861
6862 static unsigned char *
6863 display_block (data, length)
6864 unsigned char * data;
6865 unsigned long length;
6866 {
6867 printf (_(" %lu byte block: "), length);
6868
6869 while (length --)
6870 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6871
6872 return data;
6873 }
6874
6875 static void
6876 decode_location_expression (data, pointer_size, length)
6877 unsigned char * data;
6878 unsigned int pointer_size;
6879 unsigned long length;
6880 {
6881 unsigned op;
6882 int bytes_read;
6883 unsigned long uvalue;
6884 unsigned char * end = data + length;
6885
6886 while (data < end)
6887 {
6888 op = * data ++;
6889
6890 switch (op)
6891 {
6892 case DW_OP_addr:
6893 printf ("DW_OP_addr: %lx",
6894 (unsigned long) byte_get (data, pointer_size));
6895 data += pointer_size;
6896 break;
6897 case DW_OP_deref:
6898 printf ("DW_OP_deref");
6899 break;
6900 case DW_OP_const1u:
6901 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6902 break;
6903 case DW_OP_const1s:
6904 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6905 break;
6906 case DW_OP_const2u:
6907 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6908 data += 2;
6909 break;
6910 case DW_OP_const2s:
6911 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6912 data += 2;
6913 break;
6914 case DW_OP_const4u:
6915 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6916 data += 4;
6917 break;
6918 case DW_OP_const4s:
6919 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6920 data += 4;
6921 break;
6922 case DW_OP_const8u:
6923 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6924 (unsigned long) byte_get (data + 4, 4));
6925 data += 8;
6926 break;
6927 case DW_OP_const8s:
6928 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6929 (long) byte_get (data + 4, 4));
6930 data += 8;
6931 break;
6932 case DW_OP_constu:
6933 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6934 data += bytes_read;
6935 break;
6936 case DW_OP_consts:
6937 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6938 data += bytes_read;
6939 break;
6940 case DW_OP_dup:
6941 printf ("DW_OP_dup");
6942 break;
6943 case DW_OP_drop:
6944 printf ("DW_OP_drop");
6945 break;
6946 case DW_OP_over:
6947 printf ("DW_OP_over");
6948 break;
6949 case DW_OP_pick:
6950 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6951 break;
6952 case DW_OP_swap:
6953 printf ("DW_OP_swap");
6954 break;
6955 case DW_OP_rot:
6956 printf ("DW_OP_rot");
6957 break;
6958 case DW_OP_xderef:
6959 printf ("DW_OP_xderef");
6960 break;
6961 case DW_OP_abs:
6962 printf ("DW_OP_abs");
6963 break;
6964 case DW_OP_and:
6965 printf ("DW_OP_and");
6966 break;
6967 case DW_OP_div:
6968 printf ("DW_OP_div");
6969 break;
6970 case DW_OP_minus:
6971 printf ("DW_OP_minus");
6972 break;
6973 case DW_OP_mod:
6974 printf ("DW_OP_mod");
6975 break;
6976 case DW_OP_mul:
6977 printf ("DW_OP_mul");
6978 break;
6979 case DW_OP_neg:
6980 printf ("DW_OP_neg");
6981 break;
6982 case DW_OP_not:
6983 printf ("DW_OP_not");
6984 break;
6985 case DW_OP_or:
6986 printf ("DW_OP_or");
6987 break;
6988 case DW_OP_plus:
6989 printf ("DW_OP_plus");
6990 break;
6991 case DW_OP_plus_uconst:
6992 printf ("DW_OP_plus_uconst: %lu",
6993 read_leb128 (data, &bytes_read, 0));
6994 data += bytes_read;
6995 break;
6996 case DW_OP_shl:
6997 printf ("DW_OP_shl");
6998 break;
6999 case DW_OP_shr:
7000 printf ("DW_OP_shr");
7001 break;
7002 case DW_OP_shra:
7003 printf ("DW_OP_shra");
7004 break;
7005 case DW_OP_xor:
7006 printf ("DW_OP_xor");
7007 break;
7008 case DW_OP_bra:
7009 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7010 data += 2;
7011 break;
7012 case DW_OP_eq:
7013 printf ("DW_OP_eq");
7014 break;
7015 case DW_OP_ge:
7016 printf ("DW_OP_ge");
7017 break;
7018 case DW_OP_gt:
7019 printf ("DW_OP_gt");
7020 break;
7021 case DW_OP_le:
7022 printf ("DW_OP_le");
7023 break;
7024 case DW_OP_lt:
7025 printf ("DW_OP_lt");
7026 break;
7027 case DW_OP_ne:
7028 printf ("DW_OP_ne");
7029 break;
7030 case DW_OP_skip:
7031 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7032 data += 2;
7033 break;
7034
7035 case DW_OP_lit0:
7036 case DW_OP_lit1:
7037 case DW_OP_lit2:
7038 case DW_OP_lit3:
7039 case DW_OP_lit4:
7040 case DW_OP_lit5:
7041 case DW_OP_lit6:
7042 case DW_OP_lit7:
7043 case DW_OP_lit8:
7044 case DW_OP_lit9:
7045 case DW_OP_lit10:
7046 case DW_OP_lit11:
7047 case DW_OP_lit12:
7048 case DW_OP_lit13:
7049 case DW_OP_lit14:
7050 case DW_OP_lit15:
7051 case DW_OP_lit16:
7052 case DW_OP_lit17:
7053 case DW_OP_lit18:
7054 case DW_OP_lit19:
7055 case DW_OP_lit20:
7056 case DW_OP_lit21:
7057 case DW_OP_lit22:
7058 case DW_OP_lit23:
7059 case DW_OP_lit24:
7060 case DW_OP_lit25:
7061 case DW_OP_lit26:
7062 case DW_OP_lit27:
7063 case DW_OP_lit28:
7064 case DW_OP_lit29:
7065 case DW_OP_lit30:
7066 case DW_OP_lit31:
7067 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7068 break;
7069
7070 case DW_OP_reg0:
7071 case DW_OP_reg1:
7072 case DW_OP_reg2:
7073 case DW_OP_reg3:
7074 case DW_OP_reg4:
7075 case DW_OP_reg5:
7076 case DW_OP_reg6:
7077 case DW_OP_reg7:
7078 case DW_OP_reg8:
7079 case DW_OP_reg9:
7080 case DW_OP_reg10:
7081 case DW_OP_reg11:
7082 case DW_OP_reg12:
7083 case DW_OP_reg13:
7084 case DW_OP_reg14:
7085 case DW_OP_reg15:
7086 case DW_OP_reg16:
7087 case DW_OP_reg17:
7088 case DW_OP_reg18:
7089 case DW_OP_reg19:
7090 case DW_OP_reg20:
7091 case DW_OP_reg21:
7092 case DW_OP_reg22:
7093 case DW_OP_reg23:
7094 case DW_OP_reg24:
7095 case DW_OP_reg25:
7096 case DW_OP_reg26:
7097 case DW_OP_reg27:
7098 case DW_OP_reg28:
7099 case DW_OP_reg29:
7100 case DW_OP_reg30:
7101 case DW_OP_reg31:
7102 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7103 break;
7104
7105 case DW_OP_breg0:
7106 case DW_OP_breg1:
7107 case DW_OP_breg2:
7108 case DW_OP_breg3:
7109 case DW_OP_breg4:
7110 case DW_OP_breg5:
7111 case DW_OP_breg6:
7112 case DW_OP_breg7:
7113 case DW_OP_breg8:
7114 case DW_OP_breg9:
7115 case DW_OP_breg10:
7116 case DW_OP_breg11:
7117 case DW_OP_breg12:
7118 case DW_OP_breg13:
7119 case DW_OP_breg14:
7120 case DW_OP_breg15:
7121 case DW_OP_breg16:
7122 case DW_OP_breg17:
7123 case DW_OP_breg18:
7124 case DW_OP_breg19:
7125 case DW_OP_breg20:
7126 case DW_OP_breg21:
7127 case DW_OP_breg22:
7128 case DW_OP_breg23:
7129 case DW_OP_breg24:
7130 case DW_OP_breg25:
7131 case DW_OP_breg26:
7132 case DW_OP_breg27:
7133 case DW_OP_breg28:
7134 case DW_OP_breg29:
7135 case DW_OP_breg30:
7136 case DW_OP_breg31:
7137 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7138 read_leb128 (data, &bytes_read, 1));
7139 data += bytes_read;
7140 break;
7141
7142 case DW_OP_regx:
7143 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7144 data += bytes_read;
7145 break;
7146 case DW_OP_fbreg:
7147 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7148 data += bytes_read;
7149 break;
7150 case DW_OP_bregx:
7151 uvalue = read_leb128 (data, &bytes_read, 0);
7152 data += bytes_read;
7153 printf ("DW_OP_bregx: %lu %ld", uvalue,
7154 read_leb128 (data, &bytes_read, 1));
7155 data += bytes_read;
7156 break;
7157 case DW_OP_piece:
7158 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7159 data += bytes_read;
7160 break;
7161 case DW_OP_deref_size:
7162 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7163 break;
7164 case DW_OP_xderef_size:
7165 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7166 break;
7167 case DW_OP_nop:
7168 printf ("DW_OP_nop");
7169 break;
7170
7171 /* DWARF 2.1 extensions. */
7172 case DW_OP_push_object_address:
7173 printf ("DW_OP_push_object_address");
7174 break;
7175 case DW_OP_call2:
7176 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7177 data += 2;
7178 break;
7179 case DW_OP_call4:
7180 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7181 data += 4;
7182 break;
7183 case DW_OP_calli:
7184 printf ("DW_OP_calli");
7185 break;
7186
7187 default:
7188 if (op >= DW_OP_lo_user
7189 && op <= DW_OP_hi_user)
7190 printf (_("(User defined location op)"));
7191 else
7192 printf (_("(Unknown location op)"));
7193 /* No way to tell where the next op is, so just bail. */
7194 return;
7195 }
7196
7197 /* Separate the ops. */
7198 printf ("; ");
7199 }
7200 }
7201
7202 static const char * debug_loc_contents;
7203 static bfd_vma debug_loc_size;
7204
7205 static void
7206 load_debug_loc (file)
7207 FILE * file;
7208 {
7209 Elf32_Internal_Shdr * sec;
7210 unsigned int i;
7211
7212 /* If it is already loaded, do nothing. */
7213 if (debug_loc_contents != NULL)
7214 return;
7215
7216 /* Locate the .debug_loc section. */
7217 for (i = 0, sec = section_headers;
7218 i < elf_header.e_shnum;
7219 i ++, sec ++)
7220 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7221 break;
7222
7223 if (i == elf_header.e_shnum || sec->sh_size == 0)
7224 return;
7225
7226 debug_loc_size = sec->sh_size;
7227
7228 debug_loc_contents = ((char *)
7229 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7230 _("debug_loc section data")));
7231 }
7232
7233 static void
7234 free_debug_loc ()
7235 {
7236 if (debug_loc_contents == NULL)
7237 return;
7238
7239 free ((char *) debug_loc_contents);
7240 debug_loc_contents = NULL;
7241 debug_loc_size = 0;
7242 }
7243
7244
7245 static int
7246 display_debug_loc (section, start, file)
7247 Elf32_Internal_Shdr * section;
7248 unsigned char * start;
7249 FILE * file ATTRIBUTE_UNUSED;
7250 {
7251 unsigned char *section_end;
7252 unsigned long bytes;
7253 unsigned char *section_begin = start;
7254 bfd_vma addr;
7255
7256 addr = section->sh_addr;
7257 bytes = section->sh_size;
7258 section_end = start + bytes;
7259 if (bytes == 0)
7260 {
7261 printf (_("\nThe .debug_loc section is empty.\n"));
7262 return 0;
7263 }
7264 printf (_("Contents of the .debug_loc section:\n\n"));
7265 printf (_("\n Offset Begin End Expression\n"));
7266 while (start < section_end)
7267 {
7268 unsigned long begin;
7269 unsigned long end;
7270 unsigned short length;
7271 unsigned long offset;
7272
7273 offset = start - section_begin;
7274
7275 while (1)
7276 {
7277 /* Normally, the lists in the debug_loc section are related to a
7278 given compilation unit, and thus, we would use the
7279 pointer size of that compilation unit. However, since we are
7280 displaying it seperately here, we either have to store
7281 pointer sizes of all compilation units, or assume they don't
7282 change. We assume, like the debug_line display, that
7283 it doesn't change. */
7284 begin = byte_get (start, debug_line_pointer_size);
7285 start += debug_line_pointer_size;
7286 end = byte_get (start, debug_line_pointer_size);
7287 start += debug_line_pointer_size;
7288
7289 if (begin == 0 && end == 0)
7290 break;
7291
7292 begin += addr;
7293 end += addr;
7294
7295 length = byte_get (start, 2);
7296 start += 2;
7297
7298 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7299 decode_location_expression (start, debug_line_pointer_size, length);
7300 printf (")\n");
7301
7302 start += length;
7303 }
7304 printf ("\n");
7305 }
7306 return 1;
7307 }
7308
7309 static const char * debug_str_contents;
7310 static bfd_vma debug_str_size;
7311
7312 static void
7313 load_debug_str (file)
7314 FILE * file;
7315 {
7316 Elf32_Internal_Shdr * sec;
7317 unsigned int i;
7318
7319 /* If it is already loaded, do nothing. */
7320 if (debug_str_contents != NULL)
7321 return;
7322
7323 /* Locate the .debug_str section. */
7324 for (i = 0, sec = section_headers;
7325 i < elf_header.e_shnum;
7326 i ++, sec ++)
7327 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7328 break;
7329
7330 if (i == elf_header.e_shnum || sec->sh_size == 0)
7331 return;
7332
7333 debug_str_size = sec->sh_size;
7334
7335 debug_str_contents = ((char *)
7336 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7337 _("debug_str section data")));
7338 }
7339
7340 static void
7341 free_debug_str ()
7342 {
7343 if (debug_str_contents == NULL)
7344 return;
7345
7346 free ((char *) debug_str_contents);
7347 debug_str_contents = NULL;
7348 debug_str_size = 0;
7349 }
7350
7351 static const char *
7352 fetch_indirect_string (offset)
7353 unsigned long offset;
7354 {
7355 if (debug_str_contents == NULL)
7356 return _("<no .debug_str section>");
7357
7358 if (offset > debug_str_size)
7359 return _("<offset is too big>");
7360
7361 return debug_str_contents + offset;
7362 }
7363
7364
7365 static int
7366 display_debug_str (section, start, file)
7367 Elf32_Internal_Shdr * section;
7368 unsigned char * start;
7369 FILE * file ATTRIBUTE_UNUSED;
7370 {
7371 unsigned long bytes;
7372 bfd_vma addr;
7373
7374 addr = section->sh_addr;
7375 bytes = section->sh_size;
7376
7377 if (bytes == 0)
7378 {
7379 printf (_("\nThe .debug_str section is empty.\n"));
7380 return 0;
7381 }
7382
7383 printf (_("Contents of the .debug_str section:\n\n"));
7384
7385 while (bytes)
7386 {
7387 int j;
7388 int k;
7389 int lbytes;
7390
7391 lbytes = (bytes > 16 ? 16 : bytes);
7392
7393 printf (" 0x%8.8lx ", (unsigned long) addr);
7394
7395 for (j = 0; j < 16; j++)
7396 {
7397 if (j < lbytes)
7398 printf ("%2.2x", start [j]);
7399 else
7400 printf (" ");
7401
7402 if ((j & 3) == 3)
7403 printf (" ");
7404 }
7405
7406 for (j = 0; j < lbytes; j++)
7407 {
7408 k = start [j];
7409 if (k >= ' ' && k < 0x80)
7410 printf ("%c", k);
7411 else
7412 printf (".");
7413 }
7414
7415 putchar ('\n');
7416
7417 start += lbytes;
7418 addr += lbytes;
7419 bytes -= lbytes;
7420 }
7421
7422 return 1;
7423 }
7424
7425
7426 static unsigned char *
7427 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7428 unsigned long attribute;
7429 unsigned long form;
7430 unsigned char * data;
7431 unsigned long cu_offset;
7432 unsigned long pointer_size;
7433 {
7434 unsigned long uvalue = 0;
7435 unsigned char * block_start = NULL;
7436 int bytes_read;
7437
7438 switch (form)
7439 {
7440 default:
7441 break;
7442
7443 case DW_FORM_ref_addr:
7444 case DW_FORM_addr:
7445 uvalue = byte_get (data, pointer_size);
7446 data += pointer_size;
7447 break;
7448
7449 case DW_FORM_strp:
7450 uvalue = byte_get (data, /* offset_size */ 4);
7451 data += /* offset_size */ 4;
7452 break;
7453
7454 case DW_FORM_ref1:
7455 case DW_FORM_flag:
7456 case DW_FORM_data1:
7457 uvalue = byte_get (data ++, 1);
7458 break;
7459
7460 case DW_FORM_ref2:
7461 case DW_FORM_data2:
7462 uvalue = byte_get (data, 2);
7463 data += 2;
7464 break;
7465
7466 case DW_FORM_ref4:
7467 case DW_FORM_data4:
7468 uvalue = byte_get (data, 4);
7469 data += 4;
7470 break;
7471
7472 case DW_FORM_sdata:
7473 uvalue = read_leb128 (data, & bytes_read, 1);
7474 data += bytes_read;
7475 break;
7476
7477 case DW_FORM_ref_udata:
7478 case DW_FORM_udata:
7479 uvalue = read_leb128 (data, & bytes_read, 0);
7480 data += bytes_read;
7481 break;
7482
7483 case DW_FORM_indirect:
7484 form = read_leb128 (data, & bytes_read, 0);
7485 data += bytes_read;
7486 printf (" %s", get_FORM_name (form));
7487 return read_and_display_attr_value (attribute, form, data, cu_offset,
7488 pointer_size);
7489 }
7490
7491 switch (form)
7492 {
7493 case DW_FORM_ref_addr:
7494 printf (" <#%lx>", uvalue);
7495 break;
7496
7497 case DW_FORM_ref1:
7498 case DW_FORM_ref2:
7499 case DW_FORM_ref4:
7500 case DW_FORM_ref_udata:
7501 printf (" <%lx>", uvalue + cu_offset);
7502 break;
7503
7504 case DW_FORM_addr:
7505 printf (" %#lx", uvalue);
7506
7507 case DW_FORM_flag:
7508 case DW_FORM_data1:
7509 case DW_FORM_data2:
7510 case DW_FORM_data4:
7511 case DW_FORM_sdata:
7512 case DW_FORM_udata:
7513 printf (" %ld", uvalue);
7514 break;
7515
7516 case DW_FORM_ref8:
7517 case DW_FORM_data8:
7518 uvalue = byte_get (data, 4);
7519 printf (" %lx", uvalue);
7520 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7521 data += 8;
7522 break;
7523
7524 case DW_FORM_string:
7525 printf (" %s", data);
7526 data += strlen ((char *) data) + 1;
7527 break;
7528
7529 case DW_FORM_block:
7530 uvalue = read_leb128 (data, & bytes_read, 0);
7531 block_start = data + bytes_read;
7532 data = display_block (block_start, uvalue);
7533 break;
7534
7535 case DW_FORM_block1:
7536 uvalue = byte_get (data, 1);
7537 block_start = data + 1;
7538 data = display_block (block_start, uvalue);
7539 break;
7540
7541 case DW_FORM_block2:
7542 uvalue = byte_get (data, 2);
7543 block_start = data + 2;
7544 data = display_block (block_start, uvalue);
7545 break;
7546
7547 case DW_FORM_block4:
7548 uvalue = byte_get (data, 4);
7549 block_start = data + 4;
7550 data = display_block (block_start, uvalue);
7551 break;
7552
7553 case DW_FORM_strp:
7554 printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
7555 printf (fetch_indirect_string (uvalue));
7556 break;
7557
7558 case DW_FORM_indirect:
7559 /* Handled above. */
7560 break;
7561
7562 default:
7563 warn (_("Unrecognized form: %d\n"), form);
7564 break;
7565 }
7566
7567 /* For some attributes we can display futher information. */
7568
7569 printf ("\t");
7570
7571 switch (attribute)
7572 {
7573 case DW_AT_inline:
7574 switch (uvalue)
7575 {
7576 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7577 case DW_INL_inlined: printf (_("(inlined)")); break;
7578 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7579 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7580 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7581 }
7582 break;
7583
7584 case DW_AT_language:
7585 switch (uvalue)
7586 {
7587 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7588 case DW_LANG_C89: printf ("(ANSI C)"); break;
7589 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7590 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7591 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7592 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7593 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7594 case DW_LANG_Ada83: printf ("(Ada)"); break;
7595 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7596 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7597 /* DWARF 2.1 values. */
7598 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7599 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7600 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7601 /* MIPS extension. */
7602 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7603 default: printf ("(Unknown: %lx)", uvalue); break;
7604 }
7605 break;
7606
7607 case DW_AT_encoding:
7608 switch (uvalue)
7609 {
7610 case DW_ATE_void: printf ("(void)"); break;
7611 case DW_ATE_address: printf ("(machine address)"); break;
7612 case DW_ATE_boolean: printf ("(boolean)"); break;
7613 case DW_ATE_complex_float: printf ("(complex float)"); break;
7614 case DW_ATE_float: printf ("(float)"); break;
7615 case DW_ATE_signed: printf ("(signed)"); break;
7616 case DW_ATE_signed_char: printf ("(signed char)"); break;
7617 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7618 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7619 /* DWARF 2.1 value. */
7620 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7621 default:
7622 if (uvalue >= DW_ATE_lo_user
7623 && uvalue <= DW_ATE_hi_user)
7624 printf ("(user defined type)");
7625 else
7626 printf ("(unknown type)");
7627 break;
7628 }
7629 break;
7630
7631 case DW_AT_accessibility:
7632 switch (uvalue)
7633 {
7634 case DW_ACCESS_public: printf ("(public)"); break;
7635 case DW_ACCESS_protected: printf ("(protected)"); break;
7636 case DW_ACCESS_private: printf ("(private)"); break;
7637 default: printf ("(unknown accessibility)"); break;
7638 }
7639 break;
7640
7641 case DW_AT_visibility:
7642 switch (uvalue)
7643 {
7644 case DW_VIS_local: printf ("(local)"); break;
7645 case DW_VIS_exported: printf ("(exported)"); break;
7646 case DW_VIS_qualified: printf ("(qualified)"); break;
7647 default: printf ("(unknown visibility)"); break;
7648 }
7649 break;
7650
7651 case DW_AT_virtuality:
7652 switch (uvalue)
7653 {
7654 case DW_VIRTUALITY_none: printf ("(none)"); break;
7655 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7656 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7657 default: printf ("(unknown virtuality)"); break;
7658 }
7659 break;
7660
7661 case DW_AT_identifier_case:
7662 switch (uvalue)
7663 {
7664 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7665 case DW_ID_up_case: printf ("(up_case)"); break;
7666 case DW_ID_down_case: printf ("(down_case)"); break;
7667 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7668 default: printf ("(unknown case)"); break;
7669 }
7670 break;
7671
7672 case DW_AT_calling_convention:
7673 switch (uvalue)
7674 {
7675 case DW_CC_normal: printf ("(normal)"); break;
7676 case DW_CC_program: printf ("(program)"); break;
7677 case DW_CC_nocall: printf ("(nocall)"); break;
7678 default:
7679 if (uvalue >= DW_CC_lo_user
7680 && uvalue <= DW_CC_hi_user)
7681 printf ("(user defined)");
7682 else
7683 printf ("(unknown convention)");
7684 }
7685 break;
7686
7687 case DW_AT_ordering:
7688 switch (uvalue)
7689 {
7690 case -1: printf ("(undefined)"); break;
7691 case 0: printf ("(row major)"); break;
7692 case 1: printf ("(column major)"); break;
7693 }
7694 break;
7695
7696 case DW_AT_frame_base:
7697 case DW_AT_location:
7698 case DW_AT_data_member_location:
7699 case DW_AT_vtable_elem_location:
7700 case DW_AT_allocated:
7701 case DW_AT_associated:
7702 case DW_AT_data_location:
7703 case DW_AT_stride:
7704 case DW_AT_upper_bound:
7705 case DW_AT_lower_bound:
7706 if (block_start)
7707 {
7708 printf ("(");
7709 decode_location_expression (block_start, pointer_size, uvalue);
7710 printf (")");
7711 }
7712 else if (form == DW_FORM_data4)
7713 {
7714 printf ("(");
7715 printf ("location list");
7716 printf (")");
7717 }
7718 break;
7719
7720 default:
7721 break;
7722 }
7723
7724 return data;
7725 }
7726
7727 static unsigned char *
7728 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
7729 unsigned long attribute;
7730 unsigned long form;
7731 unsigned char * data;
7732 unsigned long cu_offset;
7733 unsigned long pointer_size;
7734 {
7735 printf (" %-18s:", get_AT_name (attribute));
7736 data = read_and_display_attr_value (attribute, form, data, cu_offset,
7737 pointer_size);
7738 printf ("\n");
7739 return data;
7740 }
7741
7742 static int
7743 display_debug_info (section, start, file)
7744 Elf32_Internal_Shdr * section;
7745 unsigned char * start;
7746 FILE * file;
7747 {
7748 unsigned char * end = start + section->sh_size;
7749 unsigned char * section_begin = start;
7750
7751 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7752
7753 load_debug_str (file);
7754 load_debug_loc (file);
7755
7756 while (start < end)
7757 {
7758 DWARF2_External_CompUnit * external;
7759 DWARF2_Internal_CompUnit compunit;
7760 Elf32_Internal_Shdr * relsec;
7761 unsigned char * tags;
7762 unsigned int i;
7763 int level;
7764 unsigned long cu_offset;
7765
7766 external = (DWARF2_External_CompUnit *) start;
7767
7768 compunit.cu_length = BYTE_GET (external->cu_length);
7769 compunit.cu_version = BYTE_GET (external->cu_version);
7770 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7771 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7772
7773 if (compunit.cu_length == 0xffffffff)
7774 {
7775 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7776 break;
7777 }
7778
7779 /* Check for RELA relocations in the abbrev_offset address, and
7780 apply them. */
7781 for (relsec = section_headers;
7782 relsec < section_headers + elf_header.e_shnum;
7783 ++relsec)
7784 {
7785 unsigned long nrelas;
7786 Elf_Internal_Rela *rela, *rp;
7787 Elf32_Internal_Shdr *symsec;
7788 Elf_Internal_Sym *symtab;
7789 Elf_Internal_Sym *sym;
7790
7791 if (relsec->sh_type != SHT_RELA
7792 || SECTION_HEADER (relsec->sh_info) != section)
7793 continue;
7794
7795 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7796 & rela, & nrelas))
7797 return 0;
7798
7799 symsec = SECTION_HEADER (relsec->sh_link);
7800 symtab = GET_ELF_SYMBOLS (file, symsec);
7801
7802 for (rp = rela; rp < rela + nrelas; ++rp)
7803 {
7804 if (rp->r_offset
7805 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7806 - section_begin))
7807 continue;
7808
7809 if (is_32bit_elf)
7810 {
7811 sym = symtab + ELF32_R_SYM (rp->r_info);
7812
7813 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7814 {
7815 warn (_("Skipping unexpected symbol type %u\n"),
7816 ELF32_ST_TYPE (sym->st_info));
7817 continue;
7818 }
7819 }
7820 else
7821 {
7822 sym = symtab + ELF64_R_SYM (rp->r_info);
7823
7824 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7825 {
7826 warn (_("Skipping unexpected symbol type %u\n"),
7827 ELF64_ST_TYPE (sym->st_info));
7828 continue;
7829 }
7830 }
7831
7832 compunit.cu_abbrev_offset += rp->r_addend;
7833 break;
7834 }
7835
7836 free (rela);
7837 break;
7838 }
7839
7840 tags = start + sizeof (* external);
7841 cu_offset = start - section_begin;
7842 start += compunit.cu_length + sizeof (external->cu_length);
7843
7844 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
7845 printf (_(" Length: %ld\n"), compunit.cu_length);
7846 printf (_(" Version: %d\n"), compunit.cu_version);
7847 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7848 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
7849
7850 if (compunit.cu_version != 2)
7851 {
7852 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7853 continue;
7854 }
7855
7856 free_abbrevs ();
7857
7858 /* Read in the abbrevs used by this compilation unit. */
7859
7860 {
7861 Elf32_Internal_Shdr * sec;
7862 unsigned char * begin;
7863
7864 /* Locate the .debug_abbrev section and process it. */
7865 for (i = 0, sec = section_headers;
7866 i < elf_header.e_shnum;
7867 i ++, sec ++)
7868 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7869 break;
7870
7871 if (i == elf_header.e_shnum || sec->sh_size == 0)
7872 {
7873 warn (_("Unable to locate .debug_abbrev section!\n"));
7874 return 0;
7875 }
7876
7877 begin = ((unsigned char *)
7878 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7879 _("debug_abbrev section data")));
7880 if (!begin)
7881 return 0;
7882
7883 process_abbrev_section (begin + compunit.cu_abbrev_offset,
7884 begin + sec->sh_size);
7885
7886 free (begin);
7887 }
7888
7889 level = 0;
7890 while (tags < start)
7891 {
7892 int bytes_read;
7893 unsigned long abbrev_number;
7894 abbrev_entry * entry;
7895 abbrev_attr * attr;
7896
7897 abbrev_number = read_leb128 (tags, & bytes_read, 0);
7898 tags += bytes_read;
7899
7900 /* A null DIE marks the end of a list of children. */
7901 if (abbrev_number == 0)
7902 {
7903 --level;
7904 continue;
7905 }
7906
7907 /* Scan through the abbreviation list until we reach the
7908 correct entry. */
7909 for (entry = first_abbrev;
7910 entry && entry->entry != abbrev_number;
7911 entry = entry->next)
7912 continue;
7913
7914 if (entry == NULL)
7915 {
7916 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7917 abbrev_number);
7918 return 0;
7919 }
7920
7921 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7922 level,
7923 (unsigned long) (tags - section_begin - bytes_read),
7924 abbrev_number,
7925 get_TAG_name (entry->tag));
7926
7927 for (attr = entry->first_attr; attr; attr = attr->next)
7928 tags = read_and_display_attr (attr->attribute,
7929 attr->form,
7930 tags, cu_offset,
7931 compunit.cu_pointer_size);
7932
7933 if (entry->children)
7934 ++level;
7935 }
7936 }
7937
7938 free_debug_str ();
7939 free_debug_loc ();
7940
7941 printf ("\n");
7942
7943 return 1;
7944 }
7945
7946 static int
7947 display_debug_aranges (section, start, file)
7948 Elf32_Internal_Shdr * section;
7949 unsigned char * start;
7950 FILE * file ATTRIBUTE_UNUSED;
7951 {
7952 unsigned char * end = start + section->sh_size;
7953
7954 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7955
7956 while (start < end)
7957 {
7958 DWARF2_External_ARange * external;
7959 DWARF2_Internal_ARange arange;
7960 unsigned char * ranges;
7961 unsigned long length;
7962 unsigned long address;
7963 int excess;
7964
7965 external = (DWARF2_External_ARange *) start;
7966
7967 arange.ar_length = BYTE_GET (external->ar_length);
7968 arange.ar_version = BYTE_GET (external->ar_version);
7969 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
7970 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7971 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7972
7973 if (arange.ar_length == 0xffffffff)
7974 {
7975 warn (_("64-bit DWARF aranges are not supported yet.\n"));
7976 break;
7977 }
7978
7979 if (arange.ar_version != 2)
7980 {
7981 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7982 break;
7983 }
7984
7985 printf (_(" Length: %ld\n"), arange.ar_length);
7986 printf (_(" Version: %d\n"), arange.ar_version);
7987 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
7988 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
7989 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
7990
7991 printf (_("\n Address Length\n"));
7992
7993 ranges = start + sizeof (* external);
7994
7995 /* Must pad to an alignment boundary that is twice the pointer size. */
7996 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7997 if (excess)
7998 ranges += (2 * arange.ar_pointer_size) - excess;
7999
8000 for (;;)
8001 {
8002 address = byte_get (ranges, arange.ar_pointer_size);
8003
8004 ranges += arange.ar_pointer_size;
8005
8006 length = byte_get (ranges, arange.ar_pointer_size);
8007
8008 ranges += arange.ar_pointer_size;
8009
8010 /* A pair of zeros marks the end of the list. */
8011 if (address == 0 && length == 0)
8012 break;
8013
8014 printf (" %8.8lx %lu\n", address, length);
8015 }
8016
8017 start += arange.ar_length + sizeof (external->ar_length);
8018 }
8019
8020 printf ("\n");
8021
8022 return 1;
8023 }
8024
8025 typedef struct Frame_Chunk
8026 {
8027 struct Frame_Chunk * next;
8028 unsigned char * chunk_start;
8029 int ncols;
8030 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8031 short int * col_type;
8032 int * col_offset;
8033 char * augmentation;
8034 unsigned int code_factor;
8035 int data_factor;
8036 unsigned long pc_begin;
8037 unsigned long pc_range;
8038 int cfa_reg;
8039 int cfa_offset;
8040 int ra;
8041 unsigned char fde_encoding;
8042 }
8043 Frame_Chunk;
8044
8045 /* A marker for a col_type that means this column was never referenced
8046 in the frame info. */
8047 #define DW_CFA_unreferenced (-1)
8048
8049 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8050 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8051 static int size_of_encoded_value PARAMS ((int));
8052
8053 static void
8054 frame_need_space (fc, reg)
8055 Frame_Chunk * fc;
8056 int reg;
8057 {
8058 int prev = fc->ncols;
8059
8060 if (reg < fc->ncols)
8061 return;
8062
8063 fc->ncols = reg + 1;
8064 fc->col_type = (short int *) xrealloc (fc->col_type,
8065 fc->ncols * sizeof (short int));
8066 fc->col_offset = (int *) xrealloc (fc->col_offset,
8067 fc->ncols * sizeof (int));
8068
8069 while (prev < fc->ncols)
8070 {
8071 fc->col_type[prev] = DW_CFA_unreferenced;
8072 fc->col_offset[prev] = 0;
8073 prev++;
8074 }
8075 }
8076
8077 static void
8078 frame_display_row (fc, need_col_headers, max_regs)
8079 Frame_Chunk * fc;
8080 int * need_col_headers;
8081 int * max_regs;
8082 {
8083 int r;
8084 char tmp[100];
8085
8086 if (* max_regs < fc->ncols)
8087 * max_regs = fc->ncols;
8088
8089 if (* need_col_headers)
8090 {
8091 * need_col_headers = 0;
8092
8093 printf (" LOC CFA ");
8094
8095 for (r = 0; r < * max_regs; r++)
8096 if (fc->col_type[r] != DW_CFA_unreferenced)
8097 {
8098 if (r == fc->ra)
8099 printf ("ra ");
8100 else
8101 printf ("r%-4d", r);
8102 }
8103
8104 printf ("\n");
8105 }
8106
8107 printf ("%08lx ", fc->pc_begin);
8108 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8109 printf ("%-8s ", tmp);
8110
8111 for (r = 0; r < fc->ncols; r++)
8112 {
8113 if (fc->col_type[r] != DW_CFA_unreferenced)
8114 {
8115 switch (fc->col_type[r])
8116 {
8117 case DW_CFA_undefined:
8118 strcpy (tmp, "u");
8119 break;
8120 case DW_CFA_same_value:
8121 strcpy (tmp, "s");
8122 break;
8123 case DW_CFA_offset:
8124 sprintf (tmp, "c%+d", fc->col_offset[r]);
8125 break;
8126 case DW_CFA_register:
8127 sprintf (tmp, "r%d", fc->col_offset[r]);
8128 break;
8129 default:
8130 strcpy (tmp, "n/a");
8131 break;
8132 }
8133 printf ("%-5s", tmp);
8134 }
8135 }
8136 printf ("\n");
8137 }
8138
8139 static int
8140 size_of_encoded_value (encoding)
8141 int encoding;
8142 {
8143 switch (encoding & 0x7)
8144 {
8145 default: /* ??? */
8146 case 0: return is_32bit_elf ? 4 : 8;
8147 case 2: return 2;
8148 case 3: return 4;
8149 case 4: return 8;
8150 }
8151 }
8152
8153 #define GET(N) byte_get (start, N); start += N
8154 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8155 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8156
8157 static int
8158 display_debug_frames (section, start, file)
8159 Elf32_Internal_Shdr * section;
8160 unsigned char * start;
8161 FILE * file ATTRIBUTE_UNUSED;
8162 {
8163 unsigned char * end = start + section->sh_size;
8164 unsigned char * section_start = start;
8165 Frame_Chunk * chunks = 0;
8166 Frame_Chunk * remembered_state = 0;
8167 Frame_Chunk * rs;
8168 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8169 int length_return;
8170 int max_regs = 0;
8171 int addr_size = is_32bit_elf ? 4 : 8;
8172
8173 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8174
8175 while (start < end)
8176 {
8177 unsigned char * saved_start;
8178 unsigned char * block_end;
8179 unsigned long length;
8180 unsigned long cie_id;
8181 Frame_Chunk * fc;
8182 Frame_Chunk * cie;
8183 int need_col_headers = 1;
8184 unsigned char * augmentation_data = NULL;
8185 unsigned long augmentation_data_len = 0;
8186 int encoded_ptr_size = addr_size;
8187
8188 saved_start = start;
8189 length = byte_get (start, 4); start += 4;
8190
8191 if (length == 0)
8192 return 1;
8193
8194 if (length == 0xffffffff)
8195 {
8196 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8197 break;
8198 }
8199
8200 block_end = saved_start + length + 4;
8201 cie_id = byte_get (start, 4); start += 4;
8202
8203 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8204 {
8205 int version;
8206
8207 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8208 memset (fc, 0, sizeof (Frame_Chunk));
8209
8210 fc->next = chunks;
8211 chunks = fc;
8212 fc->chunk_start = saved_start;
8213 fc->ncols = 0;
8214 fc->col_type = (short int *) xmalloc (sizeof (short int));
8215 fc->col_offset = (int *) xmalloc (sizeof (int));
8216 frame_need_space (fc, max_regs-1);
8217
8218 version = *start++;
8219
8220 fc->augmentation = start;
8221 start = strchr (start, '\0') + 1;
8222
8223 if (fc->augmentation[0] == 'z')
8224 {
8225 fc->code_factor = LEB ();
8226 fc->data_factor = SLEB ();
8227 fc->ra = byte_get (start, 1); start += 1;
8228 augmentation_data_len = LEB ();
8229 augmentation_data = start;
8230 start += augmentation_data_len;
8231 }
8232 else if (strcmp (fc->augmentation, "eh") == 0)
8233 {
8234 start += addr_size;
8235 fc->code_factor = LEB ();
8236 fc->data_factor = SLEB ();
8237 fc->ra = byte_get (start, 1); start += 1;
8238 }
8239 else
8240 {
8241 fc->code_factor = LEB ();
8242 fc->data_factor = SLEB ();
8243 fc->ra = byte_get (start, 1); start += 1;
8244 }
8245 cie = fc;
8246
8247 if (do_debug_frames_interp)
8248 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8249 (unsigned long)(saved_start - section_start), length, cie_id,
8250 fc->augmentation, fc->code_factor, fc->data_factor,
8251 fc->ra);
8252 else
8253 {
8254 printf ("\n%08lx %08lx %08lx CIE\n",
8255 (unsigned long)(saved_start - section_start), length, cie_id);
8256 printf (" Version: %d\n", version);
8257 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8258 printf (" Code alignment factor: %u\n", fc->code_factor);
8259 printf (" Data alignment factor: %d\n", fc->data_factor);
8260 printf (" Return address column: %d\n", fc->ra);
8261
8262 if (augmentation_data_len)
8263 {
8264 unsigned long i;
8265 printf (" Augmentation data: ");
8266 for (i = 0; i < augmentation_data_len; ++i)
8267 printf (" %02x", augmentation_data[i]);
8268 putchar ('\n');
8269 }
8270 putchar ('\n');
8271 }
8272
8273 if (augmentation_data_len)
8274 {
8275 unsigned char *p, *q;
8276 p = fc->augmentation + 1;
8277 q = augmentation_data;
8278
8279 while (1)
8280 {
8281 if (*p == 'L')
8282 q++;
8283 else if (*p == 'P')
8284 q += 1 + size_of_encoded_value (*q);
8285 else if (*p == 'R')
8286 fc->fde_encoding = *q++;
8287 else
8288 break;
8289 p++;
8290 }
8291
8292 if (fc->fde_encoding)
8293 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8294 }
8295
8296 frame_need_space (fc, fc->ra);
8297 }
8298 else
8299 {
8300 unsigned char * look_for;
8301 static Frame_Chunk fde_fc;
8302
8303 fc = & fde_fc;
8304 memset (fc, 0, sizeof (Frame_Chunk));
8305
8306 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8307
8308 for (cie = chunks; cie ; cie = cie->next)
8309 if (cie->chunk_start == look_for)
8310 break;
8311
8312 if (!cie)
8313 {
8314 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8315 cie_id, saved_start);
8316 start = block_end;
8317 fc->ncols = 0;
8318 fc->col_type = (short int *) xmalloc (sizeof (short int));
8319 fc->col_offset = (int *) xmalloc (sizeof (int));
8320 frame_need_space (fc, max_regs - 1);
8321 cie = fc;
8322 fc->augmentation = "";
8323 fc->fde_encoding = 0;
8324 }
8325 else
8326 {
8327 fc->ncols = cie->ncols;
8328 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8329 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8330 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8331 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8332 fc->augmentation = cie->augmentation;
8333 fc->code_factor = cie->code_factor;
8334 fc->data_factor = cie->data_factor;
8335 fc->cfa_reg = cie->cfa_reg;
8336 fc->cfa_offset = cie->cfa_offset;
8337 fc->ra = cie->ra;
8338 frame_need_space (fc, max_regs-1);
8339 fc->fde_encoding = cie->fde_encoding;
8340 }
8341
8342 if (fc->fde_encoding)
8343 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8344
8345 fc->pc_begin = byte_get (start, encoded_ptr_size);
8346 start += encoded_ptr_size;
8347 fc->pc_range = byte_get (start, encoded_ptr_size);
8348 start += encoded_ptr_size;
8349
8350 if (cie->augmentation[0] == 'z')
8351 {
8352 augmentation_data_len = LEB ();
8353 augmentation_data = start;
8354 start += augmentation_data_len;
8355 }
8356
8357 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8358 (unsigned long)(saved_start - section_start), length, cie_id,
8359 (unsigned long)(cie->chunk_start - section_start),
8360 fc->pc_begin, fc->pc_begin + fc->pc_range);
8361 if (! do_debug_frames_interp && augmentation_data_len)
8362 {
8363 unsigned long i;
8364 printf (" Augmentation data: ");
8365 for (i = 0; i < augmentation_data_len; ++i)
8366 printf (" %02x", augmentation_data[i]);
8367 putchar ('\n');
8368 putchar ('\n');
8369 }
8370 }
8371
8372 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8373 about to interpret instructions for the chunk. */
8374
8375 if (do_debug_frames_interp)
8376 {
8377 /* Start by making a pass over the chunk, allocating storage
8378 and taking note of what registers are used. */
8379 unsigned char * tmp = start;
8380
8381 while (start < block_end)
8382 {
8383 unsigned op, opa;
8384 unsigned long reg;
8385
8386 op = * start ++;
8387 opa = op & 0x3f;
8388 if (op & 0xc0)
8389 op &= 0xc0;
8390
8391 /* Warning: if you add any more cases to this switch, be
8392 sure to add them to the corresponding switch below. */
8393 switch (op)
8394 {
8395 case DW_CFA_advance_loc:
8396 break;
8397 case DW_CFA_offset:
8398 LEB ();
8399 frame_need_space (fc, opa);
8400 fc->col_type[opa] = DW_CFA_undefined;
8401 break;
8402 case DW_CFA_restore:
8403 frame_need_space (fc, opa);
8404 fc->col_type[opa] = DW_CFA_undefined;
8405 break;
8406 case DW_CFA_set_loc:
8407 start += encoded_ptr_size;
8408 break;
8409 case DW_CFA_advance_loc1:
8410 start += 1;
8411 break;
8412 case DW_CFA_advance_loc2:
8413 start += 2;
8414 break;
8415 case DW_CFA_advance_loc4:
8416 start += 4;
8417 break;
8418 case DW_CFA_offset_extended:
8419 reg = LEB (); LEB ();
8420 frame_need_space (fc, reg);
8421 fc->col_type[reg] = DW_CFA_undefined;
8422 break;
8423 case DW_CFA_restore_extended:
8424 reg = LEB ();
8425 frame_need_space (fc, reg);
8426 fc->col_type[reg] = DW_CFA_undefined;
8427 break;
8428 case DW_CFA_undefined:
8429 reg = LEB ();
8430 frame_need_space (fc, reg);
8431 fc->col_type[reg] = DW_CFA_undefined;
8432 break;
8433 case DW_CFA_same_value:
8434 reg = LEB ();
8435 frame_need_space (fc, reg);
8436 fc->col_type[reg] = DW_CFA_undefined;
8437 break;
8438 case DW_CFA_register:
8439 reg = LEB (); LEB ();
8440 frame_need_space (fc, reg);
8441 fc->col_type[reg] = DW_CFA_undefined;
8442 break;
8443 case DW_CFA_def_cfa:
8444 LEB (); LEB ();
8445 break;
8446 case DW_CFA_def_cfa_register:
8447 LEB ();
8448 break;
8449 case DW_CFA_def_cfa_offset:
8450 LEB ();
8451 break;
8452 #ifndef DW_CFA_GNU_args_size
8453 #define DW_CFA_GNU_args_size 0x2e
8454 #endif
8455 case DW_CFA_GNU_args_size:
8456 LEB ();
8457 break;
8458 #ifndef DW_CFA_GNU_negative_offset_extended
8459 #define DW_CFA_GNU_negative_offset_extended 0x2f
8460 #endif
8461 case DW_CFA_GNU_negative_offset_extended:
8462 reg = LEB (); LEB ();
8463 frame_need_space (fc, reg);
8464 fc->col_type[reg] = DW_CFA_undefined;
8465
8466 default:
8467 break;
8468 }
8469 }
8470 start = tmp;
8471 }
8472
8473 /* Now we know what registers are used, make a second pass over
8474 the chunk, this time actually printing out the info. */
8475
8476 while (start < block_end)
8477 {
8478 unsigned op, opa;
8479 unsigned long ul, reg, roffs;
8480 long l, ofs;
8481 bfd_vma vma;
8482
8483 op = * start ++;
8484 opa = op & 0x3f;
8485 if (op & 0xc0)
8486 op &= 0xc0;
8487
8488 /* Warning: if you add any more cases to this switch, be
8489 sure to add them to the corresponding switch above. */
8490 switch (op)
8491 {
8492 case DW_CFA_advance_loc:
8493 if (do_debug_frames_interp)
8494 frame_display_row (fc, &need_col_headers, &max_regs);
8495 else
8496 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8497 opa * fc->code_factor,
8498 fc->pc_begin + opa * fc->code_factor);
8499 fc->pc_begin += opa * fc->code_factor;
8500 break;
8501
8502 case DW_CFA_offset:
8503 roffs = LEB ();
8504 if (! do_debug_frames_interp)
8505 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8506 opa, roffs * fc->data_factor);
8507 fc->col_type[opa] = DW_CFA_offset;
8508 fc->col_offset[opa] = roffs * fc->data_factor;
8509 break;
8510
8511 case DW_CFA_restore:
8512 if (! do_debug_frames_interp)
8513 printf (" DW_CFA_restore: r%d\n", opa);
8514 fc->col_type[opa] = cie->col_type[opa];
8515 fc->col_offset[opa] = cie->col_offset[opa];
8516 break;
8517
8518 case DW_CFA_set_loc:
8519 vma = byte_get (start, encoded_ptr_size);
8520 start += encoded_ptr_size;
8521 if (do_debug_frames_interp)
8522 frame_display_row (fc, &need_col_headers, &max_regs);
8523 else
8524 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8525 fc->pc_begin = vma;
8526 break;
8527
8528 case DW_CFA_advance_loc1:
8529 ofs = byte_get (start, 1); start += 1;
8530 if (do_debug_frames_interp)
8531 frame_display_row (fc, &need_col_headers, &max_regs);
8532 else
8533 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8534 ofs * fc->code_factor,
8535 fc->pc_begin + ofs * fc->code_factor);
8536 fc->pc_begin += ofs * fc->code_factor;
8537 break;
8538
8539 case DW_CFA_advance_loc2:
8540 ofs = byte_get (start, 2); start += 2;
8541 if (do_debug_frames_interp)
8542 frame_display_row (fc, &need_col_headers, &max_regs);
8543 else
8544 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8545 ofs * fc->code_factor,
8546 fc->pc_begin + ofs * fc->code_factor);
8547 fc->pc_begin += ofs * fc->code_factor;
8548 break;
8549
8550 case DW_CFA_advance_loc4:
8551 ofs = byte_get (start, 4); start += 4;
8552 if (do_debug_frames_interp)
8553 frame_display_row (fc, &need_col_headers, &max_regs);
8554 else
8555 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8556 ofs * fc->code_factor,
8557 fc->pc_begin + ofs * fc->code_factor);
8558 fc->pc_begin += ofs * fc->code_factor;
8559 break;
8560
8561 case DW_CFA_offset_extended:
8562 reg = LEB ();
8563 roffs = LEB ();
8564 if (! do_debug_frames_interp)
8565 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8566 reg, roffs * fc->data_factor);
8567 fc->col_type[reg] = DW_CFA_offset;
8568 fc->col_offset[reg] = roffs * fc->data_factor;
8569 break;
8570
8571 case DW_CFA_restore_extended:
8572 reg = LEB ();
8573 if (! do_debug_frames_interp)
8574 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8575 fc->col_type[reg] = cie->col_type[reg];
8576 fc->col_offset[reg] = cie->col_offset[reg];
8577 break;
8578
8579 case DW_CFA_undefined:
8580 reg = LEB ();
8581 if (! do_debug_frames_interp)
8582 printf (" DW_CFA_undefined: r%ld\n", reg);
8583 fc->col_type[reg] = DW_CFA_undefined;
8584 fc->col_offset[reg] = 0;
8585 break;
8586
8587 case DW_CFA_same_value:
8588 reg = LEB ();
8589 if (! do_debug_frames_interp)
8590 printf (" DW_CFA_same_value: r%ld\n", reg);
8591 fc->col_type[reg] = DW_CFA_same_value;
8592 fc->col_offset[reg] = 0;
8593 break;
8594
8595 case DW_CFA_register:
8596 reg = LEB ();
8597 roffs = LEB ();
8598 if (! do_debug_frames_interp)
8599 printf (" DW_CFA_register: r%ld\n", reg);
8600 fc->col_type[reg] = DW_CFA_register;
8601 fc->col_offset[reg] = roffs;
8602 break;
8603
8604 case DW_CFA_remember_state:
8605 if (! do_debug_frames_interp)
8606 printf (" DW_CFA_remember_state\n");
8607 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8608 rs->ncols = fc->ncols;
8609 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8610 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8611 memcpy (rs->col_type, fc->col_type, rs->ncols);
8612 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8613 rs->next = remembered_state;
8614 remembered_state = rs;
8615 break;
8616
8617 case DW_CFA_restore_state:
8618 if (! do_debug_frames_interp)
8619 printf (" DW_CFA_restore_state\n");
8620 rs = remembered_state;
8621 remembered_state = rs->next;
8622 frame_need_space (fc, rs->ncols-1);
8623 memcpy (fc->col_type, rs->col_type, rs->ncols);
8624 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8625 free (rs->col_type);
8626 free (rs->col_offset);
8627 free (rs);
8628 break;
8629
8630 case DW_CFA_def_cfa:
8631 fc->cfa_reg = LEB ();
8632 fc->cfa_offset = LEB ();
8633 if (! do_debug_frames_interp)
8634 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8635 fc->cfa_reg, fc->cfa_offset);
8636 break;
8637
8638 case DW_CFA_def_cfa_register:
8639 fc->cfa_reg = LEB ();
8640 if (! do_debug_frames_interp)
8641 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8642 break;
8643
8644 case DW_CFA_def_cfa_offset:
8645 fc->cfa_offset = LEB ();
8646 if (! do_debug_frames_interp)
8647 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8648 break;
8649
8650 case DW_CFA_nop:
8651 if (! do_debug_frames_interp)
8652 printf (" DW_CFA_nop\n");
8653 break;
8654
8655 #ifndef DW_CFA_GNU_window_save
8656 #define DW_CFA_GNU_window_save 0x2d
8657 #endif
8658 case DW_CFA_GNU_window_save:
8659 if (! do_debug_frames_interp)
8660 printf (" DW_CFA_GNU_window_save\n");
8661 break;
8662
8663 case DW_CFA_GNU_args_size:
8664 ul = LEB ();
8665 if (! do_debug_frames_interp)
8666 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8667 break;
8668
8669 case DW_CFA_GNU_negative_offset_extended:
8670 reg = LEB ();
8671 l = - LEB ();
8672 frame_need_space (fc, reg);
8673 if (! do_debug_frames_interp)
8674 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8675 reg, l * fc->data_factor);
8676 fc->col_type[reg] = DW_CFA_offset;
8677 fc->col_offset[reg] = l * fc->data_factor;
8678 break;
8679
8680 default:
8681 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8682 start = block_end;
8683 }
8684 }
8685
8686 if (do_debug_frames_interp)
8687 frame_display_row (fc, &need_col_headers, &max_regs);
8688
8689 start = block_end;
8690 }
8691
8692 printf ("\n");
8693
8694 return 1;
8695 }
8696
8697 #undef GET
8698 #undef LEB
8699 #undef SLEB
8700
8701 static int
8702 display_debug_not_supported (section, start, file)
8703 Elf32_Internal_Shdr * section;
8704 unsigned char * start ATTRIBUTE_UNUSED;
8705 FILE * file ATTRIBUTE_UNUSED;
8706 {
8707 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8708 SECTION_NAME (section));
8709
8710 return 1;
8711 }
8712
8713 /* Pre-scan the .debug_info section to record the size of address.
8714 When dumping the .debug_line, we use that size information, assuming
8715 that all compilation units have the same address size. */
8716 static int
8717 prescan_debug_info (section, start, file)
8718 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8719 unsigned char * start;
8720 FILE * file ATTRIBUTE_UNUSED;
8721 {
8722 DWARF2_External_CompUnit * external;
8723
8724 external = (DWARF2_External_CompUnit *) start;
8725
8726 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8727 return 0;
8728 }
8729
8730 /* A structure containing the name of a debug section and a pointer
8731 to a function that can decode it. The third field is a prescan
8732 function to be run over the section before displaying any of the
8733 sections. */
8734 struct
8735 {
8736 const char * const name;
8737 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8738 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8739 }
8740 debug_displays[] =
8741 {
8742 { ".debug_abbrev", display_debug_abbrev, NULL },
8743 { ".debug_aranges", display_debug_aranges, NULL },
8744 { ".debug_frame", display_debug_frames, NULL },
8745 { ".debug_info", display_debug_info, prescan_debug_info },
8746 { ".debug_line", display_debug_lines, NULL },
8747 { ".debug_pubnames", display_debug_pubnames, NULL },
8748 { ".eh_frame", display_debug_frames, NULL },
8749 { ".debug_macinfo", display_debug_macinfo, NULL },
8750 { ".debug_str", display_debug_str, NULL },
8751 { ".debug_loc", display_debug_loc, NULL },
8752 { ".debug_pubtypes", display_debug_not_supported, NULL },
8753 { ".debug_ranges", display_debug_not_supported, NULL },
8754 { ".debug_static_func", display_debug_not_supported, NULL },
8755 { ".debug_static_vars", display_debug_not_supported, NULL },
8756 { ".debug_types", display_debug_not_supported, NULL },
8757 { ".debug_weaknames", display_debug_not_supported, NULL }
8758 };
8759
8760 static int
8761 display_debug_section (section, file)
8762 Elf32_Internal_Shdr * section;
8763 FILE * file;
8764 {
8765 char * name = SECTION_NAME (section);
8766 bfd_size_type length;
8767 unsigned char * start;
8768 int i;
8769
8770 length = section->sh_size;
8771 if (length == 0)
8772 {
8773 printf (_("\nSection '%s' has no debugging data.\n"), name);
8774 return 0;
8775 }
8776
8777 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8778 _("debug section data"));
8779 if (!start)
8780 return 0;
8781
8782 /* See if we know how to display the contents of this section. */
8783 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8784 name = ".debug_info";
8785
8786 for (i = NUM_ELEM (debug_displays); i--;)
8787 if (strcmp (debug_displays[i].name, name) == 0)
8788 {
8789 debug_displays[i].display (section, start, file);
8790 break;
8791 }
8792
8793 if (i == -1)
8794 printf (_("Unrecognized debug section: %s\n"), name);
8795
8796 free (start);
8797
8798 /* If we loaded in the abbrev section at some point,
8799 we must release it here. */
8800 free_abbrevs ();
8801
8802 return 1;
8803 }
8804
8805 static int
8806 process_section_contents (file)
8807 FILE * file;
8808 {
8809 Elf32_Internal_Shdr * section;
8810 unsigned int i;
8811
8812 if (! do_dump)
8813 return 1;
8814
8815 /* Pre-scan the debug sections to find some debug information not
8816 present in some of them. For the .debug_line, we must find out the
8817 size of address (specified in .debug_info and .debug_aranges). */
8818 for (i = 0, section = section_headers;
8819 i < elf_header.e_shnum && i < num_dump_sects;
8820 i ++, section ++)
8821 {
8822 char * name = SECTION_NAME (section);
8823 int j;
8824
8825 if (section->sh_size == 0)
8826 continue;
8827
8828 /* See if there is some pre-scan operation for this section. */
8829 for (j = NUM_ELEM (debug_displays); j--;)
8830 if (strcmp (debug_displays[j].name, name) == 0)
8831 {
8832 if (debug_displays[j].prescan != NULL)
8833 {
8834 bfd_size_type length;
8835 unsigned char * start;
8836
8837 length = section->sh_size;
8838 start = ((unsigned char *)
8839 get_data (NULL, file, section->sh_offset, length,
8840 _("debug section data")));
8841 if (!start)
8842 return 0;
8843
8844 debug_displays[j].prescan (section, start, file);
8845 free (start);
8846 }
8847
8848 break;
8849 }
8850 }
8851
8852 for (i = 0, section = section_headers;
8853 i < elf_header.e_shnum && i < num_dump_sects;
8854 i ++, section ++)
8855 {
8856 #ifdef SUPPORT_DISASSEMBLY
8857 if (dump_sects[i] & DISASS_DUMP)
8858 disassemble_section (section, file);
8859 #endif
8860 if (dump_sects[i] & HEX_DUMP)
8861 dump_section (section, file);
8862
8863 if (dump_sects[i] & DEBUG_DUMP)
8864 display_debug_section (section, file);
8865 }
8866
8867 if (i < num_dump_sects)
8868 warn (_("Some sections were not dumped because they do not exist!\n"));
8869
8870 return 1;
8871 }
8872
8873 static void
8874 process_mips_fpe_exception (mask)
8875 int mask;
8876 {
8877 if (mask)
8878 {
8879 int first = 1;
8880 if (mask & OEX_FPU_INEX)
8881 fputs ("INEX", stdout), first = 0;
8882 if (mask & OEX_FPU_UFLO)
8883 printf ("%sUFLO", first ? "" : "|"), first = 0;
8884 if (mask & OEX_FPU_OFLO)
8885 printf ("%sOFLO", first ? "" : "|"), first = 0;
8886 if (mask & OEX_FPU_DIV0)
8887 printf ("%sDIV0", first ? "" : "|"), first = 0;
8888 if (mask & OEX_FPU_INVAL)
8889 printf ("%sINVAL", first ? "" : "|");
8890 }
8891 else
8892 fputs ("0", stdout);
8893 }
8894
8895 static int
8896 process_mips_specific (file)
8897 FILE * file;
8898 {
8899 Elf_Internal_Dyn * entry;
8900 size_t liblist_offset = 0;
8901 size_t liblistno = 0;
8902 size_t conflictsno = 0;
8903 size_t options_offset = 0;
8904 size_t conflicts_offset = 0;
8905
8906 /* We have a lot of special sections. Thanks SGI! */
8907 if (dynamic_segment == NULL)
8908 /* No information available. */
8909 return 0;
8910
8911 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8912 switch (entry->d_tag)
8913 {
8914 case DT_MIPS_LIBLIST:
8915 liblist_offset = entry->d_un.d_val - loadaddr;
8916 break;
8917 case DT_MIPS_LIBLISTNO:
8918 liblistno = entry->d_un.d_val;
8919 break;
8920 case DT_MIPS_OPTIONS:
8921 options_offset = entry->d_un.d_val - loadaddr;
8922 break;
8923 case DT_MIPS_CONFLICT:
8924 conflicts_offset = entry->d_un.d_val - loadaddr;
8925 break;
8926 case DT_MIPS_CONFLICTNO:
8927 conflictsno = entry->d_un.d_val;
8928 break;
8929 default:
8930 break;
8931 }
8932
8933 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8934 {
8935 Elf32_External_Lib * elib;
8936 size_t cnt;
8937
8938 elib = ((Elf32_External_Lib *)
8939 get_data (NULL, file, liblist_offset,
8940 liblistno * sizeof (Elf32_External_Lib),
8941 _("liblist")));
8942 if (elib)
8943 {
8944 printf ("\nSection '.liblist' contains %lu entries:\n",
8945 (unsigned long) liblistno);
8946 fputs (" Library Time Stamp Checksum Version Flags\n",
8947 stdout);
8948
8949 for (cnt = 0; cnt < liblistno; ++cnt)
8950 {
8951 Elf32_Lib liblist;
8952 time_t time;
8953 char timebuf[20];
8954 struct tm * tmp;
8955
8956 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8957 time = BYTE_GET (elib[cnt].l_time_stamp);
8958 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8959 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8960 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8961
8962 tmp = gmtime (&time);
8963 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8964 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8965 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8966
8967 printf ("%3lu: ", (unsigned long) cnt);
8968 print_symbol (20, dynamic_strings + liblist.l_name);
8969 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8970 liblist.l_version);
8971
8972 if (liblist.l_flags == 0)
8973 puts (" NONE");
8974 else
8975 {
8976 static const struct
8977 {
8978 const char * name;
8979 int bit;
8980 }
8981 l_flags_vals[] =
8982 {
8983 { " EXACT_MATCH", LL_EXACT_MATCH },
8984 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8985 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8986 { " EXPORTS", LL_EXPORTS },
8987 { " DELAY_LOAD", LL_DELAY_LOAD },
8988 { " DELTA", LL_DELTA }
8989 };
8990 int flags = liblist.l_flags;
8991 size_t fcnt;
8992
8993 for (fcnt = 0;
8994 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8995 ++fcnt)
8996 if ((flags & l_flags_vals[fcnt].bit) != 0)
8997 {
8998 fputs (l_flags_vals[fcnt].name, stdout);
8999 flags ^= l_flags_vals[fcnt].bit;
9000 }
9001 if (flags != 0)
9002 printf (" %#x", (unsigned int) flags);
9003
9004 puts ("");
9005 }
9006 }
9007
9008 free (elib);
9009 }
9010 }
9011
9012 if (options_offset != 0)
9013 {
9014 Elf_External_Options * eopt;
9015 Elf_Internal_Shdr * sect = section_headers;
9016 Elf_Internal_Options * iopt;
9017 Elf_Internal_Options * option;
9018 size_t offset;
9019 int cnt;
9020
9021 /* Find the section header so that we get the size. */
9022 while (sect->sh_type != SHT_MIPS_OPTIONS)
9023 ++ sect;
9024
9025 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9026 sect->sh_size, _("options"));
9027 if (eopt)
9028 {
9029 iopt = ((Elf_Internal_Options *)
9030 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
9031 if (iopt == NULL)
9032 {
9033 error (_("Out of memory"));
9034 return 0;
9035 }
9036
9037 offset = cnt = 0;
9038 option = iopt;
9039
9040 while (offset < sect->sh_size)
9041 {
9042 Elf_External_Options * eoption;
9043
9044 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9045
9046 option->kind = BYTE_GET (eoption->kind);
9047 option->size = BYTE_GET (eoption->size);
9048 option->section = BYTE_GET (eoption->section);
9049 option->info = BYTE_GET (eoption->info);
9050
9051 offset += option->size;
9052
9053 ++option;
9054 ++cnt;
9055 }
9056
9057 printf (_("\nSection '%s' contains %d entries:\n"),
9058 SECTION_NAME (sect), cnt);
9059
9060 option = iopt;
9061
9062 while (cnt-- > 0)
9063 {
9064 size_t len;
9065
9066 switch (option->kind)
9067 {
9068 case ODK_NULL:
9069 /* This shouldn't happen. */
9070 printf (" NULL %d %lx", option->section, option->info);
9071 break;
9072 case ODK_REGINFO:
9073 printf (" REGINFO ");
9074 if (elf_header.e_machine == EM_MIPS)
9075 {
9076 /* 32bit form. */
9077 Elf32_External_RegInfo * ereg;
9078 Elf32_RegInfo reginfo;
9079
9080 ereg = (Elf32_External_RegInfo *) (option + 1);
9081 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9082 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9083 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9084 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9085 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9086 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9087
9088 printf ("GPR %08lx GP 0x%lx\n",
9089 reginfo.ri_gprmask,
9090 (unsigned long) reginfo.ri_gp_value);
9091 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9092 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9093 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9094 }
9095 else
9096 {
9097 /* 64 bit form. */
9098 Elf64_External_RegInfo * ereg;
9099 Elf64_Internal_RegInfo reginfo;
9100
9101 ereg = (Elf64_External_RegInfo *) (option + 1);
9102 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9103 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9104 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9105 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9106 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9107 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9108
9109 printf ("GPR %08lx GP 0x",
9110 reginfo.ri_gprmask);
9111 printf_vma (reginfo.ri_gp_value);
9112 printf ("\n");
9113
9114 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9115 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9116 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9117 }
9118 ++option;
9119 continue;
9120 case ODK_EXCEPTIONS:
9121 fputs (" EXCEPTIONS fpe_min(", stdout);
9122 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9123 fputs (") fpe_max(", stdout);
9124 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9125 fputs (")", stdout);
9126
9127 if (option->info & OEX_PAGE0)
9128 fputs (" PAGE0", stdout);
9129 if (option->info & OEX_SMM)
9130 fputs (" SMM", stdout);
9131 if (option->info & OEX_FPDBUG)
9132 fputs (" FPDBUG", stdout);
9133 if (option->info & OEX_DISMISS)
9134 fputs (" DISMISS", stdout);
9135 break;
9136 case ODK_PAD:
9137 fputs (" PAD ", stdout);
9138 if (option->info & OPAD_PREFIX)
9139 fputs (" PREFIX", stdout);
9140 if (option->info & OPAD_POSTFIX)
9141 fputs (" POSTFIX", stdout);
9142 if (option->info & OPAD_SYMBOL)
9143 fputs (" SYMBOL", stdout);
9144 break;
9145 case ODK_HWPATCH:
9146 fputs (" HWPATCH ", stdout);
9147 if (option->info & OHW_R4KEOP)
9148 fputs (" R4KEOP", stdout);
9149 if (option->info & OHW_R8KPFETCH)
9150 fputs (" R8KPFETCH", stdout);
9151 if (option->info & OHW_R5KEOP)
9152 fputs (" R5KEOP", stdout);
9153 if (option->info & OHW_R5KCVTL)
9154 fputs (" R5KCVTL", stdout);
9155 break;
9156 case ODK_FILL:
9157 fputs (" FILL ", stdout);
9158 /* XXX Print content of info word? */
9159 break;
9160 case ODK_TAGS:
9161 fputs (" TAGS ", stdout);
9162 /* XXX Print content of info word? */
9163 break;
9164 case ODK_HWAND:
9165 fputs (" HWAND ", stdout);
9166 if (option->info & OHWA0_R4KEOP_CHECKED)
9167 fputs (" R4KEOP_CHECKED", stdout);
9168 if (option->info & OHWA0_R4KEOP_CLEAN)
9169 fputs (" R4KEOP_CLEAN", stdout);
9170 break;
9171 case ODK_HWOR:
9172 fputs (" HWOR ", stdout);
9173 if (option->info & OHWA0_R4KEOP_CHECKED)
9174 fputs (" R4KEOP_CHECKED", stdout);
9175 if (option->info & OHWA0_R4KEOP_CLEAN)
9176 fputs (" R4KEOP_CLEAN", stdout);
9177 break;
9178 case ODK_GP_GROUP:
9179 printf (" GP_GROUP %#06lx self-contained %#06lx",
9180 option->info & OGP_GROUP,
9181 (option->info & OGP_SELF) >> 16);
9182 break;
9183 case ODK_IDENT:
9184 printf (" IDENT %#06lx self-contained %#06lx",
9185 option->info & OGP_GROUP,
9186 (option->info & OGP_SELF) >> 16);
9187 break;
9188 default:
9189 /* This shouldn't happen. */
9190 printf (" %3d ??? %d %lx",
9191 option->kind, option->section, option->info);
9192 break;
9193 }
9194
9195 len = sizeof (* eopt);
9196 while (len < option->size)
9197 if (((char *) option)[len] >= ' '
9198 && ((char *) option)[len] < 0x7f)
9199 printf ("%c", ((char *) option)[len++]);
9200 else
9201 printf ("\\%03o", ((char *) option)[len++]);
9202
9203 fputs ("\n", stdout);
9204 ++option;
9205 }
9206
9207 free (eopt);
9208 }
9209 }
9210
9211 if (conflicts_offset != 0 && conflictsno != 0)
9212 {
9213 Elf32_Conflict * iconf;
9214 size_t cnt;
9215
9216 if (dynamic_symbols == NULL)
9217 {
9218 error (_("conflict list with without table"));
9219 return 0;
9220 }
9221
9222 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
9223 if (iconf == NULL)
9224 {
9225 error (_("Out of memory"));
9226 return 0;
9227 }
9228
9229 if (is_32bit_elf)
9230 {
9231 Elf32_External_Conflict * econf32;
9232
9233 econf32 = ((Elf32_External_Conflict *)
9234 get_data (NULL, file, conflicts_offset,
9235 conflictsno * sizeof (* econf32),
9236 _("conflict")));
9237 if (!econf32)
9238 return 0;
9239
9240 for (cnt = 0; cnt < conflictsno; ++cnt)
9241 iconf[cnt] = BYTE_GET (econf32[cnt]);
9242
9243 free (econf32);
9244 }
9245 else
9246 {
9247 Elf64_External_Conflict * econf64;
9248
9249 econf64 = ((Elf64_External_Conflict *)
9250 get_data (NULL, file, conflicts_offset,
9251 conflictsno * sizeof (* econf64),
9252 _("conflict")));
9253 if (!econf64)
9254 return 0;
9255
9256 for (cnt = 0; cnt < conflictsno; ++cnt)
9257 iconf[cnt] = BYTE_GET (econf64[cnt]);
9258
9259 free (econf64);
9260 }
9261
9262 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9263 (long) conflictsno);
9264 puts (_(" Num: Index Value Name"));
9265
9266 for (cnt = 0; cnt < conflictsno; ++cnt)
9267 {
9268 Elf_Internal_Sym * psym = & dynamic_symbols [iconf [cnt]];
9269
9270 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf [cnt]);
9271 print_vma (psym->st_value, FULL_HEX);
9272 putchar (' ');
9273 print_symbol (25, dynamic_strings + psym->st_name);
9274 putchar ('\n');
9275 }
9276
9277 free (iconf);
9278 }
9279
9280 return 1;
9281 }
9282
9283 static const char *
9284 get_note_type (e_type)
9285 unsigned e_type;
9286 {
9287 static char buff[64];
9288
9289 switch (e_type)
9290 {
9291 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9292 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9293 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9294 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9295 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9296 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9297 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9298 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9299 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9300 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9301 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
9302 default:
9303 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9304 return buff;
9305 }
9306 }
9307
9308 static const char *
9309 get_netbsd_elfcore_note_type (e_type)
9310 unsigned e_type;
9311 {
9312 static char buff[64];
9313
9314 if (e_type == NT_NETBSDCORE_PROCINFO)
9315 {
9316 /* NetBSD core "procinfo" structure. */
9317 return _("NetBSD procinfo structure");
9318 }
9319
9320 /* As of Jan 2002 there are no other machine-independent notes
9321 defined for NetBSD core files. If the note type is less
9322 than the start of the machine-dependent note types, we don't
9323 understand it. */
9324
9325 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9326 {
9327 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9328 return buff;
9329 }
9330
9331 switch (elf_header.e_machine)
9332 {
9333 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9334 and PT_GETFPREGS == mach+2. */
9335
9336 case EM_OLD_ALPHA:
9337 case EM_ALPHA:
9338 case EM_SPARC:
9339 case EM_SPARC32PLUS:
9340 case EM_SPARCV9:
9341 switch (e_type)
9342 {
9343 case NT_NETBSDCORE_FIRSTMACH+0:
9344 return _("PT_GETREGS (reg structure)");
9345 case NT_NETBSDCORE_FIRSTMACH+2:
9346 return _("PT_GETFPREGS (fpreg structure)");
9347 default:
9348 break;
9349 }
9350 break;
9351
9352 /* On all other arch's, PT_GETREGS == mach+1 and
9353 PT_GETFPREGS == mach+3. */
9354 default:
9355 switch (e_type)
9356 {
9357 case NT_NETBSDCORE_FIRSTMACH+1:
9358 return _("PT_GETREGS (reg structure)");
9359 case NT_NETBSDCORE_FIRSTMACH+3:
9360 return _("PT_GETFPREGS (fpreg structure)");
9361 default:
9362 break;
9363 }
9364 }
9365
9366 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9367 return buff;
9368 }
9369
9370 /* Note that by the ELF standard, the name field is already null byte
9371 terminated, and namesz includes the terminating null byte.
9372 I.E. the value of namesz for the name "FSF" is 4.
9373
9374 If the value of namesz is zero, there is no name present. */
9375 static int
9376 process_note (pnote)
9377 Elf32_Internal_Note * pnote;
9378 {
9379 const char *nt;
9380
9381 if (pnote->namesz == 0)
9382 {
9383 /* If there is no note name, then use the default set of
9384 note type strings. */
9385 nt = get_note_type (pnote->type);
9386 }
9387 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9388 {
9389 /* NetBSD-specific core file notes. */
9390 nt = get_netbsd_elfcore_note_type (pnote->type);
9391 }
9392 else
9393 {
9394 /* Don't recognize this note name; just use the default set of
9395 note type strings. */
9396 nt = get_note_type (pnote->type);
9397 }
9398
9399 printf (" %s\t\t0x%08lx\t%s\n",
9400 pnote->namesz ? pnote->namedata : "(NONE)",
9401 pnote->descsz, nt);
9402 return 1;
9403 }
9404
9405
9406 static int
9407 process_corefile_note_segment (file, offset, length)
9408 FILE * file;
9409 bfd_vma offset;
9410 bfd_vma length;
9411 {
9412 Elf_External_Note * pnotes;
9413 Elf_External_Note * external;
9414 int res = 1;
9415
9416 if (length <= 0)
9417 return 0;
9418
9419 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9420 _("notes"));
9421 if (!pnotes)
9422 return 0;
9423
9424 external = pnotes;
9425
9426 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9427 (unsigned long) offset, (unsigned long) length);
9428 printf (_(" Owner\t\tData size\tDescription\n"));
9429
9430 while (external < (Elf_External_Note *)((char *) pnotes + length))
9431 {
9432 Elf_External_Note * next;
9433 Elf32_Internal_Note inote;
9434 char * temp = NULL;
9435
9436 inote.type = BYTE_GET (external->type);
9437 inote.namesz = BYTE_GET (external->namesz);
9438 inote.namedata = external->name;
9439 inote.descsz = BYTE_GET (external->descsz);
9440 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9441 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9442
9443 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9444
9445 if (((char *) next) > (((char *) pnotes) + length))
9446 {
9447 warn (_("corrupt note found at offset %x into core notes\n"),
9448 ((char *) external) - ((char *) pnotes));
9449 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9450 inote.type, inote.namesz, inote.descsz);
9451 break;
9452 }
9453
9454 external = next;
9455
9456 /* Verify that name is null terminated. It appears that at least
9457 one version of Linux (RedHat 6.0) generates corefiles that don't
9458 comply with the ELF spec by failing to include the null byte in
9459 namesz. */
9460 if (inote.namedata[inote.namesz] != '\0')
9461 {
9462 temp = malloc (inote.namesz + 1);
9463
9464 if (temp == NULL)
9465 {
9466 error (_("Out of memory\n"));
9467 res = 0;
9468 break;
9469 }
9470
9471 strncpy (temp, inote.namedata, inote.namesz);
9472 temp[inote.namesz] = 0;
9473
9474 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9475 inote.namedata = temp;
9476 }
9477
9478 res &= process_note (& inote);
9479
9480 if (temp != NULL)
9481 {
9482 free (temp);
9483 temp = NULL;
9484 }
9485 }
9486
9487 free (pnotes);
9488
9489 return res;
9490 }
9491
9492 static int
9493 process_corefile_note_segments (file)
9494 FILE * file;
9495 {
9496 Elf_Internal_Phdr * program_headers;
9497 Elf_Internal_Phdr * segment;
9498 unsigned int i;
9499 int res = 1;
9500
9501 program_headers = (Elf_Internal_Phdr *) malloc
9502 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9503
9504 if (program_headers == NULL)
9505 {
9506 error (_("Out of memory\n"));
9507 return 0;
9508 }
9509
9510 if (is_32bit_elf)
9511 i = get_32bit_program_headers (file, program_headers);
9512 else
9513 i = get_64bit_program_headers (file, program_headers);
9514
9515 if (i == 0)
9516 {
9517 free (program_headers);
9518 return 0;
9519 }
9520
9521 for (i = 0, segment = program_headers;
9522 i < elf_header.e_phnum;
9523 i ++, segment ++)
9524 {
9525 if (segment->p_type == PT_NOTE)
9526 res &= process_corefile_note_segment (file,
9527 (bfd_vma) segment->p_offset,
9528 (bfd_vma) segment->p_filesz);
9529 }
9530
9531 free (program_headers);
9532
9533 return res;
9534 }
9535
9536 static int
9537 process_corefile_contents (file)
9538 FILE * file;
9539 {
9540 /* If we have not been asked to display the notes then do nothing. */
9541 if (! do_notes)
9542 return 1;
9543
9544 /* If file is not a core file then exit. */
9545 if (elf_header.e_type != ET_CORE)
9546 return 1;
9547
9548 /* No program headers means no NOTE segment. */
9549 if (elf_header.e_phnum == 0)
9550 {
9551 printf (_("No note segments present in the core file.\n"));
9552 return 1;
9553 }
9554
9555 return process_corefile_note_segments (file);
9556 }
9557
9558 static int
9559 process_arch_specific (file)
9560 FILE * file;
9561 {
9562 if (! do_arch)
9563 return 1;
9564
9565 switch (elf_header.e_machine)
9566 {
9567 case EM_MIPS:
9568 case EM_MIPS_RS3_LE:
9569 return process_mips_specific (file);
9570 break;
9571 default:
9572 break;
9573 }
9574 return 1;
9575 }
9576
9577 static int
9578 get_file_header (file)
9579 FILE * file;
9580 {
9581 /* Read in the identity array. */
9582 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9583 return 0;
9584
9585 /* Determine how to read the rest of the header. */
9586 switch (elf_header.e_ident [EI_DATA])
9587 {
9588 default: /* fall through */
9589 case ELFDATANONE: /* fall through */
9590 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
9591 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
9592 }
9593
9594 /* For now we only support 32 bit and 64 bit ELF files. */
9595 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
9596
9597 /* Read in the rest of the header. */
9598 if (is_32bit_elf)
9599 {
9600 Elf32_External_Ehdr ehdr32;
9601
9602 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9603 return 0;
9604
9605 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9606 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9607 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9608 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9609 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9610 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9611 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9612 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9613 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9614 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9615 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9616 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9617 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9618 }
9619 else
9620 {
9621 Elf64_External_Ehdr ehdr64;
9622
9623 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9624 we will not be able to cope with the 64bit data found in
9625 64 ELF files. Detect this now and abort before we start
9626 overwritting things. */
9627 if (sizeof (bfd_vma) < 8)
9628 {
9629 error (_("This instance of readelf has been built without support for a\n\
9630 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9631 return 0;
9632 }
9633
9634 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9635 return 0;
9636
9637 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9638 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9639 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9640 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
9641 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
9642 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
9643 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9644 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9645 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9646 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9647 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9648 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9649 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9650 }
9651
9652 /* There may be some extensions in the first section header. Don't
9653 bomb if we can't read it. */
9654 if (is_32bit_elf)
9655 get_32bit_section_headers (file, 1);
9656 else
9657 get_64bit_section_headers (file, 1);
9658
9659 return 1;
9660 }
9661
9662 static int
9663 process_file (file_name)
9664 char * file_name;
9665 {
9666 FILE * file;
9667 struct stat statbuf;
9668 unsigned int i;
9669
9670 if (stat (file_name, & statbuf) < 0)
9671 {
9672 error (_("Cannot stat input file %s.\n"), file_name);
9673 return 1;
9674 }
9675
9676 file = fopen (file_name, "rb");
9677 if (file == NULL)
9678 {
9679 error (_("Input file %s not found.\n"), file_name);
9680 return 1;
9681 }
9682
9683 if (! get_file_header (file))
9684 {
9685 error (_("%s: Failed to read file header\n"), file_name);
9686 fclose (file);
9687 return 1;
9688 }
9689
9690 /* Initialise per file variables. */
9691 for (i = NUM_ELEM (version_info); i--;)
9692 version_info[i] = 0;
9693
9694 for (i = NUM_ELEM (dynamic_info); i--;)
9695 dynamic_info[i] = 0;
9696
9697 /* Process the file. */
9698 if (show_name)
9699 printf (_("\nFile: %s\n"), file_name);
9700
9701 if (! process_file_header ())
9702 {
9703 fclose (file);
9704 return 1;
9705 }
9706
9707 process_section_headers (file);
9708
9709 process_program_headers (file);
9710
9711 process_dynamic_segment (file);
9712
9713 process_relocs (file);
9714
9715 process_unwind (file);
9716
9717 process_symbol_table (file);
9718
9719 process_syminfo (file);
9720
9721 process_version_sections (file);
9722
9723 process_section_contents (file);
9724
9725 process_corefile_contents (file);
9726
9727 process_arch_specific (file);
9728
9729 fclose (file);
9730
9731 if (section_headers)
9732 {
9733 free (section_headers);
9734 section_headers = NULL;
9735 }
9736
9737 if (string_table)
9738 {
9739 free (string_table);
9740 string_table = NULL;
9741 string_table_length = 0;
9742 }
9743
9744 if (dynamic_strings)
9745 {
9746 free (dynamic_strings);
9747 dynamic_strings = NULL;
9748 }
9749
9750 if (dynamic_symbols)
9751 {
9752 free (dynamic_symbols);
9753 dynamic_symbols = NULL;
9754 num_dynamic_syms = 0;
9755 }
9756
9757 if (dynamic_syminfo)
9758 {
9759 free (dynamic_syminfo);
9760 dynamic_syminfo = NULL;
9761 }
9762
9763 return 0;
9764 }
9765
9766 #ifdef SUPPORT_DISASSEMBLY
9767 /* Needed by the i386 disassembler. For extra credit, someone could
9768 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9769 symbols. */
9770
9771 void
9772 print_address (unsigned int addr, FILE * outfile)
9773 {
9774 fprintf (outfile,"0x%8.8x", addr);
9775 }
9776
9777 /* Needed by the i386 disassembler. */
9778 void
9779 db_task_printsym (unsigned int addr)
9780 {
9781 print_address (addr, stderr);
9782 }
9783 #endif
9784
9785 int main PARAMS ((int, char **));
9786
9787 int
9788 main (argc, argv)
9789 int argc;
9790 char ** argv;
9791 {
9792 int err;
9793
9794 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9795 setlocale (LC_MESSAGES, "");
9796 #endif
9797 #if defined (HAVE_SETLOCALE)
9798 setlocale (LC_CTYPE, "");
9799 #endif
9800 bindtextdomain (PACKAGE, LOCALEDIR);
9801 textdomain (PACKAGE);
9802
9803 parse_args (argc, argv);
9804
9805 if (optind < (argc - 1))
9806 show_name = 1;
9807
9808 err = 0;
9809 while (optind < argc)
9810 err |= process_file (argv [optind ++]);
9811
9812 if (dump_sects != NULL)
9813 free (dump_sects);
9814
9815 return err;
9816 }
git-cvsimport of binutils cvsroot