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