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