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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [objdump.c] - Blame information for rev 205

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

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

powered by: WebSVN 2.1.0

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