]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - binutils/readelf.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/tc-alpha.c (md_assemble): Accept `1' and `9' in an
[thirdparty/binutils-gdb.git] / binutils / readelf.c
CommitLineData
252b5132 1/* readelf.c -- display contents of an ELF format file
305c7206 2 Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
252b5132
RH		 3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.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/stat.h>
27#include <stdio.h>
28#include <time.h>
29
a952a375 30#if __GNUC__ >= 2
19936277 31/* Define BFD64 here, even if our default architecture is 32 bit ELF
a952a375
NC		 32 as this will allow us to read in and parse 64bit and 32bit ELF files.
33 Only do this if we belive that the compiler can support a 64 bit
34 data type. For now we only rely on GCC being able to do this. */
19936277 35#define BFD64
a952a375
NC		 36#endif
37
252b5132
RH		 38#include "bfd.h"
39
40#include "elf/common.h"
41#include "elf/external.h"
42#include "elf/internal.h"
43#include "elf/dwarf2.h"
44
45/* The following headers use the elf/reloc-macros.h file to
46 automatically generate relocation recognition functions
47 such as elf_mips_reloc_type() */
48
49#define RELOC_MACROS_GEN_FUNC
50
51#include "elf/i386.h"
52#include "elf/v850.h"
53#include "elf/ppc.h"
54#include "elf/mips.h"
55#include "elf/alpha.h"
56#include "elf/arm.h"
57#include "elf/m68k.h"
58#include "elf/sparc.h"
59#include "elf/m32r.h"
60#include "elf/d10v.h"
61#include "elf/d30v.h"
62#include "elf/sh.h"
63#include "elf/mn10200.h"
64#include "elf/mn10300.h"
65#include "elf/hppa.h"
66#include "elf/arc.h"
67#include "elf/fr30.h"
68#include "elf/mcore.h"
63fcb9e9 69#include "elf/i960.h"
7d466069 70#include "elf/pj.h"
252b5132
RH		 71
72#include "bucomm.h"
73#include "getopt.h"
74
75#ifdef ANSI_PROTOTYPES
76#include <stdarg.h>
77#else
78#include <varargs.h>
79#endif
80
81char * program_name = "readelf";
82unsigned int dynamic_addr;
9ea033b2 83bfd_size_type dynamic_size;
252b5132
RH		 84unsigned int rela_addr;
85unsigned int rela_size;
86char * dynamic_strings;
87char * string_table;
19936277 88unsigned long num_dynamic_syms;
252b5132
RH		 89Elf_Internal_Sym * dynamic_symbols;
90Elf_Internal_Syminfo * dynamic_syminfo;
91unsigned long dynamic_syminfo_offset;
92unsigned int dynamic_syminfo_nent;
93char program_interpreter [64];
94int dynamic_info[DT_JMPREL + 1];
95int version_info[16];
96int loadaddr = 0;
97Elf_Internal_Ehdr elf_header;
98Elf_Internal_Shdr * section_headers;
99Elf_Internal_Dyn * dynamic_segment;
100int show_name;
101int do_dynamic;
102int do_syms;
103int do_reloc;
104int do_sections;
105int do_segments;
106int do_using_dynamic;
107int do_header;
108int do_dump;
109int do_version;
110int do_histogram;
111int do_debugging;
112int do_debug_info;
113int do_debug_abbrevs;
114int do_debug_lines;
115int do_debug_pubnames;
116int do_debug_aranges;
a952a375 117int do_arch;
779fe533 118int do_notes;
9ea033b2 119int is_32bit_elf;
252b5132
RH		 120
121/* A dynamic array of flags indicating which sections require dumping. */
122char * dump_sects = NULL;
123unsigned int num_dump_sects = 0;
124
125#define HEX_DUMP (1 << 0)
126#define DISASS_DUMP (1 << 1)
127#define DEBUG_DUMP (1 << 2)
128
843dd992
NC		 129/* How to rpint a vma value. */
130typedef enum print_mode
131{
132 HEX,
133 DEC,
134 DEC_5,
135 UNSIGNED,
136 PREFIX_HEX,
137 FULL_HEX,
138 LONG_HEX
139}
140print_mode;
141
252b5132 142/* Forward declarations for dumb compilers. */
30800947 143static void print_vma PARAMS ((bfd_vma, print_mode));
9ea033b2
NC		 144static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
145static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
146static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
147static const char * get_mips_dynamic_type PARAMS ((unsigned long));
9a097730 148static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
103f02d3 149static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
9ea033b2 150static const char * get_dynamic_type PARAMS ((unsigned long));
19936277 151static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
9ea033b2
NC		 152static char * get_file_type PARAMS ((unsigned));
153static char * get_machine_name PARAMS ((unsigned));
154static char * get_machine_flags PARAMS ((unsigned, unsigned));
155static const char * get_mips_segment_type PARAMS ((unsigned long));
103f02d3 156static const char * get_parisc_segment_type PARAMS ((unsigned long));
9ea033b2
NC		 157static const char * get_segment_type PARAMS ((unsigned long));
158static const char * get_mips_section_type_name PARAMS ((unsigned int));
103f02d3 159static const char * get_parisc_section_type_name PARAMS ((unsigned int));
9ea033b2 160static const char * get_section_type_name PARAMS ((unsigned int));
d1133906
NC		 161static const char * get_symbol_binding PARAMS ((unsigned int));
162static const char * get_symbol_type PARAMS ((unsigned int));
163static const char * get_symbol_visibility PARAMS ((unsigned int));
164static const char * get_symbol_index_type PARAMS ((unsigned int));
165static const char * get_dynamic_flags PARAMS ((bfd_vma));
252b5132 166static void usage PARAMS ((void));
9ea033b2 167static void parse_args PARAMS ((int, char **));
252b5132
RH		 168static int process_file_header PARAMS ((void));
169static int process_program_headers PARAMS ((FILE *));
170static int process_section_headers PARAMS ((FILE *));
9ea033b2 171static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
103f02d3 172static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
252b5132
RH		 173static int process_dynamic_segment PARAMS ((FILE *));
174static int process_symbol_table PARAMS ((FILE *));
175static int process_section_contents PARAMS ((FILE *));
9ea033b2 176static void process_file PARAMS ((char *));
252b5132
RH		 177static int process_relocs PARAMS ((FILE *));
178static int process_version_sections PARAMS ((FILE *));
9ea033b2 179static char * get_ver_flags PARAMS ((unsigned int));
9ea033b2
NC		 180static int get_32bit_section_headers PARAMS ((FILE *));
181static int get_64bit_section_headers PARAMS ((FILE *));
182static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
183static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
184static int get_file_header PARAMS ((FILE *));
185static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
186static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
187static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
188static int get_32bit_dynamic_segment PARAMS ((FILE *));
189static int get_64bit_dynamic_segment PARAMS ((FILE *));
252b5132
RH		 190#ifdef SUPPORT_DISASSEMBLY
191static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
192#endif
193static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
194static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
195static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
196static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
197static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
198static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
199static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
200static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
201static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
3590ea00 202static int process_extended_line_op PARAMS ((unsigned char *, int, int));
252b5132
RH		 203static void reset_state_machine PARAMS ((int));
204static char * get_TAG_name PARAMS ((unsigned long));
205static char * get_AT_name PARAMS ((unsigned long));
206static char * get_FORM_name PARAMS ((unsigned long));
207static void free_abbrevs PARAMS ((void));
208static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
209static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
210static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
211static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
212static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
213static void request_dump PARAMS ((unsigned int, char));
214static const char * get_elf_class PARAMS ((unsigned char));
215static const char * get_data_encoding PARAMS ((unsigned char));
216static const char * get_osabi_name PARAMS ((unsigned char));
9c19a809 217static int guess_is_rela PARAMS ((unsigned long));
779fe533 218static char * get_note_type PARAMS ((unsigned int));
6d118b09 219static int process_note PARAMS ((Elf32_Internal_Note *));
f7a99963 220static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
779fe533
NC		 221static int process_corefile_note_segments PARAMS ((FILE *));
222static int process_corefile_contents PARAMS ((FILE *));
252b5132
RH		 223
224typedef int Elf32_Word;
225
9c19a809
NC		 226#ifndef TRUE
227#define TRUE 1
228#define FALSE 0
229#endif
230#define UNKNOWN -1
231
252b5132
RH		 232#define SECTION_NAME(X) (string_table + (X)->sh_name)
233
234#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
235
236#define BYTE_GET(field) byte_get (field, sizeof (field))
a952a375
NC		 237
238/* If we can support a 64 bit data type then BFD64 should be defined
239 and sizeof (bfd_vma) == 8. In this case when translating from an
240 external 8 byte field to an internal field, we can assume that the
241 internal field is also 8 bytes wide and so we can extact all the data.
242 If, however, BFD64 is not defined, then we must assume that the
243 internal data structure only has 4 byte wide fields that are the
244 equivalent of the 8 byte wide external counterparts, and so we must
245 truncate the data. */
246#ifdef BFD64
9ea033b2 247#define BYTE_GET8(field) byte_get (field, -8)
a952a375
NC		 248#else
249#define BYTE_GET8(field) byte_get (field, 8)
250#endif
252b5132
RH		 251
252#define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253
254#define GET_DATA_ALLOC(offset, size, var, type, reason) \
255 if (fseek (file, offset, SEEK_SET)) \
256 { \
257 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
258 return 0; \
259 } \
260 \
261 var = (type) malloc (size); \
262 \
263 if (var == NULL) \
264 { \
265 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
266 return 0; \
267 } \
268 \
269 if (fread (var, size, 1, file) != 1) \
270 { \
271 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
272 free (var); \
273 var = NULL; \
274 return 0; \
275 }
276
277
278#define GET_DATA(offset, var, reason) \
279 if (fseek (file, offset, SEEK_SET)) \
280 { \
281 error (_("Unable to seek to %x for %s\n"), offset, reason); \
282 return 0; \
283 } \
284 else if (fread (& var, sizeof (var), 1, file) != 1) \
285 { \
286 error (_("Unable to read data at %x for %s\n"), offset, reason); \
287 return 0; \
288 }
289
9ea033b2
NC		 290#define GET_ELF_SYMBOLS(file, offset, size) \
291 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
292 : get_64bit_elf_symbols (file, offset, size))
293
294
252b5132
RH		 295#ifdef ANSI_PROTOTYPES
296static void
297error (const char * message, ...)
298{
299 va_list args;
300
301 fprintf (stderr, _("%s: Error: "), program_name);
302 va_start (args, message);
303 vfprintf (stderr, message, args);
304 va_end (args);
305 return;
306}
307
308static void
309warn (const char * message, ...)
310{
311 va_list args;
312
313 fprintf (stderr, _("%s: Warning: "), program_name);
314 va_start (args, message);
315 vfprintf (stderr, message, args);
316 va_end (args);
317 return;
318}
319#else
320static void
321error (va_alist)
322 va_dcl
323{
324 char * message;
325 va_list args;
326
327 fprintf (stderr, _("%s: Error: "), program_name);
328 va_start (args);
329 message = va_arg (args, char *);
330 vfprintf (stderr, message, args);
331 va_end (args);
332 return;
333}
334
335static void
336warn (va_alist)
337 va_dcl
338{
339 char * message;
340 va_list args;
341
342 fprintf (stderr, _("%s: Warning: "), program_name);
343 va_start (args);
344 message = va_arg (args, char *);
345 vfprintf (stderr, message, args);
346 va_end (args);
347 return;
348}
349#endif
350
9ea033b2 351static bfd_vma
252b5132
RH		 352byte_get_little_endian (field, size)
353 unsigned char * field;
354 int size;
355{
356 switch (size)
357 {
358 case 1:
359 return * field;
360
361 case 2:
362 return ((unsigned int) (field [0]))
363 | (((unsigned int) (field [1])) << 8);
364
9ea033b2
NC		 365 case 8:
366 /* We want to extract data from an 8 byte wide field and
367 place it into a 4 byte wide field. Since this is a little
368 endian source we can juts use the 4 byte extraction code. */
369 /* Fall through. */
252b5132
RH		 370 case 4:
371 return ((unsigned long) (field [0]))
372 | (((unsigned long) (field [1])) << 8)
373 | (((unsigned long) (field [2])) << 16)
374 | (((unsigned long) (field [3])) << 24);
375
a952a375 376#ifdef BFD64
9ea033b2
NC		 377 case -8:
378 /* This is a special case, generated by the BYTE_GET8 macro.
379 It means that we are loading an 8 byte value from a field
380 in an external structure into an 8 byte value in a field
381 in an internal strcuture. */
382 return ((bfd_vma) (field [0]))
383 | (((bfd_vma) (field [1])) << 8)
384 | (((bfd_vma) (field [2])) << 16)
385 | (((bfd_vma) (field [3])) << 24)
386 | (((bfd_vma) (field [4])) << 32)
387 | (((bfd_vma) (field [5])) << 40)
388 | (((bfd_vma) (field [6])) << 48)
389 | (((bfd_vma) (field [7])) << 56);
a952a375 390#endif
252b5132
RH		 391 default:
392 error (_("Unhandled data length: %d\n"), size);
9ea033b2 393 abort ();
252b5132
RH		 394 }
395}
396
f7a99963 397/* Print a VMA value. */
f7a99963
NC		 398static void
399print_vma (vma, mode)
400 bfd_vma vma;
401 print_mode mode;
402{
403#ifdef BFD64
404 if (is_32bit_elf)
405#endif
406 {
407 switch (mode)
408 {
409 case FULL_HEX: printf ("0x"); /* drop through */
5e220199 410 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
f7a99963 411 case PREFIX_HEX: printf ("0x"); /* drop through */
5e220199
NC		 412 case HEX: printf ("%lx", (unsigned long) vma); break;
413 case DEC: printf ("%ld", (unsigned long) vma); break;
414 case DEC_5: printf ("%5ld", (long) vma); break;
415 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
f7a99963
NC		 416 }
417 }
418#ifdef BFD64
419 else
420 {
421 switch (mode)
422 {
423 case FULL_HEX:
424 printf ("0x");
425 /* drop through */
426
427 case LONG_HEX:
428 printf_vma (vma);
429 break;
430
431 case PREFIX_HEX:
432 printf ("0x");
433 /* drop through */
434
435 case HEX:
436#if BFD_HOST_64BIT_LONG
437 printf ("%lx", vma);
438#else
439 if (_bfd_int64_high (vma))
440 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
441 else
442 printf ("%lx", _bfd_int64_low (vma));
443#endif
444 break;
445
446 case DEC:
2f528887
NC		 447#if BFD_HOST_64BIT_LONG
448 printf ("%ld", vma);
449#else
f7a99963
NC		 450 if (_bfd_int64_high (vma))
451 /* ugg */
452 printf ("++%ld", _bfd_int64_low (vma));
453 else
454 printf ("%ld", _bfd_int64_low (vma));
2f528887 455#endif
f7a99963
NC		 456 break;
457
458 case DEC_5:
2f528887
NC		 459#if BFD_HOST_64BIT_LONG
460 printf ("%5ld", vma);
461#else
f7a99963
NC		 462 if (_bfd_int64_high (vma))
463 /* ugg */
464 printf ("++%ld", _bfd_int64_low (vma));
465 else
466 printf ("%5ld", _bfd_int64_low (vma));
2f528887 467#endif
f7a99963
NC		 468 break;
469
470 case UNSIGNED:
2f528887
NC		 471#if BFD_HOST_64BIT_LONG
472 printf ("%lu", vma);
473#else
f7a99963
NC		 474 if (_bfd_int64_high (vma))
475 /* ugg */
476 printf ("++%lu", _bfd_int64_low (vma));
477 else
478 printf ("%lu", _bfd_int64_low (vma));
2f528887 479#endif
f7a99963
NC		 480 break;
481 }
482 }
483#endif
484}
485
9ea033b2 486static bfd_vma
252b5132
RH		 487byte_get_big_endian (field, size)
488 unsigned char * field;
489 int size;
490{
491 switch (size)
492 {
493 case 1:
494 return * field;
495
496 case 2:
497 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
498
499 case 4:
500 return ((unsigned long) (field [3]))
501 | (((unsigned long) (field [2])) << 8)
502 | (((unsigned long) (field [1])) << 16)
503 | (((unsigned long) (field [0])) << 24);
504
9ea033b2
NC		 505 case 8:
506 /* Although we are extracing data from an 8 byte wide field, we
507 are returning only 4 bytes of data. */
508 return ((unsigned long) (field [7]))
509 | (((unsigned long) (field [6])) << 8)
510 | (((unsigned long) (field [5])) << 16)
511 | (((unsigned long) (field [4])) << 24);
512
a952a375 513#ifdef BFD64
9ea033b2
NC		 514 case -8:
515 /* This is a special case, generated by the BYTE_GET8 macro.
516 It means that we are loading an 8 byte value from a field
517 in an external structure into an 8 byte value in a field
518 in an internal strcuture. */
519 return ((bfd_vma) (field [7]))
520 | (((bfd_vma) (field [6])) << 8)
521 | (((bfd_vma) (field [5])) << 16)
522 | (((bfd_vma) (field [4])) << 24)
523 | (((bfd_vma) (field [3])) << 32)
524 | (((bfd_vma) (field [2])) << 40)
525 | (((bfd_vma) (field [1])) << 48)
526 | (((bfd_vma) (field [0])) << 56);
a952a375 527#endif
103f02d3 528
252b5132
RH		 529 default:
530 error (_("Unhandled data length: %d\n"), size);
9ea033b2 531 abort ();
252b5132
RH		 532 }
533}
534
535
9c19a809 536/* Guess the relocation sized based on the sized commonly used by the specific machine. */
252b5132 537static int
9c19a809
NC		 538guess_is_rela (e_machine)
539 unsigned long e_machine;
252b5132 540{
9c19a809 541 switch (e_machine)
252b5132
RH		 542 {
543 /* Targets that use REL relocations. */
544 case EM_ARM:
545 case EM_386:
546 case EM_486:
63fcb9e9 547 case EM_960:
252b5132
RH		 548 case EM_CYGNUS_M32R:
549 case EM_CYGNUS_D10V:
550 case EM_MIPS:
551 case EM_MIPS_RS4_BE:
9c19a809 552 return FALSE;
103f02d3 553
252b5132
RH		 554 /* Targets that use RELA relocations. */
555 case EM_68K:
351b4b40
RH		 556 case EM_SPARC32PLUS:
557 case EM_SPARCV9:
252b5132
RH		 558 case EM_SPARC:
559 case EM_PPC:
560 case EM_CYGNUS_V850:
561 case EM_CYGNUS_D30V:
562 case EM_CYGNUS_MN10200:
563 case EM_CYGNUS_MN10300:
564 case EM_CYGNUS_FR30:
565 case EM_SH:
566 case EM_ALPHA:
567 case EM_MCORE:
9c19a809 568 return TRUE;
103f02d3 569
d1133906
NC		 570 case EM_MMA:
571 case EM_PCP:
572 case EM_NCPU:
573 case EM_NDR1:
574 case EM_STARCORE:
575 case EM_ME16:
576 case EM_ST100:
577 case EM_TINYJ:
578 case EM_FX66:
579 case EM_ST9PLUS:
580 case EM_ST7:
581 case EM_68HC16:
582 case EM_68HC11:
583 case EM_68HC08:
584 case EM_68HC05:
585 case EM_SVX:
586 case EM_ST19:
587 case EM_VAX:
9c19a809
NC		 588 default:
589 warn (_("Don't know about relocations on this machine architecture\n"));
590 return FALSE;
591 }
592}
252b5132 593
9ea033b2 594/* Display the contents of the relocation data found at the specified offset. */
9c19a809 595static int
19936277 596dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
9ea033b2
NC		 597 FILE * file;
598 unsigned long rel_offset;
599 unsigned long rel_size;
600 Elf_Internal_Sym * symtab;
19936277 601 unsigned long nsyms;
9ea033b2
NC		 602 char * strtab;
603 int is_rela;
9c19a809
NC		 604{
605 unsigned int i;
606 Elf_Internal_Rel * rels;
607 Elf_Internal_Rela * relas;
252b5132 608
103f02d3 609
9c19a809
NC		 610 if (is_rela == UNKNOWN)
611 is_rela = guess_is_rela (elf_header.e_machine);
252b5132 612
9c19a809
NC		 613 if (is_rela)
614 {
9ea033b2
NC		 615 if (is_32bit_elf)
616 {
617 Elf32_External_Rela * erelas;
103f02d3 618
9ea033b2
NC		 619 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
620 Elf32_External_Rela *, "relocs");
103f02d3 621
9ea033b2 622 rel_size = rel_size / sizeof (Elf32_External_Rela);
103f02d3 623
9ea033b2
NC		 624 relas = (Elf_Internal_Rela *)
625 malloc (rel_size * sizeof (Elf_Internal_Rela));
103f02d3 626
9ea033b2
NC		 627 if (relas == NULL)
628 {
629 error(_("out of memory parsing relocs"));
630 return 0;
631 }
103f02d3 632
9ea033b2
NC		 633 for (i = 0; i < rel_size; i++)
634 {
635 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
636 relas[i].r_info = BYTE_GET (erelas[i].r_info);
637 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
638 }
103f02d3 639
9ea033b2 640 free (erelas);
103f02d3 641
9ea033b2 642 rels = (Elf_Internal_Rel *) relas;
9c19a809 643 }
9ea033b2 644 else
9c19a809 645 {
9ea033b2 646 Elf64_External_Rela * erelas;
103f02d3 647
9ea033b2
NC		 648 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
649 Elf64_External_Rela *, "relocs");
103f02d3 650
9ea033b2 651 rel_size = rel_size / sizeof (Elf64_External_Rela);
103f02d3 652
9ea033b2
NC		 653 relas = (Elf_Internal_Rela *)
654 malloc (rel_size * sizeof (Elf_Internal_Rela));
103f02d3 655
9ea033b2
NC		 656 if (relas == NULL)
657 {
658 error(_("out of memory parsing relocs"));
659 return 0;
660 }
103f02d3 661
9ea033b2
NC		 662 for (i = 0; i < rel_size; i++)
663 {
664 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
665 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
666 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
667 }
103f02d3 668
9ea033b2 669 free (erelas);
103f02d3 670
9ea033b2
NC		 671 rels = (Elf_Internal_Rel *) relas;
672 }
9c19a809
NC		 673 }
674 else
675 {
9ea033b2 676 if (is_32bit_elf)
9c19a809 677 {
9ea033b2
NC		 678 Elf32_External_Rel * erels;
679
680 GET_DATA_ALLOC (rel_offset, rel_size, erels,
681 Elf32_External_Rel *, "relocs");
103f02d3 682
9ea033b2 683 rel_size = rel_size / sizeof (Elf32_External_Rel);
103f02d3 684
9ea033b2
NC		 685 rels = (Elf_Internal_Rel *)
686 malloc (rel_size * sizeof (Elf_Internal_Rel));
103f02d3 687
9ea033b2
NC		 688 if (rels == NULL)
689 {
690 error(_("out of memory parsing relocs"));
691 return 0;
692 }
103f02d3 693
9ea033b2
NC		 694 for (i = 0; i < rel_size; i++)
695 {
696 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
697 rels[i].r_info = BYTE_GET (erels[i].r_info);
698 }
103f02d3 699
9ea033b2 700 free (erels);
103f02d3 701
9ea033b2 702 relas = (Elf_Internal_Rela *) rels;
9c19a809 703 }
9ea033b2 704 else
9c19a809 705 {
9ea033b2
NC		 706 Elf64_External_Rel * erels;
707
708 GET_DATA_ALLOC (rel_offset, rel_size, erels,
709 Elf64_External_Rel *, "relocs");
103f02d3 710
9ea033b2 711 rel_size = rel_size / sizeof (Elf64_External_Rel);
103f02d3 712
9ea033b2
NC		 713 rels = (Elf_Internal_Rel *)
714 malloc (rel_size * sizeof (Elf_Internal_Rel));
103f02d3 715
9ea033b2
NC		 716 if (rels == NULL)
717 {
718 error(_("out of memory parsing relocs"));
719 return 0;
720 }
103f02d3 721
9ea033b2
NC		 722 for (i = 0; i < rel_size; i++)
723 {
724 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
725 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
726 }
103f02d3 727
9ea033b2 728 free (erels);
103f02d3 729
9ea033b2 730 relas = (Elf_Internal_Rela *) rels;
9c19a809 731 }
252b5132
RH		 732 }
733
734 if (is_rela)
735 printf
736 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
737 else
738 printf
739 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
740
741 for (i = 0; i < rel_size; i++)
742 {
9ea033b2
NC		 743 const char * rtype;
744 bfd_vma offset;
745 bfd_vma info;
746 bfd_vma symtab_index;
747 bfd_vma type;
103f02d3 748
252b5132
RH		 749 if (is_rela)
750 {
751 offset = relas [i].r_offset;
752 info = relas [i].r_info;
753 }
754 else
755 {
756 offset = rels [i].r_offset;
757 info = rels [i].r_info;
758 }
103f02d3 759
9ea033b2
NC		 760 if (is_32bit_elf)
761 {
762 type = ELF32_R_TYPE (info);
763 symtab_index = ELF32_R_SYM (info);
764 }
765 else
766 {
351b4b40
RH		 767 if (elf_header.e_machine == EM_SPARCV9)
768 type = ELF64_R_TYPE_ID (info);
769 else
770 type = ELF64_R_TYPE (info);
a952a375
NC		 771 /* The #ifdef BFD64 below is to prevent a compile time warning.
772 We know that if we do not have a 64 bit data type that we
773 will never execute this code anyway. */
103f02d3 774#ifdef BFD64
9ea033b2 775 symtab_index = ELF64_R_SYM (info);
a952a375 776#endif
9ea033b2 777 }
252b5132 778
9ea033b2
NC		 779#ifdef _bfd_int64_low
780 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
781#else
782 printf (" %8.8lx %5.5lx ", offset, info);
783#endif
103f02d3 784
252b5132
RH		 785 switch (elf_header.e_machine)
786 {
787 default:
788 rtype = NULL;
789 break;
790
791 case EM_CYGNUS_M32R:
9ea033b2 792 rtype = elf_m32r_reloc_type (type);
252b5132
RH		 793 break;
794
795 case EM_386:
796 case EM_486:
9ea033b2 797 rtype = elf_i386_reloc_type (type);
252b5132
RH		 798 break;
799
800 case EM_68K:
9ea033b2 801 rtype = elf_m68k_reloc_type (type);
252b5132
RH		 802 break;
803
63fcb9e9 804 case EM_960:
9ea033b2 805 rtype = elf_i960_reloc_type (type);
63fcb9e9
ILT		 806 break;
807
9ea033b2
NC		 808 case EM_OLD_SPARCV9:
809 case EM_SPARC32PLUS:
810 case EM_SPARCV9:
252b5132 811 case EM_SPARC:
9ea033b2 812 rtype = elf_sparc_reloc_type (type);
252b5132
RH		 813 break;
814
815 case EM_CYGNUS_V850:
9ea033b2 816 rtype = v850_reloc_type (type);
252b5132
RH		 817 break;
818
819 case EM_CYGNUS_D10V:
9ea033b2 820 rtype = elf_d10v_reloc_type (type);
252b5132
RH		 821 break;
822
823 case EM_CYGNUS_D30V:
9ea033b2 824 rtype = elf_d30v_reloc_type (type);
252b5132
RH		 825 break;
826
827 case EM_SH:
9ea033b2 828 rtype = elf_sh_reloc_type (type);
252b5132
RH		 829 break;
830
831 case EM_CYGNUS_MN10300:
9ea033b2 832 rtype = elf_mn10300_reloc_type (type);
252b5132
RH		 833 break;
834
835 case EM_CYGNUS_MN10200:
9ea033b2 836 rtype = elf_mn10200_reloc_type (type);
252b5132
RH		 837 break;
838
839 case EM_CYGNUS_FR30:
9ea033b2 840 rtype = elf_fr30_reloc_type (type);
252b5132
RH		 841 break;
842
843 case EM_MCORE:
9ea033b2 844 rtype = elf_mcore_reloc_type (type);
252b5132
RH		 845 break;
846
847 case EM_PPC:
9ea033b2 848 rtype = elf_ppc_reloc_type (type);
252b5132
RH		 849 break;
850
851 case EM_MIPS:
852 case EM_MIPS_RS4_BE:
9ea033b2 853 rtype = elf_mips_reloc_type (type);
252b5132
RH		 854 break;
855
856 case EM_ALPHA:
9ea033b2 857 rtype = elf_alpha_reloc_type (type);
252b5132
RH		 858 break;
859
860 case EM_ARM:
9ea033b2 861 rtype = elf_arm_reloc_type (type);
252b5132
RH		 862 break;
863
864 case EM_CYGNUS_ARC:
9ea033b2 865 rtype = elf_arc_reloc_type (type);
252b5132
RH		 866 break;
867
868 case EM_PARISC:
69e617ca 869 rtype = elf_hppa_reloc_type (type);
252b5132 870 break;
7d466069
ILT		 871
872 case EM_PJ:
873 rtype = elf_pj_reloc_type (type);
874 break;
252b5132
RH		 875 }
876
877 if (rtype == NULL)
103f02d3 878#ifdef _bfd_int64_low
9ea033b2
NC		 879 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
880#else
881 printf (_("unrecognised: %-7lx"), type);
882#endif
252b5132
RH		 883 else
884 printf ("%-21.21s", rtype);
885
19936277 886 if (symtab_index)
252b5132 887 {
19936277
NC		 888 if (symtab != NULL)
889 {
890 if (symtab_index >= nsyms)
891 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
892 else
893 {
894 Elf_Internal_Sym * psym;
895
896 psym = symtab + symtab_index;
103f02d3 897
f7a99963
NC		 898 printf (" ");
899 print_vma (psym->st_value, LONG_HEX);
900 printf (" ");
103f02d3 901
19936277
NC		 902 if (psym->st_name == 0)
903 printf ("%-25.25s",
904 SECTION_NAME (section_headers + psym->st_shndx));
905 else if (strtab == NULL)
906 printf (_("<string table index %3ld>"), psym->st_name);
907 else
908 printf ("%-25.25s", strtab + psym->st_name);
103f02d3 909
19936277
NC		 910 if (is_rela)
911 printf (" + %lx", (unsigned long) relas [i].r_addend);
912 }
913 }
252b5132 914 }
1b228002 915 else if (is_rela)
f7a99963
NC		 916 {
917 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
918 print_vma (relas[i].r_addend, LONG_HEX);
919 }
252b5132 920
351b4b40
RH		 921 if (elf_header.e_machine == EM_SPARCV9
922 && !strcmp (rtype, "R_SPARC_OLO10"))
923 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
924
252b5132
RH		 925 putchar ('\n');
926 }
927
928 free (relas);
929
930 return 1;
931}
932
933static const char *
934get_mips_dynamic_type (type)
935 unsigned long type;
936{
937 switch (type)
938 {
939 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
940 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
941 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
942 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
943 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
944 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
945 case DT_MIPS_MSYM: return "MIPS_MSYM";
946 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
947 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
948 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
949 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
950 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
951 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
952 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
953 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
954 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
955 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
956 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
957 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
958 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
959 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
960 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
961 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
962 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
963 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
964 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
965 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
966 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
967 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
968 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
969 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
970 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
971 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
972 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
973 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
974 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
975 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
976 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
977 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
978 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
979 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
980 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
981 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
982 default:
983 return NULL;
984 }
985}
986
9a097730
RH		 987static const char *
988get_sparc64_dynamic_type (type)
989 unsigned long type;
990{
991 switch (type)
992 {
993 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
994 default:
995 return NULL;
996 }
103f02d3
UD		 997}
998
999static const char *
1000get_parisc_dynamic_type (type)
1001 unsigned long type;
1002{
1003 switch (type)
1004 {
1005 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1006 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1007 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1008 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1009 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1010 case DT_HP_PREINIT: return "HP_PREINIT";
1011 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1012 case DT_HP_NEEDED: return "HP_NEEDED";
1013 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1014 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1015 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1016 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1017 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1018 default:
1019 return NULL;
1020 }
1021}
9a097730 1022
252b5132
RH		 1023static const char *
1024get_dynamic_type (type)
1025 unsigned long type;
1026{
1027 static char buff [32];
1028
1029 switch (type)
1030 {
1031 case DT_NULL: return "NULL";
1032 case DT_NEEDED: return "NEEDED";
1033 case DT_PLTRELSZ: return "PLTRELSZ";
1034 case DT_PLTGOT: return "PLTGOT";
1035 case DT_HASH: return "HASH";
1036 case DT_STRTAB: return "STRTAB";
1037 case DT_SYMTAB: return "SYMTAB";
1038 case DT_RELA: return "RELA";
1039 case DT_RELASZ: return "RELASZ";
1040 case DT_RELAENT: return "RELAENT";
1041 case DT_STRSZ: return "STRSZ";
1042 case DT_SYMENT: return "SYMENT";
1043 case DT_INIT: return "INIT";
1044 case DT_FINI: return "FINI";
1045 case DT_SONAME: return "SONAME";
1046 case DT_RPATH: return "RPATH";
1047 case DT_SYMBOLIC: return "SYMBOLIC";
1048 case DT_REL: return "REL";
1049 case DT_RELSZ: return "RELSZ";
1050 case DT_RELENT: return "RELENT";
1051 case DT_PLTREL: return "PLTREL";
1052 case DT_DEBUG: return "DEBUG";
1053 case DT_TEXTREL: return "TEXTREL";
1054 case DT_JMPREL: return "JMPREL";
1055 case DT_BIND_NOW: return "BIND_NOW";
1056 case DT_INIT_ARRAY: return "INIT_ARRAY";
1057 case DT_FINI_ARRAY: return "FINI_ARRAY";
1058 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1059 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
d1133906
NC		 1060 case DT_RUNPATH: return "RUNPATH";
1061 case DT_FLAGS: return "FLAGS";
2d0e6f43 1062
d1133906
NC		 1063 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1064 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
103f02d3 1065
252b5132
RH		 1066 case DT_PLTPADSZ: return "PLTPADSZ";
1067 case DT_MOVEENT: return "MOVEENT";
1068 case DT_MOVESZ: return "MOVESZ";
1069 case DT_FEATURE_1: return "FEATURE_1";
1070 case DT_POSFLAG_1: return "POSFLAG_1";
1071 case DT_SYMINSZ: return "SYMINSZ";
1072 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
103f02d3 1073
252b5132
RH		 1074 case DT_ADDRRNGLO: return "ADDRRNGLO";
1075 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
103f02d3 1076
252b5132 1077 case DT_VERSYM: return "VERSYM";
103f02d3 1078
252b5132
RH		 1079 case DT_RELACOUNT: return "RELACOUNT";
1080 case DT_RELCOUNT: return "RELCOUNT";
1081 case DT_FLAGS_1: return "FLAGS_1";
1082 case DT_VERDEF: return "VERDEF";
1083 case DT_VERDEFNUM: return "VERDEFNUM";
1084 case DT_VERNEED: return "VERNEED";
1085 case DT_VERNEEDNUM: return "VERNEEDNUM";
103f02d3 1086
252b5132
RH		 1087 case DT_AUXILIARY: return "AUXILARY";
1088 case DT_USED: return "USED";
1089 case DT_FILTER: return "FILTER";
103f02d3 1090
252b5132
RH		 1091 default:
1092 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1093 {
1094 const char * result;
103f02d3 1095
252b5132
RH		 1096 switch (elf_header.e_machine)
1097 {
1098 case EM_MIPS:
1099 case EM_MIPS_RS4_BE:
1100 result = get_mips_dynamic_type (type);
1101 break;
9a097730
RH		 1102 case EM_SPARCV9:
1103 result = get_sparc64_dynamic_type (type);
1104 break;
252b5132
RH		 1105 default:
1106 result = NULL;
1107 break;
1108 }
1109
1110 if (result != NULL)
1111 return result;
1112
1113 sprintf (buff, _("Processor Specific: %lx"), type);
1114 }
1115 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
103f02d3
UD		 1116 {
1117 const char * result;
1118
1119 switch (elf_header.e_machine)
1120 {
1121 case EM_PARISC:
1122 result = get_parisc_dynamic_type (type);
1123 break;
1124 default:
1125 result = NULL;
1126 break;
1127 }
1128
1129 if (result != NULL)
1130 return result;
1131
1132 sprintf (buff, _("Operating System specific: %lx"), type);
1133 }
252b5132
RH		 1134 else
1135 sprintf (buff, _("<unknown>: %lx"), type);
103f02d3 1136
252b5132
RH		 1137 return buff;
1138 }
1139}
1140
1141static char *
1142get_file_type (e_type)
1143 unsigned e_type;
1144{
1145 static char buff [32];
1146
1147 switch (e_type)
1148 {
1149 case ET_NONE: return _("NONE (None)");
1150 case ET_REL: return _("REL (Relocatable file)");
1151 case ET_EXEC: return _("EXEC (Executable file)");
1152 case ET_DYN: return _("DYN (Shared object file)");
1153 case ET_CORE: return _("CORE (Core file)");
1154
1155 default:
1156 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1157 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1158 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1159 sprintf (buff, _("OS Specific: (%x)"), e_type);
1160 else
1161 sprintf (buff, _("<unknown>: %x"), e_type);
1162 return buff;
1163 }
1164}
1165
1166static char *
1167get_machine_name (e_machine)
1168 unsigned e_machine;
1169{
d1133906 1170 static char buff [64]; /* XXX */
252b5132
RH		 1171
1172 switch (e_machine)
1173 {
1174 case EM_NONE: return _("None");
1175 case EM_M32: return "WE32100";
1176 case EM_SPARC: return "Sparc";
1177 case EM_386: return "Intel 80386";
1178 case EM_68K: return "MC68000";
1179 case EM_88K: return "MC88000";
1180 case EM_486: return "Intel 80486";
1181 case EM_860: return "Intel 80860";
d1133906 1182 case EM_MIPS: return "MIPS R3000";
a7c8f90e 1183 case EM_S370: return "IBM System/370";
252b5132
RH		 1184 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1185 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1186 case EM_PARISC: return "HPPA";
1187 case EM_PPC_OLD: return "Power PC (old)";
1188 case EM_SPARC32PLUS: return "Sparc v8+" ;
1189 case EM_960: return "Intel 90860";
1190 case EM_PPC: return "PowerPC";
1191 case EM_V800: return "NEC V800";
1192 case EM_FR20: return "Fujitsu FR20";
1193 case EM_RH32: return "TRW RH32";
1194 case EM_MCORE: return "MCORE";
1195 case EM_ARM: return "ARM";
1196 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1197 case EM_SH: return "Hitachi SH";
1198 case EM_SPARCV9: return "Sparc v9";
1199 case EM_TRICORE: return "Siemens Tricore";
1200 case EM_ARC: return "Argonaut RISC Core";
1201 case EM_H8_300: return "Hitachi H8/300";
1202 case EM_H8_300H: return "Hitachi H8/300H";
1203 case EM_H8S: return "Hitachi H8S";
1204 case EM_H8_500: return "Hitachi H8/500";
30800947 1205 case EM_IA_64: return "Intel IA-64";
252b5132
RH		 1206 case EM_MIPS_X: return "Stanford MIPS-X";
1207 case EM_COLDFIRE: return "Motorola Coldfire";
1208 case EM_68HC12: return "Motorola M68HC12";
1209 case EM_ALPHA: return "Alpha";
1210 case EM_CYGNUS_D10V: return "d10v";
1211 case EM_CYGNUS_D30V: return "d30v";
1212 case EM_CYGNUS_ARC: return "Arc";
1213 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1214 case EM_CYGNUS_V850: return "NEC v850";
1215 case EM_CYGNUS_MN10300: return "mn10300";
1216 case EM_CYGNUS_MN10200: return "mn10200";
1217 case EM_CYGNUS_FR30: return "Fujitsu FR30";
7d466069 1218 case EM_PJ: return "picoJava";
d1133906
NC		 1219 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1220 case EM_PCP: return "Siemens PCP";
1221 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1222 case EM_NDR1: return "Denso NDR1 microprocesspr";
1223 case EM_STARCORE: return "Motorola Star*Core processor";
1224 case EM_ME16: return "Toyota ME16 processor";
1225 case EM_ST100: return "STMicroelectronics ST100 processor";
1226 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1227 case EM_FX66: return "Siemens FX66 microcontroller";
1228 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1229 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1230 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1231 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1232 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1233 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1234 case EM_SVX: return "Silicon Graphics SVx";
1235 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1236 case EM_VAX: return "Digital VAX";
252b5132
RH		 1237 default:
1238 sprintf (buff, _("<unknown>: %x"), e_machine);
1239 return buff;
1240 }
1241}
1242
1243static char *
1244get_machine_flags (e_flags, e_machine)
1245 unsigned e_flags;
1246 unsigned e_machine;
1247{
1248 static char buf [1024];
1249
1250 buf[0] = '\0';
d1133906 1251
252b5132
RH		 1252 if (e_flags)
1253 {
1254 switch (e_machine)
1255 {
1256 default:
1257 break;
1258
33c63f9d
CM		 1259 case EM_68K:
1260 if (e_flags & EF_CPU32)
1261 strcat (buf, ", cpu32");
1262 break;
1263
252b5132
RH		 1264 case EM_PPC:
1265 if (e_flags & EF_PPC_EMB)
1266 strcat (buf, ", emb");
1267
1268 if (e_flags & EF_PPC_RELOCATABLE)
1269 strcat (buf, ", relocatable");
1270
1271 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1272 strcat (buf, ", relocatable-lib");
1273 break;
1274
1275 case EM_CYGNUS_V850:
1276 switch (e_flags & EF_V850_ARCH)
1277 {
1278 case E_V850E_ARCH:
1279 strcat (buf, ", v850e");
1280 break;
1281 case E_V850EA_ARCH:
1282 strcat (buf, ", v850ea");
1283 break;
1284 case E_V850_ARCH:
1285 strcat (buf, ", v850");
1286 break;
1287 default:
1288 strcat (buf, ", unknown v850 architecture variant");
1289 break;
1290 }
1291 break;
1292
1293 case EM_CYGNUS_M32R:
1294 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1295 strcat (buf, ", m32r");
1296
1297 break;
1298
1299 case EM_MIPS:
1300 case EM_MIPS_RS4_BE:
1301 if (e_flags & EF_MIPS_NOREORDER)
1302 strcat (buf, ", noreorder");
1303
1304 if (e_flags & EF_MIPS_PIC)
1305 strcat (buf, ", pic");
1306
1307 if (e_flags & EF_MIPS_CPIC)
1308 strcat (buf, ", cpic");
1309
1310 if (e_flags & EF_MIPS_ABI2)
1311 strcat (buf, ", abi2");
1312
1313 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1314 strcat (buf, ", mips1");
1315
1316 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1317 strcat (buf, ", mips2");
1318
1319 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1320 strcat (buf, ", mips3");
1321
1322 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1323 strcat (buf, ", mips4");
1324 break;
351b4b40
RH		 1325
1326 case EM_SPARCV9:
1327 if (e_flags & EF_SPARC_32PLUS)
1328 strcat (buf, ", v8+");
1329
1330 if (e_flags & EF_SPARC_SUN_US1)
d07faca2
RH		 1331 strcat (buf, ", ultrasparcI");
1332
1333 if (e_flags & EF_SPARC_SUN_US3)
1334 strcat (buf, ", ultrasparcIII");
351b4b40
RH		 1335
1336 if (e_flags & EF_SPARC_HAL_R1)
1337 strcat (buf, ", halr1");
1338
1339 if (e_flags & EF_SPARC_LEDATA)
1340 strcat (buf, ", ledata");
1341
1342 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1343 strcat (buf, ", tso");
1344
1345 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1346 strcat (buf, ", pso");
1347
1348 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1349 strcat (buf, ", rmo");
1350 break;
7d466069 1351
103f02d3
UD		 1352 case EM_PARISC:
1353 switch (e_flags & EF_PARISC_ARCH)
1354 {
1355 case EFA_PARISC_1_0:
1356 strcpy (buf, ", PA-RISC 1.0");
1357 break;
1358 case EFA_PARISC_1_1:
1359 strcpy (buf, ", PA-RISC 1.1");
1360 break;
1361 case EFA_PARISC_2_0:
1362 strcpy (buf, ", PA-RISC 2.0");
1363 break;
1364 default:
1365 break;
1366 }
1367 if (e_flags & EF_PARISC_TRAPNIL)
1368 strcat (buf, ", trapnil");
1369 if (e_flags & EF_PARISC_EXT)
1370 strcat (buf, ", ext");
1371 if (e_flags & EF_PARISC_LSB)
1372 strcat (buf, ", lsb");
1373 if (e_flags & EF_PARISC_WIDE)
1374 strcat (buf, ", wide");
1375 if (e_flags & EF_PARISC_NO_KABP)
1376 strcat (buf, ", no kabp");
1377 if (e_flags & EF_PARISC_LAZYSWAP)
1378 strcat (buf, ", lazyswap");
30800947
NC		 1379 break;
1380
7d466069
ILT		 1381 case EM_PJ:
1382 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1383 strcat (buf, ", new calling convention");
1384
1385 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1386 strcat (buf, ", gnu calling convention");
1387 break;
252b5132
RH		 1388 }
1389 }
1390
1391 return buf;
1392}
1393
252b5132
RH		 1394static const char *
1395get_mips_segment_type (type)
1396 unsigned long type;
1397{
1398 switch (type)
1399 {
1400 case PT_MIPS_REGINFO:
1401 return "REGINFO";
1402 case PT_MIPS_RTPROC:
1403 return "RTPROC";
1404 case PT_MIPS_OPTIONS:
1405 return "OPTIONS";
1406 default:
1407 break;
1408 }
1409
1410 return NULL;
1411}
1412
103f02d3
UD		 1413static const char *
1414get_parisc_segment_type (type)
1415 unsigned long type;
1416{
1417 switch (type)
1418 {
1419 case PT_HP_TLS: return "HP_TLS";
1420 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1421 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1422 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1423 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1424 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1425 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1426 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1427 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1428 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1429 case PT_HP_PARALLEL: return "HP_PARALLEL";
1430 case PT_HP_FASTBIND: return "HP_FASTBIND";
1431 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1432 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1433 default:
1434 break;
1435 }
1436
1437 return NULL;
1438}
1439
252b5132
RH		 1440static const char *
1441get_segment_type (p_type)
1442 unsigned long p_type;
1443{
1444 static char buff [32];
1445
1446 switch (p_type)
1447 {
1448 case PT_NULL: return "NULL";
1449 case PT_LOAD: return "LOAD";
1450 case PT_DYNAMIC: return "DYNAMIC";
1451 case PT_INTERP: return "INTERP";
1452 case PT_NOTE: return "NOTE";
1453 case PT_SHLIB: return "SHLIB";
1454 case PT_PHDR: return "PHDR";
1455
1456 default:
1457 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1458 {
1459 const char * result;
103f02d3 1460
252b5132
RH		 1461 switch (elf_header.e_machine)
1462 {
1463 case EM_MIPS:
1464 case EM_MIPS_RS4_BE:
1465 result = get_mips_segment_type (p_type);
1466 break;
103f02d3
UD		 1467 case EM_PARISC:
1468 result = get_parisc_segment_type (p_type);
1469 break;
252b5132
RH		 1470 default:
1471 result = NULL;
1472 break;
1473 }
103f02d3 1474
252b5132
RH		 1475 if (result != NULL)
1476 return result;
103f02d3 1477
252b5132
RH		 1478 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1479 }
1480 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
103f02d3
UD		 1481 {
1482 const char * result;
1483
1484 switch (elf_header.e_machine)
1485 {
1486 case EM_PARISC:
1487 result = get_parisc_segment_type (p_type);
1488 break;
1489 default:
1490 result = NULL;
1491 break;
1492 }
1493
1494 if (result != NULL)
1495 return result;
1496
1497 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1498 }
252b5132
RH		 1499 else
1500 sprintf (buff, _("<unknown>: %lx"), p_type);
1501
1502 return buff;
1503 }
1504}
1505
1506static const char *
1507get_mips_section_type_name (sh_type)
1508 unsigned int sh_type;
1509{
1510 switch (sh_type)
1511 {
1512 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1513 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1514 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1515 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1516 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1517 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1518 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1519 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1520 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1521 case SHT_MIPS_RELD: return "MIPS_RELD";
1522 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1523 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1524 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1525 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1526 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1527 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1528 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1529 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1530 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1531 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1532 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1533 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1534 case SHT_MIPS_LINE: return "MIPS_LINE";
1535 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1536 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1537 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1538 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1539 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1540 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1541 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1542 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1543 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1544 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1545 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1546 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1547 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1548 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1549 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1550 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1551 default:
1552 break;
1553 }
1554 return NULL;
1555}
1556
103f02d3
UD		 1557static const char *
1558get_parisc_section_type_name (sh_type)
1559 unsigned int sh_type;
1560{
1561 switch (sh_type)
1562 {
1563 case SHT_PARISC_EXT: return "PARISC_EXT";
1564 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1565 case SHT_PARISC_DOC: return "PARISC_DOC";
1566 default:
1567 break;
1568 }
1569 return NULL;
1570}
1571
252b5132
RH		 1572static const char *
1573get_section_type_name (sh_type)
1574 unsigned int sh_type;
1575{
1576 static char buff [32];
1577
1578 switch (sh_type)
1579 {
1580 case SHT_NULL: return "NULL";
1581 case SHT_PROGBITS: return "PROGBITS";
1582 case SHT_SYMTAB: return "SYMTAB";
1583 case SHT_STRTAB: return "STRTAB";
1584 case SHT_RELA: return "RELA";
1585 case SHT_HASH: return "HASH";
1586 case SHT_DYNAMIC: return "DYNAMIC";
1587 case SHT_NOTE: return "NOTE";
1588 case SHT_NOBITS: return "NOBITS";
1589 case SHT_REL: return "REL";
1590 case SHT_SHLIB: return "SHLIB";
1591 case SHT_DYNSYM: return "DYNSYM";
d1133906
NC		 1592 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1593 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1594 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
252b5132
RH		 1595 case SHT_GNU_verdef: return "VERDEF";
1596 case SHT_GNU_verneed: return "VERNEED";
1597 case SHT_GNU_versym: return "VERSYM";
1598 case 0x6ffffff0: return "VERSYM";
1599 case 0x6ffffffc: return "VERDEF";
1600 case 0x7ffffffd: return "AUXILIARY";
1601 case 0x7fffffff: return "FILTER";
1602
1603 default:
1604 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1605 {
1606 const char * result;
1607
1608 switch (elf_header.e_machine)
1609 {
1610 case EM_MIPS:
1611 case EM_MIPS_RS4_BE:
1612 result = get_mips_section_type_name (sh_type);
1613 break;
103f02d3
UD		 1614 case EM_PARISC:
1615 result = get_parisc_section_type_name (sh_type);
1616 break;
252b5132
RH		 1617 default:
1618 result = NULL;
1619 break;
1620 }
1621
1622 if (result != NULL)
1623 return result;
1624
1625 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1626 }
1627 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1628 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1629 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1630 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1631 else
1632 sprintf (buff, _("<unknown>: %x"), sh_type);
103f02d3 1633
252b5132
RH		 1634 return buff;
1635 }
1636}
1637
1638struct option options [] =
1639{
1640 {"all", no_argument, 0, 'a'},
1641 {"file-header", no_argument, 0, 'h'},
1642 {"program-headers", no_argument, 0, 'l'},
1643 {"headers", no_argument, 0, 'e'},
a952a375 1644 {"histogram", no_argument, 0, 'I'},
252b5132
RH		 1645 {"segments", no_argument, 0, 'l'},
1646 {"sections", no_argument, 0, 'S'},
1647 {"section-headers", no_argument, 0, 'S'},
1648 {"symbols", no_argument, 0, 's'},
1649 {"syms", no_argument, 0, 's'},
1650 {"relocs", no_argument, 0, 'r'},
779fe533 1651 {"notes", no_argument, 0, 'n'},
252b5132 1652 {"dynamic", no_argument, 0, 'd'},
a952a375 1653 {"arch-specific", no_argument, 0, 'A'},
252b5132
RH		 1654 {"version-info", no_argument, 0, 'V'},
1655 {"use-dynamic", no_argument, 0, 'D'},
1656 {"hex-dump", required_argument, 0, 'x'},
1657 {"debug-dump", optional_argument, 0, 'w'},
1658#ifdef SUPPORT_DISASSEMBLY
1659 {"instruction-dump", required_argument, 0, 'i'},
1660#endif
1661
1662 {"version", no_argument, 0, 'v'},
1663 {"help", no_argument, 0, 'H'},
1664 {0, no_argument, 0, 0}
1665};
1666
1667static void
1668usage ()
1669{
1670 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1671 fprintf (stdout, _(" Options are:\n"));
a952a375 1672 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
252b5132
RH		 1673 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1674 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1675 fprintf (stdout, _(" Display the program headers\n"));
1676 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1677 fprintf (stdout, _(" Display the sections' header\n"));
1678 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1679 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
779fe533 1680 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
252b5132
RH		 1681 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1682 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1683 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
a952a375 1684 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
252b5132
RH		 1685 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1686 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1687 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1688 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1689 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1690#ifdef SUPPORT_DISASSEMBLY
1691 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1692 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1693#endif
a952a375 1694 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
252b5132
RH		 1695 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1696 fprintf (stdout, _(" -H or --help Display this information\n"));
1697 fprintf (stdout, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1698
1699 exit (0);
1700}
1701
1702static void
1703request_dump (section, type)
1704 unsigned int section;
1705 char type;
1706{
1707 if (section >= num_dump_sects)
1708 {
1709 char * new_dump_sects;
1710
1711 new_dump_sects = (char *) calloc (section + 1, 1);
1712
1713 if (new_dump_sects == NULL)
1714 error (_("Out of memory allocating dump request table."));
1715 else
1716 {
1717 /* Copy current flag settings. */
1718 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1719
1720 free (dump_sects);
1721
1722 dump_sects = new_dump_sects;
1723 num_dump_sects = section + 1;
1724 }
1725 }
1726
1727 if (dump_sects)
1728 dump_sects [section] |= type;
1729
1730 return;
1731}
1732
1733static void
1734parse_args (argc, argv)
1735 int argc;
1736 char ** argv;
1737{
1738 int c;
1739
1740 if (argc < 2)
1741 usage ();
1742
1743 while ((c = getopt_long
779fe533 1744 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
252b5132
RH		 1745 {
1746 char * cp;
1747 int section;
1748
1749 switch (c)
1750 {
1751 case 0:
1752 /* Long options. */
1753 break;
1754 case 'H':
1755 usage ();
1756 break;
1757
1758 case 'a':
1759 do_syms ++;
1760 do_reloc ++;
1761 do_dynamic ++;
1762 do_header ++;
1763 do_sections ++;
1764 do_segments ++;
1765 do_version ++;
1766 do_histogram ++;
a952a375 1767 do_arch ++;
779fe533 1768 do_notes ++;
252b5132
RH		 1769 break;
1770 case 'e':
1771 do_header ++;
1772 do_sections ++;
1773 do_segments ++;
1774 break;
a952a375
NC		 1775 case 'A':
1776 do_arch ++;
1777 break;
252b5132
RH		 1778 case 'D':
1779 do_using_dynamic ++;
1780 break;
1781 case 'r':
1782 do_reloc ++;
1783 break;
1784 case 'h':
1785 do_header ++;
1786 break;
1787 case 'l':
1788 do_segments ++;
1789 break;
1790 case 's':
1791 do_syms ++;
1792 break;
1793 case 'S':
1794 do_sections ++;
1795 break;
1796 case 'd':
1797 do_dynamic ++;
1798 break;
a952a375
NC		 1799 case 'I':
1800 do_histogram ++;
1801 break;
779fe533
NC		 1802 case 'n':
1803 do_notes ++;
1804 break;
252b5132
RH		 1805 case 'x':
1806 do_dump ++;
1807 section = strtoul (optarg, & cp, 0);
1808 if (! * cp && section >= 0)
1809 {
1810 request_dump (section, HEX_DUMP);
1811 break;
1812 }
1813 goto oops;
1814 case 'w':
1815 do_dump ++;
1816 if (optarg == 0)
1817 do_debugging = 1;
1818 else
1819 {
1820 do_debugging = 0;
1821 switch (optarg[0])
1822 {
1823 case 'i':
1824 case 'I':
1825 do_debug_info = 1;
1826 break;
1827
1828 case 'a':
1829 case 'A':
1830 do_debug_abbrevs = 1;
1831 break;
1832
1833 case 'l':
1834 case 'L':
1835 do_debug_lines = 1;
1836 break;
1837
1838 case 'p':
1839 case 'P':
1840 do_debug_pubnames = 1;
1841 break;
1842
1843 case 'r':
1844 case 'R':
1845 do_debug_aranges = 1;
1846 break;
1847
1848 default:
1849 warn (_("Unrecognised debug option '%s'\n"), optarg);
1850 break;
1851 }
1852 }
1853 break;
1854#ifdef SUPPORT_DISASSEMBLY
1855 case 'i':
1856 do_dump ++;
1857 section = strtoul (optarg, & cp, 0);
1858 if (! * cp && section >= 0)
1859 {
1860 request_dump (section, DISASS_DUMP);
1861 break;
1862 }
1863 goto oops;
1864#endif
1865 case 'v':
1866 print_version (program_name);
1867 break;
1868 case 'V':
1869 do_version ++;
1870 break;
1871 default:
1872 oops:
1873 /* xgettext:c-format */
1874 error (_("Invalid option '-%c'\n"), c);
1875 /* Drop through. */
1876 case '?':
1877 usage ();
1878 }
1879 }
1880
1881 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
1882 && !do_segments && !do_header && !do_dump && !do_version
779fe533 1883 && !do_histogram && !do_debugging && !do_arch && !do_notes)
252b5132
RH		 1884 usage ();
1885 else if (argc < 3)
1886 {
1887 warn (_("Nothing to do.\n"));
1888 usage();
1889 }
1890}
1891
1892static const char *
1893get_elf_class (elf_class)
1894 unsigned char elf_class;
1895{
ab5e7794 1896 static char buff [32];
103f02d3 1897
252b5132
RH		 1898 switch (elf_class)
1899 {
1900 case ELFCLASSNONE: return _("none");
1901 case ELFCLASS32: return _("ELF32");
1902 case ELFCLASS64: return _("ELF64");
ab5e7794 1903 default:
789be9f7 1904 sprintf (buff, _("<unknown: %x>"), elf_class);
ab5e7794 1905 return buff;
252b5132
RH		 1906 }
1907}
1908
1909static const char *
1910get_data_encoding (encoding)
1911 unsigned char encoding;
1912{
ab5e7794 1913 static char buff [32];
103f02d3 1914
252b5132
RH		 1915 switch (encoding)
1916 {
1917 case ELFDATANONE: return _("none");
33c63f9d
CM		 1918 case ELFDATA2LSB: return _("2's complement, little endian");
1919 case ELFDATA2MSB: return _("2's complement, big endian");
103f02d3 1920 default:
789be9f7 1921 sprintf (buff, _("<unknown: %x>"), encoding);
ab5e7794 1922 return buff;
252b5132
RH		 1923 }
1924}
1925
1926static const char *
1927get_osabi_name (osabi)
1928 unsigned char osabi;
1929{
ab5e7794 1930 static char buff [32];
103f02d3 1931
252b5132
RH		 1932 switch (osabi)
1933 {
1934 case ELFOSABI_SYSV: return _("UNIX - System V");
1935 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
1ce6cb43 1936 case ELFOSABI_LINUX: return _("UNIX - Linux");
252b5132 1937 case ELFOSABI_STANDALONE: return _("Standalone App");
67a95c88 1938 case ELFOSABI_ARM: return _("ARM");
ab5e7794 1939 default:
789be9f7 1940 sprintf (buff, _("<unknown: %x>"), osabi);
ab5e7794 1941 return buff;
252b5132
RH		 1942 }
1943}
1944
1945/* Decode the data held in 'elf_header'. */
1946static int
1947process_file_header ()
1948{
1949 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
1950 || elf_header.e_ident [EI_MAG1] != ELFMAG1
1951 || elf_header.e_ident [EI_MAG2] != ELFMAG2
1952 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
1953 {
1954 error
1955 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1956 return 0;
1957 }
1958
1959 if (do_header)
1960 {
1961 int i;
1962
1963 printf (_("ELF Header:\n"));
1964 printf (_(" Magic: "));
1965 for (i = 0; i < EI_NIDENT; i ++)
1966 printf ("%2.2x ", elf_header.e_ident [i]);
1967 printf ("\n");
1968 printf (_(" Class: %s\n"),
1969 get_elf_class (elf_header.e_ident [EI_CLASS]));
1970 printf (_(" Data: %s\n"),
1971 get_data_encoding (elf_header.e_ident [EI_DATA]));
1972 printf (_(" Version: %d %s\n"),
1973 elf_header.e_ident [EI_VERSION],
789be9f7
ILT		 1974 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
1975 ? "(current)"
1976 : (elf_header.e_ident [EI_VERSION] != EV_NONE
1977 ? "<unknown: %lx>"
1978 : "")));
252b5132
RH		 1979 printf (_(" OS/ABI: %s\n"),
1980 get_osabi_name (elf_header.e_ident [EI_OSABI]));
1981 printf (_(" ABI Version: %d\n"),
1982 elf_header.e_ident [EI_ABIVERSION]);
1983 printf (_(" Type: %s\n"),
1984 get_file_type (elf_header.e_type));
1985 printf (_(" Machine: %s\n"),
1986 get_machine_name (elf_header.e_machine));
1987 printf (_(" Version: 0x%lx\n"),
1988 (unsigned long) elf_header.e_version);
f7a99963
NC		 1989
1990 printf (_(" Entry point address: "));
1991 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
1992 printf (_("\n Start of program headers: "));
1993 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
1994 printf (_(" (bytes into file)\n Start of section headers: "));
1995 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
1996 printf (_(" (bytes into file)\n"));
1997
252b5132
RH		 1998 printf (_(" Flags: 0x%lx%s\n"),
1999 (unsigned long) elf_header.e_flags,
2000 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2001 printf (_(" Size of this header: %ld (bytes)\n"),
2002 (long) elf_header.e_ehsize);
2003 printf (_(" Size of program headers: %ld (bytes)\n"),
2004 (long) elf_header.e_phentsize);
2005 printf (_(" Number of program headers: %ld\n"),
2006 (long) elf_header.e_phnum);
2007 printf (_(" Size of section headers: %ld (bytes)\n"),
2008 (long) elf_header.e_shentsize);
2009 printf (_(" Number of section headers: %ld\n"),
2010 (long) elf_header.e_shnum);
2011 printf (_(" Section header string table index: %ld\n"),
2012 (long) elf_header.e_shstrndx);
2013 }
103f02d3 2014
9ea033b2
NC		 2015 return 1;
2016}
2017
252b5132 2018
9ea033b2
NC		 2019static int
2020get_32bit_program_headers (file, program_headers)
2021 FILE * file;
2022 Elf_Internal_Phdr * program_headers;
2023{
2024 Elf32_External_Phdr * phdrs;
2025 Elf32_External_Phdr * external;
2026 Elf32_Internal_Phdr * internal;
2027 unsigned int i;
103f02d3 2028
9ea033b2
NC		 2029 GET_DATA_ALLOC (elf_header.e_phoff,
2030 elf_header.e_phentsize * elf_header.e_phnum,
2031 phdrs, Elf32_External_Phdr *, "program headers");
2032
2033 for (i = 0, internal = program_headers, external = phdrs;
2034 i < elf_header.e_phnum;
2035 i ++, internal ++, external ++)
252b5132 2036 {
9ea033b2
NC		 2037 internal->p_type = BYTE_GET (external->p_type);
2038 internal->p_offset = BYTE_GET (external->p_offset);
2039 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2040 internal->p_paddr = BYTE_GET (external->p_paddr);
2041 internal->p_filesz = BYTE_GET (external->p_filesz);
2042 internal->p_memsz = BYTE_GET (external->p_memsz);
2043 internal->p_flags = BYTE_GET (external->p_flags);
2044 internal->p_align = BYTE_GET (external->p_align);
252b5132
RH		 2045 }
2046
9ea033b2
NC		 2047 free (phdrs);
2048
252b5132
RH		 2049 return 1;
2050}
2051
9ea033b2
NC		 2052static int
2053get_64bit_program_headers (file, program_headers)
2054 FILE * file;
2055 Elf_Internal_Phdr * program_headers;
2056{
2057 Elf64_External_Phdr * phdrs;
2058 Elf64_External_Phdr * external;
2059 Elf64_Internal_Phdr * internal;
2060 unsigned int i;
103f02d3 2061
9ea033b2
NC		 2062 GET_DATA_ALLOC (elf_header.e_phoff,
2063 elf_header.e_phentsize * elf_header.e_phnum,
2064 phdrs, Elf64_External_Phdr *, "program headers");
2065
2066 for (i = 0, internal = program_headers, external = phdrs;
2067 i < elf_header.e_phnum;
2068 i ++, internal ++, external ++)
2069 {
2070 internal->p_type = BYTE_GET (external->p_type);
2071 internal->p_flags = BYTE_GET (external->p_flags);
2072 internal->p_offset = BYTE_GET8 (external->p_offset);
2073 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2074 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2075 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2076 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2077 internal->p_align = BYTE_GET8 (external->p_align);
2078 }
2079
2080 free (phdrs);
2081
2082 return 1;
2083}
252b5132
RH		 2084
2085static int
2086process_program_headers (file)
2087 FILE * file;
2088{
9ea033b2
NC		 2089 Elf_Internal_Phdr * program_headers;
2090 Elf_Internal_Phdr * segment;
2091 unsigned int i;
252b5132
RH		 2092
2093 if (elf_header.e_phnum == 0)
2094 {
2095 if (do_segments)
2096 printf (_("\nThere are no program headers in this file.\n"));
2097 return 1;
2098 }
2099
2100 if (do_segments && !do_header)
2101 {
f7a99963
NC		 2102 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2103 printf (_("Entry point "));
2104 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2105 printf (_("\nThere are %d program headers, starting at offset "),
2106 elf_header.e_phnum);
2107 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2108 printf ("\n");
252b5132
RH		 2109 }
2110
9ea033b2
NC		 2111 program_headers = (Elf_Internal_Phdr *) malloc
2112 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
252b5132
RH		 2113
2114 if (program_headers == NULL)
2115 {
2116 error (_("Out of memory\n"));
2117 return 0;
2118 }
2119
9ea033b2
NC		 2120 if (is_32bit_elf)
2121 i = get_32bit_program_headers (file, program_headers);
2122 else
2123 i = get_64bit_program_headers (file, program_headers);
2124
2125 if (i == 0)
252b5132 2126 {
9ea033b2
NC		 2127 free (program_headers);
2128 return 0;
252b5132 2129 }
103f02d3 2130
252b5132
RH		 2131 if (do_segments)
2132 {
2133 printf
2134 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
f7a99963
NC		 2135
2136 if (is_32bit_elf)
2137 printf
2138 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2139 else
2140 {
2141 printf
2142 (_(" Type Offset VirtAddr PhysAddr\n"));
2143 printf
2144 (_(" FileSiz MemSiz Flags Align\n"));
2145 }
252b5132
RH		 2146 }
2147
2148 loadaddr = -1;
2149 dynamic_addr = 0;
1b228002 2150 dynamic_size = 0;
252b5132
RH		 2151
2152 for (i = 0, segment = program_headers;
2153 i < elf_header.e_phnum;
2154 i ++, segment ++)
2155 {
2156 if (do_segments)
2157 {
103f02d3 2158 printf (" %-14.14s ", get_segment_type (segment->p_type));
f7a99963
NC		 2159
2160 if (is_32bit_elf)
2161 {
2162 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2163 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2164 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2165 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2166 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2167 printf ("%c%c%c ",
2168 (segment->p_flags & PF_R ? 'R' : ' '),
2169 (segment->p_flags & PF_W ? 'W' : ' '),
2170 (segment->p_flags & PF_X ? 'E' : ' '));
2171 printf ("%#lx", (unsigned long) segment->p_align);
2172 }
2173 else
2174 {
2175 print_vma (segment->p_offset, FULL_HEX);
2176 putchar (' ');
2177 print_vma (segment->p_vaddr, FULL_HEX);
2178 putchar (' ');
2179 print_vma (segment->p_paddr, FULL_HEX);
2180 printf ("\n ");
2181 print_vma (segment->p_filesz, FULL_HEX);
2182 putchar (' ');
2183 print_vma (segment->p_memsz, FULL_HEX);
2184 printf (" %c%c%c ",
2185 (segment->p_flags & PF_R ? 'R' : ' '),
2186 (segment->p_flags & PF_W ? 'W' : ' '),
2187 (segment->p_flags & PF_X ? 'E' : ' '));
2188 print_vma (segment->p_align, HEX);
2189 }
252b5132
RH		 2190 }
2191
2192 switch (segment->p_type)
2193 {
2194 case PT_LOAD:
2195 if (loadaddr == -1)
2196 loadaddr = (segment->p_vaddr & 0xfffff000)
2197 - (segment->p_offset & 0xfffff000);
2198 break;
2199
2200 case PT_DYNAMIC:
2201 if (dynamic_addr)
2202 error (_("more than one dynamic segment\n"));
2203
2204 dynamic_addr = segment->p_offset;
2205 dynamic_size = segment->p_filesz;
2206 break;
2207
2208 case PT_INTERP:
f7a99963 2209 if (fseek (file, (long) segment->p_offset, SEEK_SET))
252b5132
RH		 2210 error (_("Unable to find program interpreter name\n"));
2211 else
2212 {
2213 program_interpreter[0] = 0;
2214 fscanf (file, "%63s", program_interpreter);
2215
2216 if (do_segments)
2217 printf (_("\n [Requesting program interpreter: %s]"),
2218 program_interpreter);
2219 }
2220 break;
2221 }
2222
2223 if (do_segments)
2224 putc ('\n', stdout);
2225 }
2226
2227 if (loadaddr == -1)
2228 {
2229 /* Very strange. */
2230 loadaddr = 0;
2231 }
2232
2233 if (do_segments && section_headers != NULL)
2234 {
2235 printf (_("\n Section to Segment mapping:\n"));
2236 printf (_(" Segment Sections...\n"));
2237
2238 assert (string_table != NULL);
2239
2240 for (i = 0; i < elf_header.e_phnum; i++)
2241 {
9ea033b2
NC		 2242 int j;
2243 Elf_Internal_Shdr * section;
252b5132
RH		 2244
2245 segment = program_headers + i;
2246 section = section_headers;
2247
2248 printf (" %2.2d ", i);
2249
2250 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2251 {
2252 if (section->sh_size > 0
2253 /* Compare allocated sections by VMA, unallocated
2254 sections by file offset. */
2255 && (section->sh_flags & SHF_ALLOC
2256 ? (section->sh_addr >= segment->p_vaddr
2257 && section->sh_addr + section->sh_size
2258 <= segment->p_vaddr + segment->p_memsz)
b4c96d0d 2259 : ((bfd_vma) section->sh_offset >= segment->p_offset
252b5132
RH		 2260 && (section->sh_offset + section->sh_size
2261 <= segment->p_offset + segment->p_filesz))))
2262 printf ("%s ", SECTION_NAME (section));
2263 }
2264
2265 putc ('\n',stdout);
2266 }
2267 }
2268
2269 free (program_headers);
2270
2271 return 1;
2272}
2273
2274
2275static int
9ea033b2 2276get_32bit_section_headers (file)
252b5132
RH		 2277 FILE * file;
2278{
2279 Elf32_External_Shdr * shdrs;
2280 Elf32_Internal_Shdr * internal;
2281 unsigned int i;
2282
2283 GET_DATA_ALLOC (elf_header.e_shoff,
2284 elf_header.e_shentsize * elf_header.e_shnum,
2285 shdrs, Elf32_External_Shdr *, "section headers");
2286
9ea033b2
NC		 2287 section_headers = (Elf_Internal_Shdr *) malloc
2288 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
252b5132
RH		 2289
2290 if (section_headers == NULL)
2291 {
2292 error (_("Out of memory\n"));
2293 return 0;
2294 }
2295
2296 for (i = 0, internal = section_headers;
2297 i < elf_header.e_shnum;
2298 i ++, internal ++)
2299 {
2300 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2301 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2302 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2303 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2304 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2305 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2306 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2307 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2308 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2309 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2310 }
2311
2312 free (shdrs);
2313
2314 return 1;
2315}
2316
9ea033b2
NC		 2317static int
2318get_64bit_section_headers (file)
2319 FILE * file;
2320{
2321 Elf64_External_Shdr * shdrs;
2322 Elf64_Internal_Shdr * internal;
2323 unsigned int i;
2324
2325 GET_DATA_ALLOC (elf_header.e_shoff,
2326 elf_header.e_shentsize * elf_header.e_shnum,
2327 shdrs, Elf64_External_Shdr *, "section headers");
2328
2329 section_headers = (Elf_Internal_Shdr *) malloc
2330 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2331
2332 if (section_headers == NULL)
2333 {
2334 error (_("Out of memory\n"));
2335 return 0;
2336 }
2337
2338 for (i = 0, internal = section_headers;
2339 i < elf_header.e_shnum;
2340 i ++, internal ++)
2341 {
2342 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2343 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2344 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2345 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2346 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2347 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2348 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2349 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2350 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2351 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2352 }
2353
2354 free (shdrs);
2355
2356 return 1;
2357}
2358
252b5132 2359static Elf_Internal_Sym *
9ea033b2 2360get_32bit_elf_symbols (file, offset, number)
252b5132
RH		 2361 FILE * file;
2362 unsigned long offset;
2363 unsigned long number;
2364{
2365 Elf32_External_Sym * esyms;
2366 Elf_Internal_Sym * isyms;
2367 Elf_Internal_Sym * psym;
2368 unsigned int j;
2369
2370 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2371 esyms, Elf32_External_Sym *, "symbols");
2372
2373 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2374
2375 if (isyms == NULL)
2376 {
2377 error (_("Out of memory\n"));
2378 free (esyms);
2379
2380 return NULL;
2381 }
2382
2383 for (j = 0, psym = isyms;
2384 j < number;
2385 j ++, psym ++)
2386 {
2387 psym->st_name = BYTE_GET (esyms[j].st_name);
2388 psym->st_value = BYTE_GET (esyms[j].st_value);
2389 psym->st_size = BYTE_GET (esyms[j].st_size);
2390 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2391 psym->st_info = BYTE_GET (esyms[j].st_info);
2392 psym->st_other = BYTE_GET (esyms[j].st_other);
2393 }
2394
2395 free (esyms);
2396
2397 return isyms;
2398}
2399
9ea033b2
NC		 2400static Elf_Internal_Sym *
2401get_64bit_elf_symbols (file, offset, number)
2402 FILE * file;
2403 unsigned long offset;
2404 unsigned long number;
2405{
2406 Elf64_External_Sym * esyms;
2407 Elf_Internal_Sym * isyms;
2408 Elf_Internal_Sym * psym;
2409 unsigned int j;
2410
2411 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2412 esyms, Elf64_External_Sym *, "symbols");
2413
2414 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2415
2416 if (isyms == NULL)
2417 {
2418 error (_("Out of memory\n"));
2419 free (esyms);
2420
2421 return NULL;
2422 }
2423
2424 for (j = 0, psym = isyms;
2425 j < number;
2426 j ++, psym ++)
2427 {
2428 psym->st_name = BYTE_GET (esyms[j].st_name);
2429 psym->st_info = BYTE_GET (esyms[j].st_info);
2430 psym->st_other = BYTE_GET (esyms[j].st_other);
2431 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2432 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2433 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2434 }
2435
2436 free (esyms);
2437
2438 return isyms;
2439}
2440
d1133906
NC		 2441static const char *
2442get_elf_section_flags (sh_flags)
2443 bfd_vma sh_flags;
2444{
2445 static char buff [32];
2446
2447 * buff = 0;
2448
2449 while (sh_flags)
2450 {
2451 bfd_vma flag;
2452
2453 flag = sh_flags & - sh_flags;
2454 sh_flags &= ~ flag;
2455
2456 switch (flag)
2457 {
2458 case SHF_WRITE: strcat (buff, "W"); break;
2459 case SHF_ALLOC: strcat (buff, "A"); break;
2460 case SHF_EXECINSTR: strcat (buff, "X"); break;
2461 case SHF_MERGE: strcat (buff, "M"); break;
2462 case SHF_STRINGS: strcat (buff, "S"); break;
2463 case SHF_INFO_LINK: strcat (buff, "I"); break;
2464 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2465 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2466
2467 default:
2468 if (flag & SHF_MASKOS)
2469 {
2470 strcat (buff, "o");
2471 sh_flags &= ~ SHF_MASKOS;
2472 }
2473 else if (flag & SHF_MASKPROC)
2474 {
2475 strcat (buff, "p");
2476 sh_flags &= ~ SHF_MASKPROC;
2477 }
2478 else
2479 strcat (buff, "x");
2480 break;
2481 }
2482 }
2483
2484 return buff;
2485}
2486
252b5132
RH		 2487static int
2488process_section_headers (file)
2489 FILE * file;
2490{
9ea033b2
NC		 2491 Elf_Internal_Shdr * section;
2492 int i;
252b5132
RH		 2493
2494 section_headers = NULL;
2495
2496 if (elf_header.e_shnum == 0)
2497 {
2498 if (do_sections)
2499 printf (_("\nThere are no sections in this file.\n"));
2500
2501 return 1;
2502 }
2503
2504 if (do_sections && !do_header)
9ea033b2 2505 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
252b5132
RH		 2506 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2507
9ea033b2
NC		 2508 if (is_32bit_elf)
2509 {
2510 if (! get_32bit_section_headers (file))
2511 return 0;
2512 }
2513 else if (! get_64bit_section_headers (file))
252b5132
RH		 2514 return 0;
2515
2516 /* Read in the string table, so that we have names to display. */
2517 section = section_headers + elf_header.e_shstrndx;
2518
2519 if (section->sh_size != 0)
2520 {
2521 unsigned long string_table_offset;
2522
2523 string_table_offset = section->sh_offset;
2524
2525 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2526 string_table, char *, "string table");
2527 }
2528
2529 /* Scan the sections for the dynamic symbol table
2530 and dynamic string table and debug sections. */
2531 dynamic_symbols = NULL;
2532 dynamic_strings = NULL;
2533 dynamic_syminfo = NULL;
103f02d3 2534
252b5132
RH		 2535 for (i = 0, section = section_headers;
2536 i < elf_header.e_shnum;
2537 i ++, section ++)
2538 {
2539 char * name = SECTION_NAME (section);
2540
2541 if (section->sh_type == SHT_DYNSYM)
2542 {
2543 if (dynamic_symbols != NULL)
2544 {
2545 error (_("File contains multiple dynamic symbol tables\n"));
2546 continue;
2547 }
2548
19936277 2549 num_dynamic_syms = section->sh_size / section->sh_entsize;
9ea033b2 2550 dynamic_symbols =
19936277 2551 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
252b5132
RH		 2552 }
2553 else if (section->sh_type == SHT_STRTAB
2554 && strcmp (name, ".dynstr") == 0)
2555 {
2556 if (dynamic_strings != NULL)
2557 {
2558 error (_("File contains multiple dynamic string tables\n"));
2559 continue;
2560 }
2561
2562 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2563 dynamic_strings, char *, "dynamic strings");
2564 }
2565 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2566 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2567 && strncmp (name, ".debug_", 7) == 0)
2568 {
2569 name += 7;
2570
2571 if (do_debugging
2572 || (do_debug_info && (strcmp (name, "info") == 0))
2573 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2574 || (do_debug_lines && (strcmp (name, "line") == 0))
2575 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2576 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2577 )
2578 request_dump (i, DEBUG_DUMP);
2579 }
2580 }
2581
2582 if (! do_sections)
2583 return 1;
2584
2585 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
d1133906 2586
f7a99963
NC		 2587 if (is_32bit_elf)
2588 printf
2589 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2590 else
2591 {
2592 printf (_(" [Nr] Name Type Address Offset\n"));
2593 printf (_(" Size EntSize Flags Link Info Align\n"));
2594 }
252b5132
RH		 2595
2596 for (i = 0, section = section_headers;
2597 i < elf_header.e_shnum;
2598 i ++, section ++)
2599 {
2600 printf (" [%2d] %-17.17s %-15.15s ",
2601 i,
2602 SECTION_NAME (section),
2603 get_section_type_name (section->sh_type));
2604
f7a99963
NC		 2605 if (is_32bit_elf)
2606 {
2607 print_vma (section->sh_addr, LONG_HEX);
2608
2609 printf ( " %6.6lx %6.6lx %2.2lx",
2610 (unsigned long) section->sh_offset,
2611 (unsigned long) section->sh_size,
2612 (unsigned long) section->sh_entsize);
d1133906
NC		 2613
2614 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2615
2616 printf (" %2ld %3lx %ld\n",
f7a99963
NC		 2617 (unsigned long) section->sh_link,
2618 (unsigned long) section->sh_info,
2619 (unsigned long) section->sh_addralign);
2620 }
2621 else
2622 {
2623 putchar (' ');
2624 print_vma (section->sh_addr, LONG_HEX);
5e220199 2625 printf (" %8.8lx", section->sh_offset);
f7a99963
NC		 2626 printf ("\n ");
2627 print_vma (section->sh_size, LONG_HEX);
2628 printf (" ");
2629 print_vma (section->sh_entsize, LONG_HEX);
2630
d1133906
NC		 2631 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2632
f7a99963
NC		 2633 printf (" %2ld %3lx %ld\n",
2634 (unsigned long) section->sh_link,
2635 (unsigned long) section->sh_info,
2636 (unsigned long) section->sh_addralign);
2637 }
252b5132
RH		 2638 }
2639
d1133906
NC		 2640 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2641 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2642 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2643
252b5132
RH		 2644 return 1;
2645}
2646
2647/* Process the reloc section. */
2648static int
2649process_relocs (file)
2650 FILE * file;
2651{
2652 unsigned long rel_size;
2653 unsigned long rel_offset;
2654
2655
2656 if (!do_reloc)
2657 return 1;
2658
2659 if (do_using_dynamic)
2660 {
b4c96d0d 2661 int is_rela = FALSE;
9c19a809 2662
252b5132
RH		 2663 rel_size = 0;
2664 rel_offset = 0;
2665
2666 if (dynamic_info[DT_REL])
2667 {
2668 rel_offset = dynamic_info[DT_REL];
2669 rel_size = dynamic_info[DT_RELSZ];
9c19a809 2670 is_rela = FALSE;
252b5132
RH		 2671 }
2672 else if (dynamic_info [DT_RELA])
2673 {
2674 rel_offset = dynamic_info[DT_RELA];
2675 rel_size = dynamic_info[DT_RELASZ];
9c19a809 2676 is_rela = TRUE;
252b5132
RH		 2677 }
2678 else if (dynamic_info[DT_JMPREL])
2679 {
2680 rel_offset = dynamic_info[DT_JMPREL];
2681 rel_size = dynamic_info[DT_PLTRELSZ];
103f02d3 2682
aa903cfb
AS		 2683 switch (dynamic_info[DT_PLTREL])
2684 {
2685 case DT_REL:
2686 is_rela = FALSE;
2687 break;
2688 case DT_RELA:
2689 is_rela = TRUE;
2690 break;
2691 default:
2692 is_rela = UNKNOWN;
2693 break;
2694 }
252b5132
RH		 2695 }
2696
2697 if (rel_size)
2698 {
2699 printf
2700 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2701 rel_offset, rel_size);
2702
2703 dump_relocations (file, rel_offset - loadaddr, rel_size,
19936277 2704 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
252b5132
RH		 2705 }
2706 else
2707 printf (_("\nThere are no dynamic relocations in this file.\n"));
2708 }
2709 else
2710 {
2711 Elf32_Internal_Shdr * section;
2712 unsigned long i;
2713 int found = 0;
2714
2715 for (i = 0, section = section_headers;
2716 i < elf_header.e_shnum;
2717 i++, section ++)
2718 {
2719 if ( section->sh_type != SHT_RELA
2720 && section->sh_type != SHT_REL)
2721 continue;
2722
2723 rel_offset = section->sh_offset;
2724 rel_size = section->sh_size;
2725
2726 if (rel_size)
2727 {
2728 Elf32_Internal_Shdr * strsec;
2729 Elf32_Internal_Shdr * symsec;
2730 Elf_Internal_Sym * symtab;
2731 char * strtab;
9c19a809 2732 int is_rela;
19936277 2733 unsigned long nsyms;
103f02d3 2734
252b5132
RH		 2735 printf (_("\nRelocation section "));
2736
2737 if (string_table == NULL)
19936277 2738 printf ("%d", section->sh_name);
252b5132 2739 else
19936277 2740 printf ("'%s'", SECTION_NAME (section));
252b5132
RH		 2741
2742 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2743 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2744
2745 symsec = section_headers + section->sh_link;
2746
19936277
NC		 2747 nsyms = symsec->sh_size / symsec->sh_entsize;
2748 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
252b5132
RH		 2749
2750 if (symtab == NULL)
2751 continue;
2752
2753 strsec = section_headers + symsec->sh_link;
2754
2755 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2756 char *, "string table");
103f02d3 2757
aa903cfb 2758 is_rela = section->sh_type == SHT_RELA;
252b5132 2759
19936277 2760 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
252b5132
RH		 2761
2762 free (strtab);
2763 free (symtab);
2764
2765 found = 1;
2766 }
2767 }
2768
2769 if (! found)
2770 printf (_("\nThere are no relocations in this file.\n"));
2771 }
2772
2773 return 1;
2774}
2775
2776
2777static void
2778dynamic_segment_mips_val (entry)
2779 Elf_Internal_Dyn * entry;
2780{
2781 switch (entry->d_tag)
2782 {
2783 case DT_MIPS_FLAGS:
2784 if (entry->d_un.d_val == 0)
2785 printf ("NONE\n");
2786 else
2787 {
2788 static const char * opts[] =
2789 {
2790 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2791 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2792 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2793 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2794 "RLD_ORDER_SAFE"
2795 };
2796 unsigned int cnt;
2797 int first = 1;
2798 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2799 if (entry->d_un.d_val & (1 << cnt))
2800 {
2801 printf ("%s%s", first ? "" : " ", opts[cnt]);
2802 first = 0;
2803 }
2804 puts ("");
2805 }
2806 break;
103f02d3 2807
252b5132
RH		 2808 case DT_MIPS_IVERSION:
2809 if (dynamic_strings != NULL)
2810 printf ("Interface Version: %s\n",
2811 dynamic_strings + entry->d_un.d_val);
2812 else
2813 printf ("%ld\n", (long) entry->d_un.d_ptr);
2814 break;
103f02d3 2815
252b5132
RH		 2816 case DT_MIPS_TIME_STAMP:
2817 {
2818 char timebuf[20];
2819 time_t time = entry->d_un.d_val;
2820 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2821 printf ("Time Stamp: %s\n", timebuf);
2822 }
2823 break;
103f02d3 2824
252b5132
RH		 2825 case DT_MIPS_RLD_VERSION:
2826 case DT_MIPS_LOCAL_GOTNO:
2827 case DT_MIPS_CONFLICTNO:
2828 case DT_MIPS_LIBLISTNO:
2829 case DT_MIPS_SYMTABNO:
2830 case DT_MIPS_UNREFEXTNO:
2831 case DT_MIPS_HIPAGENO:
2832 case DT_MIPS_DELTA_CLASS_NO:
2833 case DT_MIPS_DELTA_INSTANCE_NO:
2834 case DT_MIPS_DELTA_RELOC_NO:
2835 case DT_MIPS_DELTA_SYM_NO:
2836 case DT_MIPS_DELTA_CLASSSYM_NO:
2837 case DT_MIPS_COMPACT_SIZE:
2838 printf ("%ld\n", (long) entry->d_un.d_ptr);
2839 break;
103f02d3
UD		 2840
2841 default:
2842 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2843 }
2844}
2845
2846
2847static void
2848dynamic_segment_parisc_val (entry)
2849 Elf_Internal_Dyn * entry;
2850{
2851 switch (entry->d_tag)
2852 {
2853 case DT_HP_DLD_FLAGS:
2854 {
2855 static struct
2856 {
2857 long int bit;
5e220199
NC		 2858 const char * str;
2859 }
2860 flags[] =
2861 {
2862 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2863 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2864 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2865 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2866 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2867 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2868 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2869 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2870 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2871 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2872 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2873 };
103f02d3 2874 int first = 1;
5e220199 2875 size_t cnt;
f7a99963 2876 bfd_vma val = entry->d_un.d_val;
103f02d3
UD		 2877
2878 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
2879 if (val & flags[cnt].bit)
30800947
NC		 2880 {
2881 if (! first)
2882 putchar (' ');
2883 fputs (flags[cnt].str, stdout);
2884 first = 0;
2885 val ^= flags[cnt].bit;
2886 }
5e220199 2887
103f02d3 2888 if (val != 0 || first)
f7a99963
NC		 2889 {
2890 if (! first)
2891 putchar (' ');
2892 print_vma (val, HEX);
2893 }
103f02d3
UD		 2894 }
2895 break;
30800947 2896
252b5132 2897 default:
f7a99963
NC		 2898 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
2899 break;
252b5132
RH		 2900 }
2901}
2902
252b5132 2903static int
9ea033b2 2904get_32bit_dynamic_segment (file)
252b5132
RH		 2905 FILE * file;
2906{
9ea033b2
NC		 2907 Elf32_External_Dyn * edyn;
2908 Elf_Internal_Dyn * entry;
2909 bfd_size_type i;
103f02d3 2910
9ea033b2
NC		 2911 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
2912 edyn, Elf32_External_Dyn *, "dynamic segment");
103f02d3 2913
9ea033b2
NC		 2914 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2915 how large this .dynamic is now. We can do this even before the byte
2916 swapping since the DT_NULL tag is recognizable. */
2917 dynamic_size = 0;
2918 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
2919 ;
252b5132 2920
9ea033b2
NC		 2921 dynamic_segment = (Elf_Internal_Dyn *)
2922 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2923
2924 if (dynamic_segment == NULL)
252b5132 2925 {
9ea033b2
NC		 2926 error (_("Out of memory\n"));
2927 free (edyn);
2928 return 0;
2929 }
252b5132 2930
9ea033b2
NC		 2931 for (i = 0, entry = dynamic_segment;
2932 i < dynamic_size;
2933 i ++, entry ++)
2934 {
2935 entry->d_tag = BYTE_GET (edyn [i].d_tag);
2936 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
252b5132
RH		 2937 }
2938
9ea033b2
NC		 2939 free (edyn);
2940
2941 return 1;
2942}
2943
2944static int
2945get_64bit_dynamic_segment (file)
2946 FILE * file;
2947{
2948 Elf64_External_Dyn * edyn;
2949 Elf_Internal_Dyn * entry;
2950 bfd_size_type i;
103f02d3 2951
252b5132 2952 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
9ea033b2 2953 edyn, Elf64_External_Dyn *, "dynamic segment");
103f02d3 2954
252b5132 2955 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
9ea033b2 2956 how large this .dynamic is now. We can do this even before the byte
252b5132
RH		 2957 swapping since the DT_NULL tag is recognizable. */
2958 dynamic_size = 0;
9ea033b2 2959 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
252b5132
RH		 2960 ;
2961
2962 dynamic_segment = (Elf_Internal_Dyn *)
2963 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2964
2965 if (dynamic_segment == NULL)
2966 {
2967 error (_("Out of memory\n"));
2968 free (edyn);
2969 return 0;
2970 }
2971
2972 for (i = 0, entry = dynamic_segment;
2973 i < dynamic_size;
2974 i ++, entry ++)
2975 {
9ea033b2
NC		 2976 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
2977 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
252b5132
RH		 2978 }
2979
2980 free (edyn);
2981
9ea033b2
NC		 2982 return 1;
2983}
2984
d1133906
NC		 2985static const char *
2986get_dynamic_flags (flags)
2987 bfd_vma flags;
2988{
2989 static char buff [64];
2990 while (flags)
2991 {
2992 bfd_vma flag;
2993
2994 flag = flags & - flags;
2995 flags &= ~ flag;
2996
2997 switch (flag)
2998 {
2999 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3000 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3001 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3002 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
305c7206 3003 default: strcat (buff, "unknown "); break;
d1133906
NC		 3004 }
3005 }
305c7206 3006 return buff;
d1133906
NC		 3007}
3008
9ea033b2
NC		 3009/* Parse and display the contents of the dynamic segment. */
3010static int
3011process_dynamic_segment (file)
3012 FILE * file;
3013{
3014 Elf_Internal_Dyn * entry;
3015 bfd_size_type i;
3016
3017 if (dynamic_size == 0)
3018 {
3019 if (do_dynamic)
3020 printf (_("\nThere is no dynamic segment in this file.\n"));
3021
3022 return 1;
3023 }
3024
3025 if (is_32bit_elf)
3026 {
3027 if (! get_32bit_dynamic_segment (file))
3028 return 0;
3029 }
3030 else if (! get_64bit_dynamic_segment (file))
3031 return 0;
3032
252b5132
RH		 3033 /* Find the appropriate symbol table. */
3034 if (dynamic_symbols == NULL)
3035 {
3036 for (i = 0, entry = dynamic_segment;
3037 i < dynamic_size;
3038 ++i, ++ entry)
3039 {
3040 unsigned long offset;
252b5132
RH		 3041
3042 if (entry->d_tag != DT_SYMTAB)
3043 continue;
3044
3045 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3046
3047 /* Since we do not know how big the symbol table is,
3048 we default to reading in the entire file (!) and
3049 processing that. This is overkill, I know, but it
3050 should work. */
252b5132
RH		 3051 offset = entry->d_un.d_val - loadaddr;
3052
3053 if (fseek (file, 0, SEEK_END))
3054 error (_("Unable to seek to end of file!"));
3055
9ea033b2 3056 if (is_32bit_elf)
19936277 3057 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
9ea033b2 3058 else
19936277 3059 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
252b5132 3060
19936277 3061 if (num_dynamic_syms < 1)
252b5132
RH		 3062 {
3063 error (_("Unable to determine the number of symbols to load\n"));
3064 continue;
3065 }
3066
19936277 3067 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
252b5132
RH		 3068 }
3069 }
3070
3071 /* Similarly find a string table. */
3072 if (dynamic_strings == NULL)
3073 {
3074 for (i = 0, entry = dynamic_segment;
3075 i < dynamic_size;
3076 ++i, ++ entry)
3077 {
3078 unsigned long offset;
3079 long str_tab_len;
3080
3081 if (entry->d_tag != DT_STRTAB)
3082 continue;
3083
3084 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3085
3086 /* Since we do not know how big the string table is,
3087 we default to reading in the entire file (!) and
3088 processing that. This is overkill, I know, but it
3089 should work. */
3090
3091 offset = entry->d_un.d_val - loadaddr;
3092 if (fseek (file, 0, SEEK_END))
3093 error (_("Unable to seek to end of file\n"));
3094 str_tab_len = ftell (file) - offset;
3095
3096 if (str_tab_len < 1)
3097 {
3098 error
3099 (_("Unable to determine the length of the dynamic string table\n"));
3100 continue;
3101 }
3102
3103 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3104 "dynamic string table");
3105
3106 break;
3107 }
3108 }
3109
3110 /* And find the syminfo section if available. */
3111 if (dynamic_syminfo == NULL)
3112 {
3113 unsigned int syminsz = 0;
3114
3115 for (i = 0, entry = dynamic_segment;
3116 i < dynamic_size;
3117 ++i, ++ entry)
3118 {
3119 if (entry->d_tag == DT_SYMINENT)
3120 {
3121 /* Note: these braces are necessary to avoid a syntax
3122 error from the SunOS4 C compiler. */
3123 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3124 }
3125 else if (entry->d_tag == DT_SYMINSZ)
3126 syminsz = entry->d_un.d_val;
3127 else if (entry->d_tag == DT_SYMINFO)
3128 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3129 }
3130
3131 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3132 {
9ea033b2
NC		 3133 Elf_External_Syminfo * extsyminfo;
3134 Elf_Internal_Syminfo * syminfo;
252b5132
RH		 3135
3136 /* There is a syminfo section. Read the data. */
3137 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3138 Elf_External_Syminfo *, "symbol information");
3139
3140 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3141 if (dynamic_syminfo == NULL)
3142 {
3143 error (_("Out of memory\n"));
3144 return 0;
3145 }
3146
3147 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3148 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3149 ++i, ++syminfo)
3150 {
3151 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3152 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3153 }
3154
3155 free (extsyminfo);
3156 }
3157 }
3158
3159 if (do_dynamic && dynamic_addr)
789be9f7
ILT		 3160 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3161 dynamic_addr, (long) dynamic_size);
252b5132
RH		 3162 if (do_dynamic)
3163 printf (_(" Tag Type Name/Value\n"));
3164
3165 for (i = 0, entry = dynamic_segment;
3166 i < dynamic_size;
3167 i++, entry ++)
3168 {
3169 if (do_dynamic)
f7a99963
NC		 3170 {
3171 putchar (' ');
3172 print_vma (entry->d_tag, FULL_HEX);
3173 printf (" (%s)%*s",
3174 get_dynamic_type (entry->d_tag),
3175 (is_32bit_elf ? 27 : 19) - strlen (get_dynamic_type (entry->d_tag)),
3176 " ");
3177 }
252b5132
RH		 3178
3179 switch (entry->d_tag)
3180 {
d1133906
NC		 3181 case DT_FLAGS:
3182 if (do_dynamic)
305c7206 3183 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
d1133906
NC		 3184 break;
3185
252b5132
RH		 3186 case DT_AUXILIARY:
3187 case DT_FILTER:
3188 if (do_dynamic)
3189 {
3190 if (entry->d_tag == DT_AUXILIARY)
3191 printf (_("Auxiliary library"));
3192 else
3193 printf (_("Filter library"));
3194
3195 if (dynamic_strings)
3196 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3197 else
f7a99963
NC		 3198 {
3199 printf (": ");
3200 print_vma (entry->d_un.d_val, PREFIX_HEX);
3201 putchar ('\n');
3202 }
252b5132
RH		 3203 }
3204 break;
3205
3206 case DT_FEATURE_1:
3207 if (do_dynamic)
3208 {
3209 printf (_("Flags:"));
3210 if (entry->d_un.d_val == 0)
3211 printf (_(" None\n"));
3212 else
3213 {
3214 unsigned long int val = entry->d_un.d_val;
3215 if (val & DTF_1_PARINIT)
3216 {
3217 printf (" PARINIT");
3218 val ^= DTF_1_PARINIT;
3219 }
3220 if (val != 0)
3221 printf (" %lx", val);
3222 puts ("");
3223 }
3224 }
3225 break;
3226
3227 case DT_POSFLAG_1:
3228 if (do_dynamic)
3229 {
3230 printf (_("Flags:"));
3231 if (entry->d_un.d_val == 0)
3232 printf (_(" None\n"));
3233 else
3234 {
3235 unsigned long int val = entry->d_un.d_val;
3236 if (val & DF_P1_LAZYLOAD)
3237 {
3238 printf (" LAZYLOAD");
3239 val ^= DF_P1_LAZYLOAD;
3240 }
3241 if (val & DF_P1_GROUPPERM)
3242 {
3243 printf (" GROUPPERM");
3244 val ^= DF_P1_GROUPPERM;
3245 }
3246 if (val != 0)
3247 printf (" %lx", val);
3248 puts ("");
3249 }
3250 }
3251 break;
3252
3253 case DT_FLAGS_1:
3254 if (do_dynamic)
3255 {
3256 printf (_("Flags:"));
3257 if (entry->d_un.d_val == 0)
3258 printf (_(" None\n"));
3259 else
3260 {
3261 unsigned long int val = entry->d_un.d_val;
3262 if (val & DF_1_NOW)
3263 {
3264 printf (" NOW");
3265 val ^= DF_1_NOW;
3266 }
3267 if (val & DF_1_GLOBAL)
3268 {
3269 printf (" GLOBAL");
3270 val ^= DF_1_GLOBAL;
3271 }
3272 if (val & DF_1_GROUP)
3273 {
3274 printf (" GROUP");
3275 val ^= DF_1_GROUP;
3276 }
3277 if (val & DF_1_NODELETE)
3278 {
3279 printf (" NODELETE");
3280 val ^= DF_1_NODELETE;
3281 }
3282 if (val & DF_1_LOADFLTR)
3283 {
3284 printf (" LOADFLTR");
3285 val ^= DF_1_LOADFLTR;
3286 }
3287 if (val & DF_1_INITFIRST)
3288 {
3289 printf (" INITFIRST");
3290 val ^= DF_1_INITFIRST;
3291 }
3292 if (val & DF_1_NOOPEN)
3293 {
3294 printf (" NOOPEN");
3295 val ^= DF_1_NOOPEN;
3296 }
3297 if (val & DF_1_ORIGIN)
3298 {
3299 printf (" ORIGIN");
3300 val ^= DF_1_ORIGIN;
3301 }
3302 if (val & DF_1_DIRECT)
3303 {
3304 printf (" DIRECT");
3305 val ^= DF_1_DIRECT;
3306 }
3307 if (val & DF_1_TRANS)
3308 {
3309 printf (" TRANS");
3310 val ^= DF_1_TRANS;
3311 }
3312 if (val & DF_1_INTERPOSE)
3313 {
3314 printf (" INTERPOSE");
3315 val ^= DF_1_INTERPOSE;
3316 }
3317 if (val != 0)
3318 printf (" %lx", val);
3319 puts ("");
3320 }
3321 }
3322 break;
3323
3324 case DT_PLTREL:
3325 if (do_dynamic)
3326 puts (get_dynamic_type (entry->d_un.d_val));
3327 break;
3328
3329 case DT_NULL :
3330 case DT_NEEDED :
3331 case DT_PLTGOT :
3332 case DT_HASH :
3333 case DT_STRTAB :
3334 case DT_SYMTAB :
3335 case DT_RELA :
3336 case DT_INIT :
3337 case DT_FINI :
3338 case DT_SONAME :
3339 case DT_RPATH :
3340 case DT_SYMBOLIC:
3341 case DT_REL :
3342 case DT_DEBUG :
3343 case DT_TEXTREL :
3344 case DT_JMPREL :
3345 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3346
3347 if (do_dynamic)
3348 {
3349 char * name;
3350
3351 if (dynamic_strings == NULL)
3352 name = NULL;
3353 else
3354 name = dynamic_strings + entry->d_un.d_val;
3355
3356 if (name)
3357 {
3358 switch (entry->d_tag)
3359 {
3360 case DT_NEEDED:
3361 printf (_("Shared library: [%s]"), name);
3362
f7a99963
NC		 3363 if (strcmp (name, program_interpreter) == 0)
3364 printf (_(" program interpreter"));
252b5132
RH		 3365 break;
3366
3367 case DT_SONAME:
f7a99963 3368 printf (_("Library soname: [%s]"), name);
252b5132
RH		 3369 break;
3370
3371 case DT_RPATH:
f7a99963 3372 printf (_("Library rpath: [%s]"), name);
252b5132
RH		 3373 break;
3374
3375 default:
f7a99963
NC		 3376 print_vma (entry->d_un.d_val, PREFIX_HEX);
3377 break;
252b5132
RH		 3378 }
3379 }
3380 else
f7a99963
NC		 3381 print_vma (entry->d_un.d_val, PREFIX_HEX);
3382
3383 putchar ('\n');
252b5132
RH		 3384 }
3385 break;
3386
3387 case DT_PLTRELSZ:
3388 case DT_RELASZ :
3389 case DT_STRSZ :
3390 case DT_RELSZ :
3391 case DT_RELAENT :
3392 case DT_SYMENT :
3393 case DT_RELENT :
3394 case DT_PLTPADSZ:
3395 case DT_MOVEENT :
3396 case DT_MOVESZ :
3397 case DT_INIT_ARRAYSZ:
3398 case DT_FINI_ARRAYSZ:
3399 if (do_dynamic)
f7a99963
NC		 3400 {
3401 print_vma (entry->d_un.d_val, UNSIGNED);
3402 printf (" (bytes)\n");
3403 }
252b5132
RH		 3404 break;
3405
3406 case DT_VERDEFNUM:
3407 case DT_VERNEEDNUM:
3408 case DT_RELACOUNT:
3409 case DT_RELCOUNT:
3410 if (do_dynamic)
f7a99963
NC		 3411 {
3412 print_vma (entry->d_un.d_val, UNSIGNED);
3413 putchar ('\n');
3414 }
252b5132
RH		 3415 break;
3416
3417 case DT_SYMINSZ:
3418 case DT_SYMINENT:
3419 case DT_SYMINFO:
3420 case DT_USED:
3421 case DT_INIT_ARRAY:
3422 case DT_FINI_ARRAY:
3423 if (do_dynamic)
3424 {
3425 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3426 {
3427 char * name;
3428
3429 name = dynamic_strings + entry->d_un.d_val;
3430
3431 if (* name)
3432 {
3433 printf (_("Not needed object: [%s]\n"), name);
3434 break;
3435 }
3436 }
103f02d3 3437
f7a99963
NC		 3438 print_vma (entry->d_un.d_val, PREFIX_HEX);
3439 putchar ('\n');
252b5132
RH		 3440 }
3441 break;
3442
3443 case DT_BIND_NOW:
3444 /* The value of this entry is ignored. */
3445 break;
103f02d3 3446
252b5132
RH		 3447 default:
3448 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3449 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3450 entry->d_un.d_val;
3451
3452 if (do_dynamic)
3453 {
3454 switch (elf_header.e_machine)
3455 {
3456 case EM_MIPS:
3457 case EM_MIPS_RS4_BE:
3458 dynamic_segment_mips_val (entry);
3459 break;
103f02d3
UD		 3460 case EM_PARISC:
3461 dynamic_segment_parisc_val (entry);
3462 break;
252b5132 3463 default:
f7a99963
NC		 3464 print_vma (entry->d_un.d_val, PREFIX_HEX);
3465 putchar ('\n');
252b5132
RH		 3466 }
3467 }
3468 break;
3469 }
3470 }
3471
3472 return 1;
3473}
3474
3475static char *
3476get_ver_flags (flags)
3477 unsigned int flags;
3478{
3479 static char buff [32];
3480
3481 buff[0] = 0;
3482
3483 if (flags == 0)
3484 return _("none");
3485
3486 if (flags & VER_FLG_BASE)
3487 strcat (buff, "BASE ");
3488
3489 if (flags & VER_FLG_WEAK)
3490 {
3491 if (flags & VER_FLG_BASE)
3492 strcat (buff, "| ");
3493
3494 strcat (buff, "WEAK ");
3495 }
3496
3497 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3498 strcat (buff, "| <unknown>");
3499
3500 return buff;
3501}
3502
3503/* Display the contents of the version sections. */
3504static int
3505process_version_sections (file)
3506 FILE * file;
3507{
3508 Elf32_Internal_Shdr * section;
3509 unsigned i;
3510 int found = 0;
3511
3512 if (! do_version)
3513 return 1;
3514
3515 for (i = 0, section = section_headers;
3516 i < elf_header.e_shnum;
3517 i++, section ++)
3518 {
3519 switch (section->sh_type)
3520 {
3521 case SHT_GNU_verdef:
3522 {
3523 Elf_External_Verdef * edefs;
3524 unsigned int idx;
3525 unsigned int cnt;
3526
3527 found = 1;
3528
3529 printf
3530 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3531 SECTION_NAME (section), section->sh_info);
3532
3533 printf (_(" Addr: 0x"));
3534 printf_vma (section->sh_addr);
3535 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
1b228002 3536 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 3537 SECTION_NAME (section_headers + section->sh_link));
3538
3539 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3540 edefs, Elf_External_Verdef *,
3541 "version definition section");
3542
3543 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3544 {
3545 char * vstart;
3546 Elf_External_Verdef * edef;
3547 Elf_Internal_Verdef ent;
3548 Elf_External_Verdaux * eaux;
3549 Elf_Internal_Verdaux aux;
3550 int j;
3551 int isum;
103f02d3 3552
252b5132
RH		 3553 vstart = ((char *) edefs) + idx;
3554
3555 edef = (Elf_External_Verdef *) vstart;
3556
3557 ent.vd_version = BYTE_GET (edef->vd_version);
3558 ent.vd_flags = BYTE_GET (edef->vd_flags);
3559 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3560 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3561 ent.vd_hash = BYTE_GET (edef->vd_hash);
3562 ent.vd_aux = BYTE_GET (edef->vd_aux);
3563 ent.vd_next = BYTE_GET (edef->vd_next);
3564
3565 printf (_(" %#06x: Rev: %d Flags: %s"),
3566 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3567
3568 printf (_(" Index: %d Cnt: %d "),
3569 ent.vd_ndx, ent.vd_cnt);
3570
3571 vstart += ent.vd_aux;
3572
3573 eaux = (Elf_External_Verdaux *) vstart;
3574
3575 aux.vda_name = BYTE_GET (eaux->vda_name);
3576 aux.vda_next = BYTE_GET (eaux->vda_next);
3577
3578 if (dynamic_strings)
3579 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3580 else
3581 printf (_("Name index: %ld\n"), aux.vda_name);
3582
3583 isum = idx + ent.vd_aux;
3584
3585 for (j = 1; j < ent.vd_cnt; j ++)
3586 {
3587 isum += aux.vda_next;
3588 vstart += aux.vda_next;
3589
3590 eaux = (Elf_External_Verdaux *) vstart;
3591
3592 aux.vda_name = BYTE_GET (eaux->vda_name);
3593 aux.vda_next = BYTE_GET (eaux->vda_next);
3594
3595 if (dynamic_strings)
3596 printf (_(" %#06x: Parent %d: %s\n"),
3597 isum, j, dynamic_strings + aux.vda_name);
3598 else
3599 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3600 isum, j, aux.vda_name);
3601 }
3602
3603 idx += ent.vd_next;
3604 }
3605
3606 free (edefs);
3607 }
3608 break;
103f02d3 3609
252b5132
RH		 3610 case SHT_GNU_verneed:
3611 {
3612 Elf_External_Verneed * eneed;
3613 unsigned int idx;
3614 unsigned int cnt;
3615
3616 found = 1;
3617
3618 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3619 SECTION_NAME (section), section->sh_info);
3620
3621 printf (_(" Addr: 0x"));
3622 printf_vma (section->sh_addr);
3623 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
1b228002 3624 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 3625 SECTION_NAME (section_headers + section->sh_link));
3626
3627 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3628 eneed, Elf_External_Verneed *,
3629 "version need section");
3630
3631 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3632 {
3633 Elf_External_Verneed * entry;
3634 Elf_Internal_Verneed ent;
3635 int j;
3636 int isum;
3637 char * vstart;
3638
3639 vstart = ((char *) eneed) + idx;
3640
3641 entry = (Elf_External_Verneed *) vstart;
3642
3643 ent.vn_version = BYTE_GET (entry->vn_version);
3644 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3645 ent.vn_file = BYTE_GET (entry->vn_file);
3646 ent.vn_aux = BYTE_GET (entry->vn_aux);
3647 ent.vn_next = BYTE_GET (entry->vn_next);
3648
3649 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3650
3651 if (dynamic_strings)
3652 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3653 else
3654 printf (_(" File: %lx"), ent.vn_file);
3655
3656 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3657
3658 vstart += ent.vn_aux;
3659
3660 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3661 {
3662 Elf_External_Vernaux * eaux;
3663 Elf_Internal_Vernaux aux;
3664
3665 eaux = (Elf_External_Vernaux *) vstart;
3666
3667 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3668 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3669 aux.vna_other = BYTE_GET (eaux->vna_other);
3670 aux.vna_name = BYTE_GET (eaux->vna_name);
3671 aux.vna_next = BYTE_GET (eaux->vna_next);
3672
3673 if (dynamic_strings)
3674 printf (_(" %#06x: Name: %s"),
3675 isum, dynamic_strings + aux.vna_name);
3676 else
3677 printf (_(" %#06x: Name index: %lx"),
3678 isum, aux.vna_name);
3679
3680 printf (_(" Flags: %s Version: %d\n"),
3681 get_ver_flags (aux.vna_flags), aux.vna_other);
3682
3683 isum += aux.vna_next;
3684 vstart += aux.vna_next;
3685 }
3686
3687 idx += ent.vn_next;
3688 }
103f02d3 3689
252b5132
RH		 3690 free (eneed);
3691 }
3692 break;
3693
3694 case SHT_GNU_versym:
3695 {
3696 Elf32_Internal_Shdr * link_section;
3697 int total;
3698 int cnt;
3699 unsigned char * edata;
3700 unsigned short * data;
3701 char * strtab;
3702 Elf_Internal_Sym * symbols;
3703 Elf32_Internal_Shdr * string_sec;
3704
3705 link_section = section_headers + section->sh_link;
3706 total = section->sh_size / section->sh_entsize;
3707
3708 found = 1;
3709
9ea033b2
NC		 3710 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3711 link_section->sh_size / link_section->sh_entsize);
252b5132
RH		 3712
3713 string_sec = section_headers + link_section->sh_link;
3714
3715 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3716 strtab, char *, "version string table");
3717
3718 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3719 SECTION_NAME (section), total);
3720
3721 printf (_(" Addr: "));
3722 printf_vma (section->sh_addr);
3723 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
1b228002 3724 (unsigned long) section->sh_offset, section->sh_link,
252b5132
RH		 3725 SECTION_NAME (link_section));
3726
3727 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3728 - loadaddr,
3729 total * sizeof (short), edata,
3730 unsigned char *, "version symbol data");
3731
3732 data = (unsigned short *) malloc (total * sizeof (short));
3733
3734 for (cnt = total; cnt --;)
3735 data [cnt] = byte_get (edata + cnt * sizeof (short),
3736 sizeof (short));
3737
3738 free (edata);
3739
3740 for (cnt = 0; cnt < total; cnt += 4)
3741 {
3742 int j, nn;
16062207 3743 char *name;
252b5132
RH		 3744
3745 printf (" %03x:", cnt);
3746
3747 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3748 switch (data [cnt + j])
3749 {
3750 case 0:
3751 fputs (_(" 0 (*local*) "), stdout);
3752 break;
3753
3754 case 1:
3755 fputs (_(" 1 (*global*) "), stdout);
3756 break;
3757
3758 default:
3759 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3760 data [cnt + j] & 0x8000 ? 'h' : ' ');
3761
3762 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3763 && section_headers[symbols [cnt + j].st_shndx].sh_type
3764 == SHT_NOBITS)
3765 {
3766 /* We must test both. */
3767 Elf_Internal_Verneed ivn;
3768 unsigned long offset;
3769
3770 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3771 - loadaddr;
3772
3773 do
3774 {
3775 Elf_External_Verneed evn;
3776 Elf_External_Vernaux evna;
3777 Elf_Internal_Vernaux ivna;
3778 unsigned long vna_off;
3779
3780 GET_DATA (offset, evn, "version need");
3781
3782 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3783 ivn.vn_next = BYTE_GET (evn.vn_next);
3784
3785 vna_off = offset + ivn.vn_aux;
3786
3787 do
3788 {
3789 GET_DATA (vna_off, evna,
3790 "version need aux (1)");
3791
3792 ivna.vna_next = BYTE_GET (evna.vna_next);
3793 ivna.vna_other = BYTE_GET (evna.vna_other);
3794
3795 vna_off += ivna.vna_next;
3796 }
3797 while (ivna.vna_other != data [cnt + j]
3798 && ivna.vna_next != 0);
3799
3800 if (ivna.vna_other == data [cnt + j])
3801 {
3802 ivna.vna_name = BYTE_GET (evna.vna_name);
3803
16062207 3804 name = strtab + ivna.vna_name;
252b5132 3805 nn += printf ("(%s%-*s",
16062207
ILT		 3806 name,
3807 12 - (int) strlen (name),
252b5132
RH		 3808 ")");
3809 break;
3810 }
3811 else if (ivn.vn_next == 0)
3812 {
3813 if (data [cnt + j] != 0x8001)
3814 {
3815 Elf_Internal_Verdef ivd;
3816 Elf_External_Verdef evd;
3817
3818 offset = version_info
3819 [DT_VERSIONTAGIDX (DT_VERDEF)]
3820 - loadaddr;
3821
3822 do
3823 {
3824 GET_DATA (offset, evd,
3825 "version definition");
3826
3827 ivd.vd_next = BYTE_GET (evd.vd_next);
3828 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3829
3830 offset += ivd.vd_next;
3831 }
3832 while (ivd.vd_ndx
3833 != (data [cnt + j] & 0x7fff)
3834 && ivd.vd_next != 0);
3835
3836 if (ivd.vd_ndx
3837 == (data [cnt + j] & 0x7fff))
3838 {
3839 Elf_External_Verdaux evda;
3840 Elf_Internal_Verdaux ivda;
3841
3842 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3843
3844 GET_DATA (offset + ivd.vd_aux, evda,
3845 "version definition aux");
3846
3847 ivda.vda_name =
3848 BYTE_GET (evda.vda_name);
3849
16062207 3850 name = strtab + ivda.vda_name;
252b5132
RH		 3851 nn +=
3852 printf ("(%s%-*s",
16062207
ILT		 3853 name,
3854 12 - (int) strlen (name),
252b5132
RH		 3855 ")");
3856 }
3857 }
3858
3859 break;
3860 }
3861 else
3862 offset += ivn.vn_next;
3863 }
3864 while (ivn.vn_next);
3865 }
3866 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3867 {
3868 Elf_Internal_Verneed ivn;
3869 unsigned long offset;
3870
3871 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3872 - loadaddr;
3873
3874 do
3875 {
3876 Elf_Internal_Vernaux ivna;
3877 Elf_External_Verneed evn;
3878 Elf_External_Vernaux evna;
3879 unsigned long a_off;
3880
3881 GET_DATA (offset, evn, "version need");
3882
3883 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3884 ivn.vn_next = BYTE_GET (evn.vn_next);
3885
3886 a_off = offset + ivn.vn_aux;
3887
3888 do
3889 {
3890 GET_DATA (a_off, evna,
3891 "version need aux (2)");
3892
3893 ivna.vna_next = BYTE_GET (evna.vna_next);
3894 ivna.vna_other = BYTE_GET (evna.vna_other);
3895
3896 a_off += ivna.vna_next;
3897 }
3898 while (ivna.vna_other != data [cnt + j]
3899 && ivna.vna_next != 0);
3900
3901 if (ivna.vna_other == data [cnt + j])
3902 {
3903 ivna.vna_name = BYTE_GET (evna.vna_name);
3904
16062207 3905 name = strtab + ivna.vna_name;
252b5132 3906 nn += printf ("(%s%-*s",
16062207
ILT		 3907 name,
3908 12 - (int) strlen (name),
252b5132
RH		 3909 ")");
3910 break;
3911 }
3912
3913 offset += ivn.vn_next;
3914 }
3915 while (ivn.vn_next);
3916 }
3917 else if (data [cnt + j] != 0x8001)
3918 {
3919 Elf_Internal_Verdef ivd;
3920 Elf_External_Verdef evd;
3921 unsigned long offset;
3922
3923 offset = version_info
3924 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
3925
3926 do
3927 {
3928 GET_DATA (offset, evd, "version def");
3929
3930 ivd.vd_next = BYTE_GET (evd.vd_next);
3931 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3932
3933 offset += ivd.vd_next;
3934 }
3935 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
3936 && ivd.vd_next != 0);
3937
3938 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
3939 {
3940 Elf_External_Verdaux evda;
3941 Elf_Internal_Verdaux ivda;
3942
3943 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3944
3945 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
3946 evda, "version def aux");
3947
3948 ivda.vda_name = BYTE_GET (evda.vda_name);
3949
16062207 3950 name = strtab + ivda.vda_name;
252b5132 3951 nn += printf ("(%s%-*s",
16062207
ILT		 3952 name,
3953 12 - (int) strlen (name),
252b5132
RH		 3954 ")");
3955 }
3956 }
3957
3958 if (nn < 18)
3959 printf ("%*c", 18 - nn, ' ');
3960 }
3961
3962 putchar ('\n');
3963 }
3964
3965 free (data);
3966 free (strtab);
3967 free (symbols);
3968 }
3969 break;
103f02d3 3970
252b5132
RH		 3971 default:
3972 break;
3973 }
3974 }
3975
3976 if (! found)
3977 printf (_("\nNo version information found in this file.\n"));
3978
3979 return 1;
3980}
3981
d1133906 3982static const char *
252b5132
RH		 3983get_symbol_binding (binding)
3984 unsigned int binding;
3985{
3986 static char buff [32];
3987
3988 switch (binding)
3989 {
103f02d3
UD		 3990 case STB_LOCAL: return "LOCAL";
3991 case STB_GLOBAL: return "GLOBAL";
3992 case STB_WEAK: return "WEAK";
252b5132
RH		 3993 default:
3994 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
3995 sprintf (buff, _("<processor specific>: %d"), binding);
3996 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3997 sprintf (buff, _("<OS specific>: %d"), binding);
3998 else
3999 sprintf (buff, _("<unknown>: %d"), binding);
4000 return buff;
4001 }
4002}
4003
d1133906 4004static const char *
252b5132
RH		 4005get_symbol_type (type)
4006 unsigned int type;
4007{
4008 static char buff [32];
4009
4010 switch (type)
4011 {
103f02d3
UD		 4012 case STT_NOTYPE: return "NOTYPE";
4013 case STT_OBJECT: return "OBJECT";
4014 case STT_FUNC: return "FUNC";
4015 case STT_SECTION: return "SECTION";
4016 case STT_FILE: return "FILE";
d1133906 4017 case STT_COMMON: return "COMMON";
252b5132
RH		 4018 default:
4019 if (type >= STT_LOPROC && type <= STT_HIPROC)
df75f1af
NC		 4020 {
4021 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
103f02d3
UD		 4022 return "THUMB_FUNC";
4023
351b4b40 4024 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
103f02d3
UD		 4025 return "REGISTER";
4026
4027 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4028 return "PARISC_MILLI";
4029
df75f1af
NC		 4030 sprintf (buff, _("<processor specific>: %d"), type);
4031 }
252b5132 4032 else if (type >= STT_LOOS && type <= STT_HIOS)
103f02d3
UD		 4033 {
4034 if (elf_header.e_machine == EM_PARISC)
4035 {
4036 if (type == STT_HP_OPAQUE)
4037 return "HP_OPAQUE";
4038 if (type == STT_HP_STUB)
4039 return "HP_STUB";
4040 }
4041
4042 sprintf (buff, _("<OS specific>: %d"), type);
4043 }
252b5132
RH		 4044 else
4045 sprintf (buff, _("<unknown>: %d"), type);
4046 return buff;
4047 }
4048}
4049
d1133906
NC		 4050static const char *
4051get_symbol_visibility (visibility)
4052 unsigned int visibility;
4053{
4054 switch (visibility)
4055 {
4056 case STV_DEFAULT: return "DEFAULT";
4057 case STV_INTERNAL: return "INTERNAL";
4058 case STV_HIDDEN: return "HIDDEN";
4059 case STV_PROTECTED: return "PROTECTED";
4060 default: abort ();
4061 }
4062}
4063
4064static const char *
252b5132
RH		 4065get_symbol_index_type (type)
4066 unsigned int type;
4067{
4068 switch (type)
4069 {
4070 case SHN_UNDEF: return "UND";
4071 case SHN_ABS: return "ABS";
4072 case SHN_COMMON: return "COM";
4073 default:
4074 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4075 return "PRC";
4076 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4077 return "RSV";
4078 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4079 return "OS ";
4080 else
4081 {
4082 static char buff [32];
4083
4084 sprintf (buff, "%3d", type);
4085 return buff;
4086 }
4087 }
4088}
4089
252b5132
RH		 4090static int *
4091get_dynamic_data (file, number)
4092 FILE * file;
4093 unsigned int number;
4094{
4095 char * e_data;
4096 int * i_data;
4097
4098 e_data = (char *) malloc (number * 4);
4099
4100 if (e_data == NULL)
4101 {
4102 error (_("Out of memory\n"));
4103 return NULL;
4104 }
4105
4106 if (fread (e_data, 4, number, file) != number)
4107 {
4108 error (_("Unable to read in dynamic data\n"));
4109 return NULL;
4110 }
4111
4112 i_data = (int *) malloc (number * sizeof (* i_data));
4113
4114 if (i_data == NULL)
4115 {
4116 error (_("Out of memory\n"));
4117 free (e_data);
4118 return NULL;
4119 }
4120
4121 while (number--)
4122 i_data [number] = byte_get (e_data + number * 4, 4);
4123
4124 free (e_data);
4125
4126 return i_data;
4127}
4128
4129/* Dump the symbol table */
4130static int
4131process_symbol_table (file)
4132 FILE * file;
4133{
4134 Elf32_Internal_Shdr * section;
4135 char nb [4];
4136 char nc [4];
b4c96d0d 4137 int nbuckets = 0;
5e220199 4138 int nchains = 0;
252b5132
RH		 4139 int * buckets = NULL;
4140 int * chains = NULL;
4141
4142 if (! do_syms && !do_histogram)
4143 return 1;
4144
4145 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4146 || do_histogram))
4147 {
4148 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4149 {
4150 error (_("Unable to seek to start of dynamic information"));
4151 return 0;
4152 }
4153
4154 if (fread (nb, sizeof (nb), 1, file) != 1)
4155 {
4156 error (_("Failed to read in number of buckets\n"));
4157 return 0;
4158 }
4159
4160 if (fread (nc, sizeof (nc), 1, file) != 1)
4161 {
4162 error (_("Failed to read in number of chains\n"));
4163 return 0;
4164 }
4165
4166 nbuckets = byte_get (nb, 4);
4167 nchains = byte_get (nc, 4);
4168
4169 buckets = get_dynamic_data (file, nbuckets);
4170 chains = get_dynamic_data (file, nchains);
4171
4172 if (buckets == NULL || chains == NULL)
4173 return 0;
4174 }
4175
4176 if (do_syms
4177 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4178 {
4179 int hn;
4180 int si;
4181
4182 printf (_("\nSymbol table for image:\n"));
f7a99963 4183 if (is_32bit_elf)
ca47b30c 4184 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 4185 else
ca47b30c 4186 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
252b5132
RH		 4187
4188 for (hn = 0; hn < nbuckets; hn++)
4189 {
4190 if (! buckets [hn])
4191 continue;
4192
f7a99963 4193 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
252b5132
RH		 4194 {
4195 Elf_Internal_Sym * psym;
4196
4197 psym = dynamic_symbols + si;
4198
f7a99963
NC		 4199 printf (" %3d %3d: ", si, hn);
4200 print_vma (psym->st_value, LONG_HEX);
4201 putchar (' ' );
d1133906 4202 print_vma (psym->st_size, DEC_5);
f7a99963 4203
d1133906
NC		 4204 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4205 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4206 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
d1133906 4207 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
252b5132
RH		 4208 printf (" %s\n", dynamic_strings + psym->st_name);
4209 }
4210 }
4211 }
4212 else if (do_syms && !do_using_dynamic)
4213 {
4214 unsigned int i;
4215
4216 for (i = 0, section = section_headers;
4217 i < elf_header.e_shnum;
4218 i++, section++)
4219 {
4220 unsigned int si;
4221 char * strtab;
4222 Elf_Internal_Sym * symtab;
4223 Elf_Internal_Sym * psym;
4224
4225
4226 if ( section->sh_type != SHT_SYMTAB
4227 && section->sh_type != SHT_DYNSYM)
4228 continue;
4229
4230 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4231 SECTION_NAME (section),
4232 (unsigned long) (section->sh_size / section->sh_entsize));
f7a99963 4233 if (is_32bit_elf)
ca47b30c 4234 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
f7a99963 4235 else
ca47b30c 4236 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
252b5132 4237
9ea033b2 4238 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
252b5132
RH		 4239 section->sh_size / section->sh_entsize);
4240 if (symtab == NULL)
4241 continue;
4242
4243 if (section->sh_link == elf_header.e_shstrndx)
4244 strtab = string_table;
4245 else
4246 {
4247 Elf32_Internal_Shdr * string_sec;
4248
4249 string_sec = section_headers + section->sh_link;
4250
4251 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4252 strtab, char *, "string table");
4253 }
4254
4255 for (si = 0, psym = symtab;
4256 si < section->sh_size / section->sh_entsize;
4257 si ++, psym ++)
4258 {
5e220199 4259 printf ("%6d: ", si);
f7a99963
NC		 4260 print_vma (psym->st_value, LONG_HEX);
4261 putchar (' ');
4262 print_vma (psym->st_size, DEC_5);
d1133906
NC		 4263 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4264 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4265 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
d1133906 4266 printf (" %4s", get_symbol_index_type (psym->st_shndx));
252b5132
RH		 4267 printf (" %s", strtab + psym->st_name);
4268
4269 if (section->sh_type == SHT_DYNSYM &&
4270 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4271 {
4272 unsigned char data[2];
4273 unsigned short vers_data;
4274 unsigned long offset;
4275 int is_nobits;
4276 int check_def;
4277
4278 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4279 - loadaddr;
4280
4281 GET_DATA (offset + si * sizeof (vers_data), data,
4282 "version data");
4283
4284 vers_data = byte_get (data, 2);
4285
4286 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4287 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4288 : 0;
4289
4290 check_def = (psym->st_shndx != SHN_UNDEF);
4291
4292 if ((vers_data & 0x8000) || vers_data > 1)
4293 {
4294 if (is_nobits || ! check_def)
4295 {
4296 Elf_External_Verneed evn;
4297 Elf_Internal_Verneed ivn;
4298 Elf_Internal_Vernaux ivna;
4299
4300 /* We must test both. */
4301 offset = version_info
4302 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4303
4304 GET_DATA (offset, evn, "version need");
4305
4306 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4307 ivn.vn_next = BYTE_GET (evn.vn_next);
4308
4309 do
4310 {
4311 unsigned long vna_off;
4312
4313 vna_off = offset + ivn.vn_aux;
4314
4315 do
4316 {
4317 Elf_External_Vernaux evna;
4318
4319 GET_DATA (vna_off, evna,
4320 "version need aux (3)");
4321
4322 ivna.vna_other = BYTE_GET (evna.vna_other);
4323 ivna.vna_next = BYTE_GET (evna.vna_next);
4324 ivna.vna_name = BYTE_GET (evna.vna_name);
4325
4326 vna_off += ivna.vna_next;
4327 }
4328 while (ivna.vna_other != vers_data
4329 && ivna.vna_next != 0);
4330
4331 if (ivna.vna_other == vers_data)
4332 break;
4333
4334 offset += ivn.vn_next;
4335 }
4336 while (ivn.vn_next != 0);
4337
4338 if (ivna.vna_other == vers_data)
4339 {
4340 printf ("@%s (%d)",
4341 strtab + ivna.vna_name, ivna.vna_other);
4342 check_def = 0;
4343 }
4344 else if (! is_nobits)
4345 error (_("bad dynamic symbol"));
4346 else
4347 check_def = 1;
4348 }
4349
4350 if (check_def)
4351 {
4352 if (vers_data != 0x8001)
4353 {
4354 Elf_Internal_Verdef ivd;
4355 Elf_Internal_Verdaux ivda;
4356 Elf_External_Verdaux evda;
4357 unsigned long offset;
4358
4359 offset =
4360 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4361 - loadaddr;
4362
4363 do
4364 {
4365 Elf_External_Verdef evd;
4366
4367 GET_DATA (offset, evd, "version def");
4368
4369 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4370 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4371 ivd.vd_next = BYTE_GET (evd.vd_next);
4372
4373 offset += ivd.vd_next;
4374 }
4375 while (ivd.vd_ndx != (vers_data & 0x7fff)
4376 && ivd.vd_next != 0);
4377
4378 offset -= ivd.vd_next;
4379 offset += ivd.vd_aux;
4380
4381 GET_DATA (offset, evda, "version def aux");
4382
4383 ivda.vda_name = BYTE_GET (evda.vda_name);
4384
4385 if (psym->st_name != ivda.vda_name)
4386 printf ((vers_data & 0x8000)
4387 ? "@%s" : "@@%s",
4388 strtab + ivda.vda_name);
4389 }
4390 }
4391 }
4392 }
4393
4394 putchar ('\n');
4395 }
4396
4397 free (symtab);
4398 if (strtab != string_table)
4399 free (strtab);
4400 }
4401 }
4402 else if (do_syms)
4403 printf
4404 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4405
4406 if (do_histogram && buckets != NULL)
4407 {
4408 int *lengths;
4409 int *counts;
4410 int hn;
4411 int si;
4412 int maxlength = 0;
4413 int nzero_counts = 0;
4414 int nsyms = 0;
4415
4416 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4417 nbuckets);
4418 printf (_(" Length Number %% of total Coverage\n"));
4419
4420 lengths = (int *) calloc (nbuckets, sizeof (int));
4421 if (lengths == NULL)
4422 {
4423 error (_("Out of memory"));
4424 return 0;
4425 }
4426 for (hn = 0; hn < nbuckets; ++hn)
4427 {
4428 if (! buckets [hn])
4429 continue;
4430
f7a99963 4431 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
252b5132 4432 {
f7a99963 4433 ++ nsyms;
252b5132 4434 if (maxlength < ++lengths[hn])
f7a99963 4435 ++ maxlength;
252b5132
RH		 4436 }
4437 }
4438
4439 counts = (int *) calloc (maxlength + 1, sizeof (int));
4440 if (counts == NULL)
4441 {
4442 error (_("Out of memory"));
4443 return 0;
4444 }
4445
4446 for (hn = 0; hn < nbuckets; ++hn)
30800947 4447 ++ counts [lengths [hn]];
252b5132 4448
103f02d3 4449 if (nbuckets > 0)
252b5132 4450 {
103f02d3
UD		 4451 printf (" 0 %-10d (%5.1f%%)\n",
4452 counts[0], (counts[0] * 100.0) / nbuckets);
4453 for (si = 1; si <= maxlength; ++si)
4454 {
4455 nzero_counts += counts[si] * si;
4456 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4457 si, counts[si], (counts[si] * 100.0) / nbuckets,
4458 (nzero_counts * 100.0) / nsyms);
4459 }
252b5132
RH		 4460 }
4461
4462 free (counts);
4463 free (lengths);
4464 }
4465
4466 if (buckets != NULL)
4467 {
4468 free (buckets);
4469 free (chains);
4470 }
4471
4472 return 1;
4473}
4474
4475static int
4476process_syminfo (file)
b4c96d0d 4477 FILE * file ATTRIBUTE_UNUSED;
252b5132 4478{
b4c96d0d 4479 unsigned int i;
252b5132
RH		 4480
4481 if (dynamic_syminfo == NULL
4482 || !do_dynamic)
4483 /* No syminfo, this is ok. */
4484 return 1;
4485
4486 /* There better should be a dynamic symbol section. */
4487 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4488 return 0;
4489
4490 if (dynamic_addr)
4491 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4492 dynamic_syminfo_offset, dynamic_syminfo_nent);
4493
4494 printf (_(" Num: Name BoundTo Flags\n"));
4495 for (i = 0; i < dynamic_syminfo_nent; ++i)
4496 {
4497 unsigned short int flags = dynamic_syminfo[i].si_flags;
4498
4499 printf ("%4d: %-30s ", i,
4500 dynamic_strings + dynamic_symbols[i].st_name);
4501
4502 switch (dynamic_syminfo[i].si_boundto)
4503 {
4504 case SYMINFO_BT_SELF:
4505 fputs ("SELF ", stdout);
4506 break;
4507 case SYMINFO_BT_PARENT:
4508 fputs ("PARENT ", stdout);
4509 break;
4510 default:
4511 if (dynamic_syminfo[i].si_boundto > 0
4512 && dynamic_syminfo[i].si_boundto < dynamic_size)
4513 printf ("%-10s ",
4514 dynamic_strings
4515 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4516 else
4517 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4518 break;
4519 }
4520
4521 if (flags & SYMINFO_FLG_DIRECT)
4522 printf (" DIRECT");
4523 if (flags & SYMINFO_FLG_PASSTHRU)
4524 printf (" PASSTHRU");
4525 if (flags & SYMINFO_FLG_COPY)
4526 printf (" COPY");
4527 if (flags & SYMINFO_FLG_LAZYLOAD)
4528 printf (" LAZYLOAD");
4529
4530 puts ("");
4531 }
4532
4533 return 1;
4534}
4535
4536#ifdef SUPPORT_DISASSEMBLY
4537static void
4538disassemble_section (section, file)
4539 Elf32_Internal_Shdr * section;
4540 FILE * file;
4541{
4542 printf (_("\nAssembly dump of section %s\n"),
4543 SECTION_NAME (section));
4544
4545 /* XXX -- to be done --- XXX */
4546
4547 return 1;
4548}
4549#endif
4550
4551static int
4552dump_section (section, file)
4553 Elf32_Internal_Shdr * section;
4554 FILE * file;
4555{
9ea033b2
NC		 4556 bfd_size_type bytes;
4557 bfd_vma addr;
252b5132
RH		 4558 unsigned char * data;
4559 unsigned char * start;
4560
4561 bytes = section->sh_size;
4562
4563 if (bytes == 0)
4564 {
4565 printf (_("\nSection '%s' has no data to dump.\n"),
4566 SECTION_NAME (section));
4567 return 0;
4568 }
4569 else
4570 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4571
4572 addr = section->sh_addr;
4573
4574 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4575 "section data");
4576
4577 data = start;
4578
4579 while (bytes)
4580 {
4581 int j;
4582 int k;
4583 int lbytes;
4584
4585 lbytes = (bytes > 16 ? 16 : bytes);
4586
148d3c43 4587 printf (" 0x%8.8lx ", (unsigned long) addr);
252b5132
RH		 4588
4589 switch (elf_header.e_ident [EI_DATA])
4590 {
9ea033b2 4591 default:
252b5132
RH		 4592 case ELFDATA2LSB:
4593 for (j = 15; j >= 0; j --)
4594 {
4595 if (j < lbytes)
4596 printf ("%2.2x", data [j]);
4597 else
4598 printf (" ");
4599
4600 if (!(j & 0x3))
4601 printf (" ");
4602 }
4603 break;
4604
4605 case ELFDATA2MSB:
4606 for (j = 0; j < 16; j++)
4607 {
4608 if (j < lbytes)
4609 printf ("%2.2x", data [j]);
4610 else
4611 printf (" ");
4612
4613 if ((j & 3) == 3)
4614 printf (" ");
4615 }
4616 break;
4617 }
4618
4619 for (j = 0; j < lbytes; j++)
4620 {
4621 k = data [j];
4622 if (k >= ' ' && k < 0x80)
4623 printf ("%c", k);
4624 else
4625 printf (".");
4626 }
4627
4628 putchar ('\n');
4629
4630 data += lbytes;
4631 addr += lbytes;
4632 bytes -= lbytes;
4633 }
4634
4635 free (start);
4636
4637 return 1;
4638}
4639
4640
4641static unsigned long int
4642read_leb128 (data, length_return, sign)
4643 unsigned char * data;
4644 int * length_return;
4645 int sign;
4646{
4647 unsigned long int result = 0;
4648 unsigned int num_read = 0;
4649 int shift = 0;
4650 unsigned char byte;
4651
4652 do
4653 {
4654 byte = * data ++;
4655 num_read ++;
4656
4657 result |= (byte & 0x7f) << shift;
4658
4659 shift += 7;
4660
4661 }
4662 while (byte & 0x80);
4663
4664 if (length_return != NULL)
4665 * length_return = num_read;
4666
4667 if (sign && (shift < 32) && (byte & 0x40))
4668 result |= -1 << shift;
4669
4670 return result;
4671}
4672
4673typedef struct State_Machine_Registers
4674{
4675 unsigned long address;
4676 unsigned int file;
4677 unsigned int line;
4678 unsigned int column;
4679 int is_stmt;
4680 int basic_block;
4681 int end_sequence;
4682/* This variable hold the number of the last entry seen
4683 in the File Table. */
4684 unsigned int last_file_entry;
4685} SMR;
4686
4687static SMR state_machine_regs;
4688
4689static void
4690reset_state_machine (is_stmt)
4691 int is_stmt;
4692{
4693 state_machine_regs.address = 0;
4694 state_machine_regs.file = 1;
4695 state_machine_regs.line = 1;
4696 state_machine_regs.column = 0;
4697 state_machine_regs.is_stmt = is_stmt;
4698 state_machine_regs.basic_block = 0;
4699 state_machine_regs.end_sequence = 0;
4700 state_machine_regs.last_file_entry = 0;
4701}
4702
4703/* Handled an extend line op. Returns true if this is the end
4704 of sequence. */
4705static int
3590ea00 4706process_extended_line_op (data, is_stmt, pointer_size)
252b5132
RH		 4707 unsigned char * data;
4708 int is_stmt;
3590ea00 4709 int pointer_size;
252b5132
RH		 4710{
4711 unsigned char op_code;
4712 int bytes_read;
4713 unsigned int len;
4714 unsigned char * name;
4715 unsigned long adr;
103f02d3 4716
252b5132
RH		 4717 len = read_leb128 (data, & bytes_read, 0);
4718 data += bytes_read;
4719
4720 if (len == 0)
4721 {
4722 warn (_("badly formed extended line op encountered!"));
4723 return bytes_read;
4724 }
4725
4726 len += bytes_read;
4727 op_code = * data ++;
4728
4729 printf (_(" Extended opcode %d: "), op_code);
103f02d3 4730
252b5132
RH		 4731 switch (op_code)
4732 {
4733 case DW_LNE_end_sequence:
4734 printf (_("End of Sequence\n\n"));
4735 reset_state_machine (is_stmt);
4736 break;
4737
4738 case DW_LNE_set_address:
3590ea00 4739 adr = byte_get (data, pointer_size);
252b5132
RH		 4740 printf (_("set Address to 0x%lx\n"), adr);
4741 state_machine_regs.address = adr;
4742 break;
4743
4744 case DW_LNE_define_file:
4745 printf (_(" define new File Table entry\n"));
4746 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
103f02d3 4747
252b5132
RH		 4748 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4749 name = data;
4750 data += strlen (data) + 1;
4751 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4752 data += bytes_read;
4753 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4754 data += bytes_read;
4755 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4756 printf (_("%s\n\n"), name);
4757 break;
4758
4759 default:
4760 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4761 break;
4762 }
4763
4764 return len;
4765}
4766
3590ea00
NC		 4767/* Size of pointers in the .debug_line section. This information is not
4768 really present in that section. It's obtained before dumping the debug
4769 sections by doing some pre-scan of the .debug_info section. */
4770static int debug_line_pointer_size = 4;
252b5132
RH		 4771
4772static int
4773display_debug_lines (section, start, file)
4774 Elf32_Internal_Shdr * section;
4775 unsigned char * start;
b4c96d0d 4776 FILE * file ATTRIBUTE_UNUSED;
252b5132
RH		 4777{
4778 DWARF2_External_LineInfo * external;
4779 DWARF2_Internal_LineInfo info;
4780 unsigned char * standard_opcodes;
4781 unsigned char * data = start;
4782 unsigned char * end = start + section->sh_size;
4783 unsigned char * end_of_sequence;
4784 int i;
4785
4786 printf (_("\nDump of debug contents of section %s:\n\n"),
4787 SECTION_NAME (section));
4788
4789 while (data < end)
4790 {
4791 external = (DWARF2_External_LineInfo *) data;
4792
4793 /* Check the length of the block. */
4794 info.li_length = BYTE_GET (external->li_length);
4795 if (info.li_length > section->sh_size)
4796 {
4797 warn
4798 (_("The line info appears to be corrupt - the section is too small\n"));
4799 return 0;
4800 }
103f02d3 4801
252b5132
RH		 4802 /* Check its version number. */
4803 info.li_version = BYTE_GET (external->li_version);
4804 if (info.li_version != 2)
4805 {
4806 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4807 return 0;
4808 }
103f02d3 4809
252b5132
RH		 4810 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4811 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4812 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4813 info.li_line_base = BYTE_GET (external->li_line_base);
4814 info.li_line_range = BYTE_GET (external->li_line_range);
4815 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
103f02d3 4816
252b5132
RH		 4817 /* Sign extend the line base field. */
4818 info.li_line_base <<= 24;
4819 info.li_line_base >>= 24;
103f02d3 4820
252b5132
RH		 4821 printf (_(" Length: %ld\n"), info.li_length);
4822 printf (_(" DWARF Version: %d\n"), info.li_version);
4823 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4824 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4825 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4826 printf (_(" Line Base: %d\n"), info.li_line_base);
4827 printf (_(" Line Range: %d\n"), info.li_line_range);
4828 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4829
4830 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4831
4832 reset_state_machine (info.li_default_is_stmt);
103f02d3 4833
252b5132
RH		 4834 /* Display the contents of the Opcodes table. */
4835 standard_opcodes = data + sizeof (* external);
103f02d3 4836
252b5132 4837 printf (_("\n Opcodes:\n"));
103f02d3 4838
252b5132 4839 for (i = 1; i < info.li_opcode_base; i++)
7a4b7442 4840 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
103f02d3 4841
252b5132
RH		 4842 /* Display the contents of the Directory table. */
4843 data = standard_opcodes + info.li_opcode_base - 1;
103f02d3 4844
252b5132
RH		 4845 if (* data == 0)
4846 printf (_("\n The Directory Table is empty.\n"));
4847 else
4848 {
4849 printf (_("\n The Directory Table:\n"));
103f02d3 4850
252b5132
RH		 4851 while (* data != 0)
4852 {
4853 printf (_(" %s\n"), data);
103f02d3 4854
252b5132
RH		 4855 data += strlen (data) + 1;
4856 }
4857 }
103f02d3 4858
252b5132
RH		 4859 /* Skip the NUL at the end of the table. */
4860 data ++;
103f02d3 4861
252b5132
RH		 4862 /* Display the contents of the File Name table. */
4863 if (* data == 0)
4864 printf (_("\n The File Name Table is empty.\n"));
4865 else
4866 {
4867 printf (_("\n The File Name Table:\n"));
4868 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
103f02d3 4869
252b5132
RH		 4870 while (* data != 0)
4871 {
4872 char * name;
4873 int bytes_read;
103f02d3 4874
252b5132
RH		 4875 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4876 name = data;
103f02d3 4877
252b5132 4878 data += strlen (data) + 1;
103f02d3 4879
252b5132
RH		 4880 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4881 data += bytes_read;
4882 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4883 data += bytes_read;
4884 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4885 data += bytes_read;
4886 printf (_("%s\n"), name);
4887 }
4888 }
103f02d3 4889
252b5132
RH		 4890 /* Skip the NUL at the end of the table. */
4891 data ++;
103f02d3 4892
252b5132
RH		 4893 /* Now display the statements. */
4894 printf (_("\n Line Number Statements:\n"));
103f02d3
UD		 4895
4896
252b5132
RH		 4897 while (data < end_of_sequence)
4898 {
4899 unsigned char op_code;
4900 int adv;
4901 int bytes_read;
103f02d3 4902
252b5132 4903 op_code = * data ++;
103f02d3 4904
252b5132
RH		 4905 switch (op_code)
4906 {
4907 case DW_LNS_extended_op:
3590ea00
NC		 4908 data += process_extended_line_op (data, info.li_default_is_stmt,
4909 debug_line_pointer_size);
252b5132 4910 break;
103f02d3 4911
252b5132
RH		 4912 case DW_LNS_copy:
4913 printf (_(" Copy\n"));
4914 break;
103f02d3 4915
252b5132
RH		 4916 case DW_LNS_advance_pc:
4917 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
4918 data += bytes_read;
4919 state_machine_regs.address += adv;
4920 printf (_(" Advance PC by %d to %lx\n"), adv,
4921 state_machine_regs.address);
4922 break;
103f02d3 4923
252b5132
RH		 4924 case DW_LNS_advance_line:
4925 adv = read_leb128 (data, & bytes_read, 1);
4926 data += bytes_read;
4927 state_machine_regs.line += adv;
4928 printf (_(" Advance Line by %d to %d\n"), adv,
4929 state_machine_regs.line);
4930 break;
103f02d3 4931
252b5132
RH		 4932 case DW_LNS_set_file:
4933 adv = read_leb128 (data, & bytes_read, 0);
4934 data += bytes_read;
4935 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4936 adv);
4937 state_machine_regs.file = adv;
4938 break;
103f02d3 4939
252b5132
RH		 4940 case DW_LNS_set_column:
4941 adv = read_leb128 (data, & bytes_read, 0);
4942 data += bytes_read;
4943 printf (_(" Set column to %d\n"), adv);
4944 state_machine_regs.column = adv;
4945 break;
103f02d3 4946
252b5132
RH		 4947 case DW_LNS_negate_stmt:
4948 adv = state_machine_regs.is_stmt;
4949 adv = ! adv;
4950 printf (_(" Set is_stmt to %d\n"), adv);
4951 state_machine_regs.is_stmt = adv;
4952 break;
103f02d3 4953
252b5132
RH		 4954 case DW_LNS_set_basic_block:
4955 printf (_(" Set basic block\n"));
4956 state_machine_regs.basic_block = 1;
4957 break;
103f02d3 4958
252b5132 4959 case DW_LNS_const_add_pc:
2366453a
NC		 4960 adv = (((255 - info.li_opcode_base) / info.li_line_range)
4961 * info.li_min_insn_length);
252b5132
RH		 4962 state_machine_regs.address += adv;
4963 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
4964 state_machine_regs.address);
4965 break;
103f02d3 4966
252b5132
RH		 4967 case DW_LNS_fixed_advance_pc:
4968 adv = byte_get (data, 2);
4969 data += 2;
4970 state_machine_regs.address += adv;
4971 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4972 adv, state_machine_regs.address);
4973 break;
103f02d3 4974
252b5132
RH		 4975 default:
4976 op_code -= info.li_opcode_base;
4977 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
4978 state_machine_regs.address += adv;
4979 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4980 op_code, adv, state_machine_regs.address);
75d74c48 4981 adv = (op_code % info.li_line_range) + info.li_line_base;
252b5132
RH		 4982 state_machine_regs.line += adv;
4983 printf (_(" and Line by %d to %d\n"),
4984 adv, state_machine_regs.line);
4985 break;
4986 }
4987 }
4988 printf ("\n");
4989 }
103f02d3 4990
252b5132
RH		 4991 return 1;
4992}
4993
4994static int
4995display_debug_pubnames (section, start, file)
4996 Elf32_Internal_Shdr * section;
4997 unsigned char * start;
b4c96d0d 4998 FILE * file ATTRIBUTE_UNUSED;
252b5132
RH		 4999{
5000 DWARF2_External_PubNames * external;
5001 DWARF2_Internal_PubNames pubnames;
5002 unsigned char * end;
5003
5004 end = start + section->sh_size;
5005
5006 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5007
5008 while (start < end)
5009 {
5010 unsigned char * data;
5011 unsigned long offset;
5012
5013 external = (DWARF2_External_PubNames *) start;
5014
5015 pubnames.pn_length = BYTE_GET (external->pn_length);
5016 pubnames.pn_version = BYTE_GET (external->pn_version);
5017 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5018 pubnames.pn_size = BYTE_GET (external->pn_size);
5019
5020 data = start + sizeof (* external);
5021 start += pubnames.pn_length + sizeof (external->pn_length);
5022
5023 if (pubnames.pn_version != 2)
5024 {
5025 warn (_("Only DWARF 2 pubnames are currently supported"));
5026 continue;
5027 }
5028
5029 printf (_(" Length: %ld\n"),
5030 pubnames.pn_length);
5031 printf (_(" Version: %d\n"),
5032 pubnames.pn_version);
5033 printf (_(" Offset into .debug_info section: %ld\n"),
5034 pubnames.pn_offset);
5035 printf (_(" Size of area in .debug_info section: %ld\n"),
5036 pubnames.pn_size);
5037
5038 printf (_("\n Offset\tName\n"));
5039
5040 do
5041 {
5042 offset = byte_get (data, 4);
5043
5044 if (offset != 0)
5045 {
5046 data += 4;
5047 printf (" %ld\t\t%s\n", offset, data);
5048 data += strlen (data) + 1;
5049 }
5050 }
5051 while (offset != 0);
5052 }
5053
5054 printf ("\n");
5055 return 1;
5056}
5057
5058static char *
5059get_TAG_name (tag)
5060 unsigned long tag;
5061{
5062 switch (tag)
5063 {
5064 case DW_TAG_padding: return "DW_TAG_padding";
5065 case DW_TAG_array_type: return "DW_TAG_array_type";
5066 case DW_TAG_class_type: return "DW_TAG_class_type";
5067 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5068 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5069 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5070 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5071 case DW_TAG_label: return "DW_TAG_label";
5072 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5073 case DW_TAG_member: return "DW_TAG_member";
5074 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5075 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5076 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5077 case DW_TAG_string_type: return "DW_TAG_string_type";
5078 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5079 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5080 case DW_TAG_typedef: return "DW_TAG_typedef";
5081 case DW_TAG_union_type: return "DW_TAG_union_type";
5082 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5083 case DW_TAG_variant: return "DW_TAG_variant";
5084 case DW_TAG_common_block: return "DW_TAG_common_block";
5085 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5086 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5087 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5088 case DW_TAG_module: return "DW_TAG_module";
5089 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5090 case DW_TAG_set_type: return "DW_TAG_set_type";
5091 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5092 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5093 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5094 case DW_TAG_base_type: return "DW_TAG_base_type";
5095 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5096 case DW_TAG_const_type: return "DW_TAG_const_type";
5097 case DW_TAG_constant: return "DW_TAG_constant";
5098 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5099 case DW_TAG_file_type: return "DW_TAG_file_type";
5100 case DW_TAG_friend: return "DW_TAG_friend";
5101 case DW_TAG_namelist: return "DW_TAG_namelist";
5102 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5103 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5104 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5105 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5106 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5107 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5108 case DW_TAG_try_block: return "DW_TAG_try_block";
5109 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5110 case DW_TAG_variable: return "DW_TAG_variable";
5111 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5112 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5113 case DW_TAG_format_label: return "DW_TAG_format_label";
5114 case DW_TAG_function_template: return "DW_TAG_function_template";
5115 case DW_TAG_class_template: return "DW_TAG_class_template";
5116 default:
5117 {
5118 static char buffer [100];
5119
5120 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5121 return buffer;
5122 }
5123 }
5124}
5125
5126static char *
5127get_AT_name (attribute)
5128 unsigned long attribute;
5129{
5130 switch (attribute)
5131 {
5132 case DW_AT_sibling: return "DW_AT_sibling";
5133 case DW_AT_location: return "DW_AT_location";
5134 case DW_AT_name: return "DW_AT_name";
5135 case DW_AT_ordering: return "DW_AT_ordering";
5136 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5137 case DW_AT_byte_size: return "DW_AT_byte_size";
5138 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5139 case DW_AT_bit_size: return "DW_AT_bit_size";
5140 case DW_AT_element_list: return "DW_AT_element_list";
5141 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5142 case DW_AT_low_pc: return "DW_AT_low_pc";
5143 case DW_AT_high_pc: return "DW_AT_high_pc";
5144 case DW_AT_language: return "DW_AT_language";
5145 case DW_AT_member: return "DW_AT_member";
5146 case DW_AT_discr: return "DW_AT_discr";
5147 case DW_AT_discr_value: return "DW_AT_discr_value";
5148 case DW_AT_visibility: return "DW_AT_visibility";
5149 case DW_AT_import: return "DW_AT_import";
5150 case DW_AT_string_length: return "DW_AT_string_length";
5151 case DW_AT_common_reference: return "DW_AT_common_reference";
5152 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5153 case DW_AT_const_value: return "DW_AT_const_value";
5154 case DW_AT_containing_type: return "DW_AT_containing_type";
5155 case DW_AT_default_value: return "DW_AT_default_value";
5156 case DW_AT_inline: return "DW_AT_inline";
5157 case DW_AT_is_optional: return "DW_AT_is_optional";
5158 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5159 case DW_AT_producer: return "DW_AT_producer";
5160 case DW_AT_prototyped: return "DW_AT_prototyped";
5161 case DW_AT_return_addr: return "DW_AT_return_addr";
5162 case DW_AT_start_scope: return "DW_AT_start_scope";
5163 case DW_AT_stride_size: return "DW_AT_stride_size";
5164 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5165 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5166 case DW_AT_accessibility: return "DW_AT_accessibility";
5167 case DW_AT_address_class: return "DW_AT_address_class";
5168 case DW_AT_artificial: return "DW_AT_artificial";
5169 case DW_AT_base_types: return "DW_AT_base_types";
5170 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5171 case DW_AT_count: return "DW_AT_count";
5172 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5173 case DW_AT_decl_column: return "DW_AT_decl_column";
5174 case DW_AT_decl_file: return "DW_AT_decl_file";
5175 case DW_AT_decl_line: return "DW_AT_decl_line";
5176 case DW_AT_declaration: return "DW_AT_declaration";
5177 case DW_AT_discr_list: return "DW_AT_discr_list";
5178 case DW_AT_encoding: return "DW_AT_encoding";
5179 case DW_AT_external: return "DW_AT_external";
5180 case DW_AT_frame_base: return "DW_AT_frame_base";
5181 case DW_AT_friend: return "DW_AT_friend";
5182 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5183 case DW_AT_macro_info: return "DW_AT_macro_info";
5184 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5185 case DW_AT_priority: return "DW_AT_priority";
5186 case DW_AT_segment: return "DW_AT_segment";
5187 case DW_AT_specification: return "DW_AT_specification";
5188 case DW_AT_static_link: return "DW_AT_static_link";
5189 case DW_AT_type: return "DW_AT_type";
5190 case DW_AT_use_location: return "DW_AT_use_location";
5191 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5192 case DW_AT_virtuality: return "DW_AT_virtuality";
5193 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5194 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5195 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5196 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5197 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5198 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5199 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5200 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5201 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5202 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5203 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5204 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5205 case DW_AT_sf_names: return "DW_AT_sf_names";
5206 case DW_AT_src_info: return "DW_AT_src_info";
5207 case DW_AT_mac_info: return "DW_AT_mac_info";
5208 case DW_AT_src_coords: return "DW_AT_src_coords";
5209 case DW_AT_body_begin: return "DW_AT_body_begin";
5210 case DW_AT_body_end: return "DW_AT_body_end";
5211 default:
5212 {
5213 static char buffer [100];
5214
5215 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5216 return buffer;
5217 }
5218 }
5219}
5220
5221static char *
5222get_FORM_name (form)
5223 unsigned long form;
5224{
5225 switch (form)
5226 {
5227 case DW_FORM_addr: return "DW_FORM_addr";
5228 case DW_FORM_block2: return "DW_FORM_block2";
5229 case DW_FORM_block4: return "DW_FORM_block4";
5230 case DW_FORM_data2: return "DW_FORM_data2";
5231 case DW_FORM_data4: return "DW_FORM_data4";
5232 case DW_FORM_data8: return "DW_FORM_data8";
5233 case DW_FORM_string: return "DW_FORM_string";
5234 case DW_FORM_block: return "DW_FORM_block";
5235 case DW_FORM_block1: return "DW_FORM_block1";
5236 case DW_FORM_data1: return "DW_FORM_data1";
5237 case DW_FORM_flag: return "DW_FORM_flag";
5238 case DW_FORM_sdata: return "DW_FORM_sdata";
5239 case DW_FORM_strp: return "DW_FORM_strp";
5240 case DW_FORM_udata: return "DW_FORM_udata";
5241 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5242 case DW_FORM_ref1: return "DW_FORM_ref1";
5243 case DW_FORM_ref2: return "DW_FORM_ref2";
5244 case DW_FORM_ref4: return "DW_FORM_ref4";
5245 case DW_FORM_ref8: return "DW_FORM_ref8";
5246 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5247 case DW_FORM_indirect: return "DW_FORM_indirect";
5248 default:
5249 {
5250 static char buffer [100];
5251
5252 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5253 return buffer;
5254 }
5255 }
5256}
5257
5258/* FIXME: There are better and more effiecint ways to handle
5259 these structures. For now though, I just want something that
5260 is simple to implement. */
5261typedef struct abbrev_attr
5262{
5263 unsigned long attribute;
5264 unsigned long form;
5265 struct abbrev_attr * next;
5266}
5267abbrev_attr;
5268
5269typedef struct abbrev_entry
5270{
5271 unsigned long entry;
5272 unsigned long tag;
5273 int children;
5274 struct abbrev_attr * first_attr;
5275 struct abbrev_attr * last_attr;
5276 struct abbrev_entry * next;
5277}
5278abbrev_entry;
5279
5280static abbrev_entry * first_abbrev = NULL;
5281static abbrev_entry * last_abbrev = NULL;
5282
5283static void
5284free_abbrevs PARAMS ((void))
5285{
5286 abbrev_entry * abbrev;
5287
5288 for (abbrev = first_abbrev; abbrev;)
5289 {
5290 abbrev_entry * next = abbrev->next;
5291 abbrev_attr * attr;
5292
5293 for (attr = abbrev->first_attr; attr;)
5294 {
5295 abbrev_attr * next = attr->next;
5296
5297 free (attr);
5298 attr = next;
5299 }
5300
5301 free (abbrev);
5302 abbrev = next;
5303 }
5304
5305 last_abbrev = first_abbrev = NULL;
5306}
5307
5308static void
5309add_abbrev (number, tag, children)
5310 unsigned long number;
5311 unsigned long tag;
5312 int children;
5313{
5314 abbrev_entry * entry;
5315
5316 entry = (abbrev_entry *) malloc (sizeof (* entry));
5317
5318 if (entry == NULL)
5319 /* ugg */
5320 return;
5321
5322 entry->entry = number;
5323 entry->tag = tag;
5324 entry->children = children;
5325 entry->first_attr = NULL;
5326 entry->last_attr = NULL;
5327 entry->next = NULL;
5328
5329 if (first_abbrev == NULL)
5330 first_abbrev = entry;
5331 else
5332 last_abbrev->next = entry;
5333
5334 last_abbrev = entry;
5335}
5336
5337static void
5338add_abbrev_attr (attribute, form)
5339 unsigned long attribute;
5340 unsigned long form;
5341{
5342 abbrev_attr * attr;
5343
5344 attr = (abbrev_attr *) malloc (sizeof (* attr));
5345
5346 if (attr == NULL)
5347 /* ugg */
5348 return;
5349
5350 attr->attribute = attribute;
5351 attr->form = form;
5352 attr->next = NULL;
5353
5354 if (last_abbrev->first_attr == NULL)
5355 last_abbrev->first_attr = attr;
5356 else
5357 last_abbrev->last_attr->next = attr;
5358
5359 last_abbrev->last_attr = attr;
5360}
5361
5362/* Processes the (partial) contents of a .debug_abbrev section.
5363 Returns NULL if the end of the section was encountered.
5364 Returns the address after the last byte read if the end of
5365 an abbreviation set was found. */
5366
5367static unsigned char *
5368process_abbrev_section (start, end)
5369 unsigned char * start;
5370 unsigned char * end;
5371{
5372 if (first_abbrev != NULL)
5373 return NULL;
5374
5375 while (start < end)
5376 {
5377 int bytes_read;
5378 unsigned long entry;
5379 unsigned long tag;
5380 unsigned long attribute;
5381 int children;
5382
5383 entry = read_leb128 (start, & bytes_read, 0);
5384 start += bytes_read;
5385
a3f779db
NC		 5386 /* A single zero is supposed to end the section according
5387 to the standard. If there's more, then signal that to
5388 the caller. */
252b5132 5389 if (entry == 0)
a3f779db 5390 return start == end ? NULL : start;
252b5132
RH		 5391
5392 tag = read_leb128 (start, & bytes_read, 0);
5393 start += bytes_read;
5394
5395 children = * start ++;
5396
5397 add_abbrev (entry, tag, children);
5398
5399 do
5400 {
5401 unsigned long form;
5402
5403 attribute = read_leb128 (start, & bytes_read, 0);
5404 start += bytes_read;
5405
5406 form = read_leb128 (start, & bytes_read, 0);
5407 start += bytes_read;
5408
5409 if (attribute != 0)
5410 add_abbrev_attr (attribute, form);
5411 }
5412 while (attribute != 0);
5413 }
5414
5415 return NULL;
5416}
5417
5418
5419static int
5420display_debug_abbrev (section, start, file)
5421 Elf32_Internal_Shdr * section;
5422 unsigned char * start;
b4c96d0d 5423 FILE * file ATTRIBUTE_UNUSED;
252b5132
RH		 5424{
5425 abbrev_entry * entry;
5426 unsigned char * end = start + section->sh_size;
5427
5428 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5429
5430 do
5431 {
5432 start = process_abbrev_section (start, end);
5433
5434 printf (_(" Number TAG\n"));
5435
5436 for (entry = first_abbrev; entry; entry = entry->next)
5437 {
5438 abbrev_attr * attr;
5439
5440 printf (_(" %ld %s [%s]\n"),
5441 entry->entry,
5442 get_TAG_name (entry->tag),
5443 entry->children ? _("has children") : _("no children"));
5444
5445 for (attr = entry->first_attr; attr; attr = attr->next)
5446 {
5447 printf (_(" %-18s %s\n"),
5448 get_AT_name (attr->attribute),
5449 get_FORM_name (attr->form));
5450 }
5451 }
5452 }
5453 while (start);
5454
5455 printf ("\n");
5456
5457 return 1;
5458}
5459
5460
5461static unsigned char *
5462display_block (data, length)
5463 unsigned char * data;
5464 unsigned long length;
5465{
5466 printf (_(" %lu byte block: "), length);
5467
5468 while (length --)
148d3c43 5469 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
252b5132
RH		 5470
5471 return data;
5472}
5473
5474static void
5475decode_location_expression (data, pointer_size)
5476 unsigned char * data;
5477 unsigned int pointer_size;
5478{
5479 unsigned char op;
5480 int bytes_read;
148d3c43 5481 unsigned long uvalue;
252b5132
RH		 5482
5483 op = * data ++;
5484
5485 switch (op)
5486 {
148d3c43
AS		 5487 case DW_OP_addr:
5488 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5489 break;
5490 case DW_OP_deref:
5491 printf ("DW_OP_deref");
5492 break;
5493 case DW_OP_const1u:
5494 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5495 break;
5496 case DW_OP_const1s:
5497 printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5498 break;
5499 case DW_OP_const2u:
5500 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5501 break;
5502 case DW_OP_const2s:
5503 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5504 break;
5505 case DW_OP_const4u:
5506 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5507 break;
5508 case DW_OP_const4s:
5509 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5510 break;
5511 case DW_OP_const8u:
5512 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5513 (unsigned long) byte_get (data + 4, 4));
5514 break;
5515 case DW_OP_const8s:
5516 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5517 (long) byte_get (data + 4, 4));
5518 break;
5519 case DW_OP_constu:
5520 printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5521 break;
5522 case DW_OP_consts:
5523 printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5524 break;
5525 case DW_OP_dup:
5526 printf ("DW_OP_dup");
5527 break;
5528 case DW_OP_drop:
5529 printf ("DW_OP_drop");
5530 break;
5531 case DW_OP_over:
5532 printf ("DW_OP_over");
5533 break;
5534 case DW_OP_pick:
5535 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5536 break;
5537 case DW_OP_swap:
5538 printf ("DW_OP_swap");
5539 break;
5540 case DW_OP_rot:
5541 printf ("DW_OP_rot");
5542 break;
5543 case DW_OP_xderef:
5544 printf ("DW_OP_xderef");
5545 break;
5546 case DW_OP_abs:
5547 printf ("DW_OP_abs");
5548 break;
5549 case DW_OP_and:
5550 printf ("DW_OP_and");
5551 break;
5552 case DW_OP_div:
5553 printf ("DW_OP_div");
5554 break;
5555 case DW_OP_minus:
5556 printf ("DW_OP_minus");
5557 break;
5558 case DW_OP_mod:
5559 printf ("DW_OP_mod");
5560 break;
5561 case DW_OP_mul:
5562 printf ("DW_OP_mul");
5563 break;
5564 case DW_OP_neg:
5565 printf ("DW_OP_neg");
5566 break;
5567 case DW_OP_not:
5568 printf ("DW_OP_not");
5569 break;
5570 case DW_OP_or:
5571 printf ("DW_OP_or");
5572 break;
5573 case DW_OP_plus:
5574 printf ("DW_OP_plus");
5575 break;
5576 case DW_OP_plus_uconst:
5577 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5578 break;
5579 case DW_OP_shl:
5580 printf ("DW_OP_shl");
5581 break;
5582 case DW_OP_shr:
5583 printf ("DW_OP_shr");
5584 break;
5585 case DW_OP_shra:
5586 printf ("DW_OP_shra");
5587 break;
5588 case DW_OP_xor:
5589 printf ("DW_OP_xor");
5590 break;
5591 case DW_OP_bra:
789be9f7 5592 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
148d3c43
AS		 5593 break;
5594 case DW_OP_eq:
5595 printf ("DW_OP_eq");
5596 break;
5597 case DW_OP_ge:
5598 printf ("DW_OP_ge");
5599 break;
5600 case DW_OP_gt:
5601 printf ("DW_OP_gt");
5602 break;
5603 case DW_OP_le:
5604 printf ("DW_OP_le");
5605 break;
5606 case DW_OP_lt:
5607 printf ("DW_OP_lt");
5608 break;
5609 case DW_OP_ne:
5610 printf ("DW_OP_ne");
5611 break;
5612 case DW_OP_skip:
5613 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5614 break;
5615 case DW_OP_lit0:
5616 printf ("DW_OP_lit0");
5617 break;
5618 case DW_OP_lit1:
5619 printf ("DW_OP_lit1");
5620 break;
5621 case DW_OP_lit2:
5622 printf ("DW_OP_lit2");
5623 break;
5624 case DW_OP_lit3:
5625 printf ("DW_OP_lit3");
5626 break;
5627 case DW_OP_lit4:
5628 printf ("DW_OP_lit4");
5629 break;
5630 case DW_OP_lit5:
5631 printf ("DW_OP_lit5");
5632 break;
5633 case DW_OP_lit6:
5634 printf ("DW_OP_lit6");
5635 break;
5636 case DW_OP_lit7:
5637 printf ("DW_OP_lit7");
5638 break;
5639 case DW_OP_lit8:
5640 printf ("DW_OP_lit8");
5641 break;
5642 case DW_OP_lit9:
5643 printf ("DW_OP_lit9");
5644 break;
5645 case DW_OP_lit10:
5646 printf ("DW_OP_lit10");
5647 break;
5648 case DW_OP_lit11:
5649 printf ("DW_OP_lit11");
5650 break;
5651 case DW_OP_lit12:
5652 printf ("DW_OP_lit12");
5653 break;
5654 case DW_OP_lit13:
5655 printf ("DW_OP_lit13");
5656 break;
5657 case DW_OP_lit14:
5658 printf ("DW_OP_lit14");
5659 break;
5660 case DW_OP_lit15:
5661 printf ("DW_OP_lit15");
5662 break;
5663 case DW_OP_lit16:
5664 printf ("DW_OP_lit16");
5665 break;
5666 case DW_OP_lit17:
5667 printf ("DW_OP_lit17");
5668 break;
5669 case DW_OP_lit18:
5670 printf ("DW_OP_lit18");
5671 break;
5672 case DW_OP_lit19:
5673 printf ("DW_OP_lit19");
5674 break;
5675 case DW_OP_lit20:
5676 printf ("DW_OP_lit20");
5677 break;
5678 case DW_OP_lit21:
5679 printf ("DW_OP_lit21");
5680 break;
5681 case DW_OP_lit22:
5682 printf ("DW_OP_lit22");
5683 break;
5684 case DW_OP_lit23:
5685 printf ("DW_OP_lit23");
5686 break;
5687 case DW_OP_lit24:
5688 printf ("DW_OP_lit24");
5689 break;
5690 case DW_OP_lit25:
5691 printf ("DW_OP_lit25");
5692 break;
5693 case DW_OP_lit26:
5694 printf ("DW_OP_lit26");
5695 break;
5696 case DW_OP_lit27:
5697 printf ("DW_OP_lit27");
5698 break;
5699 case DW_OP_lit28:
5700 printf ("DW_OP_lit28");
5701 break;
5702 case DW_OP_lit29:
5703 printf ("DW_OP_lit29");
5704 break;
5705 case DW_OP_lit30:
5706 printf ("DW_OP_lit30");
5707 break;
5708 case DW_OP_lit31:
5709 printf ("DW_OP_lit31");
5710 break;
5711 case DW_OP_reg0:
5712 printf ("DW_OP_reg0");
5713 break;
5714 case DW_OP_reg1:
5715 printf ("DW_OP_reg1");
5716 break;
5717 case DW_OP_reg2:
5718 printf ("DW_OP_reg2");
5719 break;
5720 case DW_OP_reg3:
5721 printf ("DW_OP_reg3");
5722 break;
5723 case DW_OP_reg4:
5724 printf ("DW_OP_reg4");
5725 break;
5726 case DW_OP_reg5:
5727 printf ("DW_OP_reg5");
5728 break;
5729 case DW_OP_reg6:
5730 printf ("DW_OP_reg6");
5731 break;
5732 case DW_OP_reg7:
5733 printf ("DW_OP_reg7");
5734 break;
5735 case DW_OP_reg8:
5736 printf ("DW_OP_reg8");
5737 break;
5738 case DW_OP_reg9:
5739 printf ("DW_OP_reg9");
5740 break;
5741 case DW_OP_reg10:
5742 printf ("DW_OP_reg10");
5743 break;
5744 case DW_OP_reg11:
5745 printf ("DW_OP_reg11");
5746 break;
5747 case DW_OP_reg12:
5748 printf ("DW_OP_reg12");
5749 break;
5750 case DW_OP_reg13:
5751 printf ("DW_OP_reg13");
5752 break;
5753 case DW_OP_reg14:
5754 printf ("DW_OP_reg14");
5755 break;
5756 case DW_OP_reg15:
5757 printf ("DW_OP_reg15");
5758 break;
5759 case DW_OP_reg16:
5760 printf ("DW_OP_reg16");
5761 break;
5762 case DW_OP_reg17:
5763 printf ("DW_OP_reg17");
5764 break;
5765 case DW_OP_reg18:
5766 printf ("DW_OP_reg18");
5767 break;
5768 case DW_OP_reg19:
5769 printf ("DW_OP_reg19");
5770 break;
5771 case DW_OP_reg20:
5772 printf ("DW_OP_reg20");
5773 break;
5774 case DW_OP_reg21:
5775 printf ("DW_OP_reg21");
5776 break;
5777 case DW_OP_reg22:
5778 printf ("DW_OP_reg22");
5779 break;
5780 case DW_OP_reg23:
5781 printf ("DW_OP_reg23");
5782 break;
5783 case DW_OP_reg24:
5784 printf ("DW_OP_reg24");
5785 break;
5786 case DW_OP_reg25:
5787 printf ("DW_OP_reg25");
5788 break;
5789 case DW_OP_reg26:
5790 printf ("DW_OP_reg26");
5791 break;
5792 case DW_OP_reg27:
5793 printf ("DW_OP_reg27");
5794 break;
5795 case DW_OP_reg28:
5796 printf ("DW_OP_reg28");
5797 break;
5798 case DW_OP_reg29:
5799 printf ("DW_OP_reg29");
5800 break;
5801 case DW_OP_reg30:
5802 printf ("DW_OP_reg30");
5803 break;
5804 case DW_OP_reg31:
5805 printf ("DW_OP_reg31");
5806 break;
5807 case DW_OP_breg0:
5808 printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5809 break;
5810 case DW_OP_breg1:
5811 printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5812 break;
5813 case DW_OP_breg2:
5814 printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5815 break;
5816 case DW_OP_breg3:
5817 printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5818 break;
5819 case DW_OP_breg4:
5820 printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5821 break;
5822 case DW_OP_breg5:
5823 printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5824 break;
5825 case DW_OP_breg6:
5826 printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5827 break;
5828 case DW_OP_breg7:
5829 printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5830 break;
5831 case DW_OP_breg8:
5832 printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5833 break;
5834 case DW_OP_breg9:
5835 printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5836 break;
5837 case DW_OP_breg10:
5838 printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5839 break;
5840 case DW_OP_breg11:
5841 printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5842 break;
5843 case DW_OP_breg12:
5844 printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5845 break;
5846 case DW_OP_breg13:
5847 printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5848 break;
5849 case DW_OP_breg14:
5850 printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5851 break;
5852 case DW_OP_breg15:
5853 printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5854 break;
5855 case DW_OP_breg16:
5856 printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5857 break;
5858 case DW_OP_breg17:
5859 printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5860 break;
5861 case DW_OP_breg18:
5862 printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5863 break;
5864 case DW_OP_breg19:
5865 printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5866 break;
5867 case DW_OP_breg20:
5868 printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5869 break;
5870 case DW_OP_breg21:
5871 printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5872 break;
5873 case DW_OP_breg22:
5874 printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
5875 break;
5876 case DW_OP_breg23:
5877 printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
5878 break;
5879 case DW_OP_breg24:
5880 printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
5881 break;
5882 case DW_OP_breg25:
5883 printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
5884 break;
5885 case DW_OP_breg26:
5886 printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
5887 break;
5888 case DW_OP_breg27:
5889 printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
5890 break;
5891 case DW_OP_breg28:
5892 printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
5893 break;
5894 case DW_OP_breg29:
5895 printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
5896 break;
5897 case DW_OP_breg30:
5898 printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
5899 break;
5900 case DW_OP_breg31:
5901 printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
5902 break;
5903 case DW_OP_regx:
5904 printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
5905 break;
5906 case DW_OP_fbreg:
5907 printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
5908 break;
5909 case DW_OP_bregx:
5910 uvalue = read_leb128 (data, &bytes_read, 0);
5911 printf ("DW_OP_bregx: %lu %ld", uvalue,
5912 read_leb128 (data + bytes_read, NULL, 1));
5913 break;
5914 case DW_OP_piece:
5915 printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
5916 break;
5917 case DW_OP_deref_size:
5918 printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
5919 break;
5920 case DW_OP_xderef_size:
5921 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
5922 break;
5923 case DW_OP_nop:
5924 printf ("DW_OP_nop");
5925 break;
252b5132
RH		 5926
5927 default:
5928 if (op >= DW_OP_lo_user
5929 && op <= DW_OP_hi_user)
5930 printf (_("(User defined location op)"));
5931 else
5932 printf (_("(Unknown location op)"));
5933 break;
5934 }
5935}
5936
5937
5938static unsigned char *
5939read_and_display_attr (attribute, form, data, pointer_size)
5940 unsigned long attribute;
5941 unsigned long form;
5942 unsigned char * data;
5943 unsigned long pointer_size;
5944{
b4c96d0d
ILT		 5945 unsigned long uvalue = 0;
5946 unsigned char * block_start = NULL;
252b5132
RH		 5947 int bytes_read;
5948 int is_ref = 0;
5949
5950 printf (" %-18s:", get_AT_name (attribute));
5951
5952 switch (form)
5953 {
5954 case DW_FORM_ref_addr:
5955 case DW_FORM_ref1:
5956 case DW_FORM_ref2:
5957 case DW_FORM_ref4:
5958 case DW_FORM_ref8:
5959 case DW_FORM_ref_udata:
5960 is_ref = 1;
5961 }
5962
5963 switch (form)
5964 {
5965 case DW_FORM_ref_addr:
5966 case DW_FORM_addr:
5967 uvalue = byte_get (data, pointer_size);
305c7206 5968 printf (is_ref ? " <%lx>" : " %#lx", uvalue);
252b5132
RH		 5969 data += pointer_size;
5970 break;
5971
5972 case DW_FORM_ref1:
5973 case DW_FORM_flag:
5974 case DW_FORM_data1:
5975 uvalue = byte_get (data ++, 1);
305c7206 5976 printf (is_ref ? " <%lx>" : " %ld", uvalue);
252b5132
RH		 5977 break;
5978
5979 case DW_FORM_ref2:
5980 case DW_FORM_data2:
5981 uvalue = byte_get (data, 2);
5982 data += 2;
305c7206 5983 printf (is_ref ? " <%lx>" : " %ld", uvalue);
252b5132
RH		 5984 break;
5985
5986 case DW_FORM_ref4:
5987 case DW_FORM_data4:
5988 uvalue = byte_get (data, 4);
5989 data += 4;
305c7206 5990 printf (is_ref ? " <%lx>" : " %ld", uvalue);
252b5132
RH		 5991 break;
5992
5993 case DW_FORM_ref8:
5994 case DW_FORM_data8:
5995 uvalue = byte_get (data, 4);
5996 printf (" %lx", uvalue);
148d3c43 5997 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
252b5132
RH		 5998 data += 8;
5999 break;
6000
6001 case DW_FORM_string:
6002 printf (" %s", data);
6003 data += strlen (data) + 1;
6004 break;
6005
6006 case DW_FORM_sdata:
6007 uvalue = read_leb128 (data, & bytes_read, 1);
6008 data += bytes_read;
6009 printf (" %ld", (long) uvalue);
6010 break;
6011
6012 case DW_FORM_ref_udata:
6013 case DW_FORM_udata:
6014 uvalue = read_leb128 (data, & bytes_read, 0);
6015 data += bytes_read;
6016 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6017 break;
6018
6019 case DW_FORM_block:
6020 uvalue = read_leb128 (data, & bytes_read, 0);
6021 block_start = data + bytes_read;
6022 data = display_block (block_start, uvalue);
6023 uvalue = * block_start;
6024 break;
6025
6026 case DW_FORM_block1:
6027 uvalue = byte_get (data, 1);
6028 block_start = data + 1;
6029 data = display_block (block_start, uvalue);
6030 uvalue = * block_start;
6031 break;
6032
6033 case DW_FORM_block2:
6034 uvalue = byte_get (data, 2);
6035 block_start = data + 2;
6036 data = display_block (block_start, uvalue);
6037 uvalue = * block_start;
6038 break;
6039
6040 case DW_FORM_block4:
6041 uvalue = byte_get (data, 4);
6042 block_start = data + 4;
6043 data = display_block (block_start, uvalue);
6044 uvalue = * block_start;
6045 break;
6046
6047 case DW_FORM_strp:
6048 case DW_FORM_indirect:
6049 warn (_("Unable to handle FORM: %d"), form);
6050 break;
6051
6052 default:
6053 warn (_("Unrecognised form: %d"), form);
6054 break;
6055 }
6056
6057 /* For some attributes we can display futher information. */
6058
6059 printf ("\t");
6060
6061 switch (attribute)
6062 {
6063 case DW_AT_inline:
6064 switch (uvalue)
6065 {
6066 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6067 case DW_INL_inlined: printf (_("(inlined)")); break;
6068 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6069 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6070 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6071 }
6072 break;
6073
6074 case DW_AT_frame_base:
6075 if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
6076 printf ("(reg %ld)", uvalue - DW_OP_reg0);
6077 break;
6078
6079 case DW_AT_language:
6080 switch (uvalue)
6081 {
6082 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6083 case DW_LANG_C89: printf ("(ANSI C)"); break;
6084 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6085 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6086 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6087 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6088 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6089 case DW_LANG_Ada83: printf ("(Ada)"); break;
6090 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6091 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6092 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6093 default: printf ("(Unknown: %lx)", uvalue); break;
6094 }
6095 break;
6096
6097 case DW_AT_encoding:
6098 switch (uvalue)
6099 {
6100 case DW_ATE_void: printf ("(void)"); break;
6101 case DW_ATE_address: printf ("(machine address)"); break;
6102 case DW_ATE_boolean: printf ("(boolean)"); break;
6103 case DW_ATE_complex_float: printf ("(complex float)"); break;
6104 case DW_ATE_float: printf ("(float)"); break;
6105 case DW_ATE_signed: printf ("(signed)"); break;
6106 case DW_ATE_signed_char: printf ("(signed char)"); break;
6107 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6108 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6109 default:
6110 if (uvalue >= DW_ATE_lo_user
6111 && uvalue <= DW_ATE_hi_user)
6112 printf ("(user defined type)");
6113 else
6114 printf ("(unknown type)");
6115 break;
6116 }
6117 break;
6118
6119 case DW_AT_accessibility:
6120 switch (uvalue)
6121 {
6122 case DW_ACCESS_public: printf ("(public)"); break;
6123 case DW_ACCESS_protected: printf ("(protected)"); break;
6124 case DW_ACCESS_private: printf ("(private)"); break;
6125 default: printf ("(unknown accessibility)"); break;
6126 }
6127 break;
6128
6129 case DW_AT_visibility:
6130 switch (uvalue)
6131 {
6132 case DW_VIS_local: printf ("(local)"); break;
6133 case DW_VIS_exported: printf ("(exported)"); break;
6134 case DW_VIS_qualified: printf ("(qualified)"); break;
6135 default: printf ("(unknown visibility)"); break;
6136 }
6137 break;
6138
6139 case DW_AT_virtuality:
6140 switch (uvalue)
6141 {
6142 case DW_VIRTUALITY_none: printf ("(none)"); break;
6143 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6144 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6145 default: printf ("(unknown virtuality)"); break;
6146 }
6147 break;
6148
6149 case DW_AT_identifier_case:
6150 switch (uvalue)
6151 {
6152 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6153 case DW_ID_up_case: printf ("(up_case)"); break;
6154 case DW_ID_down_case: printf ("(down_case)"); break;
6155 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6156 default: printf ("(unknown case)"); break;
6157 }
6158 break;
6159
6160 case DW_AT_calling_convention:
6161 switch (uvalue)
6162 {
6163 case DW_CC_normal: printf ("(normal)"); break;
6164 case DW_CC_program: printf ("(program)"); break;
6165 case DW_CC_nocall: printf ("(nocall)"); break;
6166 default:
6167 if (uvalue >= DW_CC_lo_user
6168 && uvalue <= DW_CC_hi_user)
6169 printf ("(user defined)");
6170 else
6171 printf ("(unknown convention)");
6172 }
6173 break;
6174
6175 case DW_AT_location:
6176 case DW_AT_data_member_location:
6177 case DW_AT_vtable_elem_location:
6178 printf ("(");
6179 decode_location_expression (block_start, pointer_size);
6180 printf (")");
6181 break;
6182
6183 default:
6184 break;
6185 }
6186
6187 printf ("\n");
6188 return data;
6189}
6190
6191static int
6192display_debug_info (section, start, file)
6193 Elf32_Internal_Shdr * section;
6194 unsigned char * start;
6195 FILE * file;
6196{
6197 unsigned char * end = start + section->sh_size;
6198 unsigned char * section_begin = start;
6199
6200 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6201
6202 while (start < end)
6203 {
6204 DWARF2_External_CompUnit * external;
6205 DWARF2_Internal_CompUnit compunit;
6206 unsigned char * tags;
6207 int i;
6208 int level;
6209
6210 external = (DWARF2_External_CompUnit *) start;
6211
6212 compunit.cu_length = BYTE_GET (external->cu_length);
6213 compunit.cu_version = BYTE_GET (external->cu_version);
6214 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6215 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6216
6217 tags = start + sizeof (* external);
6218 start += compunit.cu_length + sizeof (external->cu_length);
6219
6220 if (compunit.cu_version != 2)
6221 {
6222 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6223 continue;
6224 }
6225
6226 printf (_(" Compilation Unit:\n"));
6227 printf (_(" Length: %ld\n"), compunit.cu_length);
6228 printf (_(" Version: %d\n"), compunit.cu_version);
6229 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6230 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6231
6232 if (first_abbrev != NULL)
6233 free_abbrevs ();
6234
6235 /* Read in the abbrevs used by this compilation unit. */
6236
6237 {
6238 Elf32_Internal_Shdr * sec;
6239 unsigned char * begin;
6240
6241 /* Locate the .debug_abbrev section and process it. */
6242 for (i = 0, sec = section_headers;
6243 i < elf_header.e_shnum;
6244 i ++, sec ++)
6245 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6246 break;
6247
6248 if (i == -1 || sec->sh_size == 0)
6249 {
6250 warn (_("Unable to locate .debug_abbrev section!\n"));
6251 return 0;
6252 }
6253
6254 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6255 "debug_abbrev section data");
6256
6257 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6258 begin + sec->sh_size);
6259
6260 free (begin);
6261 }
6262
6263 level = 0;
6264 while (tags < start)
6265 {
6266 int bytes_read;
b4c96d0d 6267 unsigned long abbrev_number;
252b5132
RH		 6268 abbrev_entry * entry;
6269 abbrev_attr * attr;
6270
6271 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6272 tags += bytes_read;
6273
6274 /* A null DIE marks the end of a list of children. */
6275 if (abbrev_number == 0)
6276 {
6277 --level;
6278 continue;
6279 }
6280
6281 /* Scan through the abbreviation list until we reach the
6282 correct entry. */
6283 for (entry = first_abbrev;
6284 entry && entry->entry != abbrev_number;
6285 entry = entry->next)
6286 continue;
6287
6288 if (entry == NULL)
6289 {
b4c96d0d 6290 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
252b5132
RH		 6291 abbrev_number);
6292 return 0;
6293 }
6294
b4c96d0d 6295 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
252b5132
RH		 6296 level, tags - section_begin - bytes_read,
6297 abbrev_number,
6298 get_TAG_name (entry->tag));
6299
6300 for (attr = entry->first_attr; attr; attr = attr->next)
6301 tags = read_and_display_attr (attr->attribute,
6302 attr->form,
6303 tags,
6304 compunit.cu_pointer_size);
6305
6306 if (entry->children)
6307 ++level;
6308 }
6309 }
6310
6311 printf ("\n");
6312
6313 return 1;
6314}
6315
6316static int
6317display_debug_aranges (section, start, file)
6318 Elf32_Internal_Shdr * section;
6319 unsigned char * start;
b4c96d0d 6320 FILE * file ATTRIBUTE_UNUSED;
252b5132
RH		 6321{
6322 unsigned char * end = start + section->sh_size;
6323
6324 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6325
6326 while (start < end)
6327 {
6328 DWARF2_External_ARange * external;
6329 DWARF2_Internal_ARange arange;
6330 unsigned char * ranges;
6331 unsigned long length;
6332 unsigned long address;
7a4b7442 6333 int excess;
252b5132
RH		 6334
6335 external = (DWARF2_External_ARange *) start;
6336
6337 arange.ar_length = BYTE_GET (external->ar_length);
6338 arange.ar_version = BYTE_GET (external->ar_version);
6339 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6340 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6341 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6342
6343 printf (_(" Length: %ld\n"), arange.ar_length);
6344 printf (_(" Version: %d\n"), arange.ar_version);
6345 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6346 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6347 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6348
6349 printf (_("\n Address Length\n"));
6350
6351 ranges = start + sizeof (* external);
6352
7a4b7442
NC		 6353 /* Must pad to an alignment boundary that is twice the pointer size. */
6354 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6355 if (excess)
6356 ranges += (2 * arange.ar_pointer_size) - excess;
6357
252b5132
RH		 6358 for (;;)
6359 {
6360 address = byte_get (ranges, arange.ar_pointer_size);
6361
252b5132
RH		 6362 ranges += arange.ar_pointer_size;
6363
6364 length = byte_get (ranges, arange.ar_pointer_size);
6365
6366 ranges += arange.ar_pointer_size;
6367
7a4b7442
NC		 6368 /* A pair of zeros marks the end of the list. */
6369 if (address == 0 && length == 0)
6370 break;
103f02d3 6371
252b5132
RH		 6372 printf (" %8.8lx %lu\n", address, length);
6373 }
6374
6375 start += arange.ar_length + sizeof (external->ar_length);
6376 }
6377
6378 printf ("\n");
6379
6380 return 1;
6381}
6382
6383
6384static int
6385display_debug_not_supported (section, start, file)
6386 Elf32_Internal_Shdr * section;
b4c96d0d
ILT		 6387 unsigned char * start ATTRIBUTE_UNUSED;
6388 FILE * file ATTRIBUTE_UNUSED;
252b5132
RH		 6389{
6390 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6391 SECTION_NAME (section));
6392
6393 return 1;
6394}
6395
3590ea00
NC		 6396/* Pre-scan the .debug_info section to record the size of address.
6397 When dumping the .debug_line, we use that size information, assuming
6398 that all compilation units have the same address size. */
6399static int
6400prescan_debug_info (section, start, file)
6401 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6402 unsigned char * start;
6403 FILE * file ATTRIBUTE_UNUSED;
6404{
6405 DWARF2_External_CompUnit * external;
6406
6407 external = (DWARF2_External_CompUnit *) start;
6408
6409 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6410 return 0;
6411}
6412
252b5132 6413 /* A structure containing the name of a debug section and a pointer
3590ea00
NC		 6414 to a function that can decode it. The third field is a prescan
6415 function to be run over the section before displaying any of the
6416 sections. */
252b5132
RH		 6417struct
6418{
6419 char * name;
3590ea00
NC		 6420 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6421 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
252b5132
RH		 6422}
6423debug_displays[] =
6424{
3590ea00
NC		 6425 { ".debug_info", display_debug_info, prescan_debug_info },
6426 { ".debug_abbrev", display_debug_abbrev, NULL },
6427 { ".debug_line", display_debug_lines, NULL },
6428 { ".debug_aranges", display_debug_aranges, NULL },
6429 { ".debug_pubnames", display_debug_pubnames, NULL },
6430 { ".debug_macinfo", display_debug_not_supported, NULL },
6431 { ".debug_frame", display_debug_not_supported, NULL },
6432 { ".debug_str", display_debug_not_supported, NULL },
6433 { ".debug_static_func", display_debug_not_supported, NULL },
6434 { ".debug_static_vars", display_debug_not_supported, NULL },
6435 { ".debug_types", display_debug_not_supported, NULL },
6436 { ".debug_weaknames", display_debug_not_supported, NULL }
252b5132
RH		 6437};
6438
6439static int
6440display_debug_section (section, file)
6441 Elf32_Internal_Shdr * section;
6442 FILE * file;
6443{
6444 char * name = SECTION_NAME (section);
6445 bfd_size_type length;
6446 unsigned char * start;
6447 int i;
6448
6449 length = section->sh_size;
6450 if (length == 0)
6451 {
6452 printf (_("\nSection '%s' has no debugging data.\n"), name);
6453 return 0;
6454 }
6455
6456 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6457 "debug section data");
6458
6459 /* See if we know how to display the contents of this section. */
6460 for (i = NUM_ELEM (debug_displays); i--;)
6461 if (strcmp (debug_displays[i].name, name) == 0)
6462 {
6463 debug_displays[i].display (section, start, file);
6464 break;
6465 }
6466
6467 if (i == -1)
6468 printf (_("Unrecognised debug section: %s\n"), name);
6469
6470 free (start);
6471
6472 /* If we loaded in the abbrev section at some point,
6473 we must release it here. */
6474 if (first_abbrev != NULL)
6475 free_abbrevs ();
6476
6477 return 1;
6478}
6479
6480static int
6481process_section_contents (file)
6482 FILE * file;
6483{
3590ea00
NC		 6484 Elf32_Internal_Shdr * section;
6485 unsigned int i;
252b5132
RH		 6486
6487 if (! do_dump)
6488 return 1;
6489
3590ea00
NC		 6490 /* Pre-scan the debug sections to find some debug information not
6491 present in some of them. For the .debug_line, we must find out the
6492 size of address (specified in .debug_info and .debug_aranges). */
6493 for (i = 0, section = section_headers;
6494 i < elf_header.e_shnum && i < num_dump_sects;
6495 i ++, section ++)
6496 {
6497 char * name = SECTION_NAME (section);
6498 int j;
6499
6500 if (section->sh_size == 0)
6501 continue;
6502
6503 /* See if there is some pre-scan operation for this section. */
6504 for (j = NUM_ELEM (debug_displays); j--;)
6505 if (strcmp (debug_displays[j].name, name) == 0)
6506 {
6507 if (debug_displays[j].prescan != NULL)
6508 {
6509 bfd_size_type length;
6510 unsigned char * start;
6511
6512 length = section->sh_size;
6513 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6514 "debug section data");
6515
6516 debug_displays[j].prescan (section, start, file);
6517 free (start);
6518 }
103f02d3 6519
3590ea00
NC		 6520 break;
6521 }
6522 }
6523
252b5132 6524 for (i = 0, section = section_headers;
3590ea00 6525 i < elf_header.e_shnum && i < num_dump_sects;
252b5132
RH		 6526 i ++, section ++)
6527 {
6528#ifdef SUPPORT_DISASSEMBLY
6529 if (dump_sects[i] & DISASS_DUMP)
6530 disassemble_section (section, file);
6531#endif
6532 if (dump_sects[i] & HEX_DUMP)
6533 dump_section (section, file);
6534
6535 if (dump_sects[i] & DEBUG_DUMP)
6536 display_debug_section (section, file);
6537 }
6538
6539 if (i < num_dump_sects)
6540 warn (_("Some sections were not dumped because they do not exist!\n"));
6541
6542 return 1;
6543}
6544
6545static void
6546process_mips_fpe_exception (mask)
6547 int mask;
6548{
6549 if (mask)
6550 {
6551 int first = 1;
6552 if (mask & OEX_FPU_INEX)
6553 fputs ("INEX", stdout), first = 0;
6554 if (mask & OEX_FPU_UFLO)
6555 printf ("%sUFLO", first ? "" : "|"), first = 0;
6556 if (mask & OEX_FPU_OFLO)
6557 printf ("%sOFLO", first ? "" : "|"), first = 0;
6558 if (mask & OEX_FPU_DIV0)
6559 printf ("%sDIV0", first ? "" : "|"), first = 0;
6560 if (mask & OEX_FPU_INVAL)
6561 printf ("%sINVAL", first ? "" : "|");
6562 }
6563 else
6564 fputs ("0", stdout);
6565}
6566
6567static int
6568process_mips_specific (file)
9ea033b2 6569 FILE * file;
252b5132 6570{
9ea033b2 6571 Elf_Internal_Dyn * entry;
252b5132
RH		 6572 size_t liblist_offset = 0;
6573 size_t liblistno = 0;
6574 size_t conflictsno = 0;
6575 size_t options_offset = 0;
6576 size_t conflicts_offset = 0;
6577
6578 /* We have a lot of special sections. Thanks SGI! */
6579 if (dynamic_segment == NULL)
6580 /* No information available. */
6581 return 0;
6582
6583 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6584 switch (entry->d_tag)
6585 {
6586 case DT_MIPS_LIBLIST:
6587 liblist_offset = entry->d_un.d_val - loadaddr;
6588 break;
6589 case DT_MIPS_LIBLISTNO:
6590 liblistno = entry->d_un.d_val;
6591 break;
6592 case DT_MIPS_OPTIONS:
6593 options_offset = entry->d_un.d_val - loadaddr;
6594 break;
6595 case DT_MIPS_CONFLICT:
6596 conflicts_offset = entry->d_un.d_val - loadaddr;
6597 break;
6598 case DT_MIPS_CONFLICTNO:
6599 conflictsno = entry->d_un.d_val;
6600 break;
6601 default:
6602 break;
6603 }
6604
6605 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6606 {
9ea033b2 6607 Elf32_External_Lib * elib;
252b5132
RH		 6608 size_t cnt;
6609
6610 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6611 elib, Elf32_External_Lib *, "liblist");
6612
16062207
ILT		 6613 printf ("\nSection '.liblist' contains %lu entries:\n",
6614 (unsigned long) liblistno);
252b5132
RH		 6615 fputs (" Library Time Stamp Checksum Version Flags\n",
6616 stdout);
6617
6618 for (cnt = 0; cnt < liblistno; ++cnt)
6619 {
6620 Elf32_Lib liblist;
6621 time_t time;
6622 char timebuf[20];
6623
6624 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6625 time = BYTE_GET (elib[cnt].l_time_stamp);
6626 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6627 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6628 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6629
6630 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6631
16062207 6632 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
252b5132
RH		 6633 dynamic_strings + liblist.l_name, timebuf,
6634 liblist.l_checksum, liblist.l_version);
6635
6636 if (liblist.l_flags == 0)
6637 puts (" NONE");
6638 else
6639 {
6640 static const struct
6641 {
30800947 6642 const char * name;
252b5132 6643 int bit;
30800947
NC		 6644 }
6645 l_flags_vals[] =
6646 {
6647 { " EXACT_MATCH", LL_EXACT_MATCH },
6648 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6649 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6650 { " EXPORTS", LL_EXPORTS },
6651 { " DELAY_LOAD", LL_DELAY_LOAD },
6652 { " DELTA", LL_DELTA }
6653 };
252b5132 6654 int flags = liblist.l_flags;
b4c96d0d 6655 size_t fcnt;
252b5132
RH		 6656
6657 for (fcnt = 0;
6658 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6659 ++fcnt)
6660 if ((flags & l_flags_vals[fcnt].bit) != 0)
6661 {
6662 fputs (l_flags_vals[fcnt].name, stdout);
6663 flags ^= l_flags_vals[fcnt].bit;
6664 }
6665 if (flags != 0)
6666 printf (" %#x", (unsigned int) flags);
6667
6668 puts ("");
6669 }
6670 }
6671
6672 free (elib);
6673 }
6674
6675 if (options_offset != 0)
6676 {
9ea033b2 6677 Elf_External_Options * eopt;
d1133906 6678 Elf_Internal_Shdr * sect = section_headers;
9ea033b2
NC		 6679 Elf_Internal_Options * iopt;
6680 Elf_Internal_Options * option;
252b5132
RH		 6681 size_t offset;
6682 int cnt;
6683
6684 /* Find the section header so that we get the size. */
6685 while (sect->sh_type != SHT_MIPS_OPTIONS)
d1133906 6686 ++ sect;
252b5132
RH		 6687
6688 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6689 Elf_External_Options *, "options");
6690
6691 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6692 * sizeof (*iopt));
6693 if (iopt == NULL)
6694 {
6695 error (_("Out of memory"));
6696 return 0;
6697 }
6698
6699 offset = cnt = 0;
6700 option = iopt;
d1133906 6701
252b5132
RH		 6702 while (offset < sect->sh_size)
6703 {
9ea033b2 6704 Elf_External_Options * eoption;
252b5132
RH		 6705
6706 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6707
6708 option->kind = BYTE_GET (eoption->kind);
6709 option->size = BYTE_GET (eoption->size);
6710 option->section = BYTE_GET (eoption->section);
6711 option->info = BYTE_GET (eoption->info);
6712
6713 offset += option->size;
d1133906 6714
252b5132
RH		 6715 ++option;
6716 ++cnt;
6717 }
6718
6719 printf (_("\nSection '%s' contains %d entries:\n"),
6720 string_table + sect->sh_name, cnt);
6721
6722 option = iopt;
d1133906 6723
252b5132
RH		 6724 while (cnt-- > 0)
6725 {
6726 size_t len;
6727
6728 switch (option->kind)
6729 {
6730 case ODK_NULL:
6731 /* This shouldn't happen. */
6732 printf (" NULL %d %lx", option->section, option->info);
6733 break;
6734 case ODK_REGINFO:
6735 printf (" REGINFO ");
6736 if (elf_header.e_machine == EM_MIPS)
6737 {
6738 /* 32bit form. */
6739 Elf32_External_RegInfo *ereg;
6740 Elf32_RegInfo reginfo;
6741
6742 ereg = (Elf32_External_RegInfo *) (option + 1);
6743 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6744 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6745 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6746 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6747 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6748 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6749
6750 printf ("GPR %08lx GP 0x%lx\n",
6751 reginfo.ri_gprmask,
6752 (unsigned long) reginfo.ri_gp_value);
6753 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6754 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6755 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6756 }
6757 else
6758 {
6759 /* 64 bit form. */
9ea033b2 6760 Elf64_External_RegInfo * ereg;
252b5132
RH		 6761 Elf64_Internal_RegInfo reginfo;
6762
6763 ereg = (Elf64_External_RegInfo *) (option + 1);
9ea033b2 6764 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
252b5132
RH		 6765 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6766 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6767 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6768 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9ea033b2 6769 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
252b5132
RH		 6770
6771 printf ("GPR %08lx GP 0x",
6772 reginfo.ri_gprmask);
6773 printf_vma (reginfo.ri_gp_value);
6774 printf ("\n");
6775
6776 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6777 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6778 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6779 }
6780 ++option;
6781 continue;
6782 case ODK_EXCEPTIONS:
6783 fputs (" EXCEPTIONS fpe_min(", stdout);
6784 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6785 fputs (") fpe_max(", stdout);
6786 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6787 fputs (")", stdout);
6788
6789 if (option->info & OEX_PAGE0)
6790 fputs (" PAGE0", stdout);
6791 if (option->info & OEX_SMM)
6792 fputs (" SMM", stdout);
6793 if (option->info & OEX_FPDBUG)
6794 fputs (" FPDBUG", stdout);
6795 if (option->info & OEX_DISMISS)
6796 fputs (" DISMISS", stdout);
6797 break;
6798 case ODK_PAD:
6799 fputs (" PAD ", stdout);
6800 if (option->info & OPAD_PREFIX)
6801 fputs (" PREFIX", stdout);
6802 if (option->info & OPAD_POSTFIX)
6803 fputs (" POSTFIX", stdout);
6804 if (option->info & OPAD_SYMBOL)
6805 fputs (" SYMBOL", stdout);
6806 break;
6807 case ODK_HWPATCH:
6808 fputs (" HWPATCH ", stdout);
6809 if (option->info & OHW_R4KEOP)
6810 fputs (" R4KEOP", stdout);
6811 if (option->info & OHW_R8KPFETCH)
6812 fputs (" R8KPFETCH", stdout);
6813 if (option->info & OHW_R5KEOP)
6814 fputs (" R5KEOP", stdout);
6815 if (option->info & OHW_R5KCVTL)
6816 fputs (" R5KCVTL", stdout);
6817 break;
6818 case ODK_FILL:
6819 fputs (" FILL ", stdout);
6820 /* XXX Print content of info word? */
6821 break;
6822 case ODK_TAGS:
6823 fputs (" TAGS ", stdout);
6824 /* XXX Print content of info word? */
6825 break;
6826 case ODK_HWAND:
6827 fputs (" HWAND ", stdout);
6828 if (option->info & OHWA0_R4KEOP_CHECKED)
6829 fputs (" R4KEOP_CHECKED", stdout);
6830 if (option->info & OHWA0_R4KEOP_CLEAN)
6831 fputs (" R4KEOP_CLEAN", stdout);
6832 break;
6833 case ODK_HWOR:
6834 fputs (" HWOR ", stdout);
6835 if (option->info & OHWA0_R4KEOP_CHECKED)
6836 fputs (" R4KEOP_CHECKED", stdout);
6837 if (option->info & OHWA0_R4KEOP_CLEAN)
6838 fputs (" R4KEOP_CLEAN", stdout);
6839 break;
6840 case ODK_GP_GROUP:
6841 printf (" GP_GROUP %#06lx self-contained %#06lx",
6842 option->info & OGP_GROUP,
6843 (option->info & OGP_SELF) >> 16);
6844 break;
6845 case ODK_IDENT:
6846 printf (" IDENT %#06lx self-contained %#06lx",
6847 option->info & OGP_GROUP,
6848 (option->info & OGP_SELF) >> 16);
6849 break;
6850 default:
6851 /* This shouldn't happen. */
6852 printf (" %3d ??? %d %lx",
6853 option->kind, option->section, option->info);
6854 break;
6855 }
6856
6857 len = sizeof (*eopt);
6858 while (len < option->size)
6859 if (((char *) option)[len] >= ' '
6860 && ((char *) option)[len] < 0x7f)
6861 printf ("%c", ((char *) option)[len++]);
6862 else
6863 printf ("\\%03o", ((char *) option)[len++]);
6864
6865 fputs ("\n", stdout);
6866 ++option;
6867 }
6868
6869 free (eopt);
6870 }
6871
6872 if (conflicts_offset != 0 && conflictsno != 0)
6873 {
9ea033b2
NC		 6874 Elf32_External_Conflict * econf32;
6875 Elf64_External_Conflict * econf64;
6876 Elf32_Conflict * iconf;
252b5132
RH		 6877 size_t cnt;
6878
6879 if (dynamic_symbols == NULL)
6880 {
6881 error (_("conflict list with without table"));
6882 return 0;
6883 }
6884
6885 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6886 if (iconf == NULL)
6887 {
6888 error (_("Out of memory"));
6889 return 0;
6890 }
6891
9ea033b2 6892 if (is_32bit_elf)
252b5132
RH		 6893 {
6894 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6895 econf32, Elf32_External_Conflict *, "conflict");
6896
6897 for (cnt = 0; cnt < conflictsno; ++cnt)
6898 iconf[cnt] = BYTE_GET (econf32[cnt]);
6899 }
6900 else
6901 {
6902 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6903 econf64, Elf64_External_Conflict *, "conflict");
6904
6905 for (cnt = 0; cnt < conflictsno; ++cnt)
6906 iconf[cnt] = BYTE_GET (econf64[cnt]);
6907 }
6908
6909 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6910 puts (_(" Num: Index Value Name"));
6911
6912 for (cnt = 0; cnt < conflictsno; ++cnt)
6913 {
19936277 6914 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
252b5132 6915
16062207 6916 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
f7a99963
NC		 6917 print_vma (psym->st_value, FULL_HEX);
6918 printf (" %s\n", dynamic_strings + psym->st_name);
252b5132
RH		 6919 }
6920
252b5132
RH		 6921 free (iconf);
6922 }
6923
6924 return 1;
6925}
6926
779fe533
NC		 6927static char *
6928get_note_type (e_type)
6929 unsigned e_type;
6930{
6931 static char buff[64];
103f02d3 6932
779fe533
NC		 6933 switch (e_type)
6934 {
6935 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
6936 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
6937 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
6938 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
d1133906 6939 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
779fe533
NC		 6940 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
6941 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
6942 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
6943 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6944 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7bea2f73 6945 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
779fe533
NC		 6946 default:
6947 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
6948 return buff;
6949 }
6950}
6951
6d118b09
NC		 6952/* Note that by the ELF standard, the name field is already null byte
6953 terminated, and namesz includes the terminating null byte.
6954 I.E. the value of namesz for the name "FSF" is 4.
6955
6956 If the value of namesz is zero, there is no name present. */
779fe533
NC		 6957static int
6958process_note (pnote)
6d118b09 6959 Elf32_Internal_Note * pnote;
779fe533 6960{
103f02d3 6961 printf (" %s\t\t0x%08lx\t%s\n",
6d118b09
NC		 6962 pnote->namesz ? pnote->namedata : "(NONE)",
6963 pnote->descsz, get_note_type (pnote->type));
779fe533
NC		 6964 return 1;
6965}
6966
6d118b09 6967
779fe533
NC		 6968static int
6969process_corefile_note_segment (file, offset, length)
6970 FILE * file;
f7a99963
NC		 6971 bfd_vma offset;
6972 bfd_vma length;
779fe533
NC		 6973{
6974 Elf_External_Note * pnotes;
6975 Elf_External_Note * external;
779fe533 6976 int res = 1;
103f02d3 6977
779fe533
NC		 6978 if (length <= 0)
6979 return 0;
103f02d3 6980
779fe533
NC		 6981 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
6982
103f02d3 6983 external = pnotes;
103f02d3 6984
305c7206
AM		 6985 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
6986 (unsigned long) offset,
6987 (unsigned long) length);
779fe533 6988 printf (_(" Owner\t\tData size\tDescription\n"));
103f02d3 6989
6d118b09 6990 while (external < (Elf_External_Note *)((char *) pnotes + length))
779fe533 6991 {
6d118b09
NC		 6992 Elf32_Internal_Note inote;
6993 char * temp = NULL;
6994
6995 inote.type = BYTE_GET (external->type);
6996 inote.namesz = BYTE_GET (external->namesz);
6997 inote.namedata = external->name;
6998 inote.descsz = BYTE_GET (external->descsz);
6999 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7000 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7001
7002 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7003
7004 /* Verify that name is null terminated. It appears that at least
7005 one version of Linux (RedHat 6.0) generates corefiles that don't
7006 comply with the ELF spec by failing to include the null byte in
7007 namesz. */
7008 if (inote.namedata[inote.namesz] != '\0')
7009 {
7010 temp = malloc (inote.namesz + 1);
7011
7012 if (temp == NULL)
7013 {
7014 error (_("Out of memory\n"));
7015 res = 0;
7016 break;
7017 }
7018
7019 strncpy (temp, inote.namedata, inote.namesz);
7020 temp[inote.namesz] = 0;
7021
7022 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7023 inote.namedata = temp;
7024 }
7025
7026 res &= process_note (& inote);
103f02d3 7027
6d118b09
NC		 7028 if (temp != NULL)
7029 {
7030 free (temp);
7031 temp = NULL;
7032 }
779fe533
NC		 7033 }
7034
7035 free (pnotes);
103f02d3 7036
779fe533
NC		 7037 return res;
7038}
7039
7040static int
7041process_corefile_note_segments (file)
7042 FILE * file;
7043{
7044 Elf_Internal_Phdr * program_headers;
7045 Elf_Internal_Phdr * segment;
7046 unsigned int i;
7047 int res = 1;
103f02d3 7048
779fe533
NC		 7049 program_headers = (Elf_Internal_Phdr *) malloc
7050 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7051
7052 if (program_headers == NULL)
7053 {
7054 error (_("Out of memory\n"));
7055 return 0;
7056 }
7057
7058 if (is_32bit_elf)
7059 i = get_32bit_program_headers (file, program_headers);
7060 else
7061 i = get_64bit_program_headers (file, program_headers);
7062
7063 if (i == 0)
7064 {
7065 free (program_headers);
7066 return 0;
7067 }
103f02d3 7068
779fe533
NC		 7069 for (i = 0, segment = program_headers;
7070 i < elf_header.e_phnum;
7071 i ++, segment ++)
7072 {
7073 if (segment->p_type == PT_NOTE)
103f02d3 7074 res &= process_corefile_note_segment (file,
30800947
NC		 7075 (bfd_vma) segment->p_offset,
7076 (bfd_vma) segment->p_filesz);
779fe533 7077 }
103f02d3 7078
779fe533
NC		 7079 free (program_headers);
7080
7081 return res;
7082}
7083
7084static int
7085process_corefile_contents (file)
7086 FILE * file;
7087{
7088 /* If we have not been asked to display the notes then do nothing. */
7089 if (! do_notes)
7090 return 1;
103f02d3 7091
779fe533
NC		 7092 /* If file is not a core file then exit. */
7093 if (elf_header.e_type != ET_CORE)
7094 return 1;
103f02d3 7095
779fe533
NC		 7096 /* No program headers means no NOTE segment. */
7097 if (elf_header.e_phnum == 0)
7098 {
7099 printf (_("No note segments present in the core file.\n"));
7100 return 1;
7101 }
7102
7103 return process_corefile_note_segments (file);
7104}
7105
252b5132
RH		 7106static int
7107process_arch_specific (file)
9ea033b2 7108 FILE * file;
252b5132 7109{
a952a375
NC		 7110 if (! do_arch)
7111 return 1;
7112
252b5132
RH		 7113 switch (elf_header.e_machine)
7114 {
7115 case EM_MIPS:
7116 case EM_MIPS_RS4_BE:
7117 return process_mips_specific (file);
7118 break;
7119 default:
7120 break;
7121 }
7122 return 1;
7123}
7124
7125static int
7126get_file_header (file)
7127 FILE * file;
7128{
9ea033b2
NC		 7129 /* Read in the identity array. */
7130 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
252b5132
RH		 7131 return 0;
7132
9ea033b2
NC		 7133 /* Determine how to read the rest of the header. */
7134 switch (elf_header.e_ident [EI_DATA])
7135 {
7136 default: /* fall through */
7137 case ELFDATANONE: /* fall through */
7138 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7139 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7140 }
7141
7142 /* For now we only support 32 bit and 64 bit ELF files. */
7143 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7144
7145 /* Read in the rest of the header. */
7146 if (is_32bit_elf)
7147 {
7148 Elf32_External_Ehdr ehdr32;
252b5132 7149
9ea033b2
NC		 7150 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7151 return 0;
103f02d3 7152
9ea033b2
NC		 7153 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7154 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7155 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7156 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7157 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7158 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7159 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7160 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7161 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7162 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7163 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7164 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7165 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7166 }
252b5132 7167 else
9ea033b2
NC		 7168 {
7169 Elf64_External_Ehdr ehdr64;
a952a375
NC		 7170
7171 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7172 we will not be able to cope with the 64bit data found in
7173 64 ELF files. Detect this now and abort before we start
7174 overwritting things. */
7175 if (sizeof (bfd_vma) < 8)
7176 {
7177 error (_("This instance of readelf has been built without support for a\n"));
7178 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7179 return 0;
7180 }
103f02d3 7181
9ea033b2
NC		 7182 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7183 return 0;
103f02d3 7184
9ea033b2
NC		 7185 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7186 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7187 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7188 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7189 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7190 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7191 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7192 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7193 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7194 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7195 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7196 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7197 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7198 }
252b5132
RH		 7199
7200 return 1;
7201}
7202
7203static void
7204process_file (file_name)
7205 char * file_name;
7206{
7207 FILE * file;
7208 struct stat statbuf;
7209 unsigned int i;
7210
7211 if (stat (file_name, & statbuf) < 0)
7212 {
7213 error (_("Cannot stat input file %s.\n"), file_name);
7214 return;
7215 }
7216
7217 file = fopen (file_name, "rb");
7218 if (file == NULL)
7219 {
7220 error (_("Input file %s not found.\n"), file_name);
7221 return;
7222 }
7223
7224 if (! get_file_header (file))
7225 {
7226 error (_("%s: Failed to read file header\n"), file_name);
7227 fclose (file);
7228 return;
7229 }
7230
7231 /* Initialise per file variables. */
7232 for (i = NUM_ELEM (version_info); i--;)
7233 version_info[i] = 0;
7234
7235 for (i = NUM_ELEM (dynamic_info); i--;)
7236 dynamic_info[i] = 0;
7237
7238 /* Process the file. */
7239 if (show_name)
7240 printf (_("\nFile: %s\n"), file_name);
7241
7242 if (! process_file_header ())
7243 {
7244 fclose (file);
7245 return;
7246 }
7247
7248 process_section_headers (file);
7249
7250 process_program_headers (file);
7251
7252 process_dynamic_segment (file);
7253
7254 process_relocs (file);
7255
7256 process_symbol_table (file);
7257
7258 process_syminfo (file);
7259
7260 process_version_sections (file);
7261
7262 process_section_contents (file);
103f02d3 7263
779fe533 7264 process_corefile_contents (file);
103f02d3 7265
252b5132
RH		 7266 process_arch_specific (file);
7267
7268 fclose (file);
7269
7270 if (section_headers)
7271 {
7272 free (section_headers);
7273 section_headers = NULL;
7274 }
7275
7276 if (string_table)
7277 {
7278 free (string_table);
7279 string_table = NULL;
7280 }
7281
7282 if (dynamic_strings)
7283 {
7284 free (dynamic_strings);
7285 dynamic_strings = NULL;
7286 }
7287
7288 if (dynamic_symbols)
7289 {
7290 free (dynamic_symbols);
7291 dynamic_symbols = NULL;
19936277 7292 num_dynamic_syms = 0;
252b5132
RH		 7293 }
7294
7295 if (dynamic_syminfo)
7296 {
7297 free (dynamic_syminfo);
7298 dynamic_syminfo = NULL;
7299 }
7300}
7301
7302#ifdef SUPPORT_DISASSEMBLY
7303/* Needed by the i386 disassembler. For extra credit, someone could
9ea033b2
NC		 7304 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7305 symbols */
252b5132
RH		 7306
7307void
7308print_address (unsigned int addr, FILE * outfile)
7309{
7310 fprintf (outfile,"0x%8.8x", addr);
7311}
7312
7313/* Needed by the i386 disassembler. */
7314void
7315db_task_printsym (unsigned int addr)
7316{
7317 print_address (addr, stderr);
7318}
7319#endif
7320
7321int
7322main (argc, argv)
7323 int argc;
7324 char ** argv;
7325{
7326#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7327 setlocale (LC_MESSAGES, "");
7328#endif
7329 bindtextdomain (PACKAGE, LOCALEDIR);
7330 textdomain (PACKAGE);
7331
7332 parse_args (argc, argv);
7333
7334 if (optind < (argc - 1))
7335 show_name = 1;
7336
7337 while (optind < argc)
7338 process_file (argv [optind ++]);
7339
7340 if (dump_sects != NULL)
7341 free (dump_sects);
7342
7343 return 0;
7344}
A mirror of the official binutils-gdb repository