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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [objdump.c] - Blame information for rev 95

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 15 khays
/* objdump.c -- dump information about an object file.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GNU Binutils.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
 
24
/* Objdump overview.
25
 
26
   Objdump displays information about one or more object files, either on
27
   their own, or inside libraries.  It is commonly used as a disassembler,
28
   but it can also display information about file headers, symbol tables,
29
   relocations, debugging directives and more.
30
 
31
   The flow of execution is as follows:
32
 
33
   1. Command line arguments are checked for control switches and the
34
      information to be displayed is selected.
35
 
36
   2. Any remaining arguments are assumed to be object files, and they are
37
      processed in order by display_bfd().  If the file is an archive each
38
      of its elements is processed in turn.
39
 
40
   3. The file's target architecture and binary file format are determined
41
      by bfd_check_format().  If they are recognised, then dump_bfd() is
42
      called.
43
 
44
   4. dump_bfd() in turn calls separate functions to display the requested
45
      item(s) of information(s).  For example disassemble_data() is called if
46
      a disassembly has been requested.
47
 
48
   When disassembling the code loops through blocks of instructions bounded
49
   by symbols, calling disassemble_bytes() on each block.  The actual
50
   disassembling is done by the libopcodes library, via a function pointer
51
   supplied by the disassembler() function.  */
52
 
53
#include "sysdep.h"
54
#include "bfd.h"
55
#include "elf-bfd.h"
56
#include "progress.h"
57
#include "bucomm.h"
58
#include "elfcomm.h"
59
#include "dwarf.h"
60
#include "getopt.h"
61
#include "safe-ctype.h"
62
#include "dis-asm.h"
63
#include "libiberty.h"
64
#include "demangle.h"
65
#include "filenames.h"
66
#include "debug.h"
67
#include "budbg.h"
68
#include "objdump.h"
69
 
70
#ifdef HAVE_MMAP
71
#include <sys/mman.h>
72
#endif
73
 
74
#include <sys/stat.h>
75
 
76
/* Internal headers for the ELF .stab-dump code - sorry.  */
77
#define BYTES_IN_WORD   32
78
#include "aout/aout64.h"
79
 
80
/* Exit status.  */
81
static int exit_status = 0;
82
 
83
static char *default_target = NULL;     /* Default at runtime.  */
84
 
85
/* The following variables are set based on arguments passed on the
86
   command line.  */
87
static int show_version = 0;             /* Show the version number.  */
88
static int dump_section_contents;       /* -s */
89
static int dump_section_headers;        /* -h */
90
static bfd_boolean dump_file_header;    /* -f */
91
static int dump_symtab;                 /* -t */
92
static int dump_dynamic_symtab;         /* -T */
93
static int dump_reloc_info;             /* -r */
94
static int dump_dynamic_reloc_info;     /* -R */
95
static int dump_ar_hdrs;                /* -a */
96
static int dump_private_headers;        /* -p */
97
static char *dump_private_options;      /* -P */
98
static int prefix_addresses;            /* --prefix-addresses */
99
static int with_line_numbers;           /* -l */
100
static bfd_boolean with_source_code;    /* -S */
101
static int show_raw_insn;               /* --show-raw-insn */
102
static int dump_dwarf_section_info;     /* --dwarf */
103
static int dump_stab_section_info;      /* --stabs */
104
static int do_demangle;                 /* -C, --demangle */
105
static bfd_boolean disassemble;         /* -d */
106
static bfd_boolean disassemble_all;     /* -D */
107
static int disassemble_zeroes;          /* --disassemble-zeroes */
108
static bfd_boolean formats_info;        /* -i */
109
static int wide_output;                 /* -w */
110
static int insn_width;                  /* --insn-width */
111
static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
112
static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
113
static int dump_debugging;              /* --debugging */
114
static int dump_debugging_tags;         /* --debugging-tags */
115
static int suppress_bfd_header;
116
static int dump_special_syms = 0;        /* --special-syms */
117
static bfd_vma adjust_section_vma = 0;   /* --adjust-vma */
118
static int file_start_context = 0;      /* --file-start-context */
119
static bfd_boolean display_file_offsets;/* -F */
120
static const char *prefix;              /* --prefix */
121
static int prefix_strip;                /* --prefix-strip */
122
static size_t prefix_length;
123
 
124
/* A structure to record the sections mentioned in -j switches.  */
125
struct only
126
{
127
  const char * name; /* The name of the section.  */
128
  bfd_boolean  seen; /* A flag to indicate that the section has been found in one or more input files.  */
129
  struct only * next; /* Pointer to the next structure in the list.  */
130
};
131
/* Pointer to an array of 'only' structures.
132
   This pointer is NULL if the -j switch has not been used.  */
133
static struct only * only_list = NULL;
134
 
135
/* Variables for handling include file path table.  */
136
static const char **include_paths;
137
static int include_path_count;
138
 
139
/* Extra info to pass to the section disassembler and address printing
140
   function.  */
141
struct objdump_disasm_info
142
{
143
  bfd *              abfd;
144
  asection *         sec;
145
  bfd_boolean        require_sec;
146
  arelent **         dynrelbuf;
147
  long               dynrelcount;
148
  disassembler_ftype disassemble_fn;
149
  arelent *          reloc;
150
};
151
 
152
/* Architecture to disassemble for, or default if NULL.  */
153
static char *machine = NULL;
154
 
155
/* Target specific options to the disassembler.  */
156
static char *disassembler_options = NULL;
157
 
158
/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
159
static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
160
 
161
/* The symbol table.  */
162
static asymbol **syms;
163
 
164
/* Number of symbols in `syms'.  */
165
static long symcount = 0;
166
 
167
/* The sorted symbol table.  */
168
static asymbol **sorted_syms;
169
 
170
/* Number of symbols in `sorted_syms'.  */
171
static long sorted_symcount = 0;
172
 
173
/* The dynamic symbol table.  */
174
static asymbol **dynsyms;
175
 
176
/* The synthetic symbol table.  */
177
static asymbol *synthsyms;
178
static long synthcount = 0;
179
 
180
/* Number of symbols in `dynsyms'.  */
181
static long dynsymcount = 0;
182
 
183
static bfd_byte *stabs;
184
static bfd_size_type stab_size;
185
 
186
static char *strtab;
187
static bfd_size_type stabstr_size;
188
 
189
static bfd_boolean is_relocatable = FALSE;
190
 
191
/* Handlers for -P/--private.  */
192
static const struct objdump_private_desc * const objdump_private_vectors[] =
193
  {
194
    OBJDUMP_PRIVATE_VECTORS
195
    NULL
196
  };
197
 
198
static void
199
usage (FILE *stream, int status)
200
{
201
  fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
202
  fprintf (stream, _(" Display information from object <file(s)>.\n"));
203
  fprintf (stream, _(" At least one of the following switches must be given:\n"));
204
  fprintf (stream, _("\
205
  -a, --archive-headers    Display archive header information\n\
206
  -f, --file-headers       Display the contents of the overall file header\n\
207
  -p, --private-headers    Display object format specific file header contents\n\
208
  -P, --private=OPT,OPT... Display object format specific contents\n\
209
  -h, --[section-]headers  Display the contents of the section headers\n\
210
  -x, --all-headers        Display the contents of all headers\n\
211
  -d, --disassemble        Display assembler contents of executable sections\n\
212
  -D, --disassemble-all    Display assembler contents of all sections\n\
213
  -S, --source             Intermix source code with disassembly\n\
214
  -s, --full-contents      Display the full contents of all sections requested\n\
215
  -g, --debugging          Display debug information in object file\n\
216
  -e, --debugging-tags     Display debug information using ctags style\n\
217
  -G, --stabs              Display (in raw form) any STABS info in the file\n\
218
  -W[lLiaprmfFsoRt] or\n\
219
  --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
220
          =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
221
          =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
222
                           Display DWARF info in the file\n\
223
  -t, --syms               Display the contents of the symbol table(s)\n\
224
  -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
225
  -r, --reloc              Display the relocation entries in the file\n\
226
  -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
227
  @<file>                  Read options from <file>\n\
228
  -v, --version            Display this program's version number\n\
229
  -i, --info               List object formats and architectures supported\n\
230
  -H, --help               Display this information\n\
231
"));
232
  if (status != 2)
233
    {
234
      const struct objdump_private_desc * const *desc;
235
 
236
      fprintf (stream, _("\n The following switches are optional:\n"));
237
      fprintf (stream, _("\
238
  -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
239
  -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
240
  -j, --section=NAME             Only display information for section NAME\n\
241
  -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
242
  -EB --endian=big               Assume big endian format when disassembling\n\
243
  -EL --endian=little            Assume little endian format when disassembling\n\
244
      --file-start-context       Include context from start of file (with -S)\n\
245
  -I, --include=DIR              Add DIR to search list for source files\n\
246
  -l, --line-numbers             Include line numbers and filenames in output\n\
247
  -F, --file-offsets             Include file offsets when displaying information\n\
248
  -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
249
                                  The STYLE, if specified, can be `auto', `gnu',\n\
250
                                  `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
251
                                  or `gnat'\n\
252
  -w, --wide                     Format output for more than 80 columns\n\
253
  -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
254
      --start-address=ADDR       Only process data whose address is >= ADDR\n\
255
      --stop-address=ADDR        Only process data whose address is <= ADDR\n\
256
      --prefix-addresses         Print complete address alongside disassembly\n\
257
      --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
258
      --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n\
259
      --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
260
      --special-syms             Include special symbols in symbol dumps\n\
261
      --prefix=PREFIX            Add PREFIX to absolute paths for -S\n\
262
      --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
263
      fprintf (stream, _("\
264
      --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
265
      --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
266
                             or deeper\n\n"));
267
      list_supported_targets (program_name, stream);
268
      list_supported_architectures (program_name, stream);
269
 
270
      disassembler_usage (stream);
271
 
272
      if (objdump_private_vectors[0] != NULL)
273
        {
274
          fprintf (stream,
275
                   _("\nOptions supported for -P/--private switch:\n"));
276
          for (desc = objdump_private_vectors; *desc != NULL; desc++)
277
            (*desc)->help (stream);
278
        }
279
    }
280
  if (REPORT_BUGS_TO[0] && status == 0)
281
    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
282
  exit (status);
283
}
284
 
285
/* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
286
enum option_values
287
  {
288
    OPTION_ENDIAN=150,
289
    OPTION_START_ADDRESS,
290
    OPTION_STOP_ADDRESS,
291
    OPTION_DWARF,
292
    OPTION_PREFIX,
293
    OPTION_PREFIX_STRIP,
294
    OPTION_INSN_WIDTH,
295
    OPTION_ADJUST_VMA,
296
    OPTION_DWARF_DEPTH,
297
    OPTION_DWARF_START
298
  };
299
 
300
static struct option long_options[]=
301
{
302
  {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
303
  {"all-headers", no_argument, NULL, 'x'},
304
  {"private-headers", no_argument, NULL, 'p'},
305
  {"private", required_argument, NULL, 'P'},
306
  {"architecture", required_argument, NULL, 'm'},
307
  {"archive-headers", no_argument, NULL, 'a'},
308
  {"debugging", no_argument, NULL, 'g'},
309
  {"debugging-tags", no_argument, NULL, 'e'},
310
  {"demangle", optional_argument, NULL, 'C'},
311
  {"disassemble", no_argument, NULL, 'd'},
312
  {"disassemble-all", no_argument, NULL, 'D'},
313
  {"disassembler-options", required_argument, NULL, 'M'},
314
  {"disassemble-zeroes", no_argument, NULL, 'z'},
315
  {"dynamic-reloc", no_argument, NULL, 'R'},
316
  {"dynamic-syms", no_argument, NULL, 'T'},
317
  {"endian", required_argument, NULL, OPTION_ENDIAN},
318
  {"file-headers", no_argument, NULL, 'f'},
319
  {"file-offsets", no_argument, NULL, 'F'},
320
  {"file-start-context", no_argument, &file_start_context, 1},
321
  {"full-contents", no_argument, NULL, 's'},
322
  {"headers", no_argument, NULL, 'h'},
323
  {"help", no_argument, NULL, 'H'},
324
  {"info", no_argument, NULL, 'i'},
325
  {"line-numbers", no_argument, NULL, 'l'},
326
  {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
327
  {"prefix-addresses", no_argument, &prefix_addresses, 1},
328
  {"reloc", no_argument, NULL, 'r'},
329
  {"section", required_argument, NULL, 'j'},
330
  {"section-headers", no_argument, NULL, 'h'},
331
  {"show-raw-insn", no_argument, &show_raw_insn, 1},
332
  {"source", no_argument, NULL, 'S'},
333
  {"special-syms", no_argument, &dump_special_syms, 1},
334
  {"include", required_argument, NULL, 'I'},
335
  {"dwarf", optional_argument, NULL, OPTION_DWARF},
336
  {"stabs", no_argument, NULL, 'G'},
337
  {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
338
  {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
339
  {"syms", no_argument, NULL, 't'},
340
  {"target", required_argument, NULL, 'b'},
341
  {"version", no_argument, NULL, 'V'},
342
  {"wide", no_argument, NULL, 'w'},
343
  {"prefix", required_argument, NULL, OPTION_PREFIX},
344
  {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
345
  {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
346
  {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
347
  {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
348
  {0, no_argument, 0, 0}
349
};
350
 
351
static void
352
nonfatal (const char *msg)
353
{
354
  bfd_nonfatal (msg);
355
  exit_status = 1;
356
}
357
 
358
/* Returns TRUE if the specified section should be dumped.  */
359
 
360
static bfd_boolean
361
process_section_p (asection * section)
362
{
363
  struct only * only;
364
 
365
  if (only_list == NULL)
366
    return TRUE;
367
 
368
  for (only = only_list; only; only = only->next)
369
    if (strcmp (only->name, section->name) == 0)
370
      {
371
        only->seen = TRUE;
372
        return TRUE;
373
      }
374
 
375
  return FALSE;
376
}
377
 
378
/* Add an entry to the 'only' list.  */
379
 
380
static void
381
add_only (char * name)
382
{
383
  struct only * only;
384
 
385
  /* First check to make sure that we do not
386
     already have an entry for this name.  */
387
  for (only = only_list; only; only = only->next)
388
    if (strcmp (only->name, name) == 0)
389
      return;
390
 
391
  only = xmalloc (sizeof * only);
392
  only->name = name;
393
  only->seen = FALSE;
394
  only->next = only_list;
395
  only_list = only;
396
}
397
 
398
/* Release the memory used by the 'only' list.
399
   PR 11225: Issue a warning message for unseen sections.
400
   Only do this if none of the sections were seen.  This is mainly to support
401
   tools like the GAS testsuite where an object file is dumped with a list of
402
   generic section names known to be present in a range of different file
403
   formats.  */
404
 
405
static void
406
free_only_list (void)
407
{
408
  bfd_boolean at_least_one_seen = FALSE;
409
  struct only * only;
410
  struct only * next;
411
 
412
  if (only_list == NULL)
413
    return;
414
 
415
  for (only = only_list; only; only = only->next)
416
    if (only->seen)
417
      {
418
        at_least_one_seen = TRUE;
419
        break;
420
      }
421
 
422
  for (only = only_list; only; only = next)
423
    {
424
      if (! at_least_one_seen)
425
        {
426
          non_fatal (_("section '%s' mentioned in a -j option, "
427
                       "but not found in any input file"),
428
                     only->name);
429
          exit_status = 1;
430
        }
431
      next = only->next;
432
      free (only);
433
    }
434
}
435
 
436
 
437
static void
438
dump_section_header (bfd *abfd, asection *section,
439
                     void *ignored ATTRIBUTE_UNUSED)
440
{
441
  char *comma = "";
442
  unsigned int opb = bfd_octets_per_byte (abfd);
443
 
444
  /* Ignore linker created section.  See elfNN_ia64_object_p in
445
     bfd/elfxx-ia64.c.  */
446
  if (section->flags & SEC_LINKER_CREATED)
447
    return;
448
 
449
  /* PR 10413: Skip sections that we are ignoring.  */
450
  if (! process_section_p (section))
451
    return;
452
 
453
  printf ("%3d %-13s %08lx  ", section->index,
454
          bfd_get_section_name (abfd, section),
455
          (unsigned long) bfd_section_size (abfd, section) / opb);
456
  bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
457
  printf ("  ");
458
  bfd_printf_vma (abfd, section->lma);
459
  printf ("  %08lx  2**%u", (unsigned long) section->filepos,
460
          bfd_get_section_alignment (abfd, section));
461
  if (! wide_output)
462
    printf ("\n                ");
463
  printf ("  ");
464
 
465
#define PF(x, y) \
466
  if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
467
 
468
  PF (SEC_HAS_CONTENTS, "CONTENTS");
469
  PF (SEC_ALLOC, "ALLOC");
470
  PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
471
  PF (SEC_LOAD, "LOAD");
472
  PF (SEC_RELOC, "RELOC");
473
  PF (SEC_READONLY, "READONLY");
474
  PF (SEC_CODE, "CODE");
475
  PF (SEC_DATA, "DATA");
476
  PF (SEC_ROM, "ROM");
477
  PF (SEC_DEBUGGING, "DEBUGGING");
478
  PF (SEC_NEVER_LOAD, "NEVER_LOAD");
479
  PF (SEC_EXCLUDE, "EXCLUDE");
480
  PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
481
  if (bfd_get_arch (abfd) == bfd_arch_tic54x)
482
    {
483
      PF (SEC_TIC54X_BLOCK, "BLOCK");
484
      PF (SEC_TIC54X_CLINK, "CLINK");
485
    }
486
  PF (SEC_SMALL_DATA, "SMALL_DATA");
487
  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
488
    PF (SEC_COFF_SHARED, "SHARED");
489
  PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
490
  PF (SEC_GROUP, "GROUP");
491
 
492
  if ((section->flags & SEC_LINK_ONCE) != 0)
493
    {
494
      const char *ls;
495
      struct coff_comdat_info *comdat;
496
 
497
      switch (section->flags & SEC_LINK_DUPLICATES)
498
        {
499
        default:
500
          abort ();
501
        case SEC_LINK_DUPLICATES_DISCARD:
502
          ls = "LINK_ONCE_DISCARD";
503
          break;
504
        case SEC_LINK_DUPLICATES_ONE_ONLY:
505
          ls = "LINK_ONCE_ONE_ONLY";
506
          break;
507
        case SEC_LINK_DUPLICATES_SAME_SIZE:
508
          ls = "LINK_ONCE_SAME_SIZE";
509
          break;
510
        case SEC_LINK_DUPLICATES_SAME_CONTENTS:
511
          ls = "LINK_ONCE_SAME_CONTENTS";
512
          break;
513
        }
514
      printf ("%s%s", comma, ls);
515
 
516
      comdat = bfd_coff_get_comdat_section (abfd, section);
517
      if (comdat != NULL)
518
        printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
519
 
520
      comma = ", ";
521
    }
522
 
523
  printf ("\n");
524
#undef PF
525
}
526
 
527
static void
528
dump_headers (bfd *abfd)
529
{
530
  printf (_("Sections:\n"));
531
 
532
#ifndef BFD64
533
  printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
534
#else
535
  /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
536
  if (bfd_get_arch_size (abfd) == 32)
537
    printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
538
  else
539
    printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
540
#endif
541
 
542
  if (wide_output)
543
    printf (_("  Flags"));
544
  printf ("\n");
545
 
546
  bfd_map_over_sections (abfd, dump_section_header, NULL);
547
}
548
 
549
static asymbol **
550
slurp_symtab (bfd *abfd)
551
{
552
  asymbol **sy = NULL;
553
  long storage;
554
 
555
  if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
556
    {
557
      symcount = 0;
558
      return NULL;
559
    }
560
 
561
  storage = bfd_get_symtab_upper_bound (abfd);
562
  if (storage < 0)
563
    bfd_fatal (bfd_get_filename (abfd));
564
  if (storage)
565
    sy = (asymbol **) xmalloc (storage);
566
 
567
  symcount = bfd_canonicalize_symtab (abfd, sy);
568
  if (symcount < 0)
569
    bfd_fatal (bfd_get_filename (abfd));
570
  return sy;
571
}
572
 
573
/* Read in the dynamic symbols.  */
574
 
575
static asymbol **
576
slurp_dynamic_symtab (bfd *abfd)
577
{
578
  asymbol **sy = NULL;
579
  long storage;
580
 
581
  storage = bfd_get_dynamic_symtab_upper_bound (abfd);
582
  if (storage < 0)
583
    {
584
      if (!(bfd_get_file_flags (abfd) & DYNAMIC))
585
        {
586
          non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
587
          exit_status = 1;
588
          dynsymcount = 0;
589
          return NULL;
590
        }
591
 
592
      bfd_fatal (bfd_get_filename (abfd));
593
    }
594
  if (storage)
595
    sy = (asymbol **) xmalloc (storage);
596
 
597
  dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
598
  if (dynsymcount < 0)
599
    bfd_fatal (bfd_get_filename (abfd));
600
  return sy;
601
}
602
 
603
/* Filter out (in place) symbols that are useless for disassembly.
604
   COUNT is the number of elements in SYMBOLS.
605
   Return the number of useful symbols.  */
606
 
607
static long
608
remove_useless_symbols (asymbol **symbols, long count)
609
{
610
  asymbol **in_ptr = symbols, **out_ptr = symbols;
611
 
612
  while (--count >= 0)
613
    {
614
      asymbol *sym = *in_ptr++;
615
 
616
      if (sym->name == NULL || sym->name[0] == '\0')
617
        continue;
618
      if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
619
        continue;
620
      if (bfd_is_und_section (sym->section)
621
          || bfd_is_com_section (sym->section))
622
        continue;
623
 
624
      *out_ptr++ = sym;
625
    }
626
  return out_ptr - symbols;
627
}
628
 
629
/* Sort symbols into value order.  */
630
 
631
static int
632
compare_symbols (const void *ap, const void *bp)
633
{
634
  const asymbol *a = * (const asymbol **) ap;
635
  const asymbol *b = * (const asymbol **) bp;
636
  const char *an;
637
  const char *bn;
638
  size_t anl;
639
  size_t bnl;
640
  bfd_boolean af;
641
  bfd_boolean bf;
642
  flagword aflags;
643
  flagword bflags;
644
 
645
  if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
646
    return 1;
647
  else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
648
    return -1;
649
 
650
  if (a->section > b->section)
651
    return 1;
652
  else if (a->section < b->section)
653
    return -1;
654
 
655
  an = bfd_asymbol_name (a);
656
  bn = bfd_asymbol_name (b);
657
  anl = strlen (an);
658
  bnl = strlen (bn);
659
 
660
  /* The symbols gnu_compiled and gcc2_compiled convey no real
661
     information, so put them after other symbols with the same value.  */
662
  af = (strstr (an, "gnu_compiled") != NULL
663
        || strstr (an, "gcc2_compiled") != NULL);
664
  bf = (strstr (bn, "gnu_compiled") != NULL
665
        || strstr (bn, "gcc2_compiled") != NULL);
666
 
667
  if (af && ! bf)
668
    return 1;
669
  if (! af && bf)
670
    return -1;
671
 
672
  /* We use a heuristic for the file name, to try to sort it after
673
     more useful symbols.  It may not work on non Unix systems, but it
674
     doesn't really matter; the only difference is precisely which
675
     symbol names get printed.  */
676
 
677
#define file_symbol(s, sn, snl)                 \
678
  (((s)->flags & BSF_FILE) != 0                  \
679
   || ((sn)[(snl) - 2] == '.'                   \
680
       && ((sn)[(snl) - 1] == 'o'               \
681
           || (sn)[(snl) - 1] == 'a')))
682
 
683
  af = file_symbol (a, an, anl);
684
  bf = file_symbol (b, bn, bnl);
685
 
686
  if (af && ! bf)
687
    return 1;
688
  if (! af && bf)
689
    return -1;
690
 
691
  /* Try to sort global symbols before local symbols before function
692
     symbols before debugging symbols.  */
693
 
694
  aflags = a->flags;
695
  bflags = b->flags;
696
 
697
  if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
698
    {
699
      if ((aflags & BSF_DEBUGGING) != 0)
700
        return 1;
701
      else
702
        return -1;
703
    }
704
  if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
705
    {
706
      if ((aflags & BSF_FUNCTION) != 0)
707
        return -1;
708
      else
709
        return 1;
710
    }
711
  if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
712
    {
713
      if ((aflags & BSF_LOCAL) != 0)
714
        return 1;
715
      else
716
        return -1;
717
    }
718
  if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
719
    {
720
      if ((aflags & BSF_GLOBAL) != 0)
721
        return -1;
722
      else
723
        return 1;
724
    }
725
 
726
  /* Symbols that start with '.' might be section names, so sort them
727
     after symbols that don't start with '.'.  */
728
  if (an[0] == '.' && bn[0] != '.')
729
    return 1;
730
  if (an[0] != '.' && bn[0] == '.')
731
    return -1;
732
 
733
  /* Finally, if we can't distinguish them in any other way, try to
734
     get consistent results by sorting the symbols by name.  */
735
  return strcmp (an, bn);
736
}
737
 
738
/* Sort relocs into address order.  */
739
 
740
static int
741
compare_relocs (const void *ap, const void *bp)
742
{
743
  const arelent *a = * (const arelent **) ap;
744
  const arelent *b = * (const arelent **) bp;
745
 
746
  if (a->address > b->address)
747
    return 1;
748
  else if (a->address < b->address)
749
    return -1;
750
 
751
  /* So that associated relocations tied to the same address show up
752
     in the correct order, we don't do any further sorting.  */
753
  if (a > b)
754
    return 1;
755
  else if (a < b)
756
    return -1;
757
  else
758
    return 0;
759
}
760
 
761
/* Print an address (VMA) to the output stream in INFO.
762
   If SKIP_ZEROES is TRUE, omit leading zeroes.  */
763
 
764
static void
765
objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
766
                     bfd_boolean skip_zeroes)
767
{
768
  char buf[30];
769
  char *p;
770
  struct objdump_disasm_info *aux;
771
 
772
  aux = (struct objdump_disasm_info *) inf->application_data;
773
  bfd_sprintf_vma (aux->abfd, buf, vma);
774
  if (! skip_zeroes)
775
    p = buf;
776
  else
777
    {
778
      for (p = buf; *p == '0'; ++p)
779
        ;
780
      if (*p == '\0')
781
        --p;
782
    }
783
  (*inf->fprintf_func) (inf->stream, "%s", p);
784
}
785
 
786
/* Print the name of a symbol.  */
787
 
788
static void
789
objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
790
                       asymbol *sym)
791
{
792
  char *alloc;
793
  const char *name;
794
 
795
  alloc = NULL;
796
  name = bfd_asymbol_name (sym);
797
  if (do_demangle && name[0] != '\0')
798
    {
799
      /* Demangle the name.  */
800
      alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
801
      if (alloc != NULL)
802
        name = alloc;
803
    }
804
 
805
  if (inf != NULL)
806
    (*inf->fprintf_func) (inf->stream, "%s", name);
807
  else
808
    printf ("%s", name);
809
 
810
  if (alloc != NULL)
811
    free (alloc);
812
}
813
 
814
/* Locate a symbol given a bfd and a section (from INFO->application_data),
815
   and a VMA.  If INFO->application_data->require_sec is TRUE, then always
816
   require the symbol to be in the section.  Returns NULL if there is no
817
   suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
818
   of the symbol in sorted_syms.  */
819
 
820
static asymbol *
821
find_symbol_for_address (bfd_vma vma,
822
                         struct disassemble_info *inf,
823
                         long *place)
824
{
825
  /* @@ Would it speed things up to cache the last two symbols returned,
826
     and maybe their address ranges?  For many processors, only one memory
827
     operand can be present at a time, so the 2-entry cache wouldn't be
828
     constantly churned by code doing heavy memory accesses.  */
829
 
830
  /* Indices in `sorted_syms'.  */
831
  long min = 0;
832
  long max_count = sorted_symcount;
833
  long thisplace;
834
  struct objdump_disasm_info *aux;
835
  bfd *abfd;
836
  asection *sec;
837
  unsigned int opb;
838
  bfd_boolean want_section;
839
 
840
  if (sorted_symcount < 1)
841
    return NULL;
842
 
843
  aux = (struct objdump_disasm_info *) inf->application_data;
844
  abfd = aux->abfd;
845
  sec = aux->sec;
846
  opb = inf->octets_per_byte;
847
 
848
  /* Perform a binary search looking for the closest symbol to the
849
     required value.  We are searching the range (min, max_count].  */
850
  while (min + 1 < max_count)
851
    {
852
      asymbol *sym;
853
 
854
      thisplace = (max_count + min) / 2;
855
      sym = sorted_syms[thisplace];
856
 
857
      if (bfd_asymbol_value (sym) > vma)
858
        max_count = thisplace;
859
      else if (bfd_asymbol_value (sym) < vma)
860
        min = thisplace;
861
      else
862
        {
863
          min = thisplace;
864
          break;
865
        }
866
    }
867
 
868
  /* The symbol we want is now in min, the low end of the range we
869
     were searching.  If there are several symbols with the same
870
     value, we want the first one.  */
871
  thisplace = min;
872
  while (thisplace > 0
873
         && (bfd_asymbol_value (sorted_syms[thisplace])
874
             == bfd_asymbol_value (sorted_syms[thisplace - 1])))
875
    --thisplace;
876
 
877
  /* Prefer a symbol in the current section if we have multple symbols
878
     with the same value, as can occur with overlays or zero size
879
     sections.  */
880
  min = thisplace;
881
  while (min < max_count
882
         && (bfd_asymbol_value (sorted_syms[min])
883
             == bfd_asymbol_value (sorted_syms[thisplace])))
884
    {
885
      if (sorted_syms[min]->section == sec
886
          && inf->symbol_is_valid (sorted_syms[min], inf))
887
        {
888
          thisplace = min;
889
 
890
          if (place != NULL)
891
            *place = thisplace;
892
 
893
          return sorted_syms[thisplace];
894
        }
895
      ++min;
896
    }
897
 
898
  /* If the file is relocatable, and the symbol could be from this
899
     section, prefer a symbol from this section over symbols from
900
     others, even if the other symbol's value might be closer.
901
 
902
     Note that this may be wrong for some symbol references if the
903
     sections have overlapping memory ranges, but in that case there's
904
     no way to tell what's desired without looking at the relocation
905
     table.
906
 
907
     Also give the target a chance to reject symbols.  */
908
  want_section = (aux->require_sec
909
                  || ((abfd->flags & HAS_RELOC) != 0
910
                      && vma >= bfd_get_section_vma (abfd, sec)
911
                      && vma < (bfd_get_section_vma (abfd, sec)
912
                                + bfd_section_size (abfd, sec) / opb)));
913
  if ((sorted_syms[thisplace]->section != sec && want_section)
914
      || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
915
    {
916
      long i;
917
      long newplace = sorted_symcount;
918
 
919
      for (i = min - 1; i >= 0; i--)
920
        {
921
          if ((sorted_syms[i]->section == sec || !want_section)
922
              && inf->symbol_is_valid (sorted_syms[i], inf))
923
            {
924
              if (newplace == sorted_symcount)
925
                newplace = i;
926
 
927
              if (bfd_asymbol_value (sorted_syms[i])
928
                  != bfd_asymbol_value (sorted_syms[newplace]))
929
                break;
930
 
931
              /* Remember this symbol and keep searching until we reach
932
                 an earlier address.  */
933
              newplace = i;
934
            }
935
        }
936
 
937
      if (newplace != sorted_symcount)
938
        thisplace = newplace;
939
      else
940
        {
941
          /* We didn't find a good symbol with a smaller value.
942
             Look for one with a larger value.  */
943
          for (i = thisplace + 1; i < sorted_symcount; i++)
944
            {
945
              if ((sorted_syms[i]->section == sec || !want_section)
946
                  && inf->symbol_is_valid (sorted_syms[i], inf))
947
                {
948
                  thisplace = i;
949
                  break;
950
                }
951
            }
952
        }
953
 
954
      if ((sorted_syms[thisplace]->section != sec && want_section)
955
          || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
956
        /* There is no suitable symbol.  */
957
        return NULL;
958
    }
959
 
960
  if (place != NULL)
961
    *place = thisplace;
962
 
963
  return sorted_syms[thisplace];
964
}
965
 
966
/* Print an address and the offset to the nearest symbol.  */
967
 
968
static void
969
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
970
                             bfd_vma vma, struct disassemble_info *inf,
971
                             bfd_boolean skip_zeroes)
972
{
973
  objdump_print_value (vma, inf, skip_zeroes);
974
 
975
  if (sym == NULL)
976
    {
977
      bfd_vma secaddr;
978
 
979
      (*inf->fprintf_func) (inf->stream, " <%s",
980
                            bfd_get_section_name (abfd, sec));
981
      secaddr = bfd_get_section_vma (abfd, sec);
982
      if (vma < secaddr)
983
        {
984
          (*inf->fprintf_func) (inf->stream, "-0x");
985
          objdump_print_value (secaddr - vma, inf, TRUE);
986
        }
987
      else if (vma > secaddr)
988
        {
989
          (*inf->fprintf_func) (inf->stream, "+0x");
990
          objdump_print_value (vma - secaddr, inf, TRUE);
991
        }
992
      (*inf->fprintf_func) (inf->stream, ">");
993
    }
994
  else
995
    {
996
      (*inf->fprintf_func) (inf->stream, " <");
997
      objdump_print_symname (abfd, inf, sym);
998
      if (bfd_asymbol_value (sym) > vma)
999
        {
1000
          (*inf->fprintf_func) (inf->stream, "-0x");
1001
          objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1002
        }
1003
      else if (vma > bfd_asymbol_value (sym))
1004
        {
1005
          (*inf->fprintf_func) (inf->stream, "+0x");
1006
          objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1007
        }
1008
      (*inf->fprintf_func) (inf->stream, ">");
1009
    }
1010
 
1011
  if (display_file_offsets)
1012
    inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1013
                        (long int)(sec->filepos + (vma - sec->vma)));
1014
}
1015
 
1016
/* Print an address (VMA), symbolically if possible.
1017
   If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
1018
 
1019
static void
1020
objdump_print_addr (bfd_vma vma,
1021
                    struct disassemble_info *inf,
1022
                    bfd_boolean skip_zeroes)
1023
{
1024
  struct objdump_disasm_info *aux;
1025
  asymbol *sym = NULL;
1026
  bfd_boolean skip_find = FALSE;
1027
 
1028
  aux = (struct objdump_disasm_info *) inf->application_data;
1029
 
1030
  if (sorted_symcount < 1)
1031
    {
1032
      (*inf->fprintf_func) (inf->stream, "0x");
1033
      objdump_print_value (vma, inf, skip_zeroes);
1034
 
1035
      if (display_file_offsets)
1036
        inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1037
                           (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1038
      return;
1039
    }
1040
 
1041
  if (aux->reloc != NULL
1042
      && aux->reloc->sym_ptr_ptr != NULL
1043
      && * aux->reloc->sym_ptr_ptr != NULL)
1044
    {
1045
      sym = * aux->reloc->sym_ptr_ptr;
1046
 
1047
      /* Adjust the vma to the reloc.  */
1048
      vma += bfd_asymbol_value (sym);
1049
 
1050
      if (bfd_is_und_section (bfd_get_section (sym)))
1051
        skip_find = TRUE;
1052
    }
1053
 
1054
  if (!skip_find)
1055
    sym = find_symbol_for_address (vma, inf, NULL);
1056
 
1057
  objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1058
                               skip_zeroes);
1059
}
1060
 
1061
/* Print VMA to INFO.  This function is passed to the disassembler
1062
   routine.  */
1063
 
1064
static void
1065
objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1066
{
1067
  objdump_print_addr (vma, inf, ! prefix_addresses);
1068
}
1069
 
1070
/* Determine if the given address has a symbol associated with it.  */
1071
 
1072
static int
1073
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1074
{
1075
  asymbol * sym;
1076
 
1077
  sym = find_symbol_for_address (vma, inf, NULL);
1078
 
1079
  return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1080
}
1081
 
1082
/* Hold the last function name and the last line number we displayed
1083
   in a disassembly.  */
1084
 
1085
static char *prev_functionname;
1086
static unsigned int prev_line;
1087
 
1088
/* We keep a list of all files that we have seen when doing a
1089
   disassembly with source, so that we know how much of the file to
1090
   display.  This can be important for inlined functions.  */
1091
 
1092
struct print_file_list
1093
{
1094
  struct print_file_list *next;
1095
  const char *filename;
1096
  const char *modname;
1097
  const char *map;
1098
  size_t mapsize;
1099
  const char **linemap;
1100
  unsigned maxline;
1101
  unsigned last_line;
1102
  int first;
1103
};
1104
 
1105
static struct print_file_list *print_files;
1106
 
1107
/* The number of preceding context lines to show when we start
1108
   displaying a file for the first time.  */
1109
 
1110
#define SHOW_PRECEDING_CONTEXT_LINES (5)
1111
 
1112
/* Read a complete file into memory.  */
1113
 
1114
static const char *
1115
slurp_file (const char *fn, size_t *size)
1116
{
1117
#ifdef HAVE_MMAP
1118
  int ps = getpagesize ();
1119
  size_t msize;
1120
#endif
1121
  const char *map;
1122
  struct stat st;
1123
  int fd = open (fn, O_RDONLY | O_BINARY);
1124
 
1125
  if (fd < 0)
1126
    return NULL;
1127
  if (fstat (fd, &st) < 0)
1128
    return NULL;
1129
  *size = st.st_size;
1130
#ifdef HAVE_MMAP
1131
  msize = (*size + ps - 1) & ~(ps - 1);
1132
  map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1133
  if (map != (char *)-1L)
1134
    {
1135
      close(fd);
1136
      return map;
1137
    }
1138
#endif
1139
  map = (const char *) malloc (*size);
1140
  if (!map || (size_t) read (fd, (char *)map, *size) != *size)
1141
    {
1142
      free ((void *)map);
1143
      map = NULL;
1144
    }
1145
  close (fd);
1146
  return map;
1147
}
1148
 
1149
#define line_map_decrease 5
1150
 
1151
/* Precompute array of lines for a mapped file. */
1152
 
1153
static const char **
1154
index_file (const char *map, size_t size, unsigned int *maxline)
1155
{
1156
  const char *p, *lstart, *end;
1157
  int chars_per_line = 45; /* First iteration will use 40.  */
1158
  unsigned int lineno;
1159
  const char **linemap = NULL;
1160
  unsigned long line_map_size = 0;
1161
 
1162
  lineno = 0;
1163
  lstart = map;
1164
  end = map + size;
1165
 
1166
  for (p = map; p < end; p++)
1167
    {
1168
      if (*p == '\n')
1169
        {
1170
          if (p + 1 < end && p[1] == '\r')
1171
            p++;
1172
        }
1173
      else if (*p == '\r')
1174
        {
1175
          if (p + 1 < end && p[1] == '\n')
1176
            p++;
1177
        }
1178
      else
1179
        continue;
1180
 
1181
      /* End of line found.  */
1182
 
1183
      if (linemap == NULL || line_map_size < lineno + 1)
1184
        {
1185
          unsigned long newsize;
1186
 
1187
          chars_per_line -= line_map_decrease;
1188
          if (chars_per_line <= 1)
1189
            chars_per_line = 1;
1190
          line_map_size = size / chars_per_line + 1;
1191
          if (line_map_size < lineno + 1)
1192
            line_map_size = lineno + 1;
1193
          newsize = line_map_size * sizeof (char *);
1194
          linemap = (const char **) xrealloc (linemap, newsize);
1195
        }
1196
 
1197
      linemap[lineno++] = lstart;
1198
      lstart = p + 1;
1199
    }
1200
 
1201
  *maxline = lineno;
1202
  return linemap;
1203
}
1204
 
1205
/* Tries to open MODNAME, and if successful adds a node to print_files
1206
   linked list and returns that node.  Returns NULL on failure.  */
1207
 
1208
static struct print_file_list *
1209
try_print_file_open (const char *origname, const char *modname)
1210
{
1211
  struct print_file_list *p;
1212
 
1213
  p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1214
 
1215
  p->map = slurp_file (modname, &p->mapsize);
1216
  if (p->map == NULL)
1217
    {
1218
      free (p);
1219
      return NULL;
1220
    }
1221
 
1222
  p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1223
  p->last_line = 0;
1224
  p->filename = origname;
1225
  p->modname = modname;
1226
  p->next = print_files;
1227
  p->first = 1;
1228
  print_files = p;
1229
  return p;
1230
}
1231
 
1232
/* If the the source file, as described in the symtab, is not found
1233
   try to locate it in one of the paths specified with -I
1234
   If found, add location to print_files linked list.  */
1235
 
1236
static struct print_file_list *
1237
update_source_path (const char *filename)
1238
{
1239
  struct print_file_list *p;
1240
  const char *fname;
1241
  int i;
1242
 
1243
  p = try_print_file_open (filename, filename);
1244
  if (p != NULL)
1245
    return p;
1246
 
1247
  if (include_path_count == 0)
1248
    return NULL;
1249
 
1250
  /* Get the name of the file.  */
1251
  fname = lbasename (filename);
1252
 
1253
  /* If file exists under a new path, we need to add it to the list
1254
     so that show_line knows about it.  */
1255
  for (i = 0; i < include_path_count; i++)
1256
    {
1257
      char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1258
 
1259
      p = try_print_file_open (filename, modname);
1260
      if (p)
1261
        return p;
1262
 
1263
      free (modname);
1264
    }
1265
 
1266
  return NULL;
1267
}
1268
 
1269
/* Print a source file line.  */
1270
 
1271
static void
1272
print_line (struct print_file_list *p, unsigned int linenum)
1273
{
1274
  const char *l;
1275
  size_t len;
1276
 
1277
  --linenum;
1278
  if (linenum >= p->maxline)
1279
    return;
1280
  l = p->linemap [linenum];
1281
  /* Test fwrite return value to quiet glibc warning.  */
1282
  len = strcspn (l, "\n\r");
1283
  if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1284
    putchar ('\n');
1285
}
1286
 
1287
/* Print a range of source code lines. */
1288
 
1289
static void
1290
dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1291
{
1292
  if (p->map == NULL)
1293
    return;
1294
  while (start <= end)
1295
    {
1296
      print_line (p, start);
1297
      start++;
1298
    }
1299
}
1300
 
1301
/* Show the line number, or the source line, in a disassembly
1302
   listing.  */
1303
 
1304
static void
1305
show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1306
{
1307
  const char *filename;
1308
  const char *functionname;
1309
  unsigned int linenumber;
1310
  bfd_boolean reloc;
1311
 
1312
  if (! with_line_numbers && ! with_source_code)
1313
    return;
1314
 
1315
  if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1316
                               &functionname, &linenumber))
1317
    return;
1318
 
1319
  if (filename != NULL && *filename == '\0')
1320
    filename = NULL;
1321
  if (functionname != NULL && *functionname == '\0')
1322
    functionname = NULL;
1323
 
1324
  if (filename
1325
      && IS_ABSOLUTE_PATH (filename)
1326
      && prefix)
1327
    {
1328
      char *path_up;
1329
      const char *fname = filename;
1330
      char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1331
 
1332
      if (prefix_length)
1333
        memcpy (path, prefix, prefix_length);
1334
      path_up = path + prefix_length;
1335
 
1336
      /* Build relocated filename, stripping off leading directories
1337
         from the initial filename if requested. */
1338
      if (prefix_strip > 0)
1339
        {
1340
          int level = 0;
1341
          const char *s;
1342
 
1343
          /* Skip selected directory levels. */
1344
          for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1345
            if (IS_DIR_SEPARATOR(*s))
1346
              {
1347
                fname = s;
1348
                level++;
1349
              }
1350
        }
1351
 
1352
      /* Update complete filename. */
1353
      strncpy (path_up, fname, PATH_MAX);
1354
      path_up[PATH_MAX] = '\0';
1355
 
1356
      filename = path;
1357
      reloc = TRUE;
1358
    }
1359
  else
1360
    reloc = FALSE;
1361
 
1362
  if (with_line_numbers)
1363
    {
1364
      if (functionname != NULL
1365
          && (prev_functionname == NULL
1366
              || strcmp (functionname, prev_functionname) != 0))
1367
        printf ("%s():\n", functionname);
1368
      if (linenumber > 0 && linenumber != prev_line)
1369
        printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1370
    }
1371
 
1372
  if (with_source_code
1373
      && filename != NULL
1374
      && linenumber > 0)
1375
    {
1376
      struct print_file_list **pp, *p;
1377
      unsigned l;
1378
 
1379
      for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1380
        if (filename_cmp ((*pp)->filename, filename) == 0)
1381
          break;
1382
      p = *pp;
1383
 
1384
      if (p == NULL)
1385
        {
1386
          if (reloc)
1387
            filename = xstrdup (filename);
1388
          p = update_source_path (filename);
1389
        }
1390
 
1391
      if (p != NULL && linenumber != p->last_line)
1392
        {
1393
          if (file_start_context && p->first)
1394
            l = 1;
1395
          else
1396
            {
1397
              l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1398
              if (l >= linenumber)
1399
                l = 1;
1400
              if (p->last_line >= l && p->last_line <= linenumber)
1401
                l = p->last_line + 1;
1402
            }
1403
          dump_lines (p, l, linenumber);
1404
          p->last_line = linenumber;
1405
          p->first = 0;
1406
        }
1407
    }
1408
 
1409
  if (functionname != NULL
1410
      && (prev_functionname == NULL
1411
          || strcmp (functionname, prev_functionname) != 0))
1412
    {
1413
      if (prev_functionname != NULL)
1414
        free (prev_functionname);
1415
      prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1416
      strcpy (prev_functionname, functionname);
1417
    }
1418
 
1419
  if (linenumber > 0 && linenumber != prev_line)
1420
    prev_line = linenumber;
1421
}
1422
 
1423
/* Pseudo FILE object for strings.  */
1424
typedef struct
1425
{
1426
  char *buffer;
1427
  size_t pos;
1428
  size_t alloc;
1429
} SFILE;
1430
 
1431
/* sprintf to a "stream".  */
1432
 
1433
static int ATTRIBUTE_PRINTF_2
1434
objdump_sprintf (SFILE *f, const char *format, ...)
1435
{
1436
  size_t n;
1437
  va_list args;
1438
 
1439
  while (1)
1440
    {
1441
      size_t space = f->alloc - f->pos;
1442
 
1443
      va_start (args, format);
1444
      n = vsnprintf (f->buffer + f->pos, space, format, args);
1445
      va_end (args);
1446
 
1447
      if (space > n)
1448
        break;
1449
 
1450
      f->alloc = (f->alloc + n) * 2;
1451
      f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1452
    }
1453
  f->pos += n;
1454
 
1455
  return n;
1456
}
1457
 
1458
/* The number of zeroes we want to see before we start skipping them.
1459
   The number is arbitrarily chosen.  */
1460
 
1461
#define DEFAULT_SKIP_ZEROES 8
1462
 
1463
/* The number of zeroes to skip at the end of a section.  If the
1464
   number of zeroes at the end is between SKIP_ZEROES_AT_END and
1465
   SKIP_ZEROES, they will be disassembled.  If there are fewer than
1466
   SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1467
   attempt to avoid disassembling zeroes inserted by section
1468
   alignment.  */
1469
 
1470
#define DEFAULT_SKIP_ZEROES_AT_END 3
1471
 
1472
/* Disassemble some data in memory between given values.  */
1473
 
1474
static void
1475
disassemble_bytes (struct disassemble_info * inf,
1476
                   disassembler_ftype        disassemble_fn,
1477
                   bfd_boolean               insns,
1478
                   bfd_byte *                data,
1479
                   bfd_vma                   start_offset,
1480
                   bfd_vma                   stop_offset,
1481
                   bfd_vma                   rel_offset,
1482
                   arelent ***               relppp,
1483
                   arelent **                relppend)
1484
{
1485
  struct objdump_disasm_info *aux;
1486
  asection *section;
1487
  int octets_per_line;
1488
  int skip_addr_chars;
1489
  bfd_vma addr_offset;
1490
  unsigned int opb = inf->octets_per_byte;
1491
  unsigned int skip_zeroes = inf->skip_zeroes;
1492
  unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1493
  int octets = opb;
1494
  SFILE sfile;
1495
 
1496
  aux = (struct objdump_disasm_info *) inf->application_data;
1497
  section = aux->sec;
1498
 
1499
  sfile.alloc = 120;
1500
  sfile.buffer = (char *) xmalloc (sfile.alloc);
1501
  sfile.pos = 0;
1502
 
1503
  if (insn_width)
1504
    octets_per_line = insn_width;
1505
  else if (insns)
1506
    octets_per_line = 4;
1507
  else
1508
    octets_per_line = 16;
1509
 
1510
  /* Figure out how many characters to skip at the start of an
1511
     address, to make the disassembly look nicer.  We discard leading
1512
     zeroes in chunks of 4, ensuring that there is always a leading
1513
     zero remaining.  */
1514
  skip_addr_chars = 0;
1515
  if (! prefix_addresses)
1516
    {
1517
      char buf[30];
1518
 
1519
      bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1520
 
1521
      while (buf[skip_addr_chars] == '0')
1522
        ++skip_addr_chars;
1523
 
1524
      /* Don't discard zeros on overflow.  */
1525
      if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1526
        skip_addr_chars = 0;
1527
 
1528
      if (skip_addr_chars != 0)
1529
        skip_addr_chars = (skip_addr_chars - 1) & -4;
1530
    }
1531
 
1532
  inf->insn_info_valid = 0;
1533
 
1534
  addr_offset = start_offset;
1535
  while (addr_offset < stop_offset)
1536
    {
1537
      bfd_vma z;
1538
      bfd_boolean need_nl = FALSE;
1539
      int previous_octets;
1540
 
1541
      /* Remember the length of the previous instruction.  */
1542
      previous_octets = octets;
1543
      octets = 0;
1544
 
1545
      /* Make sure we don't use relocs from previous instructions.  */
1546
      aux->reloc = NULL;
1547
 
1548
      /* If we see more than SKIP_ZEROES octets of zeroes, we just
1549
         print `...'.  */
1550
      for (z = addr_offset * opb; z < stop_offset * opb; z++)
1551
        if (data[z] != 0)
1552
          break;
1553
      if (! disassemble_zeroes
1554
          && (inf->insn_info_valid == 0
1555
              || inf->branch_delay_insns == 0)
1556
          && (z - addr_offset * opb >= skip_zeroes
1557
              || (z == stop_offset * opb &&
1558
                  z - addr_offset * opb < skip_zeroes_at_end)))
1559
        {
1560
          /* If there are more nonzero octets to follow, we only skip
1561
             zeroes in multiples of 4, to try to avoid running over
1562
             the start of an instruction which happens to start with
1563
             zero.  */
1564
          if (z != stop_offset * opb)
1565
            z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1566
 
1567
          octets = z - addr_offset * opb;
1568
 
1569
          /* If we are going to display more data, and we are displaying
1570
             file offsets, then tell the user how many zeroes we skip
1571
             and the file offset from where we resume dumping.  */
1572
          if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1573
            printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1574
                    octets / opb,
1575
                    (unsigned long) (section->filepos
1576
                                     + (addr_offset + (octets / opb))));
1577
          else
1578
            printf ("\t...\n");
1579
        }
1580
      else
1581
        {
1582
          char buf[50];
1583
          int bpc = 0;
1584
          int pb = 0;
1585
 
1586
          if (with_line_numbers || with_source_code)
1587
            show_line (aux->abfd, section, addr_offset);
1588
 
1589
          if (! prefix_addresses)
1590
            {
1591
              char *s;
1592
 
1593
              bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1594
              for (s = buf + skip_addr_chars; *s == '0'; s++)
1595
                *s = ' ';
1596
              if (*s == '\0')
1597
                *--s = '0';
1598
              printf ("%s:\t", buf + skip_addr_chars);
1599
            }
1600
          else
1601
            {
1602
              aux->require_sec = TRUE;
1603
              objdump_print_address (section->vma + addr_offset, inf);
1604
              aux->require_sec = FALSE;
1605
              putchar (' ');
1606
            }
1607
 
1608
          if (insns)
1609
            {
1610
              sfile.pos = 0;
1611
              inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1612
              inf->stream = &sfile;
1613
              inf->bytes_per_line = 0;
1614
              inf->bytes_per_chunk = 0;
1615
              inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1616
              if (machine)
1617
                inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1618
 
1619
              if (inf->disassembler_needs_relocs
1620
                  && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1621
                  && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1622
                  && *relppp < relppend)
1623
                {
1624
                  bfd_signed_vma distance_to_rel;
1625
 
1626
                  distance_to_rel = (**relppp)->address
1627
                    - (rel_offset + addr_offset);
1628
 
1629
                  /* Check to see if the current reloc is associated with
1630
                     the instruction that we are about to disassemble.  */
1631
                  if (distance_to_rel == 0
1632
                      /* FIXME: This is wrong.  We are trying to catch
1633
                         relocs that are addressed part way through the
1634
                         current instruction, as might happen with a packed
1635
                         VLIW instruction.  Unfortunately we do not know the
1636
                         length of the current instruction since we have not
1637
                         disassembled it yet.  Instead we take a guess based
1638
                         upon the length of the previous instruction.  The
1639
                         proper solution is to have a new target-specific
1640
                         disassembler function which just returns the length
1641
                         of an instruction at a given address without trying
1642
                         to display its disassembly. */
1643
                      || (distance_to_rel > 0
1644
                          && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1645
                    {
1646
                      inf->flags |= INSN_HAS_RELOC;
1647
                      aux->reloc = **relppp;
1648
                    }
1649
                }
1650
 
1651
              octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1652
              inf->fprintf_func = (fprintf_ftype) fprintf;
1653
              inf->stream = stdout;
1654
              if (insn_width == 0 && inf->bytes_per_line != 0)
1655
                octets_per_line = inf->bytes_per_line;
1656
              if (octets < (int) opb)
1657
                {
1658
                  if (sfile.pos)
1659
                    printf ("%s\n", sfile.buffer);
1660
                  if (octets >= 0)
1661
                    {
1662
                      non_fatal (_("disassemble_fn returned length %d"),
1663
                                 octets);
1664
                      exit_status = 1;
1665
                    }
1666
                  break;
1667
                }
1668
            }
1669
          else
1670
            {
1671
              bfd_vma j;
1672
 
1673
              octets = octets_per_line;
1674
              if (addr_offset + octets / opb > stop_offset)
1675
                octets = (stop_offset - addr_offset) * opb;
1676
 
1677
              for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1678
                {
1679
                  if (ISPRINT (data[j]))
1680
                    buf[j - addr_offset * opb] = data[j];
1681
                  else
1682
                    buf[j - addr_offset * opb] = '.';
1683
                }
1684
              buf[j - addr_offset * opb] = '\0';
1685
            }
1686
 
1687
          if (prefix_addresses
1688
              ? show_raw_insn > 0
1689
              : show_raw_insn >= 0)
1690
            {
1691
              bfd_vma j;
1692
 
1693
              /* If ! prefix_addresses and ! wide_output, we print
1694
                 octets_per_line octets per line.  */
1695
              pb = octets;
1696
              if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1697
                pb = octets_per_line;
1698
 
1699
              if (inf->bytes_per_chunk)
1700
                bpc = inf->bytes_per_chunk;
1701
              else
1702
                bpc = 1;
1703
 
1704
              for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1705
                {
1706
                  int k;
1707
 
1708
                  if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1709
                    {
1710
                      for (k = bpc - 1; k >= 0; k--)
1711
                        printf ("%02x", (unsigned) data[j + k]);
1712
                      putchar (' ');
1713
                    }
1714
                  else
1715
                    {
1716
                      for (k = 0; k < bpc; k++)
1717
                        printf ("%02x", (unsigned) data[j + k]);
1718
                      putchar (' ');
1719
                    }
1720
                }
1721
 
1722
              for (; pb < octets_per_line; pb += bpc)
1723
                {
1724
                  int k;
1725
 
1726
                  for (k = 0; k < bpc; k++)
1727
                    printf ("  ");
1728
                  putchar (' ');
1729
                }
1730
 
1731
              /* Separate raw data from instruction by extra space.  */
1732
              if (insns)
1733
                putchar ('\t');
1734
              else
1735
                printf ("    ");
1736
            }
1737
 
1738
          if (! insns)
1739
            printf ("%s", buf);
1740
          else if (sfile.pos)
1741
            printf ("%s", sfile.buffer);
1742
 
1743
          if (prefix_addresses
1744
              ? show_raw_insn > 0
1745
              : show_raw_insn >= 0)
1746
            {
1747
              while (pb < octets)
1748
                {
1749
                  bfd_vma j;
1750
                  char *s;
1751
 
1752
                  putchar ('\n');
1753
                  j = addr_offset * opb + pb;
1754
 
1755
                  bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1756
                  for (s = buf + skip_addr_chars; *s == '0'; s++)
1757
                    *s = ' ';
1758
                  if (*s == '\0')
1759
                    *--s = '0';
1760
                  printf ("%s:\t", buf + skip_addr_chars);
1761
 
1762
                  pb += octets_per_line;
1763
                  if (pb > octets)
1764
                    pb = octets;
1765
                  for (; j < addr_offset * opb + pb; j += bpc)
1766
                    {
1767
                      int k;
1768
 
1769
                      if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1770
                        {
1771
                          for (k = bpc - 1; k >= 0; k--)
1772
                            printf ("%02x", (unsigned) data[j + k]);
1773
                          putchar (' ');
1774
                        }
1775
                      else
1776
                        {
1777
                          for (k = 0; k < bpc; k++)
1778
                            printf ("%02x", (unsigned) data[j + k]);
1779
                          putchar (' ');
1780
                        }
1781
                    }
1782
                }
1783
            }
1784
 
1785
          if (!wide_output)
1786
            putchar ('\n');
1787
          else
1788
            need_nl = TRUE;
1789
        }
1790
 
1791
      while ((*relppp) < relppend
1792
             && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1793
        {
1794
          if (dump_reloc_info || dump_dynamic_reloc_info)
1795
            {
1796
              arelent *q;
1797
 
1798
              q = **relppp;
1799
 
1800
              if (wide_output)
1801
                putchar ('\t');
1802
              else
1803
                printf ("\t\t\t");
1804
 
1805
              objdump_print_value (section->vma - rel_offset + q->address,
1806
                                   inf, TRUE);
1807
 
1808
              if (q->howto == NULL)
1809
                printf (": *unknown*\t");
1810
              else if (q->howto->name)
1811
                printf (": %s\t", q->howto->name);
1812
              else
1813
                printf (": %d\t", q->howto->type);
1814
 
1815
              if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1816
                printf ("*unknown*");
1817
              else
1818
                {
1819
                  const char *sym_name;
1820
 
1821
                  sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1822
                  if (sym_name != NULL && *sym_name != '\0')
1823
                    objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1824
                  else
1825
                    {
1826
                      asection *sym_sec;
1827
 
1828
                      sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1829
                      sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1830
                      if (sym_name == NULL || *sym_name == '\0')
1831
                        sym_name = "*unknown*";
1832
                      printf ("%s", sym_name);
1833
                    }
1834
                }
1835
 
1836
              if (q->addend)
1837
                {
1838
                  printf ("+0x");
1839
                  objdump_print_value (q->addend, inf, TRUE);
1840
                }
1841
 
1842
              printf ("\n");
1843
              need_nl = FALSE;
1844
            }
1845
          ++(*relppp);
1846
        }
1847
 
1848
      if (need_nl)
1849
        printf ("\n");
1850
 
1851
      addr_offset += octets / opb;
1852
    }
1853
 
1854
  free (sfile.buffer);
1855
}
1856
 
1857
static void
1858
disassemble_section (bfd *abfd, asection *section, void *inf)
1859
{
1860
  const struct elf_backend_data * bed;
1861
  bfd_vma                      sign_adjust = 0;
1862
  struct disassemble_info *    pinfo = (struct disassemble_info *) inf;
1863
  struct objdump_disasm_info * paux;
1864
  unsigned int                 opb = pinfo->octets_per_byte;
1865
  bfd_byte *                   data = NULL;
1866
  bfd_size_type                datasize = 0;
1867
  arelent **                   rel_pp = NULL;
1868
  arelent **                   rel_ppstart = NULL;
1869
  arelent **                   rel_ppend;
1870
  unsigned long                stop_offset;
1871
  asymbol *                    sym = NULL;
1872
  long                         place = 0;
1873
  long                         rel_count;
1874
  bfd_vma                      rel_offset;
1875
  unsigned long                addr_offset;
1876
 
1877
  /* Sections that do not contain machine
1878
     code are not normally disassembled.  */
1879
  if (! disassemble_all
1880
      && only_list == NULL
1881
      && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1882
          != (SEC_CODE | SEC_HAS_CONTENTS)))
1883
    return;
1884
 
1885
  if (! process_section_p (section))
1886
    return;
1887
 
1888
  datasize = bfd_get_section_size (section);
1889
  if (datasize == 0)
1890
    return;
1891
 
1892
  /* Decide which set of relocs to use.  Load them if necessary.  */
1893
  paux = (struct objdump_disasm_info *) pinfo->application_data;
1894
  if (paux->dynrelbuf)
1895
    {
1896
      rel_pp = paux->dynrelbuf;
1897
      rel_count = paux->dynrelcount;
1898
      /* Dynamic reloc addresses are absolute, non-dynamic are section
1899
         relative.  REL_OFFSET specifies the reloc address corresponding
1900
         to the start of this section.  */
1901
      rel_offset = section->vma;
1902
    }
1903
  else
1904
    {
1905
      rel_count = 0;
1906
      rel_pp = NULL;
1907
      rel_offset = 0;
1908
 
1909
      if ((section->flags & SEC_RELOC) != 0
1910
          && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1911
        {
1912
          long relsize;
1913
 
1914
          relsize = bfd_get_reloc_upper_bound (abfd, section);
1915
          if (relsize < 0)
1916
            bfd_fatal (bfd_get_filename (abfd));
1917
 
1918
          if (relsize > 0)
1919
            {
1920
              rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1921
              rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1922
              if (rel_count < 0)
1923
                bfd_fatal (bfd_get_filename (abfd));
1924
 
1925
              /* Sort the relocs by address.  */
1926
              qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1927
            }
1928
        }
1929
    }
1930
  rel_ppend = rel_pp + rel_count;
1931
 
1932
  data = (bfd_byte *) xmalloc (datasize);
1933
 
1934
  bfd_get_section_contents (abfd, section, data, 0, datasize);
1935
 
1936
  paux->sec = section;
1937
  pinfo->buffer = data;
1938
  pinfo->buffer_vma = section->vma;
1939
  pinfo->buffer_length = datasize;
1940
  pinfo->section = section;
1941
 
1942
  if (start_address == (bfd_vma) -1
1943
      || start_address < pinfo->buffer_vma)
1944
    addr_offset = 0;
1945
  else
1946
    addr_offset = start_address - pinfo->buffer_vma;
1947
 
1948
  if (stop_address == (bfd_vma) -1)
1949
    stop_offset = datasize / opb;
1950
  else
1951
    {
1952
      if (stop_address < pinfo->buffer_vma)
1953
        stop_offset = 0;
1954
      else
1955
        stop_offset = stop_address - pinfo->buffer_vma;
1956
      if (stop_offset > pinfo->buffer_length / opb)
1957
        stop_offset = pinfo->buffer_length / opb;
1958
    }
1959
 
1960
  /* Skip over the relocs belonging to addresses below the
1961
     start address.  */
1962
  while (rel_pp < rel_ppend
1963
         && (*rel_pp)->address < rel_offset + addr_offset)
1964
    ++rel_pp;
1965
 
1966
  if (addr_offset < stop_offset)
1967
    printf (_("\nDisassembly of section %s:\n"), section->name);
1968
 
1969
  /* Find the nearest symbol forwards from our current position.  */
1970
  paux->require_sec = TRUE;
1971
  sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
1972
                                             (struct disassemble_info *) inf,
1973
                                             &place);
1974
  paux->require_sec = FALSE;
1975
 
1976
  /* PR 9774: If the target used signed addresses then we must make
1977
     sure that we sign extend the value that we calculate for 'addr'
1978
     in the loop below.  */
1979
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1980
      && (bed = get_elf_backend_data (abfd)) != NULL
1981
      && bed->sign_extend_vma)
1982
    sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
1983
 
1984
  /* Disassemble a block of instructions up to the address associated with
1985
     the symbol we have just found.  Then print the symbol and find the
1986
     next symbol on.  Repeat until we have disassembled the entire section
1987
     or we have reached the end of the address range we are interested in.  */
1988
  while (addr_offset < stop_offset)
1989
    {
1990
      bfd_vma addr;
1991
      asymbol *nextsym;
1992
      unsigned long nextstop_offset;
1993
      bfd_boolean insns;
1994
 
1995
      addr = section->vma + addr_offset;
1996
      addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
1997
 
1998
      if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1999
        {
2000
          int x;
2001
 
2002
          for (x = place;
2003
               (x < sorted_symcount
2004
                && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2005
               ++x)
2006
            continue;
2007
 
2008
          pinfo->symbols = sorted_syms + place;
2009
          pinfo->num_symbols = x - place;
2010
          pinfo->symtab_pos = place;
2011
        }
2012
      else
2013
        {
2014
          pinfo->symbols = NULL;
2015
          pinfo->num_symbols = 0;
2016
          pinfo->symtab_pos = -1;
2017
        }
2018
 
2019
      if (! prefix_addresses)
2020
        {
2021
          pinfo->fprintf_func (pinfo->stream, "\n");
2022
          objdump_print_addr_with_sym (abfd, section, sym, addr,
2023
                                       pinfo, FALSE);
2024
          pinfo->fprintf_func (pinfo->stream, ":\n");
2025
        }
2026
 
2027
      if (sym != NULL && bfd_asymbol_value (sym) > addr)
2028
        nextsym = sym;
2029
      else if (sym == NULL)
2030
        nextsym = NULL;
2031
      else
2032
        {
2033
#define is_valid_next_sym(SYM) \
2034
  ((SYM)->section == section \
2035
   && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2036
   && pinfo->symbol_is_valid (SYM, pinfo))
2037
 
2038
          /* Search forward for the next appropriate symbol in
2039
             SECTION.  Note that all the symbols are sorted
2040
             together into one big array, and that some sections
2041
             may have overlapping addresses.  */
2042
          while (place < sorted_symcount
2043
                 && ! is_valid_next_sym (sorted_syms [place]))
2044
            ++place;
2045
 
2046
          if (place >= sorted_symcount)
2047
            nextsym = NULL;
2048
          else
2049
            nextsym = sorted_syms[place];
2050
        }
2051
 
2052
      if (sym != NULL && bfd_asymbol_value (sym) > addr)
2053
        nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2054
      else if (nextsym == NULL)
2055
        nextstop_offset = stop_offset;
2056
      else
2057
        nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2058
 
2059
      if (nextstop_offset > stop_offset
2060
          || nextstop_offset <= addr_offset)
2061
        nextstop_offset = stop_offset;
2062
 
2063
      /* If a symbol is explicitly marked as being an object
2064
         rather than a function, just dump the bytes without
2065
         disassembling them.  */
2066
      if (disassemble_all
2067
          || sym == NULL
2068
          || sym->section != section
2069
          || bfd_asymbol_value (sym) > addr
2070
          || ((sym->flags & BSF_OBJECT) == 0
2071
              && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2072
                  == NULL)
2073
              && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2074
                  == NULL))
2075
          || (sym->flags & BSF_FUNCTION) != 0)
2076
        insns = TRUE;
2077
      else
2078
        insns = FALSE;
2079
 
2080
      disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2081
                         addr_offset, nextstop_offset,
2082
                         rel_offset, &rel_pp, rel_ppend);
2083
 
2084
      addr_offset = nextstop_offset;
2085
      sym = nextsym;
2086
    }
2087
 
2088
  free (data);
2089
 
2090
  if (rel_ppstart != NULL)
2091
    free (rel_ppstart);
2092
}
2093
 
2094
/* Disassemble the contents of an object file.  */
2095
 
2096
static void
2097
disassemble_data (bfd *abfd)
2098
{
2099
  struct disassemble_info disasm_info;
2100
  struct objdump_disasm_info aux;
2101
  long i;
2102
 
2103
  print_files = NULL;
2104
  prev_functionname = NULL;
2105
  prev_line = -1;
2106
 
2107
  /* We make a copy of syms to sort.  We don't want to sort syms
2108
     because that will screw up the relocs.  */
2109
  sorted_symcount = symcount ? symcount : dynsymcount;
2110
  sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2111
                                      * sizeof (asymbol *));
2112
  memcpy (sorted_syms, symcount ? syms : dynsyms,
2113
          sorted_symcount * sizeof (asymbol *));
2114
 
2115
  sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2116
 
2117
  for (i = 0; i < synthcount; ++i)
2118
    {
2119
      sorted_syms[sorted_symcount] = synthsyms + i;
2120
      ++sorted_symcount;
2121
    }
2122
 
2123
  /* Sort the symbols into section and symbol order.  */
2124
  qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2125
 
2126
  init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2127
 
2128
  disasm_info.application_data = (void *) &aux;
2129
  aux.abfd = abfd;
2130
  aux.require_sec = FALSE;
2131
  aux.dynrelbuf = NULL;
2132
  aux.dynrelcount = 0;
2133
  aux.reloc = NULL;
2134
 
2135
  disasm_info.print_address_func = objdump_print_address;
2136
  disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2137
 
2138
  if (machine != NULL)
2139
    {
2140
      const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2141
 
2142
      if (inf == NULL)
2143
        fatal (_("can't use supplied machine %s"), machine);
2144
 
2145
      abfd->arch_info = inf;
2146
    }
2147
 
2148
  if (endian != BFD_ENDIAN_UNKNOWN)
2149
    {
2150
      struct bfd_target *xvec;
2151
 
2152
      xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2153
      memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2154
      xvec->byteorder = endian;
2155
      abfd->xvec = xvec;
2156
    }
2157
 
2158
  /* Use libopcodes to locate a suitable disassembler.  */
2159
  aux.disassemble_fn = disassembler (abfd);
2160
  if (!aux.disassemble_fn)
2161
    {
2162
      non_fatal (_("can't disassemble for architecture %s\n"),
2163
                 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2164
      exit_status = 1;
2165
      return;
2166
    }
2167
 
2168
  disasm_info.flavour = bfd_get_flavour (abfd);
2169
  disasm_info.arch = bfd_get_arch (abfd);
2170
  disasm_info.mach = bfd_get_mach (abfd);
2171
  disasm_info.disassembler_options = disassembler_options;
2172
  disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2173
  disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2174
  disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2175
  disasm_info.disassembler_needs_relocs = FALSE;
2176
 
2177
  if (bfd_big_endian (abfd))
2178
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2179
  else if (bfd_little_endian (abfd))
2180
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2181
  else
2182
    /* ??? Aborting here seems too drastic.  We could default to big or little
2183
       instead.  */
2184
    disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2185
 
2186
  /* Allow the target to customize the info structure.  */
2187
  disassemble_init_for_target (& disasm_info);
2188
 
2189
  /* Pre-load the dynamic relocs if we are going
2190
     to be dumping them along with the disassembly.  */
2191
  if (dump_dynamic_reloc_info)
2192
    {
2193
      long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2194
 
2195
      if (relsize < 0)
2196
        bfd_fatal (bfd_get_filename (abfd));
2197
 
2198
      if (relsize > 0)
2199
        {
2200
          aux.dynrelbuf = (arelent **) xmalloc (relsize);
2201
          aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2202
                                                            aux.dynrelbuf,
2203
                                                            dynsyms);
2204
          if (aux.dynrelcount < 0)
2205
            bfd_fatal (bfd_get_filename (abfd));
2206
 
2207
          /* Sort the relocs by address.  */
2208
          qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2209
                 compare_relocs);
2210
        }
2211
    }
2212
  disasm_info.symtab = sorted_syms;
2213
  disasm_info.symtab_size = sorted_symcount;
2214
 
2215
  bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2216
 
2217
  if (aux.dynrelbuf != NULL)
2218
    free (aux.dynrelbuf);
2219
  free (sorted_syms);
2220
}
2221
 
2222
static int
2223
load_specific_debug_section (enum dwarf_section_display_enum debug,
2224
                             asection *sec, void *file)
2225
{
2226
  struct dwarf_section *section = &debug_displays [debug].section;
2227
  bfd *abfd = (bfd *) file;
2228
  bfd_boolean ret;
2229
 
2230
  /* If it is already loaded, do nothing.  */
2231
  if (section->start != NULL)
2232
    return 1;
2233
 
2234
  section->address = 0;
2235
  section->size = bfd_get_section_size (sec);
2236
  section->start = NULL;
2237
  ret = bfd_get_full_section_contents (abfd, sec, &section->start);
2238
 
2239
  if (! ret)
2240
    {
2241
      free_debug_section (debug);
2242
      printf (_("\nCan't get contents for section '%s'.\n"),
2243
              section->name);
2244
      return 0;
2245
    }
2246
 
2247
  if (is_relocatable && debug_displays [debug].relocate)
2248
    {
2249
      /* We want to relocate the data we've already read (and
2250
         decompressed), so we store a pointer to the data in
2251
         the bfd_section, and tell it that the contents are
2252
         already in memory.  */
2253
      sec->contents = section->start;
2254
      sec->flags |= SEC_IN_MEMORY;
2255
      sec->size = section->size;
2256
 
2257
      ret = bfd_simple_get_relocated_section_contents (abfd,
2258
                                                       sec,
2259
                                                       section->start,
2260
                                                       syms) != NULL;
2261
 
2262
      if (! ret)
2263
        {
2264
          free_debug_section (debug);
2265
          printf (_("\nCan't get contents for section '%s'.\n"),
2266
                  section->name);
2267
          return 0;
2268
        }
2269
    }
2270
 
2271
  return 1;
2272
}
2273
 
2274
int
2275
load_debug_section (enum dwarf_section_display_enum debug, void *file)
2276
{
2277
  struct dwarf_section *section = &debug_displays [debug].section;
2278
  bfd *abfd = (bfd *) file;
2279
  asection *sec;
2280
 
2281
  /* If it is already loaded, do nothing.  */
2282
  if (section->start != NULL)
2283
    return 1;
2284
 
2285
  /* Locate the debug section.  */
2286
  sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2287
  if (sec != NULL)
2288
    section->name = section->uncompressed_name;
2289
  else
2290
    {
2291
      sec = bfd_get_section_by_name (abfd, section->compressed_name);
2292
      if (sec != NULL)
2293
        section->name = section->compressed_name;
2294
    }
2295
  if (sec == NULL)
2296
    return 0;
2297
 
2298
  return load_specific_debug_section (debug, sec, file);
2299
}
2300
 
2301
void
2302
free_debug_section (enum dwarf_section_display_enum debug)
2303
{
2304
  struct dwarf_section *section = &debug_displays [debug].section;
2305
 
2306
  if (section->start == NULL)
2307
    return;
2308
 
2309
  free ((char *) section->start);
2310
  section->start = NULL;
2311
  section->address = 0;
2312
  section->size = 0;
2313
}
2314
 
2315
static void
2316
dump_dwarf_section (bfd *abfd, asection *section,
2317
                    void *arg ATTRIBUTE_UNUSED)
2318
{
2319
  const char *name = bfd_get_section_name (abfd, section);
2320
  const char *match;
2321
  int i;
2322
 
2323
  if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2324
    match = ".debug_info";
2325
  else
2326
    match = name;
2327
 
2328
  for (i = 0; i < max; i++)
2329
    if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2330
         || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2331
        && debug_displays [i].enabled != NULL
2332
        && *debug_displays [i].enabled)
2333
      {
2334
        struct dwarf_section *sec = &debug_displays [i].section;
2335
 
2336
        if (strcmp (sec->uncompressed_name, match) == 0)
2337
          sec->name = sec->uncompressed_name;
2338
        else
2339
          sec->name = sec->compressed_name;
2340
        if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2341
                                         section, abfd))
2342
          {
2343
            debug_displays [i].display (sec, abfd);
2344
 
2345
            if (i != info && i != abbrev)
2346
              free_debug_section ((enum dwarf_section_display_enum) i);
2347
          }
2348
        break;
2349
      }
2350
}
2351
 
2352
/* Dump the dwarf debugging information.  */
2353
 
2354
static void
2355
dump_dwarf (bfd *abfd)
2356
{
2357
  is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2358
 
2359
  eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2360
 
2361
  if (bfd_big_endian (abfd))
2362
    byte_get = byte_get_big_endian;
2363
  else if (bfd_little_endian (abfd))
2364
    byte_get = byte_get_little_endian;
2365
  else
2366
    abort ();
2367
 
2368
  switch (bfd_get_arch (abfd))
2369
    {
2370
    case bfd_arch_i386:
2371
      switch (bfd_get_mach (abfd))
2372
        {
2373
        case bfd_mach_x86_64:
2374
        case bfd_mach_x86_64_intel_syntax:
2375
          init_dwarf_regnames_x86_64 ();
2376
          break;
2377
 
2378
        default:
2379
          init_dwarf_regnames_i386 ();
2380
          break;
2381
        }
2382
      break;
2383
 
2384
    default:
2385
      break;
2386
    }
2387
 
2388
  bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2389
 
2390
  free_debug_memory ();
2391
}
2392
 
2393
/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2394
   it.  Return NULL on failure.   */
2395
 
2396
static char *
2397
read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2398
{
2399
  asection *stabsect;
2400
  bfd_size_type size;
2401
  char *contents;
2402
 
2403
  stabsect = bfd_get_section_by_name (abfd, sect_name);
2404
  if (stabsect == NULL)
2405
    {
2406
      printf (_("No %s section present\n\n"), sect_name);
2407
      return FALSE;
2408
    }
2409
 
2410
  size = bfd_section_size (abfd, stabsect);
2411
  contents  = (char *) xmalloc (size);
2412
 
2413
  if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2414
    {
2415
      non_fatal (_("reading %s section of %s failed: %s"),
2416
                 sect_name, bfd_get_filename (abfd),
2417
                 bfd_errmsg (bfd_get_error ()));
2418
      exit_status = 1;
2419
      free (contents);
2420
      return NULL;
2421
    }
2422
 
2423
  *size_ptr = size;
2424
 
2425
  return contents;
2426
}
2427
 
2428
/* Stabs entries use a 12 byte format:
2429
     4 byte string table index
2430
     1 byte stab type
2431
     1 byte stab other field
2432
     2 byte stab desc field
2433
     4 byte stab value
2434
   FIXME: This will have to change for a 64 bit object format.  */
2435
 
2436
#define STRDXOFF  (0)
2437
#define TYPEOFF   (4)
2438
#define OTHEROFF  (5)
2439
#define DESCOFF   (6)
2440
#define VALOFF    (8)
2441
#define STABSIZE (12)
2442
 
2443
/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2444
   using string table section STRSECT_NAME (in `strtab').  */
2445
 
2446
static void
2447
print_section_stabs (bfd *abfd,
2448
                     const char *stabsect_name,
2449
                     unsigned *string_offset_ptr)
2450
{
2451
  int i;
2452
  unsigned file_string_table_offset = 0;
2453
  unsigned next_file_string_table_offset = *string_offset_ptr;
2454
  bfd_byte *stabp, *stabs_end;
2455
 
2456
  stabp = stabs;
2457
  stabs_end = stabp + stab_size;
2458
 
2459
  printf (_("Contents of %s section:\n\n"), stabsect_name);
2460
  printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2461
 
2462
  /* Loop through all symbols and print them.
2463
 
2464
     We start the index at -1 because there is a dummy symbol on
2465
     the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2466
  for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2467
    {
2468
      const char *name;
2469
      unsigned long strx;
2470
      unsigned char type, other;
2471
      unsigned short desc;
2472
      bfd_vma value;
2473
 
2474
      strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2475
      type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2476
      other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2477
      desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2478
      value = bfd_h_get_32 (abfd, stabp + VALOFF);
2479
 
2480
      printf ("\n%-6d ", i);
2481
      /* Either print the stab name, or, if unnamed, print its number
2482
         again (makes consistent formatting for tools like awk).  */
2483
      name = bfd_get_stab_name (type);
2484
      if (name != NULL)
2485
        printf ("%-6s", name);
2486
      else if (type == N_UNDF)
2487
        printf ("HdrSym");
2488
      else
2489
        printf ("%-6d", type);
2490
      printf (" %-6d %-6d ", other, desc);
2491
      bfd_printf_vma (abfd, value);
2492
      printf (" %-6lu", strx);
2493
 
2494
      /* Symbols with type == 0 (N_UNDF) specify the length of the
2495
         string table associated with this file.  We use that info
2496
         to know how to relocate the *next* file's string table indices.  */
2497
      if (type == N_UNDF)
2498
        {
2499
          file_string_table_offset = next_file_string_table_offset;
2500
          next_file_string_table_offset += value;
2501
        }
2502
      else
2503
        {
2504
          /* Using the (possibly updated) string table offset, print the
2505
             string (if any) associated with this symbol.  */
2506
          if ((strx + file_string_table_offset) < stabstr_size)
2507
            printf (" %s", &strtab[strx + file_string_table_offset]);
2508
          else
2509
            printf (" *");
2510
        }
2511
    }
2512
  printf ("\n\n");
2513
  *string_offset_ptr = next_file_string_table_offset;
2514
}
2515
 
2516
typedef struct
2517
{
2518
  const char * section_name;
2519
  const char * string_section_name;
2520
  unsigned string_offset;
2521
}
2522
stab_section_names;
2523
 
2524
static void
2525
find_stabs_section (bfd *abfd, asection *section, void *names)
2526
{
2527
  int len;
2528
  stab_section_names * sought = (stab_section_names *) names;
2529
 
2530
  /* Check for section names for which stabsect_name is a prefix, to
2531
     handle .stab.N, etc.  */
2532
  len = strlen (sought->section_name);
2533
 
2534
  /* If the prefix matches, and the files section name ends with a
2535
     nul or a digit, then we match.  I.e., we want either an exact
2536
     match or a section followed by a number.  */
2537
  if (strncmp (sought->section_name, section->name, len) == 0
2538
      && (section->name[len] == 0
2539
          || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2540
    {
2541
      if (strtab == NULL)
2542
        strtab = read_section_stabs (abfd, sought->string_section_name,
2543
                                     &stabstr_size);
2544
 
2545
      if (strtab)
2546
        {
2547
          stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2548
                                                   &stab_size);
2549
          if (stabs)
2550
            print_section_stabs (abfd, section->name, &sought->string_offset);
2551
        }
2552
    }
2553
}
2554
 
2555
static void
2556
dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2557
{
2558
  stab_section_names s;
2559
 
2560
  s.section_name = stabsect_name;
2561
  s.string_section_name = strsect_name;
2562
  s.string_offset = 0;
2563
 
2564
  bfd_map_over_sections (abfd, find_stabs_section, & s);
2565
 
2566
  free (strtab);
2567
  strtab = NULL;
2568
}
2569
 
2570
/* Dump the any sections containing stabs debugging information.  */
2571
 
2572
static void
2573
dump_stabs (bfd *abfd)
2574
{
2575
  dump_stabs_section (abfd, ".stab", ".stabstr");
2576
  dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2577
  dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2578
 
2579
  /* For Darwin.  */
2580
  dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2581
 
2582
  dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2583
}
2584
 
2585
static void
2586
dump_bfd_header (bfd *abfd)
2587
{
2588
  char *comma = "";
2589
 
2590
  printf (_("architecture: %s, "),
2591
          bfd_printable_arch_mach (bfd_get_arch (abfd),
2592
                                   bfd_get_mach (abfd)));
2593
  printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2594
 
2595
#define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2596
  PF (HAS_RELOC, "HAS_RELOC");
2597
  PF (EXEC_P, "EXEC_P");
2598
  PF (HAS_LINENO, "HAS_LINENO");
2599
  PF (HAS_DEBUG, "HAS_DEBUG");
2600
  PF (HAS_SYMS, "HAS_SYMS");
2601
  PF (HAS_LOCALS, "HAS_LOCALS");
2602
  PF (DYNAMIC, "DYNAMIC");
2603
  PF (WP_TEXT, "WP_TEXT");
2604
  PF (D_PAGED, "D_PAGED");
2605
  PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2606
  PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2607
  printf (_("\nstart address 0x"));
2608
  bfd_printf_vma (abfd, abfd->start_address);
2609
  printf ("\n");
2610
}
2611
 
2612
 
2613
static void
2614
dump_bfd_private_header (bfd *abfd)
2615
{
2616
  bfd_print_private_bfd_data (abfd, stdout);
2617
}
2618
 
2619
static void
2620
dump_target_specific (bfd *abfd)
2621
{
2622
  const struct objdump_private_desc * const *desc;
2623
  struct objdump_private_option *opt;
2624
  char *e, *b;
2625
 
2626
  /* Find the desc.  */
2627
  for (desc = objdump_private_vectors; *desc != NULL; desc++)
2628
    if ((*desc)->filter (abfd))
2629
      break;
2630
 
2631
  if (desc == NULL)
2632
    {
2633
      non_fatal (_("option -P/--private not supported by this file"));
2634
      return;
2635
    }
2636
 
2637
  /* Clear all options.  */
2638
  for (opt = (*desc)->options; opt->name; opt++)
2639
    opt->selected = FALSE;
2640
 
2641
  /* Decode options.  */
2642
  b = dump_private_options;
2643
  do
2644
    {
2645
      e = strchr (b, ',');
2646
 
2647
      if (e)
2648
        *e = 0;
2649
 
2650
      for (opt = (*desc)->options; opt->name; opt++)
2651
        if (strcmp (opt->name, b) == 0)
2652
          {
2653
            opt->selected = TRUE;
2654
            break;
2655
          }
2656
      if (opt->name == NULL)
2657
        non_fatal (_("target specific dump '%s' not supported"), b);
2658
 
2659
      if (e)
2660
        {
2661
          *e = ',';
2662
          b = e + 1;
2663
        }
2664
    }
2665
  while (e != NULL);
2666
 
2667
  /* Dump.  */
2668
  (*desc)->dump (abfd);
2669
}
2670
 
2671
/* Display a section in hexadecimal format with associated characters.
2672
   Each line prefixed by the zero padded address.  */
2673
 
2674
static void
2675
dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2676
{
2677
  bfd_byte *data = 0;
2678
  bfd_size_type datasize;
2679
  bfd_size_type addr_offset;
2680
  bfd_size_type start_offset;
2681
  bfd_size_type stop_offset;
2682
  unsigned int opb = bfd_octets_per_byte (abfd);
2683
  /* Bytes per line.  */
2684
  const int onaline = 16;
2685
  char buf[64];
2686
  int count;
2687
  int width;
2688
 
2689
  if ((section->flags & SEC_HAS_CONTENTS) == 0)
2690
    return;
2691
 
2692
  if (! process_section_p (section))
2693
    return;
2694
 
2695
  if ((datasize = bfd_section_size (abfd, section)) == 0)
2696
    return;
2697
 
2698
  /* Compute the address range to display.  */
2699
  if (start_address == (bfd_vma) -1
2700
      || start_address < section->vma)
2701
    start_offset = 0;
2702
  else
2703
    start_offset = start_address - section->vma;
2704
 
2705
  if (stop_address == (bfd_vma) -1)
2706
    stop_offset = datasize / opb;
2707
  else
2708
    {
2709
      if (stop_address < section->vma)
2710
        stop_offset = 0;
2711
      else
2712
        stop_offset = stop_address - section->vma;
2713
 
2714
      if (stop_offset > datasize / opb)
2715
        stop_offset = datasize / opb;
2716
    }
2717
 
2718
  if (start_offset >= stop_offset)
2719
    return;
2720
 
2721
  printf (_("Contents of section %s:"), section->name);
2722
  if (display_file_offsets)
2723
    printf (_("  (Starting at file offset: 0x%lx)"),
2724
            (unsigned long) (section->filepos + start_offset));
2725
  printf ("\n");
2726
 
2727
  if (!bfd_get_full_section_contents (abfd, section, &data))
2728
    {
2729
      non_fatal (_("Reading section failed"));
2730
      return;
2731
    }
2732
 
2733
  width = 4;
2734
 
2735
  bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2736
  if (strlen (buf) >= sizeof (buf))
2737
    abort ();
2738
 
2739
  count = 0;
2740
  while (buf[count] == '0' && buf[count+1] != '\0')
2741
    count++;
2742
  count = strlen (buf) - count;
2743
  if (count > width)
2744
    width = count;
2745
 
2746
  bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2747
  if (strlen (buf) >= sizeof (buf))
2748
    abort ();
2749
 
2750
  count = 0;
2751
  while (buf[count] == '0' && buf[count+1] != '\0')
2752
    count++;
2753
  count = strlen (buf) - count;
2754
  if (count > width)
2755
    width = count;
2756
 
2757
  for (addr_offset = start_offset;
2758
       addr_offset < stop_offset; addr_offset += onaline / opb)
2759
    {
2760
      bfd_size_type j;
2761
 
2762
      bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2763
      count = strlen (buf);
2764
      if ((size_t) count >= sizeof (buf))
2765
        abort ();
2766
 
2767
      putchar (' ');
2768
      while (count < width)
2769
        {
2770
          putchar ('0');
2771
          count++;
2772
        }
2773
      fputs (buf + count - width, stdout);
2774
      putchar (' ');
2775
 
2776
      for (j = addr_offset * opb;
2777
           j < addr_offset * opb + onaline; j++)
2778
        {
2779
          if (j < stop_offset * opb)
2780
            printf ("%02x", (unsigned) (data[j]));
2781
          else
2782
            printf ("  ");
2783
          if ((j & 3) == 3)
2784
            printf (" ");
2785
        }
2786
 
2787
      printf (" ");
2788
      for (j = addr_offset * opb;
2789
           j < addr_offset * opb + onaline; j++)
2790
        {
2791
          if (j >= stop_offset * opb)
2792
            printf (" ");
2793
          else
2794
            printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2795
        }
2796
      putchar ('\n');
2797
    }
2798
  free (data);
2799
}
2800
 
2801
/* Actually display the various requested regions.  */
2802
 
2803
static void
2804
dump_data (bfd *abfd)
2805
{
2806
  bfd_map_over_sections (abfd, dump_section, NULL);
2807
}
2808
 
2809
/* Should perhaps share code and display with nm?  */
2810
 
2811
static void
2812
dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2813
{
2814
  asymbol **current;
2815
  long max_count;
2816
  long count;
2817
 
2818
  if (dynamic)
2819
    {
2820
      current = dynsyms;
2821
      max_count = dynsymcount;
2822
      printf ("DYNAMIC SYMBOL TABLE:\n");
2823
    }
2824
  else
2825
    {
2826
      current = syms;
2827
      max_count = symcount;
2828
      printf ("SYMBOL TABLE:\n");
2829
    }
2830
 
2831
  if (max_count == 0)
2832
    printf (_("no symbols\n"));
2833
 
2834
  for (count = 0; count < max_count; count++)
2835
    {
2836
      bfd *cur_bfd;
2837
 
2838
      if (*current == NULL)
2839
        printf (_("no information for symbol number %ld\n"), count);
2840
 
2841
      else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2842
        printf (_("could not determine the type of symbol number %ld\n"),
2843
                count);
2844
 
2845
      else if (process_section_p ((* current)->section)
2846
               && (dump_special_syms
2847
                   || !bfd_is_target_special_symbol (cur_bfd, *current)))
2848
        {
2849
          const char *name = (*current)->name;
2850
 
2851
          if (do_demangle && name != NULL && *name != '\0')
2852
            {
2853
              char *alloc;
2854
 
2855
              /* If we want to demangle the name, we demangle it
2856
                 here, and temporarily clobber it while calling
2857
                 bfd_print_symbol.  FIXME: This is a gross hack.  */
2858
              alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2859
              if (alloc != NULL)
2860
                (*current)->name = alloc;
2861
              bfd_print_symbol (cur_bfd, stdout, *current,
2862
                                bfd_print_symbol_all);
2863
              if (alloc != NULL)
2864
                {
2865
                  (*current)->name = name;
2866
                  free (alloc);
2867
                }
2868
            }
2869
          else
2870
            bfd_print_symbol (cur_bfd, stdout, *current,
2871
                              bfd_print_symbol_all);
2872
          printf ("\n");
2873
        }
2874
 
2875
      current++;
2876
    }
2877
  printf ("\n\n");
2878
}
2879
 
2880
static void
2881
dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2882
{
2883
  arelent **p;
2884
  char *last_filename, *last_functionname;
2885
  unsigned int last_line;
2886
 
2887
  /* Get column headers lined up reasonably.  */
2888
  {
2889
    static int width;
2890
 
2891
    if (width == 0)
2892
      {
2893
        char buf[30];
2894
 
2895
        bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2896
        width = strlen (buf) - 7;
2897
      }
2898
    printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2899
  }
2900
 
2901
  last_filename = NULL;
2902
  last_functionname = NULL;
2903
  last_line = 0;
2904
 
2905
  for (p = relpp; relcount && *p != NULL; p++, relcount--)
2906
    {
2907
      arelent *q = *p;
2908
      const char *filename, *functionname;
2909
      unsigned int linenumber;
2910
      const char *sym_name;
2911
      const char *section_name;
2912
      bfd_vma addend2 = 0;
2913
 
2914
      if (start_address != (bfd_vma) -1
2915
          && q->address < start_address)
2916
        continue;
2917
      if (stop_address != (bfd_vma) -1
2918
          && q->address > stop_address)
2919
        continue;
2920
 
2921
      if (with_line_numbers
2922
          && sec != NULL
2923
          && bfd_find_nearest_line (abfd, sec, syms, q->address,
2924
                                    &filename, &functionname, &linenumber))
2925
        {
2926
          if (functionname != NULL
2927
              && (last_functionname == NULL
2928
                  || strcmp (functionname, last_functionname) != 0))
2929
            {
2930
              printf ("%s():\n", functionname);
2931
              if (last_functionname != NULL)
2932
                free (last_functionname);
2933
              last_functionname = xstrdup (functionname);
2934
            }
2935
 
2936
          if (linenumber > 0
2937
              && (linenumber != last_line
2938
                  || (filename != NULL
2939
                      && last_filename != NULL
2940
                      && filename_cmp (filename, last_filename) != 0)))
2941
            {
2942
              printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2943
              last_line = linenumber;
2944
              if (last_filename != NULL)
2945
                free (last_filename);
2946
              if (filename == NULL)
2947
                last_filename = NULL;
2948
              else
2949
                last_filename = xstrdup (filename);
2950
            }
2951
        }
2952
 
2953
      if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2954
        {
2955
          sym_name = (*(q->sym_ptr_ptr))->name;
2956
          section_name = (*(q->sym_ptr_ptr))->section->name;
2957
        }
2958
      else
2959
        {
2960
          sym_name = NULL;
2961
          section_name = NULL;
2962
        }
2963
 
2964
      bfd_printf_vma (abfd, q->address);
2965
      if (q->howto == NULL)
2966
        printf (" *unknown*         ");
2967
      else if (q->howto->name)
2968
        {
2969
          const char *name = q->howto->name;
2970
 
2971
          /* R_SPARC_OLO10 relocations contain two addends.
2972
             But because 'arelent' lacks enough storage to
2973
             store them both, the 64-bit ELF Sparc backend
2974
             records this as two relocations.  One R_SPARC_LO10
2975
             and one R_SPARC_13, both pointing to the same
2976
             address.  This is merely so that we have some
2977
             place to store both addend fields.
2978
 
2979
             Undo this transformation, otherwise the output
2980
             will be confusing.  */
2981
          if (abfd->xvec->flavour == bfd_target_elf_flavour
2982
              && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
2983
              && relcount > 1
2984
              && !strcmp (q->howto->name, "R_SPARC_LO10"))
2985
            {
2986
              arelent *q2 = *(p + 1);
2987
              if (q2 != NULL
2988
                  && q2->howto
2989
                  && q->address == q2->address
2990
                  && !strcmp (q2->howto->name, "R_SPARC_13"))
2991
                {
2992
                  name = "R_SPARC_OLO10";
2993
                  addend2 = q2->addend;
2994
                  p++;
2995
                }
2996
            }
2997
          printf (" %-16s  ", name);
2998
        }
2999
      else
3000
        printf (" %-16d  ", q->howto->type);
3001
 
3002
      if (sym_name)
3003
        {
3004
          objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3005
        }
3006
      else
3007
        {
3008
          if (section_name == NULL)
3009
            section_name = "*unknown*";
3010
          printf ("[%s]", section_name);
3011
        }
3012
 
3013
      if (q->addend)
3014
        {
3015
          printf ("+0x");
3016
          bfd_printf_vma (abfd, q->addend);
3017
        }
3018
      if (addend2)
3019
        {
3020
          printf ("+0x");
3021
          bfd_printf_vma (abfd, addend2);
3022
        }
3023
 
3024
      printf ("\n");
3025
    }
3026
 
3027
  if (last_filename != NULL)
3028
    free (last_filename);
3029
  if (last_functionname != NULL)
3030
    free (last_functionname);
3031
}
3032
 
3033
static void
3034
dump_relocs_in_section (bfd *abfd,
3035
                        asection *section,
3036
                        void *dummy ATTRIBUTE_UNUSED)
3037
{
3038
  arelent **relpp;
3039
  long relcount;
3040
  long relsize;
3041
 
3042
  if (   bfd_is_abs_section (section)
3043
      || bfd_is_und_section (section)
3044
      || bfd_is_com_section (section)
3045
      || (! process_section_p (section))
3046
      || ((section->flags & SEC_RELOC) == 0))
3047
    return;
3048
 
3049
  relsize = bfd_get_reloc_upper_bound (abfd, section);
3050
  if (relsize < 0)
3051
    bfd_fatal (bfd_get_filename (abfd));
3052
 
3053
  printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3054
 
3055
  if (relsize == 0)
3056
    {
3057
      printf (" (none)\n\n");
3058
      return;
3059
    }
3060
 
3061
  relpp = (arelent **) xmalloc (relsize);
3062
  relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3063
 
3064
  if (relcount < 0)
3065
    bfd_fatal (bfd_get_filename (abfd));
3066
  else if (relcount == 0)
3067
    printf (" (none)\n\n");
3068
  else
3069
    {
3070
      printf ("\n");
3071
      dump_reloc_set (abfd, section, relpp, relcount);
3072
      printf ("\n\n");
3073
    }
3074
  free (relpp);
3075
}
3076
 
3077
static void
3078
dump_relocs (bfd *abfd)
3079
{
3080
  bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3081
}
3082
 
3083
static void
3084
dump_dynamic_relocs (bfd *abfd)
3085
{
3086
  long relsize;
3087
  arelent **relpp;
3088
  long relcount;
3089
 
3090
  relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3091
  if (relsize < 0)
3092
    bfd_fatal (bfd_get_filename (abfd));
3093
 
3094
  printf ("DYNAMIC RELOCATION RECORDS");
3095
 
3096
  if (relsize == 0)
3097
    printf (" (none)\n\n");
3098
  else
3099
    {
3100
      relpp = (arelent **) xmalloc (relsize);
3101
      relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3102
 
3103
      if (relcount < 0)
3104
        bfd_fatal (bfd_get_filename (abfd));
3105
      else if (relcount == 0)
3106
        printf (" (none)\n\n");
3107
      else
3108
        {
3109
          printf ("\n");
3110
          dump_reloc_set (abfd, NULL, relpp, relcount);
3111
          printf ("\n\n");
3112
        }
3113
      free (relpp);
3114
    }
3115
}
3116
 
3117
/* Creates a table of paths, to search for source files.  */
3118
 
3119
static void
3120
add_include_path (const char *path)
3121
{
3122
  if (path[0] == 0)
3123
    return;
3124
  include_path_count++;
3125
  include_paths = (const char **)
3126
      xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3127
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3128
  if (path[1] == ':' && path[2] == 0)
3129
    path = concat (path, ".", (const char *) 0);
3130
#endif
3131
  include_paths[include_path_count - 1] = path;
3132
}
3133
 
3134
static void
3135
adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3136
                  asection *section,
3137
                  void *arg)
3138
{
3139
  if ((section->flags & SEC_DEBUGGING) == 0)
3140
    {
3141
      bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3142
      section->vma += adjust_section_vma;
3143
      if (*has_reloc_p)
3144
        section->lma += adjust_section_vma;
3145
    }
3146
}
3147
 
3148
/* Dump selected contents of ABFD.  */
3149
 
3150
static void
3151
dump_bfd (bfd *abfd)
3152
{
3153
  /* If we are adjusting section VMA's, change them all now.  Changing
3154
     the BFD information is a hack.  However, we must do it, or
3155
     bfd_find_nearest_line will not do the right thing.  */
3156
  if (adjust_section_vma != 0)
3157
    {
3158
      bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3159
      bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3160
    }
3161
 
3162
  if (! dump_debugging_tags && ! suppress_bfd_header)
3163
    printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
3164
            abfd->xvec->name);
3165
  if (dump_ar_hdrs)
3166
    print_arelt_descr (stdout, abfd, TRUE);
3167
  if (dump_file_header)
3168
    dump_bfd_header (abfd);
3169
  if (dump_private_headers)
3170
    dump_bfd_private_header (abfd);
3171
  if (dump_private_options != NULL)
3172
    dump_target_specific (abfd);
3173
  if (! dump_debugging_tags && ! suppress_bfd_header)
3174
    putchar ('\n');
3175
  if (dump_section_headers)
3176
    dump_headers (abfd);
3177
 
3178
  if (dump_symtab
3179
      || dump_reloc_info
3180
      || disassemble
3181
      || dump_debugging
3182
      || dump_dwarf_section_info)
3183
    syms = slurp_symtab (abfd);
3184
  if (dump_dynamic_symtab || dump_dynamic_reloc_info
3185
      || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3186
    dynsyms = slurp_dynamic_symtab (abfd);
3187
  if (disassemble)
3188
    {
3189
      synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3190
                                             dynsymcount, dynsyms, &synthsyms);
3191
      if (synthcount < 0)
3192
        synthcount = 0;
3193
    }
3194
 
3195
  if (dump_symtab)
3196
    dump_symbols (abfd, FALSE);
3197
  if (dump_dynamic_symtab)
3198
    dump_symbols (abfd, TRUE);
3199
  if (dump_dwarf_section_info)
3200
    dump_dwarf (abfd);
3201
  if (dump_stab_section_info)
3202
    dump_stabs (abfd);
3203
  if (dump_reloc_info && ! disassemble)
3204
    dump_relocs (abfd);
3205
  if (dump_dynamic_reloc_info && ! disassemble)
3206
    dump_dynamic_relocs (abfd);
3207
  if (dump_section_contents)
3208
    dump_data (abfd);
3209
  if (disassemble)
3210
    disassemble_data (abfd);
3211
 
3212
  if (dump_debugging)
3213
    {
3214
      void *dhandle;
3215
 
3216
      dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3217
      if (dhandle != NULL)
3218
        {
3219
          if (!print_debugging_info (stdout, dhandle, abfd, syms,
3220
                                     bfd_demangle,
3221
                                     dump_debugging_tags ? TRUE : FALSE))
3222
            {
3223
              non_fatal (_("%s: printing debugging information failed"),
3224
                         bfd_get_filename (abfd));
3225
              exit_status = 1;
3226
            }
3227
        }
3228
      /* PR 6483: If there was no STABS or IEEE debug
3229
         info in the file, try DWARF instead.  */
3230
      else if (! dump_dwarf_section_info)
3231
        {
3232
          dump_dwarf (abfd);
3233
        }
3234
    }
3235
 
3236
  if (syms)
3237
    {
3238
      free (syms);
3239
      syms = NULL;
3240
    }
3241
 
3242
  if (dynsyms)
3243
    {
3244
      free (dynsyms);
3245
      dynsyms = NULL;
3246
    }
3247
 
3248
  if (synthsyms)
3249
    {
3250
      free (synthsyms);
3251
      synthsyms = NULL;
3252
    }
3253
 
3254
  symcount = 0;
3255
  dynsymcount = 0;
3256
  synthcount = 0;
3257
}
3258
 
3259
static void
3260
display_bfd (bfd *abfd)
3261
{
3262
  char **matching;
3263
 
3264
  if (bfd_check_format_matches (abfd, bfd_object, &matching))
3265
    {
3266
      dump_bfd (abfd);
3267
      return;
3268
    }
3269
 
3270
  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3271
    {
3272
      nonfatal (bfd_get_filename (abfd));
3273
      list_matching_formats (matching);
3274
      free (matching);
3275
      return;
3276
    }
3277
 
3278
  if (bfd_get_error () != bfd_error_file_not_recognized)
3279
    {
3280
      nonfatal (bfd_get_filename (abfd));
3281
      return;
3282
    }
3283
 
3284
  if (bfd_check_format_matches (abfd, bfd_core, &matching))
3285
    {
3286
      dump_bfd (abfd);
3287
      return;
3288
    }
3289
 
3290
  nonfatal (bfd_get_filename (abfd));
3291
 
3292
  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3293
    {
3294
      list_matching_formats (matching);
3295
      free (matching);
3296
    }
3297
}
3298
 
3299
static void
3300
display_file (char *filename, char *target)
3301
{
3302
  bfd *file;
3303
  bfd *arfile = NULL;
3304
 
3305
  if (get_file_size (filename) < 1)
3306
    {
3307
      exit_status = 1;
3308
      return;
3309
    }
3310
 
3311
  file = bfd_openr (filename, target);
3312
  if (file == NULL)
3313
    {
3314
      nonfatal (filename);
3315
      return;
3316
    }
3317
 
3318
  /* Decompress sections unless dumping the section contents.  */
3319
  if (!dump_section_contents)
3320
    file->flags |= BFD_DECOMPRESS;
3321
 
3322
  /* If the file is an archive, process all of its elements.  */
3323
  if (bfd_check_format (file, bfd_archive))
3324
    {
3325
      bfd *last_arfile = NULL;
3326
 
3327
      printf (_("In archive %s:\n"), bfd_get_filename (file));
3328
      for (;;)
3329
        {
3330
          bfd_set_error (bfd_error_no_error);
3331
 
3332
          arfile = bfd_openr_next_archived_file (file, arfile);
3333
          if (arfile == NULL)
3334
            {
3335
              if (bfd_get_error () != bfd_error_no_more_archived_files)
3336
                nonfatal (bfd_get_filename (file));
3337
              break;
3338
            }
3339
 
3340
          display_bfd (arfile);
3341
 
3342
          if (last_arfile != NULL)
3343
            bfd_close (last_arfile);
3344
          last_arfile = arfile;
3345
        }
3346
 
3347
      if (last_arfile != NULL)
3348
        bfd_close (last_arfile);
3349
    }
3350
  else
3351
    display_bfd (file);
3352
 
3353
  bfd_close (file);
3354
}
3355
 
3356
int
3357
main (int argc, char **argv)
3358
{
3359
  int c;
3360
  char *target = default_target;
3361
  bfd_boolean seenflag = FALSE;
3362
 
3363
#if defined (HAVE_SETLOCALE)
3364
#if defined (HAVE_LC_MESSAGES)
3365
  setlocale (LC_MESSAGES, "");
3366
#endif
3367
  setlocale (LC_CTYPE, "");
3368
#endif
3369
 
3370
  bindtextdomain (PACKAGE, LOCALEDIR);
3371
  textdomain (PACKAGE);
3372
 
3373
  program_name = *argv;
3374
  xmalloc_set_program_name (program_name);
3375
 
3376
  START_PROGRESS (program_name, 0);
3377
 
3378
  expandargv (&argc, &argv);
3379
 
3380
  bfd_init ();
3381
  set_default_bfd_target ();
3382
 
3383
  while ((c = getopt_long (argc, argv,
3384
                           "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3385
                           long_options, (int *) 0))
3386
         != EOF)
3387
    {
3388
      switch (c)
3389
        {
3390
        case 0:
3391
          break;                /* We've been given a long option.  */
3392
        case 'm':
3393
          machine = optarg;
3394
          break;
3395
        case 'M':
3396
          if (disassembler_options)
3397
            /* Ignore potential memory leak for now.  */
3398
            disassembler_options = concat (disassembler_options, ",",
3399
                                           optarg, (const char *) NULL);
3400
          else
3401
            disassembler_options = optarg;
3402
          break;
3403
        case 'j':
3404
          add_only (optarg);
3405
          break;
3406
        case 'F':
3407
          display_file_offsets = TRUE;
3408
          break;
3409
        case 'l':
3410
          with_line_numbers = TRUE;
3411
          break;
3412
        case 'b':
3413
          target = optarg;
3414
          break;
3415
        case 'C':
3416
          do_demangle = TRUE;
3417
          if (optarg != NULL)
3418
            {
3419
              enum demangling_styles style;
3420
 
3421
              style = cplus_demangle_name_to_style (optarg);
3422
              if (style == unknown_demangling)
3423
                fatal (_("unknown demangling style `%s'"),
3424
                       optarg);
3425
 
3426
              cplus_demangle_set_style (style);
3427
            }
3428
          break;
3429
        case 'w':
3430
          wide_output = TRUE;
3431
          break;
3432
        case OPTION_ADJUST_VMA:
3433
          adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3434
          break;
3435
        case OPTION_START_ADDRESS:
3436
          start_address = parse_vma (optarg, "--start-address");
3437
          if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3438
            fatal (_("error: the start address should be before the end address"));
3439
          break;
3440
        case OPTION_STOP_ADDRESS:
3441
          stop_address = parse_vma (optarg, "--stop-address");
3442
          if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3443
            fatal (_("error: the stop address should be after the start address"));
3444
          break;
3445
        case OPTION_PREFIX:
3446
          prefix = optarg;
3447
          prefix_length = strlen (prefix);
3448
          /* Remove an unnecessary trailing '/' */
3449
          while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3450
            prefix_length--;
3451
          break;
3452
        case OPTION_PREFIX_STRIP:
3453
          prefix_strip = atoi (optarg);
3454
          if (prefix_strip < 0)
3455
            fatal (_("error: prefix strip must be non-negative"));
3456
          break;
3457
        case OPTION_INSN_WIDTH:
3458
          insn_width = strtoul (optarg, NULL, 0);
3459
          if (insn_width <= 0)
3460
            fatal (_("error: instruction width must be positive"));
3461
          break;
3462
        case 'E':
3463
          if (strcmp (optarg, "B") == 0)
3464
            endian = BFD_ENDIAN_BIG;
3465
          else if (strcmp (optarg, "L") == 0)
3466
            endian = BFD_ENDIAN_LITTLE;
3467
          else
3468
            {
3469
              nonfatal (_("unrecognized -E option"));
3470
              usage (stderr, 1);
3471
            }
3472
          break;
3473
        case OPTION_ENDIAN:
3474
          if (strncmp (optarg, "big", strlen (optarg)) == 0)
3475
            endian = BFD_ENDIAN_BIG;
3476
          else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3477
            endian = BFD_ENDIAN_LITTLE;
3478
          else
3479
            {
3480
              non_fatal (_("unrecognized --endian type `%s'"), optarg);
3481
              exit_status = 1;
3482
              usage (stderr, 1);
3483
            }
3484
          break;
3485
 
3486
        case 'f':
3487
          dump_file_header = TRUE;
3488
          seenflag = TRUE;
3489
          break;
3490
        case 'i':
3491
          formats_info = TRUE;
3492
          seenflag = TRUE;
3493
          break;
3494
        case 'I':
3495
          add_include_path (optarg);
3496
          break;
3497
        case 'p':
3498
          dump_private_headers = TRUE;
3499
          seenflag = TRUE;
3500
          break;
3501
        case 'P':
3502
          dump_private_options = optarg;
3503
          seenflag = TRUE;
3504
          break;
3505
        case 'x':
3506
          dump_private_headers = TRUE;
3507
          dump_symtab = TRUE;
3508
          dump_reloc_info = TRUE;
3509
          dump_file_header = TRUE;
3510
          dump_ar_hdrs = TRUE;
3511
          dump_section_headers = TRUE;
3512
          seenflag = TRUE;
3513
          break;
3514
        case 't':
3515
          dump_symtab = TRUE;
3516
          seenflag = TRUE;
3517
          break;
3518
        case 'T':
3519
          dump_dynamic_symtab = TRUE;
3520
          seenflag = TRUE;
3521
          break;
3522
        case 'd':
3523
          disassemble = TRUE;
3524
          seenflag = TRUE;
3525
          break;
3526
        case 'z':
3527
          disassemble_zeroes = TRUE;
3528
          break;
3529
        case 'D':
3530
          disassemble = TRUE;
3531
          disassemble_all = TRUE;
3532
          seenflag = TRUE;
3533
          break;
3534
        case 'S':
3535
          disassemble = TRUE;
3536
          with_source_code = TRUE;
3537
          seenflag = TRUE;
3538
          break;
3539
        case 'g':
3540
          dump_debugging = 1;
3541
          seenflag = TRUE;
3542
          break;
3543
        case 'e':
3544
          dump_debugging = 1;
3545
          dump_debugging_tags = 1;
3546
          do_demangle = TRUE;
3547
          seenflag = TRUE;
3548
          break;
3549
        case 'W':
3550
          dump_dwarf_section_info = TRUE;
3551
          seenflag = TRUE;
3552
          if (optarg)
3553
            dwarf_select_sections_by_letters (optarg);
3554
          else
3555
            dwarf_select_sections_all ();
3556
          break;
3557
        case OPTION_DWARF:
3558
          dump_dwarf_section_info = TRUE;
3559
          seenflag = TRUE;
3560
          if (optarg)
3561
            dwarf_select_sections_by_names (optarg);
3562
          else
3563
            dwarf_select_sections_all ();
3564
          break;
3565
        case OPTION_DWARF_DEPTH:
3566
          {
3567
            char *cp;
3568
            dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3569
          }
3570
          break;
3571
        case OPTION_DWARF_START:
3572
          {
3573
            char *cp;
3574
            dwarf_start_die = strtoul (optarg, & cp, 0);
3575
            suppress_bfd_header = 1;
3576
          }
3577
          break;
3578
        case 'G':
3579
          dump_stab_section_info = TRUE;
3580
          seenflag = TRUE;
3581
          break;
3582
        case 's':
3583
          dump_section_contents = TRUE;
3584
          seenflag = TRUE;
3585
          break;
3586
        case 'r':
3587
          dump_reloc_info = TRUE;
3588
          seenflag = TRUE;
3589
          break;
3590
        case 'R':
3591
          dump_dynamic_reloc_info = TRUE;
3592
          seenflag = TRUE;
3593
          break;
3594
        case 'a':
3595
          dump_ar_hdrs = TRUE;
3596
          seenflag = TRUE;
3597
          break;
3598
        case 'h':
3599
          dump_section_headers = TRUE;
3600
          seenflag = TRUE;
3601
          break;
3602
        case 'H':
3603
          usage (stdout, 0);
3604
          seenflag = TRUE;
3605
        case 'v':
3606
        case 'V':
3607
          show_version = TRUE;
3608
          seenflag = TRUE;
3609
          break;
3610
 
3611
        default:
3612
          usage (stderr, 1);
3613
        }
3614
    }
3615
 
3616
  if (show_version)
3617
    print_version ("objdump");
3618
 
3619
  if (!seenflag)
3620
    usage (stderr, 2);
3621
 
3622
  if (formats_info)
3623
    exit_status = display_info ();
3624
  else
3625
    {
3626
      if (optind == argc)
3627
        display_file ("a.out", target);
3628
      else
3629
        for (; optind < argc;)
3630
          display_file (argv[optind++], target);
3631
    }
3632
 
3633
  free_only_list ();
3634
 
3635
  END_PROGRESS (program_name);
3636
 
3637
  return exit_status;
3638
}

powered by: WebSVN 2.1.0

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