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