OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [binutils/] [readelf.c] - Blame information for rev 156

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.