projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR 10288
[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 {
c8450da8 2239 struct dwarf_section *sec = &debug_displays [i].section;
365544c3 2240
c8450da8
TG		 2241 if (strcmp (sec->uncompressed_name, match) == 0)
2242 sec->name = sec->uncompressed_name;
2243 else
2244 sec->name = sec->compressed_name;
2245 if (load_specific_debug_section (i, section, abfd))
2246 {
2247 debug_displays [i].display (sec, abfd);
2248
2249 if (i != info && i != abbrev)
2250 free_debug_section (i);
365544c3
L		 2251 }
2252 break;
2253 }
2254}
2255
2256/* Dump the dwarf debugging information. */
2257
2258static void
2259dump_dwarf (bfd *abfd)
2260{
5184c2ae 2261 is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
365544c3
L		 2262
2263 /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
2264 targets will return 64. */
2265 eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2266
2267 if (bfd_big_endian (abfd))
2268 byte_get = byte_get_big_endian;
2269 else if (bfd_little_endian (abfd))
2270 byte_get = byte_get_little_endian;
2271 else
2272 abort ();
2273
2dc4cec1
L		 2274 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2275 {
2276 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2277 init_dwarf_regnames (bed->elf_machine_code);
2278 }
2279
365544c3
L		 2280 bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2281
2282 free_debug_memory ();
2283}
2284\f
29ca8dc5
NS		 2285/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2286 it. Return NULL on failure. */
252b5132 2287
29ca8dc5
NS		 2288static char *
2289read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
252b5132 2290{
29ca8dc5
NS		 2291 asection *stabsect;
2292 bfd_size_type size;
2293 char *contents;
252b5132 2294
29ca8dc5 2295 stabsect = bfd_get_section_by_name (abfd, sect_name);
155e0d23 2296 if (stabsect == NULL)
252b5132 2297 {
29ca8dc5 2298 printf (_("No %s section present\n\n"), sect_name);
b34976b6 2299 return FALSE;
252b5132
RH		 2300 }
2301
29ca8dc5
NS		 2302 size = bfd_section_size (abfd, stabsect);
2303 contents = xmalloc (size);
0af11b59 2304
29ca8dc5 2305 if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
252b5132 2306 {
37cc8ec1 2307 non_fatal (_("Reading %s section of %s failed: %s"),
29ca8dc5 2308 sect_name, bfd_get_filename (abfd),
37cc8ec1 2309 bfd_errmsg (bfd_get_error ()));
29ca8dc5 2310 free (contents);
75cd796a 2311 exit_status = 1;
29ca8dc5 2312 return NULL;
252b5132
RH		 2313 }
2314
29ca8dc5 2315 *size_ptr = size;
252b5132 2316
29ca8dc5 2317 return contents;
252b5132
RH		 2318}
2319
2320/* Stabs entries use a 12 byte format:
2321 4 byte string table index
2322 1 byte stab type
2323 1 byte stab other field
2324 2 byte stab desc field
2325 4 byte stab value
2326 FIXME: This will have to change for a 64 bit object format. */
2327
46dca2e0
NC		 2328#define STRDXOFF (0)
2329#define TYPEOFF (4)
2330#define OTHEROFF (5)
2331#define DESCOFF (6)
2332#define VALOFF (8)
252b5132
RH		 2333#define STABSIZE (12)
2334
2335/* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2336 using string table section STRSECT_NAME (in `strtab'). */
2337
2338static void
3b9ad1cc
AM		 2339print_section_stabs (bfd *abfd,
2340 const char *stabsect_name,
2341 unsigned *string_offset_ptr)
252b5132
RH		 2342{
2343 int i;
46dca2e0 2344 unsigned file_string_table_offset = 0;
29ca8dc5 2345 unsigned next_file_string_table_offset = *string_offset_ptr;
252b5132
RH		 2346 bfd_byte *stabp, *stabs_end;
2347
2348 stabp = stabs;
2349 stabs_end = stabp + stab_size;
2350
2351 printf (_("Contents of %s section:\n\n"), stabsect_name);
2352 printf ("Symnum n_type n_othr n_desc n_value n_strx String\n");
2353
2354 /* Loop through all symbols and print them.
2355
2356 We start the index at -1 because there is a dummy symbol on
2357 the front of stabs-in-{coff,elf} sections that supplies sizes. */
252b5132
RH		 2358 for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2359 {
2360 const char *name;
2361 unsigned long strx;
2362 unsigned char type, other;
2363 unsigned short desc;
2364 bfd_vma value;
2365
2366 strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2367 type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2368 other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2369 desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2370 value = bfd_h_get_32 (abfd, stabp + VALOFF);
2371
2372 printf ("\n%-6d ", i);
2373 /* Either print the stab name, or, if unnamed, print its number
0af11b59 2374 again (makes consistent formatting for tools like awk). */
252b5132
RH		 2375 name = bfd_get_stab_name (type);
2376 if (name != NULL)
2377 printf ("%-6s", name);
2378 else if (type == N_UNDF)
2379 printf ("HdrSym");
2380 else
2381 printf ("%-6d", type);
2382 printf (" %-6d %-6d ", other, desc);
d8180c76 2383 bfd_printf_vma (abfd, value);
252b5132
RH		 2384 printf (" %-6lu", strx);
2385
2386 /* Symbols with type == 0 (N_UNDF) specify the length of the
2387 string table associated with this file. We use that info
2388 to know how to relocate the *next* file's string table indices. */
252b5132
RH		 2389 if (type == N_UNDF)
2390 {
2391 file_string_table_offset = next_file_string_table_offset;
2392 next_file_string_table_offset += value;
2393 }
2394 else
2395 {
2396 /* Using the (possibly updated) string table offset, print the
2397 string (if any) associated with this symbol. */
252b5132
RH		 2398 if ((strx + file_string_table_offset) < stabstr_size)
2399 printf (" %s", &strtab[strx + file_string_table_offset]);
2400 else
2401 printf (" *");
2402 }
2403 }
2404 printf ("\n\n");
29ca8dc5 2405 *string_offset_ptr = next_file_string_table_offset;
252b5132
RH		 2406}
2407
155e0d23
NC		 2408typedef struct
2409{
2410 const char * section_name;
2411 const char * string_section_name;
29ca8dc5 2412 unsigned string_offset;
155e0d23
NC		 2413}
2414stab_section_names;
2415
252b5132 2416static void
155e0d23 2417find_stabs_section (bfd *abfd, asection *section, void *names)
252b5132 2418{
155e0d23
NC		 2419 int len;
2420 stab_section_names * sought = (stab_section_names *) names;
252b5132
RH		 2421
2422 /* Check for section names for which stabsect_name is a prefix, to
29ca8dc5 2423 handle .stab.N, etc. */
155e0d23
NC		 2424 len = strlen (sought->section_name);
2425
2426 /* If the prefix matches, and the files section name ends with a
2427 nul or a digit, then we match. I.e., we want either an exact
2428 match or a section followed by a number. */
2429 if (strncmp (sought->section_name, section->name, len) == 0
2430 && (section->name[len] == 0
29ca8dc5 2431 || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
252b5132 2432 {
29ca8dc5
NS		 2433 if (strtab == NULL)
2434 strtab = read_section_stabs (abfd, sought->string_section_name,
2435 &stabstr_size);
2436
2437 if (strtab)
252b5132 2438 {
9210d879
AM		 2439 stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2440 &stab_size);
29ca8dc5
NS		 2441 if (stabs)
2442 print_section_stabs (abfd, section->name, &sought->string_offset);
252b5132
RH		 2443 }
2444 }
2445}
98a91d6a 2446
155e0d23
NC		 2447static void
2448dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2449{
2450 stab_section_names s;
2451
2452 s.section_name = stabsect_name;
2453 s.string_section_name = strsect_name;
29ca8dc5
NS		 2454 s.string_offset = 0;
2455
155e0d23 2456 bfd_map_over_sections (abfd, find_stabs_section, & s);
29ca8dc5
NS		 2457
2458 free (strtab);
2459 strtab = NULL;
155e0d23
NC		 2460}
2461
2462/* Dump the any sections containing stabs debugging information. */
2463
2464static void
2465dump_stabs (bfd *abfd)
2466{
2467 dump_stabs_section (abfd, ".stab", ".stabstr");
2468 dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2469 dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
62bb81b8
TG		 2470
2471 /* For Darwin. */
2472 dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2473
155e0d23
NC		 2474 dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2475}
252b5132
RH		 2476\f
2477static void
46dca2e0 2478dump_bfd_header (bfd *abfd)
252b5132
RH		 2479{
2480 char *comma = "";
2481
2482 printf (_("architecture: %s, "),
2483 bfd_printable_arch_mach (bfd_get_arch (abfd),
2484 bfd_get_mach (abfd)));
2485 printf (_("flags 0x%08x:\n"), abfd->flags);
2486
2487#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2488 PF (HAS_RELOC, "HAS_RELOC");
2489 PF (EXEC_P, "EXEC_P");
2490 PF (HAS_LINENO, "HAS_LINENO");
2491 PF (HAS_DEBUG, "HAS_DEBUG");
2492 PF (HAS_SYMS, "HAS_SYMS");
2493 PF (HAS_LOCALS, "HAS_LOCALS");
2494 PF (DYNAMIC, "DYNAMIC");
2495 PF (WP_TEXT, "WP_TEXT");
2496 PF (D_PAGED, "D_PAGED");
2497 PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
026df7c5 2498 PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
252b5132 2499 printf (_("\nstart address 0x"));
d8180c76 2500 bfd_printf_vma (abfd, abfd->start_address);
252b5132
RH		 2501 printf ("\n");
2502}
98a91d6a 2503
252b5132
RH		 2504\f
2505static void
46dca2e0 2506dump_bfd_private_header (bfd *abfd)
252b5132
RH		 2507{
2508 bfd_print_private_bfd_data (abfd, stdout);
2509}
2510
155e0d23
NC		 2511\f
2512/* Display a section in hexadecimal format with associated characters.
2513 Each line prefixed by the zero padded address. */
d24de309 2514
252b5132 2515static void
155e0d23 2516dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
252b5132 2517{
155e0d23
NC		 2518 bfd_byte *data = 0;
2519 bfd_size_type datasize;
2520 bfd_size_type addr_offset;
2521 bfd_size_type start_offset;
2522 bfd_size_type stop_offset;
2523 unsigned int opb = bfd_octets_per_byte (abfd);
2524 /* Bytes per line. */
2525 const int onaline = 16;
2526 char buf[64];
2527 int count;
2528 int width;
2529
2530 if ((section->flags & SEC_HAS_CONTENTS) == 0)
2531 return;
2532
2533 if (! process_section_p (section))
2534 return;
2535
2536 if ((datasize = bfd_section_size (abfd, section)) == 0)
2537 return;
2538
155e0d23
NC		 2539 /* Compute the address range to display. */
2540 if (start_address == (bfd_vma) -1
2541 || start_address < section->vma)
2542 start_offset = 0;
2543 else
2544 start_offset = start_address - section->vma;
2545
2546 if (stop_address == (bfd_vma) -1)
2547 stop_offset = datasize / opb;
2548 else
252b5132 2549 {
155e0d23
NC		 2550 if (stop_address < section->vma)
2551 stop_offset = 0;
2552 else
2553 stop_offset = stop_address - section->vma;
252b5132 2554
155e0d23
NC		 2555 if (stop_offset > datasize / opb)
2556 stop_offset = datasize / opb;
252b5132
RH		 2557 }
2558
32760852
NC		 2559 if (start_offset >= stop_offset)
2560 return;
2561
2562 printf (_("Contents of section %s:"), section->name);
2563 if (display_file_offsets)
0af1713e
AM		 2564 printf (_(" (Starting at file offset: 0x%lx)"),
2565 (unsigned long) (section->filepos + start_offset));
32760852
NC		 2566 printf ("\n");
2567
2568 data = xmalloc (datasize);
2569
2570 bfd_get_section_contents (abfd, section, data, 0, datasize);
2571
155e0d23 2572 width = 4;
026df7c5 2573
155e0d23
NC		 2574 bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2575 if (strlen (buf) >= sizeof (buf))
2576 abort ();
026df7c5 2577
155e0d23
NC		 2578 count = 0;
2579 while (buf[count] == '0' && buf[count+1] != '\0')
2580 count++;
2581 count = strlen (buf) - count;
2582 if (count > width)
2583 width = count;
252b5132 2584
155e0d23
NC		 2585 bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2586 if (strlen (buf) >= sizeof (buf))
2587 abort ();
026df7c5 2588
155e0d23
NC		 2589 count = 0;
2590 while (buf[count] == '0' && buf[count+1] != '\0')
2591 count++;
2592 count = strlen (buf) - count;
2593 if (count > width)
2594 width = count;
026df7c5 2595
155e0d23
NC		 2596 for (addr_offset = start_offset;
2597 addr_offset < stop_offset; addr_offset += onaline / opb)
d24de309 2598 {
155e0d23 2599 bfd_size_type j;
d24de309 2600
155e0d23
NC		 2601 bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2602 count = strlen (buf);
2603 if ((size_t) count >= sizeof (buf))
2604 abort ();
d24de309 2605
155e0d23
NC		 2606 putchar (' ');
2607 while (count < width)
252b5132 2608 {
155e0d23
NC		 2609 putchar ('0');
2610 count++;
2611 }
2612 fputs (buf + count - width, stdout);
2613 putchar (' ');
252b5132 2614
155e0d23
NC		 2615 for (j = addr_offset * opb;
2616 j < addr_offset * opb + onaline; j++)
2617 {
2618 if (j < stop_offset * opb)
2619 printf ("%02x", (unsigned) (data[j]));
2620 else
2621 printf (" ");
2622 if ((j & 3) == 3)
2623 printf (" ");
252b5132
RH		 2624 }
2625
155e0d23
NC		 2626 printf (" ");
2627 for (j = addr_offset * opb;
2628 j < addr_offset * opb + onaline; j++)
2629 {
2630 if (j >= stop_offset * opb)
2631 printf (" ");
2632 else
2633 printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2634 }
2635 putchar ('\n');
252b5132 2636 }
155e0d23 2637 free (data);
252b5132 2638}
155e0d23 2639
98a91d6a 2640/* Actually display the various requested regions. */
252b5132
RH		 2641
2642static void
46dca2e0 2643dump_data (bfd *abfd)
252b5132 2644{
155e0d23 2645 bfd_map_over_sections (abfd, dump_section, NULL);
252b5132
RH		 2646}
2647
98a91d6a
NC		 2648/* Should perhaps share code and display with nm? */
2649
252b5132 2650static void
46dca2e0 2651dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
252b5132
RH		 2652{
2653 asymbol **current;
2654 long max;
2655 long count;
2656
2657 if (dynamic)
2658 {
2659 current = dynsyms;
2660 max = dynsymcount;
252b5132
RH		 2661 printf ("DYNAMIC SYMBOL TABLE:\n");
2662 }
2663 else
2664 {
2665 current = syms;
2666 max = symcount;
252b5132
RH		 2667 printf ("SYMBOL TABLE:\n");
2668 }
2669
a1df01d1
AM		 2670 if (max == 0)
2671 printf (_("no symbols\n"));
2672
252b5132
RH		 2673 for (count = 0; count < max; count++)
2674 {
155e0d23
NC		 2675 bfd *cur_bfd;
2676
2677 if (*current == NULL)
83ef0798 2678 printf (_("no information for symbol number %ld\n"), count);
155e0d23
NC		 2679
2680 else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
83ef0798 2681 printf (_("could not determine the type of symbol number %ld\n"),
155e0d23
NC		 2682 count);
2683
661f7c35
NC		 2684 else if (process_section_p ((* current)->section)
2685 && (dump_special_syms
2686 || !bfd_is_target_special_symbol (cur_bfd, *current)))
252b5132 2687 {
155e0d23 2688 const char *name = (*current)->name;
252b5132 2689
155e0d23 2690 if (do_demangle && name != NULL && *name != '\0')
252b5132 2691 {
252b5132
RH		 2692 char *alloc;
2693
155e0d23
NC		 2694 /* If we want to demangle the name, we demangle it
2695 here, and temporarily clobber it while calling
2696 bfd_print_symbol. FIXME: This is a gross hack. */
ed180cc5
AM		 2697 alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2698 if (alloc != NULL)
2699 (*current)->name = alloc;
252b5132
RH		 2700 bfd_print_symbol (cur_bfd, stdout, *current,
2701 bfd_print_symbol_all);
ed180cc5
AM		 2702 if (alloc != NULL)
2703 {
2704 (*current)->name = name;
2705 free (alloc);
2706 }
252b5132 2707 }
252b5132 2708 else
155e0d23
NC		 2709 bfd_print_symbol (cur_bfd, stdout, *current,
2710 bfd_print_symbol_all);
83ef0798 2711 printf ("\n");
252b5132 2712 }
661f7c35 2713
155e0d23 2714 current++;
252b5132 2715 }
155e0d23 2716 printf ("\n\n");
252b5132 2717}
155e0d23 2718\f
252b5132 2719static void
46dca2e0 2720dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
252b5132
RH		 2721{
2722 arelent **p;
2723 char *last_filename, *last_functionname;
2724 unsigned int last_line;
2725
2726 /* Get column headers lined up reasonably. */
2727 {
2728 static int width;
98a91d6a 2729
252b5132
RH		 2730 if (width == 0)
2731 {
2732 char buf[30];
155e0d23 2733
d8180c76 2734 bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
252b5132
RH		 2735 width = strlen (buf) - 7;
2736 }
2737 printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2738 }
2739
2740 last_filename = NULL;
2741 last_functionname = NULL;
2742 last_line = 0;
2743
d3ba0551 2744 for (p = relpp; relcount && *p != NULL; p++, relcount--)
252b5132
RH		 2745 {
2746 arelent *q = *p;
2747 const char *filename, *functionname;
2748 unsigned int line;
2749 const char *sym_name;
2750 const char *section_name;
2751
2752 if (start_address != (bfd_vma) -1
2753 && q->address < start_address)
2754 continue;
2755 if (stop_address != (bfd_vma) -1
2756 && q->address > stop_address)
2757 continue;
2758
2759 if (with_line_numbers
2760 && sec != NULL
2761 && bfd_find_nearest_line (abfd, sec, syms, q->address,
2762 &filename, &functionname, &line))
2763 {
2764 if (functionname != NULL
2765 && (last_functionname == NULL
2766 || strcmp (functionname, last_functionname) != 0))
2767 {
2768 printf ("%s():\n", functionname);
2769 if (last_functionname != NULL)
2770 free (last_functionname);
2771 last_functionname = xstrdup (functionname);
2772 }
98a91d6a 2773
252b5132
RH		 2774 if (line > 0
2775 && (line != last_line
2776 || (filename != NULL
2777 && last_filename != NULL
2778 && strcmp (filename, last_filename) != 0)))
2779 {
2780 printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2781 last_line = line;
2782 if (last_filename != NULL)
2783 free (last_filename);
2784 if (filename == NULL)
2785 last_filename = NULL;
2786 else
2787 last_filename = xstrdup (filename);
2788 }
2789 }
2790
2791 if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2792 {
2793 sym_name = (*(q->sym_ptr_ptr))->name;
2794 section_name = (*(q->sym_ptr_ptr))->section->name;
2795 }
2796 else
2797 {
2798 sym_name = NULL;
2799 section_name = NULL;
2800 }
98a91d6a 2801
f9ecb0a4
JJ		 2802 bfd_printf_vma (abfd, q->address);
2803 if (q->howto == NULL)
2804 printf (" *unknown* ");
2805 else if (q->howto->name)
2806 printf (" %-16s ", q->howto->name);
2807 else
2808 printf (" %-16d ", q->howto->type);
171191ba 2809
252b5132 2810 if (sym_name)
171191ba
NC		 2811 {
2812 objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
171191ba 2813 }
252b5132
RH		 2814 else
2815 {
d3ba0551 2816 if (section_name == NULL)
252b5132 2817 section_name = "*unknown*";
f9ecb0a4 2818 printf ("[%s]", section_name);
252b5132 2819 }
98a91d6a 2820
252b5132
RH		 2821 if (q->addend)
2822 {
2823 printf ("+0x");
d8180c76 2824 bfd_printf_vma (abfd, q->addend);
252b5132 2825 }
98a91d6a 2826
252b5132
RH		 2827 printf ("\n");
2828 }
2829}
43ac9881 2830
155e0d23 2831static void
3b9ad1cc
AM		 2832dump_relocs_in_section (bfd *abfd,
2833 asection *section,
2834 void *dummy ATTRIBUTE_UNUSED)
155e0d23
NC		 2835{
2836 arelent **relpp;
2837 long relcount;
2838 long relsize;
2839
2840 if ( bfd_is_abs_section (section)
2841 || bfd_is_und_section (section)
2842 || bfd_is_com_section (section)
2843 || (! process_section_p (section))
2844 || ((section->flags & SEC_RELOC) == 0))
2845 return;
2846
2847 relsize = bfd_get_reloc_upper_bound (abfd, section);
2848 if (relsize < 0)
2849 bfd_fatal (bfd_get_filename (abfd));
2850
2851 printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2852
2853 if (relsize == 0)
2854 {
2855 printf (" (none)\n\n");
2856 return;
2857 }
2858
2859 relpp = xmalloc (relsize);
2860 relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2861
2862 if (relcount < 0)
2863 bfd_fatal (bfd_get_filename (abfd));
2864 else if (relcount == 0)
2865 printf (" (none)\n\n");
2866 else
2867 {
2868 printf ("\n");
2869 dump_reloc_set (abfd, section, relpp, relcount);
2870 printf ("\n\n");
2871 }
2872 free (relpp);
2873}
2874
2875static void
2876dump_relocs (bfd *abfd)
2877{
2878 bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2879}
2880
2881static void
2882dump_dynamic_relocs (bfd *abfd)
2883{
2884 long relsize;
2885 arelent **relpp;
2886 long relcount;
2887
2888 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2889 if (relsize < 0)
2890 bfd_fatal (bfd_get_filename (abfd));
2891
2892 printf ("DYNAMIC RELOCATION RECORDS");
2893
2894 if (relsize == 0)
2895 printf (" (none)\n\n");
2896 else
2897 {
2898 relpp = xmalloc (relsize);
2899 relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2900
2901 if (relcount < 0)
2902 bfd_fatal (bfd_get_filename (abfd));
2903 else if (relcount == 0)
2904 printf (" (none)\n\n");
2905 else
2906 {
2907 printf ("\n");
2908 dump_reloc_set (abfd, NULL, relpp, relcount);
2909 printf ("\n\n");
2910 }
2911 free (relpp);
2912 }
2913}
2914
43ac9881
AM		 2915/* Creates a table of paths, to search for source files. */
2916
2917static void
2918add_include_path (const char *path)
2919{
2920 if (path[0] == 0)
2921 return;
2922 include_path_count++;
2923 include_paths = xrealloc (include_paths,
2924 include_path_count * sizeof (*include_paths));
2925#ifdef HAVE_DOS_BASED_FILE_SYSTEM
2926 if (path[1] == ':' && path[2] == 0)
2927 path = concat (path, ".", (const char *) 0);
2928#endif
2929 include_paths[include_path_count - 1] = path;
2930}
155e0d23
NC		 2931
2932static void
3b9ad1cc
AM		 2933adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2934 asection *section,
bc79cded 2935 void *arg)
155e0d23 2936{
bc79cded
L		 2937 if ((section->flags & SEC_DEBUGGING) == 0)
2938 {
2939 bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2940 section->vma += adjust_section_vma;
2941 if (*has_reloc_p)
2942 section->lma += adjust_section_vma;
2943 }
155e0d23
NC		 2944}
2945
2946/* Dump selected contents of ABFD. */
2947
2948static void
2949dump_bfd (bfd *abfd)
2950{
2951 /* If we are adjusting section VMA's, change them all now. Changing
2952 the BFD information is a hack. However, we must do it, or
2953 bfd_find_nearest_line will not do the right thing. */
2954 if (adjust_section_vma != 0)
bc79cded
L		 2955 {
2956 bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2957 bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2958 }
155e0d23
NC		 2959
2960 if (! dump_debugging_tags)
2961 printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
2962 abfd->xvec->name);
2963 if (dump_ar_hdrs)
2964 print_arelt_descr (stdout, abfd, TRUE);
2965 if (dump_file_header)
2966 dump_bfd_header (abfd);
2967 if (dump_private_headers)
2968 dump_bfd_private_header (abfd);
2969 if (! dump_debugging_tags)
2970 putchar ('\n');
2971 if (dump_section_headers)
2972 dump_headers (abfd);
2973
365544c3
L		 2974 if (dump_symtab
2975 || dump_reloc_info
2976 || disassemble
2977 || dump_debugging
2978 || dump_dwarf_section_info)
155e0d23 2979 syms = slurp_symtab (abfd);
4c45e5c9
JJ		 2980 if (dump_dynamic_symtab || dump_dynamic_reloc_info
2981 || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
155e0d23 2982 dynsyms = slurp_dynamic_symtab (abfd);
90e3cdf2 2983 if (disassemble)
4c45e5c9 2984 {
c9727e01
AM		 2985 synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2986 dynsymcount, dynsyms, &synthsyms);
2987 if (synthcount < 0)
2988 synthcount = 0;
4c45e5c9 2989 }
155e0d23
NC		 2990
2991 if (dump_symtab)
2992 dump_symbols (abfd, FALSE);
2993 if (dump_dynamic_symtab)
2994 dump_symbols (abfd, TRUE);
365544c3
L		 2995 if (dump_dwarf_section_info)
2996 dump_dwarf (abfd);
155e0d23
NC		 2997 if (dump_stab_section_info)
2998 dump_stabs (abfd);
2999 if (dump_reloc_info && ! disassemble)
3000 dump_relocs (abfd);
3001 if (dump_dynamic_reloc_info && ! disassemble)
3002 dump_dynamic_relocs (abfd);
3003 if (dump_section_contents)
3004 dump_data (abfd);
3005 if (disassemble)
3006 disassemble_data (abfd);
3007
3008 if (dump_debugging)
3009 {
3010 void *dhandle;
3011
b922d590 3012 dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
155e0d23
NC		 3013 if (dhandle != NULL)
3014 {
ed180cc5
AM		 3015 if (!print_debugging_info (stdout, dhandle, abfd, syms,
3016 bfd_demangle,
3017 dump_debugging_tags ? TRUE : FALSE))
155e0d23
NC		 3018 {
3019 non_fatal (_("%s: printing debugging information failed"),
3020 bfd_get_filename (abfd));
3021 exit_status = 1;
3022 }
3023 }
b922d590
NC		 3024 /* PR 6483: If there was no STABS or IEEE debug
3025 info in the file, try DWARF instead. */
3026 else if (! dump_dwarf_section_info)
3027 {
3028 dump_dwarf (abfd);
3029 }
155e0d23
NC		 3030 }
3031
3032 if (syms)
3033 {
3034 free (syms);
3035 syms = NULL;
3036 }
3037
3038 if (dynsyms)
3039 {
3040 free (dynsyms);
3041 dynsyms = NULL;
3042 }
4c45e5c9
JJ		 3043
3044 if (synthsyms)
3045 {
3046 free (synthsyms);
3047 synthsyms = NULL;
3048 }
3049
3050 symcount = 0;
3051 dynsymcount = 0;
3052 synthcount = 0;
155e0d23
NC		 3053}
3054
3055static void
3056display_bfd (bfd *abfd)
3057{
3058 char **matching;
3059
3060 if (bfd_check_format_matches (abfd, bfd_object, &matching))
3061 {
3062 dump_bfd (abfd);
3063 return;
3064 }
3065
3066 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3067 {
3068 nonfatal (bfd_get_filename (abfd));
3069 list_matching_formats (matching);
3070 free (matching);
3071 return;
3072 }
3073
3074 if (bfd_get_error () != bfd_error_file_not_recognized)
3075 {
3076 nonfatal (bfd_get_filename (abfd));
3077 return;
3078 }
3079
3080 if (bfd_check_format_matches (abfd, bfd_core, &matching))
3081 {
3082 dump_bfd (abfd);
3083 return;
3084 }
3085
3086 nonfatal (bfd_get_filename (abfd));
3087
3088 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3089 {
3090 list_matching_formats (matching);
3091 free (matching);
3092 }
3093}
3094
3095static void
3096display_file (char *filename, char *target)
3097{
f24ddbdd
NC		 3098 bfd *file;
3099 bfd *arfile = NULL;
3100
3101 if (get_file_size (filename) < 1)
d68c385b
NC		 3102 {
3103 exit_status = 1;
3104 return;
3105 }
155e0d23
NC		 3106
3107 file = bfd_openr (filename, target);
3108 if (file == NULL)
3109 {
3110 nonfatal (filename);
3111 return;
3112 }
3113
3114 /* If the file is an archive, process all of its elements. */
3115 if (bfd_check_format (file, bfd_archive))
3116 {
3117 bfd *last_arfile = NULL;
3118
3119 printf (_("In archive %s:\n"), bfd_get_filename (file));
3120 for (;;)
3121 {
3122 bfd_set_error (bfd_error_no_error);
3123
3124 arfile = bfd_openr_next_archived_file (file, arfile);
3125 if (arfile == NULL)
3126 {
3127 if (bfd_get_error () != bfd_error_no_more_archived_files)
3128 nonfatal (bfd_get_filename (file));
3129 break;
3130 }
3131
3132 display_bfd (arfile);
3133
3134 if (last_arfile != NULL)
3135 bfd_close (last_arfile);
3136 last_arfile = arfile;
3137 }
3138
3139 if (last_arfile != NULL)
3140 bfd_close (last_arfile);
3141 }
3142 else
3143 display_bfd (file);
3144
3145 bfd_close (file);
3146}
252b5132 3147\f
252b5132 3148int
46dca2e0 3149main (int argc, char **argv)
252b5132
RH		 3150{
3151 int c;
3152 char *target = default_target;
b34976b6 3153 bfd_boolean seenflag = FALSE;
252b5132 3154
155e0d23
NC		 3155#if defined (HAVE_SETLOCALE)
3156#if defined (HAVE_LC_MESSAGES)
252b5132 3157 setlocale (LC_MESSAGES, "");
3882b010 3158#endif
3882b010 3159 setlocale (LC_CTYPE, "");
252b5132 3160#endif
155e0d23 3161
252b5132
RH		 3162 bindtextdomain (PACKAGE, LOCALEDIR);
3163 textdomain (PACKAGE);
3164
3165 program_name = *argv;
3166 xmalloc_set_program_name (program_name);
3167
3168 START_PROGRESS (program_name, 0);
3169
869b9d07
MM		 3170 expandargv (&argc, &argv);
3171
252b5132
RH		 3172 bfd_init ();
3173 set_default_bfd_target ();
3174
4cb93e3b
TG		 3175 while ((c = getopt_long (argc, argv,
3176 "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
252b5132
RH		 3177 long_options, (int *) 0))
3178 != EOF)
3179 {
252b5132
RH		 3180 switch (c)
3181 {
3182 case 0:
8b53311e 3183 break; /* We've been given a long option. */
252b5132
RH		 3184 case 'm':
3185 machine = optarg;
3186 break;
dd92f639 3187 case 'M':
073fbac6 3188 if (disassembler_options)
31e0f3cd 3189 /* Ignore potential memory leak for now. */
46dca2e0 3190 disassembler_options = concat (disassembler_options, ",",
ee832e18 3191 optarg, (const char *) NULL);
31e0f3cd
NC		 3192 else
3193 disassembler_options = optarg;
dd92f639 3194 break;
252b5132 3195 case 'j':
43ac9881 3196 if (only_used == only_size)
6e50c90c
L		 3197 {
3198 only_size += 8;
43ac9881 3199 only = xrealloc (only, only_size * sizeof (char *));
6e50c90c
L		 3200 }
3201 only [only_used++] = optarg;
252b5132 3202 break;
98ec6e72
NC		 3203 case 'F':
3204 display_file_offsets = TRUE;
3205 break;
252b5132 3206 case 'l':
b34976b6 3207 with_line_numbers = TRUE;
252b5132
RH		 3208 break;
3209 case 'b':
3210 target = optarg;
3211 break;
1dada9c5 3212 case 'C':
b34976b6 3213 do_demangle = TRUE;
28c309a2
NC		 3214 if (optarg != NULL)
3215 {
3216 enum demangling_styles style;
8b53311e 3217
28c309a2 3218 style = cplus_demangle_name_to_style (optarg);
0af11b59 3219 if (style == unknown_demangling)
28c309a2
NC		 3220 fatal (_("unknown demangling style `%s'"),
3221 optarg);
8b53311e 3222
28c309a2 3223 cplus_demangle_set_style (style);
0af11b59 3224 }
1dada9c5
NC		 3225 break;
3226 case 'w':
b34976b6 3227 wide_output = TRUE;
1dada9c5
NC		 3228 break;
3229 case OPTION_ADJUST_VMA:
3230 adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3231 break;
3232 case OPTION_START_ADDRESS:
3233 start_address = parse_vma (optarg, "--start-address");
98ec6e72
NC		 3234 if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3235 fatal (_("error: the start address should be before the end address"));
1dada9c5
NC		 3236 break;
3237 case OPTION_STOP_ADDRESS:
3238 stop_address = parse_vma (optarg, "--stop-address");
98ec6e72
NC		 3239 if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3240 fatal (_("error: the stop address should be after the start address"));
1dada9c5 3241 break;
0dafdf3f
L		 3242 case OPTION_PREFIX:
3243 prefix = optarg;
3244 prefix_length = strlen (prefix);
3245 /* Remove an unnecessary trailing '/' */
3246 while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3247 prefix_length--;
3248 break;
3249 case OPTION_PREFIX_STRIP:
3250 prefix_strip = atoi (optarg);
3251 if (prefix_strip < 0)
3252 fatal (_("error: prefix strip must be non-negative"));
3253 break;
1dada9c5
NC		 3254 case 'E':
3255 if (strcmp (optarg, "B") == 0)
3256 endian = BFD_ENDIAN_BIG;
3257 else if (strcmp (optarg, "L") == 0)
3258 endian = BFD_ENDIAN_LITTLE;
3259 else
3260 {
37cc8ec1 3261 non_fatal (_("unrecognized -E option"));
1dada9c5
NC		 3262 usage (stderr, 1);
3263 }
3264 break;
3265 case OPTION_ENDIAN:
3266 if (strncmp (optarg, "big", strlen (optarg)) == 0)
3267 endian = BFD_ENDIAN_BIG;
3268 else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3269 endian = BFD_ENDIAN_LITTLE;
3270 else
3271 {
37cc8ec1 3272 non_fatal (_("unrecognized --endian type `%s'"), optarg);
1dada9c5
NC		 3273 usage (stderr, 1);
3274 }
3275 break;
8b53311e 3276
252b5132 3277 case 'f':
b34976b6
AM		 3278 dump_file_header = TRUE;
3279 seenflag = TRUE;
252b5132
RH		 3280 break;
3281 case 'i':
b34976b6
AM		 3282 formats_info = TRUE;
3283 seenflag = TRUE;
252b5132 3284 break;
43ac9881
AM		 3285 case 'I':
3286 add_include_path (optarg);
3287 break;
252b5132 3288 case 'p':
b34976b6
AM		 3289 dump_private_headers = TRUE;
3290 seenflag = TRUE;
252b5132
RH		 3291 break;
3292 case 'x':
b34976b6
AM		 3293 dump_private_headers = TRUE;
3294 dump_symtab = TRUE;
3295 dump_reloc_info = TRUE;
3296 dump_file_header = TRUE;
3297 dump_ar_hdrs = TRUE;
3298 dump_section_headers = TRUE;
3299 seenflag = TRUE;
252b5132
RH		 3300 break;
3301 case 't':
b34976b6
AM		 3302 dump_symtab = TRUE;
3303 seenflag = TRUE;
252b5132
RH		 3304 break;
3305 case 'T':
b34976b6
AM		 3306 dump_dynamic_symtab = TRUE;
3307 seenflag = TRUE;
252b5132
RH		 3308 break;
3309 case 'd':
b34976b6
AM		 3310 disassemble = TRUE;
3311 seenflag = TRUE;
1dada9c5
NC		 3312 break;
3313 case 'z':
b34976b6 3314 disassemble_zeroes = TRUE;
252b5132
RH		 3315 break;
3316 case 'D':
b34976b6
AM		 3317 disassemble = TRUE;
3318 disassemble_all = TRUE;
3319 seenflag = TRUE;
252b5132
RH		 3320 break;
3321 case 'S':
b34976b6
AM		 3322 disassemble = TRUE;
3323 with_source_code = TRUE;
3324 seenflag = TRUE;
1dada9c5
NC		 3325 break;
3326 case 'g':
3327 dump_debugging = 1;
b34976b6 3328 seenflag = TRUE;
1dada9c5 3329 break;
51cdc6e0
NC		 3330 case 'e':
3331 dump_debugging = 1;
3332 dump_debugging_tags = 1;
3333 do_demangle = TRUE;
3334 seenflag = TRUE;
3335 break;
365544c3
L		 3336 case 'W':
3337 dump_dwarf_section_info = TRUE;
3338 seenflag = TRUE;
4cb93e3b
TG		 3339 if (optarg)
3340 dwarf_select_sections_by_letters (optarg);
3341 else
3342 dwarf_select_sections_all ();
3343 break;
3344 case OPTION_DWARF:
3345 dump_dwarf_section_info = TRUE;
3346 seenflag = TRUE;
3347 if (optarg)
3348 dwarf_select_sections_by_names (optarg);
3349 else
3350 dwarf_select_sections_all ();
365544c3 3351 break;
1dada9c5 3352 case 'G':
b34976b6
AM		 3353 dump_stab_section_info = TRUE;
3354 seenflag = TRUE;
252b5132
RH		 3355 break;
3356 case 's':
b34976b6
AM		 3357 dump_section_contents = TRUE;
3358 seenflag = TRUE;
252b5132
RH		 3359 break;
3360 case 'r':
b34976b6
AM		 3361 dump_reloc_info = TRUE;
3362 seenflag = TRUE;
252b5132
RH		 3363 break;
3364 case 'R':
b34976b6
AM		 3365 dump_dynamic_reloc_info = TRUE;
3366 seenflag = TRUE;
252b5132
RH		 3367 break;
3368 case 'a':
b34976b6
AM		 3369 dump_ar_hdrs = TRUE;
3370 seenflag = TRUE;
252b5132
RH		 3371 break;
3372 case 'h':
b34976b6
AM		 3373 dump_section_headers = TRUE;
3374 seenflag = TRUE;
252b5132
RH		 3375 break;
3376 case 'H':
3377 usage (stdout, 0);
b34976b6 3378 seenflag = TRUE;
8b53311e 3379 case 'v':
252b5132 3380 case 'V':
b34976b6
AM		 3381 show_version = TRUE;
3382 seenflag = TRUE;
252b5132 3383 break;
0af11b59 3384
252b5132
RH		 3385 default:
3386 usage (stderr, 1);
3387 }
3388 }
3389
3390 if (show_version)
3391 print_version ("objdump");
3392
b34976b6 3393 if (!seenflag)
1dada9c5 3394 usage (stderr, 2);
252b5132
RH		 3395
3396 if (formats_info)
06d86cf7 3397 exit_status = display_info ();
252b5132
RH		 3398 else
3399 {
3400 if (optind == argc)
3401 display_file ("a.out", target);
3402 else
3403 for (; optind < argc;)
3404 display_file (argv[optind++], target);
3405 }
3406
3407 END_PROGRESS (program_name);
3408
75cd796a 3409 return exit_status;
252b5132 3410}
GDB Binutils - Deliverables
This page took 0.616674 seconds and 4 git commands to generate.