projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* ld.texinfo: Fix typo.
[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;
1316c8b3 1528 info->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
0313a2b8
NC		 1529 if (machine)
1530 info->flags |= USER_SPECIFIED_MACHINE_TYPE;
252b5132 1531
d99b6465 1532 if (info->disassembler_needs_relocs
7df428b1
RS		 1533 && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1534 && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
d99b6465 1535 && *relppp < relppend)
ce04548a
NC		 1536 {
1537 bfd_signed_vma distance_to_rel;
1538
1539 distance_to_rel = (**relppp)->address
1540 - (rel_offset + addr_offset);
1541
1542 /* Check to see if the current reloc is associated with
1543 the instruction that we are about to disassemble. */
1544 if (distance_to_rel == 0
1545 /* FIXME: This is wrong. We are trying to catch
1546 relocs that are addressed part way through the
1547 current instruction, as might happen with a packed
1548 VLIW instruction. Unfortunately we do not know the
1549 length of the current instruction since we have not
1550 disassembled it yet. Instead we take a guess based
1551 upon the length of the previous instruction. The
1552 proper solution is to have a new target-specific
1553 disassembler function which just returns the length
1554 of an instruction at a given address without trying
1555 to display its disassembly. */
1556 || (distance_to_rel > 0
1557 && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1558 {
1316c8b3 1559 info->flags |= INSN_HAS_RELOC;
ce04548a
NC		 1560 aux->reloc = **relppp;
1561 }
1562 else
1563 aux->reloc = NULL;
1564 }
d99b6465 1565
940b2b78 1566 octets = (*disassemble_fn) (section->vma + addr_offset, info);
252b5132
RH		 1567 info->fprintf_func = (fprintf_ftype) fprintf;
1568 info->stream = stdout;
1569 if (info->bytes_per_line != 0)
940b2b78
TW		 1570 octets_per_line = info->bytes_per_line;
1571 if (octets < 0)
e07bf1ac 1572 {
6f104306 1573 if (sfile.pos)
e07bf1ac 1574 printf ("%s\n", sfile.buffer);
e07bf1ac
ILT		 1575 break;
1576 }
252b5132
RH		 1577 }
1578 else
1579 {
b4c96d0d 1580 bfd_vma j;
252b5132 1581
940b2b78
TW		 1582 octets = octets_per_line;
1583 if (addr_offset + octets / opb > stop_offset)
1584 octets = (stop_offset - addr_offset) * opb;
252b5132 1585
940b2b78 1586 for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
252b5132 1587 {
3882b010 1588 if (ISPRINT (data[j]))
940b2b78 1589 buf[j - addr_offset * opb] = data[j];
252b5132 1590 else
940b2b78 1591 buf[j - addr_offset * opb] = '.';
252b5132 1592 }
940b2b78 1593 buf[j - addr_offset * opb] = '\0';
252b5132
RH		 1594 }
1595
1596 if (prefix_addresses
1597 ? show_raw_insn > 0
1598 : show_raw_insn >= 0)
1599 {
b4c96d0d 1600 bfd_vma j;
252b5132
RH		 1601
1602 /* If ! prefix_addresses and ! wide_output, we print
43ac9881 1603 octets_per_line octets per line. */
940b2b78
TW		 1604 pb = octets;
1605 if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1606 pb = octets_per_line;
252b5132
RH		 1607
1608 if (info->bytes_per_chunk)
1609 bpc = info->bytes_per_chunk;
1610 else
1611 bpc = 1;
1612
940b2b78 1613 for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
252b5132
RH		 1614 {
1615 int k;
ed049af3 1616
252b5132
RH		 1617 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1618 {
1619 for (k = bpc - 1; k >= 0; k--)
1620 printf ("%02x", (unsigned) data[j + k]);
1621 putchar (' ');
1622 }
1623 else
1624 {
1625 for (k = 0; k < bpc; k++)
1626 printf ("%02x", (unsigned) data[j + k]);
1627 putchar (' ');
1628 }
1629 }
1630
940b2b78 1631 for (; pb < octets_per_line; pb += bpc)
252b5132
RH		 1632 {
1633 int k;
1634
1635 for (k = 0; k < bpc; k++)
1636 printf (" ");
1637 putchar (' ');
1638 }
1639
1640 /* Separate raw data from instruction by extra space. */
1641 if (insns)
1642 putchar ('\t');
1643 else
1644 printf (" ");
1645 }
1646
1647 if (! insns)
1648 printf ("%s", buf);
6f104306
NS		 1649 else if (sfile.pos)
1650 printf ("%s", sfile.buffer);
252b5132
RH		 1651
1652 if (prefix_addresses
1653 ? show_raw_insn > 0
1654 : show_raw_insn >= 0)
1655 {
940b2b78 1656 while (pb < octets)
252b5132 1657 {
b4c96d0d 1658 bfd_vma j;
252b5132
RH		 1659 char *s;
1660
1661 putchar ('\n');
940b2b78 1662 j = addr_offset * opb + pb;
252b5132 1663
d8180c76 1664 bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
252b5132
RH		 1665 for (s = buf + skip_addr_chars; *s == '0'; s++)
1666 *s = ' ';
1667 if (*s == '\0')
1668 *--s = '0';
1669 printf ("%s:\t", buf + skip_addr_chars);
1670
940b2b78
TW		 1671 pb += octets_per_line;
1672 if (pb > octets)
1673 pb = octets;
1674 for (; j < addr_offset * opb + pb; j += bpc)
252b5132
RH		 1675 {
1676 int k;
1677
1678 if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1679 {
1680 for (k = bpc - 1; k >= 0; k--)
1681 printf ("%02x", (unsigned) data[j + k]);
1682 putchar (' ');
1683 }
1684 else
1685 {
1686 for (k = 0; k < bpc; k++)
1687 printf ("%02x", (unsigned) data[j + k]);
1688 putchar (' ');
1689 }
1690 }
1691 }
1692 }
1693
1694 if (!wide_output)
1695 putchar ('\n');
1696 else
b34976b6 1697 need_nl = TRUE;
252b5132
RH		 1698 }
1699
fd7bb956
AM		 1700 while ((*relppp) < relppend
1701 && (**relppp)->address < rel_offset + addr_offset + octets / opb)
252b5132 1702 {
fd7bb956 1703 if (dump_reloc_info || dump_dynamic_reloc_info)
252b5132
RH		 1704 {
1705 arelent *q;
1706
1707 q = **relppp;
1708
1709 if (wide_output)
1710 putchar ('\t');
1711 else
1712 printf ("\t\t\t");
1713
68b3b8dc
JJ		 1714 objdump_print_value (section->vma - rel_offset + q->address,
1715 info, TRUE);
252b5132 1716
f9ecb0a4
JJ		 1717 if (q->howto == NULL)
1718 printf (": *unknown*\t");
1719 else if (q->howto->name)
1720 printf (": %s\t", q->howto->name);
1721 else
1722 printf (": %d\t", q->howto->type);
252b5132
RH		 1723
1724 if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1725 printf ("*unknown*");
1726 else
1727 {
1728 const char *sym_name;
1729
1730 sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1731 if (sym_name != NULL && *sym_name != '\0')
1732 objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1733 else
1734 {
1735 asection *sym_sec;
1736
1737 sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1738 sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1739 if (sym_name == NULL || *sym_name == '\0')
1740 sym_name = "*unknown*";
1741 printf ("%s", sym_name);
1742 }
1743 }
1744
1745 if (q->addend)
1746 {
1747 printf ("+0x");
b34976b6 1748 objdump_print_value (q->addend, info, TRUE);
252b5132
RH		 1749 }
1750
1751 printf ("\n");
b34976b6 1752 need_nl = FALSE;
252b5132 1753 }
fd7bb956 1754 ++(*relppp);
252b5132
RH		 1755 }
1756
1757 if (need_nl)
1758 printf ("\n");
1759
940b2b78 1760 addr_offset += octets / opb;
252b5132 1761 }
6f104306
NS		 1762
1763 free (sfile.buffer);
252b5132
RH		 1764}
1765
155e0d23
NC		 1766static void
1767disassemble_section (bfd *abfd, asection *section, void *info)
1768{
1b0adfe0
NC		 1769 const struct elf_backend_data * bed;
1770 bfd_vma sign_adjust = 0;
155e0d23 1771 struct disassemble_info * pinfo = (struct disassemble_info *) info;
3b9ad1cc 1772 struct objdump_disasm_info * paux;
155e0d23
NC		 1773 unsigned int opb = pinfo->octets_per_byte;
1774 bfd_byte * data = NULL;
1775 bfd_size_type datasize = 0;
1776 arelent ** rel_pp = NULL;
1777 arelent ** rel_ppstart = NULL;
1778 arelent ** rel_ppend;
1779 unsigned long stop_offset;
1780 asymbol * sym = NULL;
1781 long place = 0;
1782 long rel_count;
1783 bfd_vma rel_offset;
1784 unsigned long addr_offset;
1785
1786 /* Sections that do not contain machine
1787 code are not normally disassembled. */
1788 if (! disassemble_all
1789 && only == NULL
46212538
AM		 1790 && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1791 != (SEC_CODE | SEC_HAS_CONTENTS)))
155e0d23
NC		 1792 return;
1793
1794 if (! process_section_p (section))
1795 return;
1796
135dfb4a 1797 datasize = bfd_get_section_size (section);
155e0d23
NC		 1798 if (datasize == 0)
1799 return;
1800
1801 /* Decide which set of relocs to use. Load them if necessary. */
3b9ad1cc 1802 paux = (struct objdump_disasm_info *) pinfo->application_data;
155e0d23
NC		 1803 if (paux->dynrelbuf)
1804 {
1805 rel_pp = paux->dynrelbuf;
1806 rel_count = paux->dynrelcount;
1807 /* Dynamic reloc addresses are absolute, non-dynamic are section
50c2245b 1808 relative. REL_OFFSET specifies the reloc address corresponding
155e0d23 1809 to the start of this section. */
68b3b8dc 1810 rel_offset = section->vma;
155e0d23
NC		 1811 }
1812 else
1813 {
1814 rel_count = 0;
1815 rel_pp = NULL;
1816 rel_offset = 0;
1817
1818 if ((section->flags & SEC_RELOC) != 0
d99b6465 1819 && (dump_reloc_info || pinfo->disassembler_needs_relocs))
155e0d23
NC		 1820 {
1821 long relsize;
1822
1823 relsize = bfd_get_reloc_upper_bound (abfd, section);
1824 if (relsize < 0)
1825 bfd_fatal (bfd_get_filename (abfd));
1826
1827 if (relsize > 0)
1828 {
1829 rel_ppstart = rel_pp = xmalloc (relsize);
1830 rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1831 if (rel_count < 0)
1832 bfd_fatal (bfd_get_filename (abfd));
1833
1834 /* Sort the relocs by address. */
1835 qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1836 }
1837 }
155e0d23
NC		 1838 }
1839 rel_ppend = rel_pp + rel_count;
1840
1841 data = xmalloc (datasize);
1842
1843 bfd_get_section_contents (abfd, section, data, 0, datasize);
1844
1845 paux->sec = section;
1846 pinfo->buffer = data;
1847 pinfo->buffer_vma = section->vma;
1848 pinfo->buffer_length = datasize;
1849 pinfo->section = section;
1850
1851 if (start_address == (bfd_vma) -1
1852 || start_address < pinfo->buffer_vma)
1853 addr_offset = 0;
1854 else
1855 addr_offset = start_address - pinfo->buffer_vma;
1856
1857 if (stop_address == (bfd_vma) -1)
1858 stop_offset = datasize / opb;
1859 else
1860 {
1861 if (stop_address < pinfo->buffer_vma)
1862 stop_offset = 0;
1863 else
1864 stop_offset = stop_address - pinfo->buffer_vma;
1865 if (stop_offset > pinfo->buffer_length / opb)
1866 stop_offset = pinfo->buffer_length / opb;
1867 }
1868
1869 /* Skip over the relocs belonging to addresses below the
1870 start address. */
1871 while (rel_pp < rel_ppend
1872 && (*rel_pp)->address < rel_offset + addr_offset)
1873 ++rel_pp;
1874
98ec6e72
NC		 1875 if (addr_offset < stop_offset)
1876 printf (_("\nDisassembly of section %s:\n"), section->name);
155e0d23
NC		 1877
1878 /* Find the nearest symbol forwards from our current position. */
3b9ad1cc 1879 paux->require_sec = TRUE;
22a398e1 1880 sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
3b9ad1cc 1881 paux->require_sec = FALSE;
155e0d23 1882
1b0adfe0
NC		 1883 /* PR 9774: If the target used signed 32-bit addresses then we must make
1884 sure that we sign extend the value that we calculate for 'addr' in the
1885 loop below. */
1886 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1887 && (bed = get_elf_backend_data (abfd)) != NULL
1888 && bed->sign_extend_vma)
1889 sign_adjust = 0x80000000;
1890
155e0d23
NC		 1891 /* Disassemble a block of instructions up to the address associated with
1892 the symbol we have just found. Then print the symbol and find the
1893 next symbol on. Repeat until we have disassembled the entire section
1894 or we have reached the end of the address range we are interested in. */
1895 while (addr_offset < stop_offset)
1896 {
22a398e1 1897 bfd_vma addr;
155e0d23
NC		 1898 asymbol *nextsym;
1899 unsigned long nextstop_offset;
1900 bfd_boolean insns;
1901
22a398e1 1902 addr = section->vma + addr_offset;
095ad3b8 1903 addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
22a398e1
NC		 1904
1905 if (sym != NULL && bfd_asymbol_value (sym) <= addr)
155e0d23
NC		 1906 {
1907 int x;
1908
1909 for (x = place;
1910 (x < sorted_symcount
22a398e1 1911 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
155e0d23
NC		 1912 ++x)
1913 continue;
1914
22a398e1 1915 pinfo->symbols = sorted_syms + place;
155e0d23 1916 pinfo->num_symbols = x - place;
2087ad84 1917 pinfo->symtab_pos = place;
155e0d23
NC		 1918 }
1919 else
22a398e1
NC		 1920 {
1921 pinfo->symbols = NULL;
1922 pinfo->num_symbols = 0;
2087ad84 1923 pinfo->symtab_pos = -1;
22a398e1 1924 }
155e0d23
NC		 1925
1926 if (! prefix_addresses)
1927 {
1928 pinfo->fprintf_func (pinfo->stream, "\n");
22a398e1 1929 objdump_print_addr_with_sym (abfd, section, sym, addr,
155e0d23
NC		 1930 pinfo, FALSE);
1931 pinfo->fprintf_func (pinfo->stream, ":\n");
1932 }
1933
22a398e1 1934 if (sym != NULL && bfd_asymbol_value (sym) > addr)
155e0d23
NC		 1935 nextsym = sym;
1936 else if (sym == NULL)
1937 nextsym = NULL;
1938 else
1939 {
22a398e1
NC		 1940#define is_valid_next_sym(SYM) \
1941 ((SYM)->section == section \
1942 && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1943 && pinfo->symbol_is_valid (SYM, pinfo))
1944
155e0d23
NC		 1945 /* Search forward for the next appropriate symbol in
1946 SECTION. Note that all the symbols are sorted
1947 together into one big array, and that some sections
1948 may have overlapping addresses. */
1949 while (place < sorted_symcount
22a398e1 1950 && ! is_valid_next_sym (sorted_syms [place]))
155e0d23 1951 ++place;
22a398e1 1952
155e0d23
NC		 1953 if (place >= sorted_symcount)
1954 nextsym = NULL;
1955 else
1956 nextsym = sorted_syms[place];
1957 }
1958
22a398e1
NC		 1959 if (sym != NULL && bfd_asymbol_value (sym) > addr)
1960 nextstop_offset = bfd_asymbol_value (sym) - section->vma;
155e0d23
NC		 1961 else if (nextsym == NULL)
1962 nextstop_offset = stop_offset;
1963 else
22a398e1
NC		 1964 nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1965
84d7b001
NC		 1966 if (nextstop_offset > stop_offset
1967 || nextstop_offset <= addr_offset)
22a398e1 1968 nextstop_offset = stop_offset;
155e0d23
NC		 1969
1970 /* If a symbol is explicitly marked as being an object
1971 rather than a function, just dump the bytes without
1972 disassembling them. */
1973 if (disassemble_all
1974 || sym == NULL
abf71725 1975 || sym->section != section
22a398e1 1976 || bfd_asymbol_value (sym) > addr
155e0d23
NC		 1977 || ((sym->flags & BSF_OBJECT) == 0
1978 && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1979 == NULL)
1980 && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1981 == NULL))
1982 || (sym->flags & BSF_FUNCTION) != 0)
1983 insns = TRUE;
1984 else
1985 insns = FALSE;
1986
1987 disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1988 addr_offset, nextstop_offset,
1989 rel_offset, &rel_pp, rel_ppend);
84d7b001 1990
155e0d23
NC		 1991 addr_offset = nextstop_offset;
1992 sym = nextsym;
1993 }
1994
1995 free (data);
1996
1997 if (rel_ppstart != NULL)
1998 free (rel_ppstart);
1999}
2000
252b5132
RH		 2001/* Disassemble the contents of an object file. */
2002
2003static void
46dca2e0 2004disassemble_data (bfd *abfd)
252b5132 2005{
252b5132
RH		 2006 struct disassemble_info disasm_info;
2007 struct objdump_disasm_info aux;
4c45e5c9 2008 long i;
252b5132
RH		 2009
2010 print_files = NULL;
2011 prev_functionname = NULL;
2012 prev_line = -1;
2013
2014 /* We make a copy of syms to sort. We don't want to sort syms
2015 because that will screw up the relocs. */
4c45e5c9
JJ		 2016 sorted_symcount = symcount ? symcount : dynsymcount;
2017 sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
2018 memcpy (sorted_syms, symcount ? syms : dynsyms,
2019 sorted_symcount * sizeof (asymbol *));
252b5132 2020
4c45e5c9
JJ		 2021 sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2022
2023 for (i = 0; i < synthcount; ++i)
2024 {
2025 sorted_syms[sorted_symcount] = synthsyms + i;
2026 ++sorted_symcount;
2027 }
252b5132 2028
98a91d6a 2029 /* Sort the symbols into section and symbol order. */
252b5132
RH		 2030 qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2031
22a398e1 2032 init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
98a91d6a 2033
46dca2e0 2034 disasm_info.application_data = (void *) &aux;
252b5132 2035 aux.abfd = abfd;
b34976b6 2036 aux.require_sec = FALSE;
155e0d23
NC		 2037 aux.dynrelbuf = NULL;
2038 aux.dynrelcount = 0;
ce04548a 2039 aux.reloc = NULL;
155e0d23 2040
252b5132
RH		 2041 disasm_info.print_address_func = objdump_print_address;
2042 disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2043
d3ba0551 2044 if (machine != NULL)
252b5132
RH		 2045 {
2046 const bfd_arch_info_type *info = bfd_scan_arch (machine);
98a91d6a 2047
252b5132 2048 if (info == NULL)
98a91d6a
NC		 2049 fatal (_("Can't use supplied machine %s"), machine);
2050
252b5132
RH		 2051 abfd->arch_info = info;
2052 }
2053
2054 if (endian != BFD_ENDIAN_UNKNOWN)
2055 {
2056 struct bfd_target *xvec;
2057
d3ba0551 2058 xvec = xmalloc (sizeof (struct bfd_target));
252b5132
RH		 2059 memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2060 xvec->byteorder = endian;
2061 abfd->xvec = xvec;
2062 }
2063
155e0d23
NC		 2064 /* Use libopcodes to locate a suitable disassembler. */
2065 aux.disassemble_fn = disassembler (abfd);
2066 if (!aux.disassemble_fn)
252b5132 2067 {
37cc8ec1
AM		 2068 non_fatal (_("Can't disassemble for architecture %s\n"),
2069 bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
75cd796a 2070 exit_status = 1;
252b5132
RH		 2071 return;
2072 }
2073
2074 disasm_info.flavour = bfd_get_flavour (abfd);
2075 disasm_info.arch = bfd_get_arch (abfd);
2076 disasm_info.mach = bfd_get_mach (abfd);
dd92f639 2077 disasm_info.disassembler_options = disassembler_options;
155e0d23 2078 disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
0bcb06d2
AS		 2079 disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2080 disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
d99b6465 2081 disasm_info.disassembler_needs_relocs = FALSE;
0af11b59 2082
252b5132 2083 if (bfd_big_endian (abfd))
a8a9050d 2084 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
252b5132 2085 else if (bfd_little_endian (abfd))
a8a9050d 2086 disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
252b5132
RH		 2087 else
2088 /* ??? Aborting here seems too drastic. We could default to big or little
2089 instead. */
2090 disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2091
22a398e1
NC		 2092 /* Allow the target to customize the info structure. */
2093 disassemble_init_for_target (& disasm_info);
2094
155e0d23
NC		 2095 /* Pre-load the dynamic relocs if we are going
2096 to be dumping them along with the disassembly. */
fd7bb956
AM		 2097 if (dump_dynamic_reloc_info)
2098 {
2099 long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
155e0d23 2100
fd7bb956
AM		 2101 if (relsize < 0)
2102 bfd_fatal (bfd_get_filename (abfd));
2103
2104 if (relsize > 0)
2105 {
155e0d23 2106 aux.dynrelbuf = xmalloc (relsize);
3b9ad1cc
AM		 2107 aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2108 aux.dynrelbuf,
2109 dynsyms);
155e0d23 2110 if (aux.dynrelcount < 0)
fd7bb956
AM		 2111 bfd_fatal (bfd_get_filename (abfd));
2112
2113 /* Sort the relocs by address. */
3b9ad1cc
AM		 2114 qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2115 compare_relocs);
fd7bb956
AM		 2116 }
2117 }
2087ad84
PB		 2118 disasm_info.symtab = sorted_syms;
2119 disasm_info.symtab_size = sorted_symcount;
fd7bb956 2120
155e0d23 2121 bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
98a91d6a 2122
155e0d23
NC		 2123 if (aux.dynrelbuf != NULL)
2124 free (aux.dynrelbuf);
252b5132
RH		 2125 free (sorted_syms);
2126}
2127\f
7bcbeb0f
CC		 2128static int
2129load_specific_debug_section (enum dwarf_section_display_enum debug,
2130 asection *sec, void *file)
365544c3
L		 2131{
2132 struct dwarf_section *section = &debug_displays [debug].section;
2133 bfd *abfd = file;
365544c3 2134 bfd_boolean ret;
1b315056 2135 int section_is_compressed;
365544c3
L		 2136
2137 /* If it is already loaded, do nothing. */
2138 if (section->start != NULL)
2139 return 1;
2140
a71cc8e0 2141 section_is_compressed = section->name == section->compressed_name;
365544c3 2142
f5913efe 2143 section->address = 0;
365544c3
L		 2144 section->size = bfd_get_section_size (sec);
2145 section->start = xmalloc (section->size);
2146
2147 if (is_relocatable && debug_displays [debug].relocate)
2148 ret = bfd_simple_get_relocated_section_contents (abfd,
2149 sec,
2150 section->start,
2151 syms) != NULL;
2152 else
2153 ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2154 section->size);
2155
1b315056 2156 if (! ret)
365544c3
L		 2157 {
2158 free_debug_section (debug);
2159 printf (_("\nCan't get contents for section '%s'.\n"),
2160 section->name);
1b315056
CS		 2161 return 0;
2162 }
2163
2164 if (section_is_compressed)
2165 {
2166 bfd_size_type size = section->size;
2167 if (! bfd_uncompress_section_contents (&section->start, &size))
2168 {
2169 free_debug_section (debug);
2170 printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2171 return 0;
2172 }
2173 section->size = size;
365544c3
L		 2174 }
2175
7bcbeb0f
CC		 2176 return 1;
2177}
2178
2179int
2180load_debug_section (enum dwarf_section_display_enum debug, void *file)
2181{
2182 struct dwarf_section *section = &debug_displays [debug].section;
2183 bfd *abfd = file;
2184 asection *sec;
2185
2186 /* If it is already loaded, do nothing. */
2187 if (section->start != NULL)
2188 return 1;
2189
2190 /* Locate the debug section. */
2191 sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2192 if (sec != NULL)
2193 section->name = section->uncompressed_name;
2194 else
2195 {
2196 sec = bfd_get_section_by_name (abfd, section->compressed_name);
2197 if (sec != NULL)
2198 section->name = section->compressed_name;
2199 }
2200 if (sec == NULL)
2201 return 0;
2202
2203 return load_specific_debug_section (debug, sec, file);
365544c3
L		 2204}
2205
2206void
2207free_debug_section (enum dwarf_section_display_enum debug)
2208{
2209 struct dwarf_section *section = &debug_displays [debug].section;
2210
2211 if (section->start == NULL)
2212 return;
2213
2214 free ((char *) section->start);
2215 section->start = NULL;
2216 section->address = 0;
2217 section->size = 0;
2218}
2219
2220static void
2221dump_dwarf_section (bfd *abfd, asection *section,
2222 void *arg ATTRIBUTE_UNUSED)
2223{
2224 const char *name = bfd_get_section_name (abfd, section);
2225 const char *match;
2226 enum dwarf_section_display_enum i;
2227
0112cd26 2228 if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
365544c3
L		 2229 match = ".debug_info";
2230 else
2231 match = name;
2232
2233 for (i = 0; i < max; i++)
4cb93e3b
TG		 2234 if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2235 || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2236 && debug_displays [i].enabled != NULL
2237 && *debug_displays [i].enabled)
365544c3 2238 {
1b315056 2239 if (!debug_displays [i].eh_frame)
365544c3
L		 2240 {
2241 struct dwarf_section *sec = &debug_displays [i].section;
2242
7bcbeb0f
CC		 2243 if (strcmp (sec->uncompressed_name, match) == 0)
2244 sec->name = sec->uncompressed_name;
2245 else
2246 sec->name = sec->compressed_name;
2247 if (load_specific_debug_section (i, section, abfd))
365544c3 2248 {
1b315056 2249 debug_displays [i].display (sec, abfd);
365544c3
L		 2250
2251 if (i != info && i != abbrev)
2252 free_debug_section (i);
2253 }
2254 }
2255 break;
2256 }
2257}
2258
2259/* Dump the dwarf debugging information. */
2260
2261static void
2262dump_dwarf (bfd *abfd)
2263{
5184c2ae 2264 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
365544c3
L		 2265
2266 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2267 targets will return 64. */
2268 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2269
2270 if (bfd_big_endian (abfd))
2271 byte_get = byte_get_big_endian;
2272 else if (bfd_little_endian (abfd))
2273 byte_get = byte_get_little_endian;
2274 else
2275 abort ();
2276
2dc4cec1
L		 2277 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2278 {
2279 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2280 init_dwarf_regnames (bed->elf_machine_code);
2281 }
2282
365544c3
L		 2283 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2284
2285 free_debug_memory ();
2286}
2287\f
29ca8dc5
NS		 2288/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2289 it. Return NULL on failure. */
252b5132 2290
29ca8dc5
NS		 2291static char *
2292read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
252b5132 2293{
29ca8dc5
NS		 2294 asection *stabsect;
2295 bfd_size_type size;
2296 char *contents;
252b5132 2297
29ca8dc5 2298 stabsect = bfd_get_section_by_name (abfd, sect_name);
155e0d23 2299 if (stabsect == NULL)
252b5132 2300 {
29ca8dc5 2301 printf (_("No %s section present\n\n"), sect_name);
b34976b6 2302 return FALSE;
252b5132
RH		 2303 }
2304
29ca8dc5
NS		 2305 size = bfd_section_size (abfd, stabsect);
2306 contents = xmalloc (size);
0af11b59 2307
29ca8dc5 2308 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
252b5132 2309 {
37cc8ec1 2310 non_fatal (_("Reading %s section of %s failed: %s"),
29ca8dc5 2311 sect_name, bfd_get_filename (abfd),
37cc8ec1 2312 bfd_errmsg (bfd_get_error ()));
29ca8dc5 2313 free (contents);
75cd796a 2314 exit_status = 1;
29ca8dc5 2315 return NULL;
252b5132
RH		 2316 }
2317
29ca8dc5 2318 *size_ptr = size;
252b5132 2319
29ca8dc5 2320 return contents;
252b5132
RH		 2321}
2322
2323/* Stabs entries use a 12 byte format:
2324 4 byte string table index
2325 1 byte stab type
2326 1 byte stab other field
2327 2 byte stab desc field
2328 4 byte stab value
2329 FIXME: This will have to change for a 64 bit object format. */
2330
46dca2e0
NC		 2331#define STRDXOFF (0)
2332#define TYPEOFF (4)
2333#define OTHEROFF (5)
2334#define DESCOFF (6)
2335#define VALOFF (8)
252b5132
RH		 2336#define STABSIZE (12)
2337
2338/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2339 using string table section STRSECT_NAME (in `strtab'). */
2340
2341static void
3b9ad1cc
AM		 2342print_section_stabs (bfd *abfd,
2343 const char *stabsect_name,
2344 unsigned *string_offset_ptr)
252b5132
RH		 2345{
2346 int i;
46dca2e0 2347 unsigned file_string_table_offset = 0;
29ca8dc5 2348 unsigned next_file_string_table_offset = *string_offset_ptr;
252b5132
RH		 2349 bfd_byte *stabp, *stabs_end;
2350
2351 stabp = stabs;
2352 stabs_end = stabp + stab_size;
2353
2354 printf (_("Contents of %s section:\n\n"), stabsect_name);
2355 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2356
2357 /* Loop through all symbols and print them.
2358
2359 We start the index at -1 because there is a dummy symbol on
2360 the front of stabs-in-{coff,elf} sections that supplies sizes. */
252b5132
RH		 2361 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2362 {
2363 const char *name;
2364 unsigned long strx;
2365 unsigned char type, other;
2366 unsigned short desc;
2367 bfd_vma value;
2368
2369 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2370 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2371 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2372 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2373 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2374
2375 printf ("\n%-6d ", i);
2376 /* Either print the stab name, or, if unnamed, print its number
0af11b59 2377 again (makes consistent formatting for tools like awk). */
252b5132
RH		 2378 name = bfd_get_stab_name (type);
2379 if (name != NULL)
2380 printf ("%-6s", name);
2381 else if (type == N_UNDF)
2382 printf ("HdrSym");
2383 else
2384 printf ("%-6d", type);
2385 printf (" %-6d %-6d ", other, desc);
d8180c76 2386 bfd_printf_vma (abfd, value);
252b5132
RH		 2387 printf (" %-6lu", strx);
2388
2389 /* Symbols with type == 0 (N_UNDF) specify the length of the
2390 string table associated with this file. We use that info
2391 to know how to relocate the *next* file's string table indices. */
252b5132
RH		 2392 if (type == N_UNDF)
2393 {
2394 file_string_table_offset = next_file_string_table_offset;
2395 next_file_string_table_offset += value;
2396 }
2397 else
2398 {
2399 /* Using the (possibly updated) string table offset, print the
2400 string (if any) associated with this symbol. */
252b5132
RH		 2401 if ((strx + file_string_table_offset) < stabstr_size)
2402 printf (" %s", &strtab[strx + file_string_table_offset]);
2403 else
2404 printf (" *");
2405 }
2406 }
2407 printf ("\n\n");
29ca8dc5 2408 *string_offset_ptr = next_file_string_table_offset;
252b5132
RH		 2409}
2410
155e0d23
NC		 2411typedef struct
2412{
2413 const char * section_name;
2414 const char * string_section_name;
29ca8dc5 2415 unsigned string_offset;
155e0d23
NC		 2416}
2417stab_section_names;
2418
252b5132 2419static void
155e0d23 2420find_stabs_section (bfd *abfd, asection *section, void *names)
252b5132 2421{
155e0d23
NC		 2422 int len;
2423 stab_section_names * sought = (stab_section_names *) names;
252b5132
RH		 2424
2425 /* Check for section names for which stabsect_name is a prefix, to
29ca8dc5 2426 handle .stab.N, etc. */
155e0d23
NC		 2427 len = strlen (sought->section_name);
2428
2429 /* If the prefix matches, and the files section name ends with a
2430 nul or a digit, then we match. I.e., we want either an exact
2431 match or a section followed by a number. */
2432 if (strncmp (sought->section_name, section->name, len) == 0
2433 && (section->name[len] == 0
29ca8dc5 2434 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
252b5132 2435 {
29ca8dc5
NS		 2436 if (strtab == NULL)
2437 strtab = read_section_stabs (abfd, sought->string_section_name,
2438 &stabstr_size);
2439
2440 if (strtab)
252b5132 2441 {
9210d879
AM		 2442 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2443 &stab_size);
29ca8dc5
NS		 2444 if (stabs)
2445 print_section_stabs (abfd, section->name, &sought->string_offset);
252b5132
RH		 2446 }
2447 }
2448}
98a91d6a 2449
155e0d23
NC		 2450static void
2451dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2452{
2453 stab_section_names s;
2454
2455 s.section_name = stabsect_name;
2456 s.string_section_name = strsect_name;
29ca8dc5
NS		 2457 s.string_offset = 0;
2458
155e0d23 2459 bfd_map_over_sections (abfd, find_stabs_section, & s);
29ca8dc5
NS		 2460
2461 free (strtab);
2462 strtab = NULL;
155e0d23
NC		 2463}
2464
2465/* Dump the any sections containing stabs debugging information. */
2466
2467static void
2468dump_stabs (bfd *abfd)
2469{
2470 dump_stabs_section (abfd, ".stab", ".stabstr");
2471 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2472 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
62bb81b8
TG		 2473
2474 /* For Darwin. */
2475 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2476
155e0d23
NC		 2477 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2478}
252b5132
RH		 2479\f
2480static void
46dca2e0 2481dump_bfd_header (bfd *abfd)
252b5132
RH		 2482{
2483 char *comma = "";
2484
2485 printf (_("architecture: %s, "),
2486 bfd_printable_arch_mach (bfd_get_arch (abfd),
2487 bfd_get_mach (abfd)));
2488 printf (_("flags 0x%08x:\n"), abfd->flags);
2489
2490#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2491 PF (HAS_RELOC, "HAS_RELOC");
2492 PF (EXEC_P, "EXEC_P");
2493 PF (HAS_LINENO, "HAS_LINENO");
2494 PF (HAS_DEBUG, "HAS_DEBUG");
2495 PF (HAS_SYMS, "HAS_SYMS");
2496 PF (HAS_LOCALS, "HAS_LOCALS");
2497 PF (DYNAMIC, "DYNAMIC");
2498 PF (WP_TEXT, "WP_TEXT");
2499 PF (D_PAGED, "D_PAGED");
2500 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
026df7c5 2501 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
252b5132 2502 printf (_("\nstart address 0x"));
d8180c76 2503 bfd_printf_vma (abfd, abfd->start_address);
252b5132
RH		 2504 printf ("\n");
2505}
98a91d6a 2506
252b5132
RH		 2507\f
2508static void
46dca2e0 2509dump_bfd_private_header (bfd *abfd)
252b5132
RH		 2510{
2511 bfd_print_private_bfd_data (abfd, stdout);
2512}
2513
155e0d23
NC		 2514\f
2515/* Display a section in hexadecimal format with associated characters.
2516 Each line prefixed by the zero padded address. */
d24de309 2517
252b5132 2518static void
155e0d23 2519dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
252b5132 2520{
155e0d23
NC		 2521 bfd_byte *data = 0;
2522 bfd_size_type datasize;
2523 bfd_size_type addr_offset;
2524 bfd_size_type start_offset;
2525 bfd_size_type stop_offset;
2526 unsigned int opb = bfd_octets_per_byte (abfd);
2527 /* Bytes per line. */
2528 const int onaline = 16;
2529 char buf[64];
2530 int count;
2531 int width;
2532
2533 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2534 return;
2535
2536 if (! process_section_p (section))
2537 return;
2538
2539 if ((datasize = bfd_section_size (abfd, section)) == 0)
2540 return;
2541
155e0d23
NC		 2542 /* Compute the address range to display. */
2543 if (start_address == (bfd_vma) -1
2544 || start_address < section->vma)
2545 start_offset = 0;
2546 else
2547 start_offset = start_address - section->vma;
2548
2549 if (stop_address == (bfd_vma) -1)
2550 stop_offset = datasize / opb;
2551 else
252b5132 2552 {
155e0d23
NC		 2553 if (stop_address < section->vma)
2554 stop_offset = 0;
2555 else
2556 stop_offset = stop_address - section->vma;
252b5132 2557
155e0d23
NC		 2558 if (stop_offset > datasize / opb)
2559 stop_offset = datasize / opb;
252b5132
RH		 2560 }
2561
32760852
NC		 2562 if (start_offset >= stop_offset)
2563 return;
2564
2565 printf (_("Contents of section %s:"), section->name);
2566 if (display_file_offsets)
0af1713e
AM		 2567 printf (_(" (Starting at file offset: 0x%lx)"),
2568 (unsigned long) (section->filepos + start_offset));
32760852
NC		 2569 printf ("\n");
2570
2571 data = xmalloc (datasize);
2572
2573 bfd_get_section_contents (abfd, section, data, 0, datasize);
2574
155e0d23 2575 width = 4;
026df7c5 2576
155e0d23
NC		 2577 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2578 if (strlen (buf) >= sizeof (buf))
2579 abort ();
026df7c5 2580
155e0d23
NC		 2581 count = 0;
2582 while (buf[count] == '0' && buf[count+1] != '\0')
2583 count++;
2584 count = strlen (buf) - count;
2585 if (count > width)
2586 width = count;
252b5132 2587
155e0d23
NC		 2588 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2589 if (strlen (buf) >= sizeof (buf))
2590 abort ();
026df7c5 2591
155e0d23
NC		 2592 count = 0;
2593 while (buf[count] == '0' && buf[count+1] != '\0')
2594 count++;
2595 count = strlen (buf) - count;
2596 if (count > width)
2597 width = count;
026df7c5 2598
155e0d23
NC		 2599 for (addr_offset = start_offset;
2600 addr_offset < stop_offset; addr_offset += onaline / opb)
d24de309 2601 {
155e0d23 2602 bfd_size_type j;
d24de309 2603
155e0d23
NC		 2604 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2605 count = strlen (buf);
2606 if ((size_t) count >= sizeof (buf))
2607 abort ();
d24de309 2608
155e0d23
NC		 2609 putchar (' ');
2610 while (count < width)
252b5132 2611 {
155e0d23
NC		 2612 putchar ('0');
2613 count++;
2614 }
2615 fputs (buf + count - width, stdout);
2616 putchar (' ');
252b5132 2617
155e0d23
NC		 2618 for (j = addr_offset * opb;
2619 j < addr_offset * opb + onaline; j++)
2620 {
2621 if (j < stop_offset * opb)
2622 printf ("%02x", (unsigned) (data[j]));
2623 else
2624 printf (" ");
2625 if ((j & 3) == 3)
2626 printf (" ");
252b5132
RH		 2627 }
2628
155e0d23
NC		 2629 printf (" ");
2630 for (j = addr_offset * opb;
2631 j < addr_offset * opb + onaline; j++)
2632 {
2633 if (j >= stop_offset * opb)
2634 printf (" ");
2635 else
2636 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2637 }
2638 putchar ('\n');
252b5132 2639 }
155e0d23 2640 free (data);
252b5132 2641}
155e0d23 2642
98a91d6a 2643/* Actually display the various requested regions. */
252b5132
RH		 2644
2645static void
46dca2e0 2646dump_data (bfd *abfd)
252b5132 2647{
155e0d23 2648 bfd_map_over_sections (abfd, dump_section, NULL);
252b5132
RH		 2649}
2650
98a91d6a
NC		 2651/* Should perhaps share code and display with nm? */
2652
252b5132 2653static void
46dca2e0 2654dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
252b5132
RH		 2655{
2656 asymbol **current;
2657 long max;
2658 long count;
2659
2660 if (dynamic)
2661 {
2662 current = dynsyms;
2663 max = dynsymcount;
252b5132
RH		 2664 printf ("DYNAMIC SYMBOL TABLE:\n");
2665 }
2666 else
2667 {
2668 current = syms;
2669 max = symcount;
252b5132
RH		 2670 printf ("SYMBOL TABLE:\n");
2671 }
2672
a1df01d1
AM		 2673 if (max == 0)
2674 printf (_("no symbols\n"));
2675
252b5132
RH		 2676 for (count = 0; count < max; count++)
2677 {
155e0d23
NC		 2678 bfd *cur_bfd;
2679
2680 if (*current == NULL)
83ef0798 2681 printf (_("no information for symbol number %ld\n"), count);
155e0d23
NC		 2682
2683 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
83ef0798 2684 printf (_("could not determine the type of symbol number %ld\n"),
155e0d23
NC		 2685 count);
2686
661f7c35
NC		 2687 else if (process_section_p ((* current)->section)
2688 && (dump_special_syms
2689 || !bfd_is_target_special_symbol (cur_bfd, *current)))
252b5132 2690 {
155e0d23 2691 const char *name = (*current)->name;
252b5132 2692
155e0d23 2693 if (do_demangle && name != NULL && *name != '\0')
252b5132 2694 {
252b5132
RH		 2695 char *alloc;
2696
155e0d23
NC		 2697 /* If we want to demangle the name, we demangle it
2698 here, and temporarily clobber it while calling
2699 bfd_print_symbol. FIXME: This is a gross hack. */
ed180cc5
AM		 2700 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2701 if (alloc != NULL)
2702 (*current)->name = alloc;
252b5132
RH		 2703 bfd_print_symbol (cur_bfd, stdout, *current,
2704 bfd_print_symbol_all);
ed180cc5
AM		 2705 if (alloc != NULL)
2706 {
2707 (*current)->name = name;
2708 free (alloc);
2709 }
252b5132 2710 }
252b5132 2711 else
155e0d23
NC		 2712 bfd_print_symbol (cur_bfd, stdout, *current,
2713 bfd_print_symbol_all);
83ef0798 2714 printf ("\n");
252b5132 2715 }
661f7c35 2716
155e0d23 2717 current++;
252b5132 2718 }
155e0d23 2719 printf ("\n\n");
252b5132 2720}
155e0d23 2721\f
252b5132 2722static void
46dca2e0 2723dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
252b5132
RH		 2724{
2725 arelent **p;
2726 char *last_filename, *last_functionname;
2727 unsigned int last_line;
2728
2729 /* Get column headers lined up reasonably. */
2730 {
2731 static int width;
98a91d6a 2732
252b5132
RH		 2733 if (width == 0)
2734 {
2735 char buf[30];
155e0d23 2736
d8180c76 2737 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
252b5132
RH		 2738 width = strlen (buf) - 7;
2739 }
2740 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2741 }
2742
2743 last_filename = NULL;
2744 last_functionname = NULL;
2745 last_line = 0;
2746
d3ba0551 2747 for (p = relpp; relcount && *p != NULL; p++, relcount--)
252b5132
RH		 2748 {
2749 arelent *q = *p;
2750 const char *filename, *functionname;
2751 unsigned int line;
2752 const char *sym_name;
2753 const char *section_name;
2754
2755 if (start_address != (bfd_vma) -1
2756 && q->address < start_address)
2757 continue;
2758 if (stop_address != (bfd_vma) -1
2759 && q->address > stop_address)
2760 continue;
2761
2762 if (with_line_numbers
2763 && sec != NULL
2764 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2765 &filename, &functionname, &line))
2766 {
2767 if (functionname != NULL
2768 && (last_functionname == NULL
2769 || strcmp (functionname, last_functionname) != 0))
2770 {
2771 printf ("%s():\n", functionname);
2772 if (last_functionname != NULL)
2773 free (last_functionname);
2774 last_functionname = xstrdup (functionname);
2775 }
98a91d6a 2776
252b5132
RH		 2777 if (line > 0
2778 && (line != last_line
2779 || (filename != NULL
2780 && last_filename != NULL
2781 && strcmp (filename, last_filename) != 0)))
2782 {
2783 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2784 last_line = line;
2785 if (last_filename != NULL)
2786 free (last_filename);
2787 if (filename == NULL)
2788 last_filename = NULL;
2789 else
2790 last_filename = xstrdup (filename);
2791 }
2792 }
2793
2794 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2795 {
2796 sym_name = (*(q->sym_ptr_ptr))->name;
2797 section_name = (*(q->sym_ptr_ptr))->section->name;
2798 }
2799 else
2800 {
2801 sym_name = NULL;
2802 section_name = NULL;
2803 }
98a91d6a 2804
f9ecb0a4
JJ		 2805 bfd_printf_vma (abfd, q->address);
2806 if (q->howto == NULL)
2807 printf (" *unknown* ");
2808 else if (q->howto->name)
2809 printf (" %-16s ", q->howto->name);
2810 else
2811 printf (" %-16d ", q->howto->type);
171191ba 2812
252b5132 2813 if (sym_name)
171191ba
NC		 2814 {
2815 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
171191ba 2816 }
252b5132
RH		 2817 else
2818 {
d3ba0551 2819 if (section_name == NULL)
252b5132 2820 section_name = "*unknown*";
f9ecb0a4 2821 printf ("[%s]", section_name);
252b5132 2822 }
98a91d6a 2823
252b5132
RH		 2824 if (q->addend)
2825 {
2826 printf ("+0x");
d8180c76 2827 bfd_printf_vma (abfd, q->addend);
252b5132 2828 }
98a91d6a 2829
252b5132
RH		 2830 printf ("\n");
2831 }
2832}
43ac9881 2833
155e0d23 2834static void
3b9ad1cc
AM		 2835dump_relocs_in_section (bfd *abfd,
2836 asection *section,
2837 void *dummy ATTRIBUTE_UNUSED)
155e0d23
NC		 2838{
2839 arelent **relpp;
2840 long relcount;
2841 long relsize;
2842
2843 if ( bfd_is_abs_section (section)
2844 || bfd_is_und_section (section)
2845 || bfd_is_com_section (section)
2846 || (! process_section_p (section))
2847 || ((section->flags & SEC_RELOC) == 0))
2848 return;
2849
2850 relsize = bfd_get_reloc_upper_bound (abfd, section);
2851 if (relsize < 0)
2852 bfd_fatal (bfd_get_filename (abfd));
2853
2854 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2855
2856 if (relsize == 0)
2857 {
2858 printf (" (none)\n\n");
2859 return;
2860 }
2861
2862 relpp = xmalloc (relsize);
2863 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2864
2865 if (relcount < 0)
2866 bfd_fatal (bfd_get_filename (abfd));
2867 else if (relcount == 0)
2868 printf (" (none)\n\n");
2869 else
2870 {
2871 printf ("\n");
2872 dump_reloc_set (abfd, section, relpp, relcount);
2873 printf ("\n\n");
2874 }
2875 free (relpp);
2876}
2877
2878static void
2879dump_relocs (bfd *abfd)
2880{
2881 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2882}
2883
2884static void
2885dump_dynamic_relocs (bfd *abfd)
2886{
2887 long relsize;
2888 arelent **relpp;
2889 long relcount;
2890
2891 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2892 if (relsize < 0)
2893 bfd_fatal (bfd_get_filename (abfd));
2894
2895 printf ("DYNAMIC RELOCATION RECORDS");
2896
2897 if (relsize == 0)
2898 printf (" (none)\n\n");
2899 else
2900 {
2901 relpp = xmalloc (relsize);
2902 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2903
2904 if (relcount < 0)
2905 bfd_fatal (bfd_get_filename (abfd));
2906 else if (relcount == 0)
2907 printf (" (none)\n\n");
2908 else
2909 {
2910 printf ("\n");
2911 dump_reloc_set (abfd, NULL, relpp, relcount);
2912 printf ("\n\n");
2913 }
2914 free (relpp);
2915 }
2916}
2917
43ac9881
AM		 2918/* Creates a table of paths, to search for source files. */
2919
2920static void
2921add_include_path (const char *path)
2922{
2923 if (path[0] == 0)
2924 return;
2925 include_path_count++;
2926 include_paths = xrealloc (include_paths,
2927 include_path_count * sizeof (*include_paths));
2928#ifdef HAVE_DOS_BASED_FILE_SYSTEM
2929 if (path[1] == ':' && path[2] == 0)
2930 path = concat (path, ".", (const char *) 0);
2931#endif
2932 include_paths[include_path_count - 1] = path;
2933}
155e0d23
NC		 2934
2935static void
3b9ad1cc
AM		 2936adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2937 asection *section,
bc79cded 2938 void *arg)
155e0d23 2939{
bc79cded
L		 2940 if ((section->flags & SEC_DEBUGGING) == 0)
2941 {
2942 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2943 section->vma += adjust_section_vma;
2944 if (*has_reloc_p)
2945 section->lma += adjust_section_vma;
2946 }
155e0d23
NC		 2947}
2948
2949/* Dump selected contents of ABFD. */
2950
2951static void
2952dump_bfd (bfd *abfd)
2953{
2954 /* If we are adjusting section VMA's, change them all now. Changing
2955 the BFD information is a hack. However, we must do it, or
2956 bfd_find_nearest_line will not do the right thing. */
2957 if (adjust_section_vma != 0)
bc79cded
L		 2958 {
2959 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2960 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2961 }
155e0d23
NC		 2962
2963 if (! dump_debugging_tags)
2964 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2965 abfd->xvec->name);
2966 if (dump_ar_hdrs)
2967 print_arelt_descr (stdout, abfd, TRUE);
2968 if (dump_file_header)
2969 dump_bfd_header (abfd);
2970 if (dump_private_headers)
2971 dump_bfd_private_header (abfd);
2972 if (! dump_debugging_tags)
2973 putchar ('\n');
2974 if (dump_section_headers)
2975 dump_headers (abfd);
2976
365544c3
L		 2977 if (dump_symtab
2978 || dump_reloc_info
2979 || disassemble
2980 || dump_debugging
2981 || dump_dwarf_section_info)
155e0d23 2982 syms = slurp_symtab (abfd);
4c45e5c9
JJ		 2983 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2984 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
155e0d23 2985 dynsyms = slurp_dynamic_symtab (abfd);
90e3cdf2 2986 if (disassemble)
4c45e5c9 2987 {
c9727e01
AM		 2988 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2989 dynsymcount, dynsyms, &synthsyms);
2990 if (synthcount < 0)
2991 synthcount = 0;
4c45e5c9 2992 }
155e0d23
NC		 2993
2994 if (dump_symtab)
2995 dump_symbols (abfd, FALSE);
2996 if (dump_dynamic_symtab)
2997 dump_symbols (abfd, TRUE);
365544c3
L		 2998 if (dump_dwarf_section_info)
2999 dump_dwarf (abfd);
155e0d23
NC		 3000 if (dump_stab_section_info)
3001 dump_stabs (abfd);
3002 if (dump_reloc_info && ! disassemble)
3003 dump_relocs (abfd);
3004 if (dump_dynamic_reloc_info && ! disassemble)
3005 dump_dynamic_relocs (abfd);
3006 if (dump_section_contents)
3007 dump_data (abfd);
3008 if (disassemble)
3009 disassemble_data (abfd);
3010
3011 if (dump_debugging)
3012 {
3013 void *dhandle;
3014
b922d590 3015 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
155e0d23
NC		 3016 if (dhandle != NULL)
3017 {
ed180cc5
AM		 3018 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3019 bfd_demangle,
3020 dump_debugging_tags ? TRUE : FALSE))
155e0d23
NC		 3021 {
3022 non_fatal (_("%s: printing debugging information failed"),
3023 bfd_get_filename (abfd));
3024 exit_status = 1;
3025 }
3026 }
b922d590
NC		 3027 /* PR 6483: If there was no STABS or IEEE debug
3028 info in the file, try DWARF instead. */
3029 else if (! dump_dwarf_section_info)
3030 {
3031 dump_dwarf (abfd);
3032 }
155e0d23
NC		 3033 }
3034
3035 if (syms)
3036 {
3037 free (syms);
3038 syms = NULL;
3039 }
3040
3041 if (dynsyms)
3042 {
3043 free (dynsyms);
3044 dynsyms = NULL;
3045 }
4c45e5c9
JJ		 3046
3047 if (synthsyms)
3048 {
3049 free (synthsyms);
3050 synthsyms = NULL;
3051 }
3052
3053 symcount = 0;
3054 dynsymcount = 0;
3055 synthcount = 0;
155e0d23
NC		 3056}
3057
3058static void
3059display_bfd (bfd *abfd)
3060{
3061 char **matching;
3062
3063 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3064 {
3065 dump_bfd (abfd);
3066 return;
3067 }
3068
3069 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3070 {
3071 nonfatal (bfd_get_filename (abfd));
3072 list_matching_formats (matching);
3073 free (matching);
3074 return;
3075 }
3076
3077 if (bfd_get_error () != bfd_error_file_not_recognized)
3078 {
3079 nonfatal (bfd_get_filename (abfd));
3080 return;
3081 }
3082
3083 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3084 {
3085 dump_bfd (abfd);
3086 return;
3087 }
3088
3089 nonfatal (bfd_get_filename (abfd));
3090
3091 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3092 {
3093 list_matching_formats (matching);
3094 free (matching);
3095 }
3096}
3097
3098static void
3099display_file (char *filename, char *target)
3100{
f24ddbdd
NC		 3101 bfd *file;
3102 bfd *arfile = NULL;
3103
3104 if (get_file_size (filename) < 1)
d68c385b
NC		 3105 {
3106 exit_status = 1;
3107 return;
3108 }
155e0d23
NC		 3109
3110 file = bfd_openr (filename, target);
3111 if (file == NULL)
3112 {
3113 nonfatal (filename);
3114 return;
3115 }
3116
3117 /* If the file is an archive, process all of its elements. */
3118 if (bfd_check_format (file, bfd_archive))
3119 {
3120 bfd *last_arfile = NULL;
3121
3122 printf (_("In archive %s:\n"), bfd_get_filename (file));
3123 for (;;)
3124 {
3125 bfd_set_error (bfd_error_no_error);
3126
3127 arfile = bfd_openr_next_archived_file (file, arfile);
3128 if (arfile == NULL)
3129 {
3130 if (bfd_get_error () != bfd_error_no_more_archived_files)
3131 nonfatal (bfd_get_filename (file));
3132 break;
3133 }
3134
3135 display_bfd (arfile);
3136
3137 if (last_arfile != NULL)
3138 bfd_close (last_arfile);
3139 last_arfile = arfile;
3140 }
3141
3142 if (last_arfile != NULL)
3143 bfd_close (last_arfile);
3144 }
3145 else
3146 display_bfd (file);
3147
3148 bfd_close (file);
3149}
252b5132 3150\f
252b5132 3151int
46dca2e0 3152main (int argc, char **argv)
252b5132
RH		 3153{
3154 int c;
3155 char *target = default_target;
b34976b6 3156 bfd_boolean seenflag = FALSE;
252b5132 3157
155e0d23
NC		 3158#if defined (HAVE_SETLOCALE)
3159#if defined (HAVE_LC_MESSAGES)
252b5132 3160 setlocale (LC_MESSAGES, "");
3882b010 3161#endif
3882b010 3162 setlocale (LC_CTYPE, "");
252b5132 3163#endif
155e0d23 3164
252b5132
RH		 3165 bindtextdomain (PACKAGE, LOCALEDIR);
3166 textdomain (PACKAGE);
3167
3168 program_name = *argv;
3169 xmalloc_set_program_name (program_name);
3170
3171 START_PROGRESS (program_name, 0);
3172
869b9d07
MM		 3173 expandargv (&argc, &argv);
3174
252b5132
RH		 3175 bfd_init ();
3176 set_default_bfd_target ();
3177
4cb93e3b
TG		 3178 while ((c = getopt_long (argc, argv,
3179 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
252b5132
RH		 3180 long_options, (int *) 0))
3181 != EOF)
3182 {
252b5132
RH		 3183 switch (c)
3184 {
3185 case 0:
8b53311e 3186 break; /* We've been given a long option. */
252b5132
RH		 3187 case 'm':
3188 machine = optarg;
3189 break;
dd92f639 3190 case 'M':
073fbac6 3191 if (disassembler_options)
31e0f3cd 3192 /* Ignore potential memory leak for now. */
46dca2e0 3193 disassembler_options = concat (disassembler_options, ",",
ee832e18 3194 optarg, (const char *) NULL);
31e0f3cd
NC		 3195 else
3196 disassembler_options = optarg;
dd92f639 3197 break;
252b5132 3198 case 'j':
43ac9881 3199 if (only_used == only_size)
6e50c90c
L		 3200 {
3201 only_size += 8;
43ac9881 3202 only = xrealloc (only, only_size * sizeof (char *));
6e50c90c
L		 3203 }
3204 only [only_used++] = optarg;
252b5132 3205 break;
98ec6e72
NC		 3206 case 'F':
3207 display_file_offsets = TRUE;
3208 break;
252b5132 3209 case 'l':
b34976b6 3210 with_line_numbers = TRUE;
252b5132
RH		 3211 break;
3212 case 'b':
3213 target = optarg;
3214 break;
1dada9c5 3215 case 'C':
b34976b6 3216 do_demangle = TRUE;
28c309a2
NC		 3217 if (optarg != NULL)
3218 {
3219 enum demangling_styles style;
8b53311e 3220
28c309a2 3221 style = cplus_demangle_name_to_style (optarg);
0af11b59 3222 if (style == unknown_demangling)
28c309a2
NC		 3223 fatal (_("unknown demangling style `%s'"),
3224 optarg);
8b53311e 3225
28c309a2 3226 cplus_demangle_set_style (style);
0af11b59 3227 }
1dada9c5
NC		 3228 break;
3229 case 'w':
b34976b6 3230 wide_output = TRUE;
1dada9c5
NC		 3231 break;
3232 case OPTION_ADJUST_VMA:
3233 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3234 break;
3235 case OPTION_START_ADDRESS:
3236 start_address = parse_vma (optarg, "--start-address");
98ec6e72
NC		 3237 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3238 fatal (_("error: the start address should be before the end address"));
1dada9c5
NC		 3239 break;
3240 case OPTION_STOP_ADDRESS:
3241 stop_address = parse_vma (optarg, "--stop-address");
98ec6e72
NC		 3242 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3243 fatal (_("error: the stop address should be after the start address"));
1dada9c5 3244 break;
0dafdf3f
L		 3245 case OPTION_PREFIX:
3246 prefix = optarg;
3247 prefix_length = strlen (prefix);
3248 /* Remove an unnecessary trailing '/' */
3249 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3250 prefix_length--;
3251 break;
3252 case OPTION_PREFIX_STRIP:
3253 prefix_strip = atoi (optarg);
3254 if (prefix_strip < 0)
3255 fatal (_("error: prefix strip must be non-negative"));
3256 break;
1dada9c5
NC		 3257 case 'E':
3258 if (strcmp (optarg, "B") == 0)
3259 endian = BFD_ENDIAN_BIG;
3260 else if (strcmp (optarg, "L") == 0)
3261 endian = BFD_ENDIAN_LITTLE;
3262 else
3263 {
37cc8ec1 3264 non_fatal (_("unrecognized -E option"));
1dada9c5
NC		 3265 usage (stderr, 1);
3266 }
3267 break;
3268 case OPTION_ENDIAN:
3269 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3270 endian = BFD_ENDIAN_BIG;
3271 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3272 endian = BFD_ENDIAN_LITTLE;
3273 else
3274 {
37cc8ec1 3275 non_fatal (_("unrecognized --endian type `%s'"), optarg);
1dada9c5
NC		 3276 usage (stderr, 1);
3277 }
3278 break;
8b53311e 3279
252b5132 3280 case 'f':
b34976b6
AM		 3281 dump_file_header = TRUE;
3282 seenflag = TRUE;
252b5132
RH		 3283 break;
3284 case 'i':
b34976b6
AM		 3285 formats_info = TRUE;
3286 seenflag = TRUE;
252b5132 3287 break;
43ac9881
AM		 3288 case 'I':
3289 add_include_path (optarg);
3290 break;
252b5132 3291 case 'p':
b34976b6
AM		 3292 dump_private_headers = TRUE;
3293 seenflag = TRUE;
252b5132
RH		 3294 break;
3295 case 'x':
b34976b6
AM		 3296 dump_private_headers = TRUE;
3297 dump_symtab = TRUE;
3298 dump_reloc_info = TRUE;
3299 dump_file_header = TRUE;
3300 dump_ar_hdrs = TRUE;
3301 dump_section_headers = TRUE;
3302 seenflag = TRUE;
252b5132
RH		 3303 break;
3304 case 't':
b34976b6
AM		 3305 dump_symtab = TRUE;
3306 seenflag = TRUE;
252b5132
RH		 3307 break;
3308 case 'T':
b34976b6
AM		 3309 dump_dynamic_symtab = TRUE;
3310 seenflag = TRUE;
252b5132
RH		 3311 break;
3312 case 'd':
b34976b6
AM		 3313 disassemble = TRUE;
3314 seenflag = TRUE;
1dada9c5
NC		 3315 break;
3316 case 'z':
b34976b6 3317 disassemble_zeroes = TRUE;
252b5132
RH		 3318 break;
3319 case 'D':
b34976b6
AM		 3320 disassemble = TRUE;
3321 disassemble_all = TRUE;
3322 seenflag = TRUE;
252b5132
RH		 3323 break;
3324 case 'S':
b34976b6
AM		 3325 disassemble = TRUE;
3326 with_source_code = TRUE;
3327 seenflag = TRUE;
1dada9c5
NC		 3328 break;
3329 case 'g':
3330 dump_debugging = 1;
b34976b6 3331 seenflag = TRUE;
1dada9c5 3332 break;
51cdc6e0
NC		 3333 case 'e':
3334 dump_debugging = 1;
3335 dump_debugging_tags = 1;
3336 do_demangle = TRUE;
3337 seenflag = TRUE;
3338 break;
365544c3
L		 3339 case 'W':
3340 dump_dwarf_section_info = TRUE;
3341 seenflag = TRUE;
4cb93e3b
TG		 3342 if (optarg)
3343 dwarf_select_sections_by_letters (optarg);
3344 else
3345 dwarf_select_sections_all ();
3346 break;
3347 case OPTION_DWARF:
3348 dump_dwarf_section_info = TRUE;
3349 seenflag = TRUE;
3350 if (optarg)
3351 dwarf_select_sections_by_names (optarg);
3352 else
3353 dwarf_select_sections_all ();
365544c3 3354 break;
1dada9c5 3355 case 'G':
b34976b6
AM		 3356 dump_stab_section_info = TRUE;
3357 seenflag = TRUE;
252b5132
RH		 3358 break;
3359 case 's':
b34976b6
AM		 3360 dump_section_contents = TRUE;
3361 seenflag = TRUE;
252b5132
RH		 3362 break;
3363 case 'r':
b34976b6
AM		 3364 dump_reloc_info = TRUE;
3365 seenflag = TRUE;
252b5132
RH		 3366 break;
3367 case 'R':
b34976b6
AM		 3368 dump_dynamic_reloc_info = TRUE;
3369 seenflag = TRUE;
252b5132
RH		 3370 break;
3371 case 'a':
b34976b6
AM		 3372 dump_ar_hdrs = TRUE;
3373 seenflag = TRUE;
252b5132
RH		 3374 break;
3375 case 'h':
b34976b6
AM		 3376 dump_section_headers = TRUE;
3377 seenflag = TRUE;
252b5132
RH		 3378 break;
3379 case 'H':
3380 usage (stdout, 0);
b34976b6 3381 seenflag = TRUE;
8b53311e 3382 case 'v':
252b5132 3383 case 'V':
b34976b6
AM		 3384 show_version = TRUE;
3385 seenflag = TRUE;
252b5132 3386 break;
0af11b59 3387
252b5132
RH		 3388 default:
3389 usage (stderr, 1);
3390 }
3391 }
3392
3393 if (show_version)
3394 print_version ("objdump");
3395
b34976b6 3396 if (!seenflag)
1dada9c5 3397 usage (stderr, 2);
252b5132
RH		 3398
3399 if (formats_info)
06d86cf7 3400 exit_status = display_info ();
252b5132
RH		 3401 else
3402 {
3403 if (optind == argc)
3404 display_file ("a.out", target);
3405 else
3406 for (; optind < argc;)
3407 display_file (argv[optind++], target);
3408 }
3409
3410 END_PROGRESS (program_name);
3411
75cd796a 3412 return exit_status;
252b5132 3413}
GDB Binutils - Deliverables
This page took 0.574904 seconds and 4 git commands to generate.