Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Enumerations | Functions | Variables
objdump.c File Reference
#include "bfd.h"
#include "progress.h"
#include "bucomm.h"
#include "dwarf.h"
#include "budemang.h"
#include "getopt.h"
#include "safe-ctype.h"
#include "dis-asm.h"
#include "libiberty.h"
#include "demangle.h"
#include "debug.h"
#include "budbg.h"
#include "aout/aout64.h"

Go to the source code of this file.

Classes

struct  objdump_disasm_info
struct  print_file_list
struct  SFILE
struct  stab_section_names

Defines

#define BYTES_IN_WORD   32
#define PF(x, y)   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
#define file_symbol(s, sn, snl)
#define SHOW_PRECEDING_CONTEXT_LINES   (5)
#define DEFAULT_SKIP_ZEROES   8
#define DEFAULT_SKIP_ZEROES_AT_END   3
#define is_valid_next_sym(SYM)
#define STRDXOFF   (0)
#define TYPEOFF   (4)
#define OTHEROFF   (5)
#define DESCOFF   (6)
#define VALOFF   (8)
#define STABSIZE   (12)
#define PF(x, y)   if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}

Enumerations

enum  option_values {
  OPTION_ENDIAN = 150, OPTION_START_ADDRESS, OPTION_STOP_ADDRESS, OPTION_ADJUST_VMA,
  OPTION_ASSERT = 150, OPTION_CALL_SHARED, OPTION_CREF, OPTION_DEFSYM,
  OPTION_DEMANGLE, OPTION_DYNAMIC_LINKER, OPTION_SYSROOT, OPTION_EB,
  OPTION_EL, OPTION_EMBEDDED_RELOCS, OPTION_EXPORT_DYNAMIC, OPTION_HELP,
  OPTION_IGNORE, OPTION_MAP, OPTION_NO_DEMANGLE, OPTION_NO_KEEP_MEMORY,
  OPTION_NO_WARN_MISMATCH, OPTION_NOINHIBIT_EXEC, OPTION_NON_SHARED, OPTION_NO_WHOLE_ARCHIVE,
  OPTION_OFORMAT, OPTION_RELAX, OPTION_RETAIN_SYMBOLS_FILE, OPTION_RPATH,
  OPTION_RPATH_LINK, OPTION_SHARED, OPTION_SONAME, OPTION_SORT_COMMON,
  OPTION_SORT_SECTION, OPTION_STATS, OPTION_SYMBOLIC, OPTION_SYMBOLIC_FUNCTIONS,
  OPTION_TASK_LINK, OPTION_TBSS, OPTION_TDATA, OPTION_TTEXT,
  OPTION_TRADITIONAL_FORMAT, OPTION_UR, OPTION_VERBOSE, OPTION_VERSION,
  OPTION_VERSION_SCRIPT, OPTION_VERSION_EXPORTS_SECTION, OPTION_DYNAMIC_LIST, OPTION_DYNAMIC_LIST_CPP_NEW,
  OPTION_DYNAMIC_LIST_CPP_TYPEINFO, OPTION_DYNAMIC_LIST_DATA, OPTION_WARN_COMMON, OPTION_WARN_CONSTRUCTORS,
  OPTION_WARN_FATAL, OPTION_WARN_MULTIPLE_GP, OPTION_WARN_ONCE, OPTION_WARN_SECTION_ALIGN,
  OPTION_SPLIT_BY_RELOC, OPTION_SPLIT_BY_FILE, OPTION_WHOLE_ARCHIVE, OPTION_ADD_NEEDED,
  OPTION_NO_ADD_NEEDED, OPTION_AS_NEEDED, OPTION_NO_AS_NEEDED, OPTION_WRAP,
  OPTION_FORCE_EXE_SUFFIX, OPTION_GC_SECTIONS, OPTION_NO_GC_SECTIONS, OPTION_PRINT_GC_SECTIONS,
  OPTION_NO_PRINT_GC_SECTIONS, OPTION_HASH_SIZE, OPTION_CHECK_SECTIONS, OPTION_NO_CHECK_SECTIONS,
  OPTION_NO_UNDEFINED, OPTION_INIT, OPTION_FINI, OPTION_SECTION_START,
  OPTION_UNIQUE, OPTION_TARGET_HELP, OPTION_ALLOW_SHLIB_UNDEFINED, OPTION_NO_ALLOW_SHLIB_UNDEFINED,
  OPTION_ALLOW_MULTIPLE_DEFINITION, OPTION_NO_UNDEFINED_VERSION, OPTION_DEFAULT_SYMVER, OPTION_DEFAULT_IMPORTED_SYMVER,
  OPTION_DISCARD_NONE, OPTION_SPARE_DYNAMIC_TAGS, OPTION_NO_DEFINE_COMMON, OPTION_NOSTDLIB,
  OPTION_NO_OMAGIC, OPTION_STRIP_DISCARDED, OPTION_NO_STRIP_DISCARDED, OPTION_ACCEPT_UNKNOWN_INPUT_ARCH,
  OPTION_NO_ACCEPT_UNKNOWN_INPUT_ARCH, OPTION_PIE, OPTION_UNRESOLVED_SYMBOLS, OPTION_WARN_UNRESOLVED_SYMBOLS,
  OPTION_ERROR_UNRESOLVED_SYMBOLS, OPTION_WARN_SHARED_TEXTREL, OPTION_REDUCE_MEMORY_OVERHEADS, OPTION_DEFAULT_SCRIPT
}

Functions

static enum static bfd_endian
asymbol **static syms long
static symcount asymbol
**static sorted_syms long
static sorted_symcount asymbol
**static dynsyms asymbol
*static synthsyms long static
synthcount long static
dynsymcount bfd_byte *static
stabs bfd_size_type static
stab_size char *static strtab
bfd_size_type static
stabstr_size void 
usage (FILE *stream, int status)
static void nonfatal (const char *msg)
static void dump_section_header (bfd *abfd, asection *section, void *ignored ATTRIBUTE_UNUSED)
static void dump_headers (bfd *abfd)
static asymbol ** slurp_symtab (bfd *abfd)
static asymbol ** slurp_dynamic_symtab (bfd *abfd)
static long remove_useless_symbols (asymbol **symbols, long count)
static int compare_symbols (const void *ap, const void *bp)
static int compare_relocs (const void *ap, const void *bp)
static void objdump_print_value (bfd_vma vma, struct disassemble_info *info, bfd_boolean skip_zeroes)
static void objdump_print_symname (bfd *abfd, struct disassemble_info *info, asymbol *sym)
static asymbolfind_symbol_for_address (bfd_vma vma, struct disassemble_info *info, long *place)
static void objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym, bfd_vma vma, struct disassemble_info *info, bfd_boolean skip_zeroes)
static void objdump_print_addr (bfd_vma vma, struct disassemble_info *info, bfd_boolean skip_zeroes)
static void objdump_print_address (bfd_vma vma, struct disassemble_info *info)
static int objdump_symbol_at_address (bfd_vma vma, struct disassemble_info *info)
static struct print_file_listtry_print_file_open (const char *origname, const char *modname)
static struct print_file_listupdate_source_path (const char *filename)
static void skip_to_line (struct print_file_list *p, unsigned int line, bfd_boolean show)
static void show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
static int ATTRIBUTE_PRINTF_2 objdump_sprintf (SFILE *f, const char *format,...)
static bfd_boolean process_section_p (asection *section)
static void disassemble_bytes (struct disassemble_info *info, disassembler_ftype disassemble_fn, bfd_boolean insns, bfd_byte *data, bfd_vma start_offset, bfd_vma stop_offset, bfd_vma rel_offset, arelent ***relppp, arelent **relppend)
static void disassemble_section (bfd *abfd, asection *section, void *info)
static void disassemble_data (bfd *abfd)
int load_debug_section (enum dwarf_section_display_enum debug, void *file)
void free_debug_section (enum dwarf_section_display_enum debug)
static void dump_dwarf_section (bfd *abfd, asection *section, void *arg ATTRIBUTE_UNUSED)
static void check_mach_o_dwarf (bfd *abfd)
static void dump_dwarf (bfd *abfd)
static char * read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
static void print_section_stabs (bfd *abfd, const char *stabsect_name, unsigned *string_offset_ptr)
static void find_stabs_section (bfd *abfd, asection *section, void *names)
static void dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
static void dump_stabs (bfd *abfd)
static void dump_bfd_header (bfd *abfd)
static void dump_bfd_private_header (bfd *abfd)
static void dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
static void dump_data (bfd *abfd)
static void dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
static void dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
static void dump_relocs_in_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
static void dump_relocs (bfd *abfd)
static void dump_dynamic_relocs (bfd *abfd)
static void add_include_path (const char *path)
static void adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *arg)
static void dump_bfd (bfd *abfd)
static void display_bfd (bfd *abfd)
static void display_file (char *filename, char *target)
int main (int argc, char **argv)

Variables

static int exit_status = 0
static char * default_target = NULL
static int show_version = 0
static int dump_section_contents
static int dump_section_headers
static bfd_boolean dump_file_header
static int dump_symtab
static int dump_dynamic_symtab
static int dump_reloc_info
static int dump_dynamic_reloc_info
static int dump_ar_hdrs
static int dump_private_headers
static int prefix_addresses
static int with_line_numbers
static bfd_boolean with_source_code
static int show_raw_insn
static int dump_dwarf_section_info
static int dump_stab_section_info
static int do_demangle
static bfd_boolean disassemble
static bfd_boolean disassemble_all
static int disassemble_zeroes
static bfd_boolean formats_info
static int wide_output
static bfd_vma start_address = (bfd_vma) -1
static bfd_vma stop_address = (bfd_vma) -1
static int dump_debugging
static int dump_debugging_tags
static int dump_special_syms = 0
static bfd_vma adjust_section_vma = 0
static int file_start_context = 0
static char ** only
static size_t only_size = 0
static size_t only_used = 0
static const char ** include_paths
static int include_path_count
static char * machine = NULL
static char * disassembler_options = NULL
static struct option []
static char * prev_functionname
static unsigned int prev_line
static struct print_file_listprint_files
static const char * mach_o_dwarf_sections []
static const char * generic_dwarf_sections [max]

Class Documentation

struct objdump_disasm_info

Definition at line 119 of file objdump.c.

Collaboration diagram for objdump_disasm_info:
Class Members
bfd * abfd
disassembler_ftype disassemble_fn
arelent ** dynrelbuf
long dynrelcount
arelent * reloc
bfd_boolean require_sec
asection * sec
struct print_file_list

Definition at line 923 of file objdump.c.

Collaboration diagram for print_file_list:
Class Members
FILE * f
const char * filename
unsigned int line
const char * modname
struct print_file_list * next
struct SFILE

Definition at line 1176 of file objdump.c.

Class Members
size_t alloc
char * buffer
size_t pos
struct stab_section_names

Definition at line 2239 of file objdump.c.

Class Members
const char * section_name
unsigned string_offset
const char * string_section_name

Define Documentation

#define BYTES_IN_WORD   32

Definition at line 65 of file objdump.c.

#define DEFAULT_SKIP_ZEROES   8

Definition at line 1231 of file objdump.c.

Definition at line 1240 of file objdump.c.

#define DESCOFF   (6)

Definition at line 2162 of file objdump.c.

#define file_symbol (   s,
  sn,
  snl 
)
Value:
(((s)->flags & BSF_FILE) != 0                    \
   || ((sn)[(snl) - 2] == '.'                    \
       && ((sn)[(snl) - 1] == 'o'         \
          || (sn)[(snl) - 1] == 'a')))
#define is_valid_next_sym (   SYM)
Value:
((SYM)->section == section \
   && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
   && pinfo->symbol_is_valid (SYM, pinfo))
#define OTHEROFF   (5)

Definition at line 2161 of file objdump.c.

#define PF (   x,
  y 
)    if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
#define PF (   x,
  y 
)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
#define SHOW_PRECEDING_CONTEXT_LINES   (5)

Definition at line 937 of file objdump.c.

#define STABSIZE   (12)

Definition at line 2164 of file objdump.c.

#define STRDXOFF   (0)

Definition at line 2159 of file objdump.c.

#define TYPEOFF   (4)

Definition at line 2160 of file objdump.c.

#define VALOFF   (8)

Definition at line 2163 of file objdump.c.


Enumeration Type Documentation

Enumerator:
OPTION_ENDIAN 
OPTION_START_ADDRESS 
OPTION_STOP_ADDRESS 
OPTION_ADJUST_VMA 
OPTION_ASSERT 
OPTION_CALL_SHARED 
OPTION_CREF 
OPTION_DEFSYM 
OPTION_DEMANGLE 
OPTION_DYNAMIC_LINKER 
OPTION_SYSROOT 
OPTION_EB 
OPTION_EL 
OPTION_EMBEDDED_RELOCS 
OPTION_EXPORT_DYNAMIC 
OPTION_HELP 
OPTION_IGNORE 
OPTION_MAP 
OPTION_NO_DEMANGLE 
OPTION_NO_KEEP_MEMORY 
OPTION_NO_WARN_MISMATCH 
OPTION_NOINHIBIT_EXEC 
OPTION_NON_SHARED 
OPTION_NO_WHOLE_ARCHIVE 
OPTION_OFORMAT 
OPTION_RELAX 
OPTION_RETAIN_SYMBOLS_FILE 
OPTION_RPATH 
OPTION_RPATH_LINK 
OPTION_SHARED 
OPTION_SONAME 
OPTION_SORT_COMMON 
OPTION_SORT_SECTION 
OPTION_STATS 
OPTION_SYMBOLIC 
OPTION_SYMBOLIC_FUNCTIONS 
OPTION_TASK_LINK 
OPTION_TBSS 
OPTION_TDATA 
OPTION_TTEXT 
OPTION_TRADITIONAL_FORMAT 
OPTION_UR 
OPTION_VERBOSE 
OPTION_VERSION 
OPTION_VERSION_SCRIPT 
OPTION_VERSION_EXPORTS_SECTION 
OPTION_DYNAMIC_LIST 
OPTION_DYNAMIC_LIST_CPP_NEW 
OPTION_DYNAMIC_LIST_CPP_TYPEINFO 
OPTION_DYNAMIC_LIST_DATA 
OPTION_WARN_COMMON 
OPTION_WARN_CONSTRUCTORS 
OPTION_WARN_FATAL 
OPTION_WARN_MULTIPLE_GP 
OPTION_WARN_ONCE 
OPTION_WARN_SECTION_ALIGN 
OPTION_SPLIT_BY_RELOC 
OPTION_SPLIT_BY_FILE 
OPTION_WHOLE_ARCHIVE 
OPTION_ADD_NEEDED 
OPTION_NO_ADD_NEEDED 
OPTION_AS_NEEDED 
OPTION_NO_AS_NEEDED 
OPTION_WRAP 
OPTION_FORCE_EXE_SUFFIX 
OPTION_GC_SECTIONS 
OPTION_NO_GC_SECTIONS 
OPTION_PRINT_GC_SECTIONS 
OPTION_NO_PRINT_GC_SECTIONS 
OPTION_HASH_SIZE 
OPTION_CHECK_SECTIONS 
OPTION_NO_CHECK_SECTIONS 
OPTION_NO_UNDEFINED 
OPTION_INIT 
OPTION_FINI 
OPTION_SECTION_START 
OPTION_UNIQUE 
OPTION_TARGET_HELP 
OPTION_ALLOW_SHLIB_UNDEFINED 
OPTION_NO_ALLOW_SHLIB_UNDEFINED 
OPTION_ALLOW_MULTIPLE_DEFINITION 
OPTION_NO_UNDEFINED_VERSION 
OPTION_DEFAULT_SYMVER 
OPTION_DEFAULT_IMPORTED_SYMVER 
OPTION_DISCARD_NONE 
OPTION_SPARE_DYNAMIC_TAGS 
OPTION_NO_DEFINE_COMMON 
OPTION_NOSTDLIB 
OPTION_NO_OMAGIC 
OPTION_STRIP_DISCARDED 
OPTION_NO_STRIP_DISCARDED 
OPTION_ACCEPT_UNKNOWN_INPUT_ARCH 
OPTION_NO_ACCEPT_UNKNOWN_INPUT_ARCH 
OPTION_PIE 
OPTION_UNRESOLVED_SYMBOLS 
OPTION_WARN_UNRESOLVED_SYMBOLS 
OPTION_ERROR_UNRESOLVED_SYMBOLS 
OPTION_WARN_SHARED_TEXTREL 
OPTION_REDUCE_MEMORY_OVERHEADS 
OPTION_DEFAULT_SCRIPT 

Definition at line 233 of file objdump.c.


Function Documentation

static void add_include_path ( const char *  path) [static]

Definition at line 2731 of file objdump.c.

{
  if (path[0] == 0)
    return;
  include_path_count++;
  include_paths = xrealloc (include_paths,
                         include_path_count * sizeof (*include_paths));
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
  if (path[1] == ':' && path[2] == 0)
    path = concat (path, ".", (const char *) 0);
#endif
  include_paths[include_path_count - 1] = path;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void adjust_addresses ( bfd *abfd  ATTRIBUTE_UNUSED,
asection section,
void *  arg 
) [static]

Definition at line 2746 of file objdump.c.

{
  if ((section->flags & SEC_DEBUGGING) == 0)
    {
      bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
      section->vma += adjust_section_vma;
      if (*has_reloc_p)
       section->lma += adjust_section_vma;
    }
}

Here is the caller graph for this function:

static void check_mach_o_dwarf ( bfd abfd) [static]

Definition at line 2067 of file objdump.c.

{
  static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
  enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
  enum dwarf_section_display_enum i;

  if (generic_dwarf_sections [0] == NULL)
    for (i = 0; i < max; i++)
      generic_dwarf_sections [i] = debug_displays[i].section.name;

  if (old_flavour != current_flavour)
    {
      if (current_flavour == bfd_target_mach_o_flavour)
       for (i = 0; i < max; i++)
         debug_displays[i].section.name = mach_o_dwarf_sections [i];
      else if (old_flavour == bfd_target_mach_o_flavour)
       for (i = 0; i < max; i++)
         debug_displays[i].section.name = generic_dwarf_sections [i];

      old_flavour = current_flavour;
    }
}

Here is the caller graph for this function:

static int compare_relocs ( const void *  ap,
const void *  bp 
) [static]

Definition at line 593 of file objdump.c.

{
  const arelent *a = * (const arelent **) ap;
  const arelent *b = * (const arelent **) bp;

  if (a->address > b->address)
    return 1;
  else if (a->address < b->address)
    return -1;

  /* So that associated relocations tied to the same address show up
     in the correct order, we don't do any further sorting.  */
  if (a > b)
    return 1;
  else if (a < b)
    return -1;
  else
    return 0;
}

Here is the caller graph for this function:

static int compare_symbols ( const void *  ap,
const void *  bp 
) [static]

Definition at line 484 of file objdump.c.

{
  const asymbol *a = * (const asymbol **) ap;
  const asymbol *b = * (const asymbol **) bp;
  const char *an;
  const char *bn;
  size_t anl;
  size_t bnl;
  bfd_boolean af;
  bfd_boolean bf;
  flagword aflags;
  flagword bflags;

  if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
    return 1;
  else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
    return -1;

  if (a->section > b->section)
    return 1;
  else if (a->section < b->section)
    return -1;

  an = bfd_asymbol_name (a);
  bn = bfd_asymbol_name (b);
  anl = strlen (an);
  bnl = strlen (bn);

  /* The symbols gnu_compiled and gcc2_compiled convey no real
     information, so put them after other symbols with the same value.  */
  af = (strstr (an, "gnu_compiled") != NULL
       || strstr (an, "gcc2_compiled") != NULL);
  bf = (strstr (bn, "gnu_compiled") != NULL
       || strstr (bn, "gcc2_compiled") != NULL);

  if (af && ! bf)
    return 1;
  if (! af && bf)
    return -1;

  /* We use a heuristic for the file name, to try to sort it after
     more useful symbols.  It may not work on non Unix systems, but it
     doesn't really matter; the only difference is precisely which
     symbol names get printed.  */

#define file_symbol(s, sn, snl)                  \
  (((s)->flags & BSF_FILE) != 0                  \
   || ((sn)[(snl) - 2] == '.'                    \
       && ((sn)[(snl) - 1] == 'o'         \
          || (sn)[(snl) - 1] == 'a')))

  af = file_symbol (a, an, anl);
  bf = file_symbol (b, bn, bnl);

  if (af && ! bf)
    return 1;
  if (! af && bf)
    return -1;

  /* Try to sort global symbols before local symbols before function
     symbols before debugging symbols.  */

  aflags = a->flags;
  bflags = b->flags;

  if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
    {
      if ((aflags & BSF_DEBUGGING) != 0)
       return 1;
      else
       return -1;
    }
  if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
    {
      if ((aflags & BSF_FUNCTION) != 0)
       return -1;
      else
       return 1;
    }
  if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
    {
      if ((aflags & BSF_LOCAL) != 0)
       return 1;
      else
       return -1;
    }
  if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
    {
      if ((aflags & BSF_GLOBAL) != 0)
       return -1;
      else
       return 1;
    }

  /* Symbols that start with '.' might be section names, so sort them
     after symbols that don't start with '.'.  */
  if (an[0] == '.' && bn[0] != '.')
    return 1;
  if (an[0] != '.' && bn[0] == '.')
    return -1;

  /* Finally, if we can't distinguish them in any other way, try to
     get consistent results by sorting the symbols by name.  */
  return strcmp (an, bn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void disassemble_bytes ( struct disassemble_info info,
disassembler_ftype  disassemble_fn,
bfd_boolean  insns,
bfd_byte data,
bfd_vma  start_offset,
bfd_vma  stop_offset,
bfd_vma  rel_offset,
arelent ***  relppp,
arelent **  relppend 
) [static]

Definition at line 1245 of file objdump.c.

{
  struct objdump_disasm_info *aux;
  asection *section;
  int octets_per_line;
  bfd_boolean done_dot;
  int skip_addr_chars;
  bfd_vma addr_offset;
  unsigned int opb = info->octets_per_byte;
  unsigned int skip_zeroes = info->skip_zeroes;
  unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
  int octets = opb;
  SFILE sfile;

  aux = (struct objdump_disasm_info *) info->application_data;
  section = aux->sec;

  sfile.alloc = 120;
  sfile.buffer = xmalloc (sfile.alloc);
  sfile.pos = 0;
  
  if (insns)
    octets_per_line = 4;
  else
    octets_per_line = 16;

  /* Figure out how many characters to skip at the start of an
     address, to make the disassembly look nicer.  We discard leading
     zeroes in chunks of 4, ensuring that there is always a leading
     zero remaining.  */
  skip_addr_chars = 0;
  if (! prefix_addresses)
    {
      char buf[30];
      char *s;

      bfd_sprintf_vma
       (aux->abfd, buf,
        (section->vma
         + bfd_section_size (section->owner, section) / opb));
      s = buf;
      while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
            && s[4] == '0')
       {
         skip_addr_chars += 4;
         s += 4;
       }
    }

  info->insn_info_valid = 0;

  done_dot = FALSE;
  addr_offset = start_offset;
  while (addr_offset < stop_offset)
    {
      bfd_vma z;
      bfd_boolean need_nl = FALSE;
      int previous_octets;

      /* Remember the length of the previous instruction.  */
      previous_octets = octets;
      octets = 0;

      /* If we see more than SKIP_ZEROES octets of zeroes, we just
        print `...'.  */
      for (z = addr_offset * opb; z < stop_offset * opb; z++)
       if (data[z] != 0)
         break;
      if (! disassemble_zeroes
         && (info->insn_info_valid == 0
             || info->branch_delay_insns == 0)
         && (z - addr_offset * opb >= skip_zeroes
             || (z == stop_offset * opb &&
                z - addr_offset * opb < skip_zeroes_at_end)))
       {
         printf ("\t...\n");

         /* If there are more nonzero octets to follow, we only skip
            zeroes in multiples of 4, to try to avoid running over
            the start of an instruction which happens to start with
            zero.  */
         if (z != stop_offset * opb)
           z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);

         octets = z - addr_offset * opb;
       }
      else
       {
         char buf[50];
         int bpc = 0;
         int pb = 0;

         done_dot = FALSE;

         if (with_line_numbers || with_source_code)
           show_line (aux->abfd, section, addr_offset);

         if (! prefix_addresses)
           {
             char *s;

             bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
             for (s = buf + skip_addr_chars; *s == '0'; s++)
              *s = ' ';
             if (*s == '\0')
              *--s = '0';
             printf ("%s:\t", buf + skip_addr_chars);
           }
         else
           {
             aux->require_sec = TRUE;
             objdump_print_address (section->vma + addr_offset, info);
             aux->require_sec = FALSE;
             putchar (' ');
           }

         if (insns)
           {
             sfile.pos = 0;
             info->fprintf_func = (fprintf_ftype) objdump_sprintf;
             info->stream = &sfile;
             info->bytes_per_line = 0;
             info->bytes_per_chunk = 0;
             info->flags = 0;

             if (info->disassembler_needs_relocs
                && *relppp < relppend)
              {
                bfd_signed_vma distance_to_rel;

                distance_to_rel = (**relppp)->address
                  - (rel_offset + addr_offset);

                /* Check to see if the current reloc is associated with
                   the instruction that we are about to disassemble.  */
                if (distance_to_rel == 0
                    /* FIXME: This is wrong.  We are trying to catch
                      relocs that are addressed part way through the
                      current instruction, as might happen with a packed
                      VLIW instruction.  Unfortunately we do not know the
                      length of the current instruction since we have not
                      disassembled it yet.  Instead we take a guess based
                      upon the length of the previous instruction.  The
                      proper solution is to have a new target-specific
                      disassembler function which just returns the length
                      of an instruction at a given address without trying
                      to display its disassembly. */
                    || (distance_to_rel > 0
                       && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
                  {
                    info->flags = INSN_HAS_RELOC;
                    aux->reloc = **relppp;
                  }
                else
                  aux->reloc = NULL;
              }

             octets = (*disassemble_fn) (section->vma + addr_offset, info);
             info->fprintf_func = (fprintf_ftype) fprintf;
             info->stream = stdout;
             if (info->bytes_per_line != 0)
              octets_per_line = info->bytes_per_line;
             if (octets < 0)
              {
                if (sfile.pos)
                  printf ("%s\n", sfile.buffer);
                break;
              }
           }
         else
           {
             bfd_vma j;

             octets = octets_per_line;
             if (addr_offset + octets / opb > stop_offset)
              octets = (stop_offset - addr_offset) * opb;

             for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
              {
                if (ISPRINT (data[j]))
                  buf[j - addr_offset * opb] = data[j];
                else
                  buf[j - addr_offset * opb] = '.';
              }
             buf[j - addr_offset * opb] = '\0';
           }

         if (prefix_addresses
             ? show_raw_insn > 0
             : show_raw_insn >= 0)
           {
             bfd_vma j;

             /* If ! prefix_addresses and ! wide_output, we print
               octets_per_line octets per line.  */
             pb = octets;
             if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
              pb = octets_per_line;

             if (info->bytes_per_chunk)
              bpc = info->bytes_per_chunk;
             else
              bpc = 1;

             for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
              {
                int k;

                if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
                  {
                    for (k = bpc - 1; k >= 0; k--)
                     printf ("%02x", (unsigned) data[j + k]);
                    putchar (' ');
                  }
                else
                  {
                    for (k = 0; k < bpc; k++)
                     printf ("%02x", (unsigned) data[j + k]);
                    putchar (' ');
                  }
              }

             for (; pb < octets_per_line; pb += bpc)
              {
                int k;

                for (k = 0; k < bpc; k++)
                  printf ("  ");
                putchar (' ');
              }

             /* Separate raw data from instruction by extra space.  */
             if (insns)
              putchar ('\t');
             else
              printf ("    ");
           }

         if (! insns)
           printf ("%s", buf);
         else if (sfile.pos)
           printf ("%s", sfile.buffer);

         if (prefix_addresses
             ? show_raw_insn > 0
             : show_raw_insn >= 0)
           {
             while (pb < octets)
              {
                bfd_vma j;
                char *s;

                putchar ('\n');
                j = addr_offset * opb + pb;

                bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
                for (s = buf + skip_addr_chars; *s == '0'; s++)
                  *s = ' ';
                if (*s == '\0')
                  *--s = '0';
                printf ("%s:\t", buf + skip_addr_chars);

                pb += octets_per_line;
                if (pb > octets)
                  pb = octets;
                for (; j < addr_offset * opb + pb; j += bpc)
                  {
                    int k;

                    if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
                     {
                       for (k = bpc - 1; k >= 0; k--)
                         printf ("%02x", (unsigned) data[j + k]);
                       putchar (' ');
                     }
                    else
                     {
                       for (k = 0; k < bpc; k++)
                         printf ("%02x", (unsigned) data[j + k]);
                       putchar (' ');
                     }
                  }
              }
           }

         if (!wide_output)
           putchar ('\n');
         else
           need_nl = TRUE;
       }

      while ((*relppp) < relppend
            && (**relppp)->address < rel_offset + addr_offset + octets / opb)
       {
         if (dump_reloc_info || dump_dynamic_reloc_info)
           {
             arelent *q;

             q = **relppp;

             if (wide_output)
              putchar ('\t');
             else
              printf ("\t\t\t");

             objdump_print_value (section->vma - rel_offset + q->address,
                               info, TRUE);

             if (q->howto == NULL)
              printf (": *unknown*\t");
             else if (q->howto->name)
              printf (": %s\t", q->howto->name);
             else
              printf (": %d\t", q->howto->type);

             if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
              printf ("*unknown*");
             else
              {
                const char *sym_name;

                sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
                if (sym_name != NULL && *sym_name != '\0')
                  objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
                else
                  {
                    asection *sym_sec;

                    sym_sec = bfd_get_section (*q->sym_ptr_ptr);
                    sym_name = bfd_get_section_name (aux->abfd, sym_sec);
                    if (sym_name == NULL || *sym_name == '\0')
                     sym_name = "*unknown*";
                    printf ("%s", sym_name);
                  }
              }

             if (q->addend)
              {
                printf ("+0x");
                objdump_print_value (q->addend, info, TRUE);
              }

             printf ("\n");
             need_nl = FALSE;
           }
         ++(*relppp);
       }

      if (need_nl)
       printf ("\n");

      addr_offset += octets / opb;
    }

  free (sfile.buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void disassemble_data ( bfd abfd) [static]

Definition at line 1835 of file objdump.c.

{
  struct disassemble_info disasm_info;
  struct objdump_disasm_info aux;
  long i;

  print_files = NULL;
  prev_functionname = NULL;
  prev_line = -1;

  /* We make a copy of syms to sort.  We don't want to sort syms
     because that will screw up the relocs.  */
  sorted_symcount = symcount ? symcount : dynsymcount;
  sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
  memcpy (sorted_syms, symcount ? syms : dynsyms,
         sorted_symcount * sizeof (asymbol *));

  sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);

  for (i = 0; i < synthcount; ++i)
    {
      sorted_syms[sorted_symcount] = synthsyms + i;
      ++sorted_symcount;
    }

  /* Sort the symbols into section and symbol order.  */
  qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);

  init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);

  disasm_info.application_data = (void *) &aux;
  aux.abfd = abfd;
  aux.require_sec = FALSE;
  aux.dynrelbuf = NULL;
  aux.dynrelcount = 0;
  aux.reloc = NULL;

  disasm_info.print_address_func = objdump_print_address;
  disasm_info.symbol_at_address_func = objdump_symbol_at_address;

  if (machine != NULL)
    {
      const bfd_arch_info_type *info = bfd_scan_arch (machine);

      if (info == NULL)
       fatal (_("Can't use supplied machine %s"), machine);

      abfd->arch_info = info;
    }

  if (endian != BFD_ENDIAN_UNKNOWN)
    {
      struct bfd_target *xvec;

      xvec = xmalloc (sizeof (struct bfd_target));
      memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
      xvec->byteorder = endian;
      abfd->xvec = xvec;
    }

  /* Use libopcodes to locate a suitable disassembler.  */
  aux.disassemble_fn = disassembler (abfd);
  if (!aux.disassemble_fn)
    {
      non_fatal (_("Can't disassemble for architecture %s\n"),
               bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
      exit_status = 1;
      return;
    }

  disasm_info.flavour = bfd_get_flavour (abfd);
  disasm_info.arch = bfd_get_arch (abfd);
  disasm_info.mach = bfd_get_mach (abfd);
  disasm_info.disassembler_options = disassembler_options;
  disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
  disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
  disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
  disasm_info.disassembler_needs_relocs = FALSE;

  if (bfd_big_endian (abfd))
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
  else if (bfd_little_endian (abfd))
    disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
  else
    /* ??? Aborting here seems too drastic.  We could default to big or little
       instead.  */
    disasm_info.endian = BFD_ENDIAN_UNKNOWN;

  /* Allow the target to customize the info structure.  */
  disassemble_init_for_target (& disasm_info);

  /* Pre-load the dynamic relocs if we are going
     to be dumping them along with the disassembly.  */
  if (dump_dynamic_reloc_info)
    {
      long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
  
      if (relsize < 0)
       bfd_fatal (bfd_get_filename (abfd));

      if (relsize > 0)
       {
         aux.dynrelbuf = xmalloc (relsize);
         aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
                                                     aux.dynrelbuf,
                                                     dynsyms);
         if (aux.dynrelcount < 0)
           bfd_fatal (bfd_get_filename (abfd));

         /* Sort the relocs by address.  */
         qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
               compare_relocs);
       }
    }
  disasm_info.symtab = sorted_syms;
  disasm_info.symtab_size = sorted_symcount;

  bfd_map_over_sections (abfd, disassemble_section, & disasm_info);

  if (aux.dynrelbuf != NULL)
    free (aux.dynrelbuf);
  free (sorted_syms);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void disassemble_section ( bfd abfd,
asection section,
void *  info 
) [static]

Definition at line 1611 of file objdump.c.

{
  struct disassemble_info *    pinfo = (struct disassemble_info *) info;
  struct objdump_disasm_info * paux;
  unsigned int                 opb = pinfo->octets_per_byte;
  bfd_byte *                   data = NULL;
  bfd_size_type                datasize = 0;
  arelent **                   rel_pp = NULL;
  arelent **                   rel_ppstart = NULL;
  arelent **                   rel_ppend;
  unsigned long                stop_offset;
  asymbol *                    sym = NULL;
  long                         place = 0;
  long                         rel_count;
  bfd_vma                      rel_offset;
  unsigned long                addr_offset;

  /* Sections that do not contain machine
     code are not normally disassembled.  */
  if (! disassemble_all
      && only == NULL
      && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
         != (SEC_CODE | SEC_HAS_CONTENTS)))
    return;

  if (! process_section_p (section))
    return;

  datasize = bfd_get_section_size (section);
  if (datasize == 0)
    return;

  /* Decide which set of relocs to use.  Load them if necessary.  */
  paux = (struct objdump_disasm_info *) pinfo->application_data;
  if (paux->dynrelbuf)
    {
      rel_pp = paux->dynrelbuf;
      rel_count = paux->dynrelcount;
      /* Dynamic reloc addresses are absolute, non-dynamic are section
        relative.  REL_OFFSET specifies the reloc address corresponding
        to the start of this section.  */
      rel_offset = section->vma;
    }
  else
    {
      rel_count = 0;
      rel_pp = NULL;
      rel_offset = 0;

      if ((section->flags & SEC_RELOC) != 0
         && (dump_reloc_info || pinfo->disassembler_needs_relocs))
       {
         long relsize;

         relsize = bfd_get_reloc_upper_bound (abfd, section);
         if (relsize < 0)
           bfd_fatal (bfd_get_filename (abfd));

         if (relsize > 0)
           {
             rel_ppstart = rel_pp = xmalloc (relsize);
             rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
             if (rel_count < 0)
              bfd_fatal (bfd_get_filename (abfd));

             /* Sort the relocs by address.  */
             qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
           }
       }

    }
  rel_ppend = rel_pp + rel_count;

  data = xmalloc (datasize);

  bfd_get_section_contents (abfd, section, data, 0, datasize);

  paux->sec = section;
  pinfo->buffer = data;
  pinfo->buffer_vma = section->vma;
  pinfo->buffer_length = datasize;
  pinfo->section = section;

  if (start_address == (bfd_vma) -1
      || start_address < pinfo->buffer_vma)
    addr_offset = 0;
  else
    addr_offset = start_address - pinfo->buffer_vma;

  if (stop_address == (bfd_vma) -1)
    stop_offset = datasize / opb;
  else
    {
      if (stop_address < pinfo->buffer_vma)
       stop_offset = 0;
      else
       stop_offset = stop_address - pinfo->buffer_vma;
      if (stop_offset > pinfo->buffer_length / opb)
       stop_offset = pinfo->buffer_length / opb;
    }

  /* Skip over the relocs belonging to addresses below the
     start address.  */
  while (rel_pp < rel_ppend
        && (*rel_pp)->address < rel_offset + addr_offset)
    ++rel_pp;

  printf (_("Disassembly of section %s:\n"), section->name);

  /* Find the nearest symbol forwards from our current position.  */
  paux->require_sec = TRUE;
  sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
  paux->require_sec = FALSE;

  /* Disassemble a block of instructions up to the address associated with
     the symbol we have just found.  Then print the symbol and find the
     next symbol on.  Repeat until we have disassembled the entire section
     or we have reached the end of the address range we are interested in.  */
  while (addr_offset < stop_offset)
    {
      bfd_vma addr;
      asymbol *nextsym;
      unsigned long nextstop_offset;
      bfd_boolean insns;

      addr = section->vma + addr_offset;

      if (sym != NULL && bfd_asymbol_value (sym) <= addr)
       {
         int x;

         for (x = place;
              (x < sorted_symcount
              && (bfd_asymbol_value (sorted_syms[x]) <= addr));
              ++x)
           continue;

         pinfo->symbols = sorted_syms + place;
         pinfo->num_symbols = x - place;
         pinfo->symtab_pos = place;
       }
      else
       {
         pinfo->symbols = NULL;
         pinfo->num_symbols = 0;
         pinfo->symtab_pos = -1;
       }

      if (! prefix_addresses)
       {
         pinfo->fprintf_func (pinfo->stream, "\n");
         objdump_print_addr_with_sym (abfd, section, sym, addr,
                                   pinfo, FALSE);
         pinfo->fprintf_func (pinfo->stream, ":\n");
       }

      if (sym != NULL && bfd_asymbol_value (sym) > addr)
       nextsym = sym;
      else if (sym == NULL)
       nextsym = NULL;
      else
       {
#define is_valid_next_sym(SYM) \
  ((SYM)->section == section \
   && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
   && pinfo->symbol_is_valid (SYM, pinfo))
           
         /* Search forward for the next appropriate symbol in
            SECTION.  Note that all the symbols are sorted
            together into one big array, and that some sections
            may have overlapping addresses.  */
         while (place < sorted_symcount
               && ! is_valid_next_sym (sorted_syms [place]))
           ++place;

         if (place >= sorted_symcount)
           nextsym = NULL;
         else
           nextsym = sorted_syms[place];
       }

      if (sym != NULL && bfd_asymbol_value (sym) > addr)
       nextstop_offset = bfd_asymbol_value (sym) - section->vma;
      else if (nextsym == NULL)
       nextstop_offset = stop_offset;
      else
       nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;

      if (nextstop_offset > stop_offset)
       nextstop_offset = stop_offset;

      /* If a symbol is explicitly marked as being an object
        rather than a function, just dump the bytes without
        disassembling them.  */
      if (disassemble_all
         || sym == NULL
         || bfd_asymbol_value (sym) > addr
         || ((sym->flags & BSF_OBJECT) == 0
             && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
                == NULL)
             && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
                == NULL))
         || (sym->flags & BSF_FUNCTION) != 0)
       insns = TRUE;
      else
       insns = FALSE;

      disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
                      addr_offset, nextstop_offset,
                      rel_offset, &rel_pp, rel_ppend);

      addr_offset = nextstop_offset;
      sym = nextsym;
    }

  free (data);

  if (rel_ppstart != NULL)
    free (rel_ppstart);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void display_bfd ( bfd abfd) [static]

Definition at line 2862 of file objdump.c.

{
  char **matching;

  if (bfd_check_format_matches (abfd, bfd_object, &matching))
    {
      dump_bfd (abfd);
      return;
    }

  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
    {
      nonfatal (bfd_get_filename (abfd));
      list_matching_formats (matching);
      free (matching);
      return;
    }

  if (bfd_get_error () != bfd_error_file_not_recognized)
    {
      nonfatal (bfd_get_filename (abfd));
      return;
    }

  if (bfd_check_format_matches (abfd, bfd_core, &matching))
    {
      dump_bfd (abfd);
      return;
    }

  nonfatal (bfd_get_filename (abfd));

  if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
    {
      list_matching_formats (matching);
      free (matching);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void display_file ( char *  filename,
char *  target 
) [static]

Definition at line 2902 of file objdump.c.

{
  bfd *file;
  bfd *arfile = NULL;

  if (get_file_size (filename) < 1)
    {
      exit_status = 1;
      return;
    }

  file = bfd_openr (filename, target);
  if (file == NULL)
    {
      nonfatal (filename);
      return;
    }

  /* If the file is an archive, process all of its elements.  */
  if (bfd_check_format (file, bfd_archive))
    {
      bfd *last_arfile = NULL;

      printf (_("In archive %s:\n"), bfd_get_filename (file));
      for (;;)
       {
         bfd_set_error (bfd_error_no_error);

         arfile = bfd_openr_next_archived_file (file, arfile);
         if (arfile == NULL)
           {
             if (bfd_get_error () != bfd_error_no_more_archived_files)
              nonfatal (bfd_get_filename (file));
             break;
           }

         display_bfd (arfile);

         if (last_arfile != NULL)
           bfd_close (last_arfile);
         last_arfile = arfile;
       }

      if (last_arfile != NULL)
       bfd_close (last_arfile);
    }
  else
    display_bfd (file);

  bfd_close (file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_bfd ( bfd abfd) [static]

Definition at line 2762 of file objdump.c.

{
  /* If we are adjusting section VMA's, change them all now.  Changing
     the BFD information is a hack.  However, we must do it, or
     bfd_find_nearest_line will not do the right thing.  */
  if (adjust_section_vma != 0)
    {
      bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
      bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
    }

  if (! dump_debugging_tags)
    printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
           abfd->xvec->name);
  if (dump_ar_hdrs)
    print_arelt_descr (stdout, abfd, TRUE);
  if (dump_file_header)
    dump_bfd_header (abfd);
  if (dump_private_headers)
    dump_bfd_private_header (abfd);
  if (! dump_debugging_tags)
    putchar ('\n');
  if (dump_section_headers)
    dump_headers (abfd);

  if (dump_symtab
      || dump_reloc_info
      || disassemble
      || dump_debugging
      || dump_dwarf_section_info)
    syms = slurp_symtab (abfd);
  if (dump_dynamic_symtab || dump_dynamic_reloc_info
      || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
    dynsyms = slurp_dynamic_symtab (abfd);
  if (disassemble)
    {
      synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
                                        dynsymcount, dynsyms, &synthsyms);
      if (synthcount < 0)
       synthcount = 0;
    }

  if (dump_symtab)
    dump_symbols (abfd, FALSE);
  if (dump_dynamic_symtab)
    dump_symbols (abfd, TRUE);
  if (dump_dwarf_section_info)
    dump_dwarf (abfd);
  if (dump_stab_section_info)
    dump_stabs (abfd);
  if (dump_reloc_info && ! disassemble)
    dump_relocs (abfd);
  if (dump_dynamic_reloc_info && ! disassemble)
    dump_dynamic_relocs (abfd);
  if (dump_section_contents)
    dump_data (abfd);
  if (disassemble)
    disassemble_data (abfd);

  if (dump_debugging)
    {
      void *dhandle;

      dhandle = read_debugging_info (abfd, syms, symcount);
      if (dhandle != NULL)
       {
         if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
             dump_debugging_tags ? TRUE : FALSE))
           {
             non_fatal (_("%s: printing debugging information failed"),
                      bfd_get_filename (abfd));
             exit_status = 1;
           }
       }
    }

  if (syms)
    {
      free (syms);
      syms = NULL;
    }

  if (dynsyms)
    {
      free (dynsyms);
      dynsyms = NULL;
    }

  if (synthsyms)
    {
      free (synthsyms);
      synthsyms = NULL;
    }

  symcount = 0;
  dynsymcount = 0;
  synthcount = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_bfd_header ( bfd abfd) [static]

Definition at line 2305 of file objdump.c.

{
  char *comma = "";

  printf (_("architecture: %s, "),
         bfd_printable_arch_mach (bfd_get_arch (abfd),
                               bfd_get_mach (abfd)));
  printf (_("flags 0x%08x:\n"), abfd->flags);

#define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
  PF (HAS_RELOC, "HAS_RELOC");
  PF (EXEC_P, "EXEC_P");
  PF (HAS_LINENO, "HAS_LINENO");
  PF (HAS_DEBUG, "HAS_DEBUG");
  PF (HAS_SYMS, "HAS_SYMS");
  PF (HAS_LOCALS, "HAS_LOCALS");
  PF (DYNAMIC, "DYNAMIC");
  PF (WP_TEXT, "WP_TEXT");
  PF (D_PAGED, "D_PAGED");
  PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
  PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
  printf (_("\nstart address 0x"));
  bfd_printf_vma (abfd, abfd->start_address);
  printf ("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_bfd_private_header ( bfd abfd) [static]

Definition at line 2333 of file objdump.c.

{
  bfd_print_private_bfd_data (abfd, stdout);
}

Here is the caller graph for this function:

static void dump_data ( bfd abfd) [static]

Definition at line 2463 of file objdump.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_dwarf ( bfd abfd) [static]

Definition at line 2093 of file objdump.c.

{
  is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
                  == HAS_RELOC);

  /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
     targets will return 64.  */
  eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;

  if (bfd_big_endian (abfd))
    byte_get = byte_get_big_endian;
  else if (bfd_little_endian (abfd))
    byte_get = byte_get_little_endian;
  else
    abort ();

  check_mach_o_dwarf (abfd);

  bfd_map_over_sections (abfd, dump_dwarf_section, NULL);

  free_debug_memory ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_dwarf_section ( bfd abfd,
asection section,
void *arg  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2014 of file objdump.c.

{
  const char *name = bfd_get_section_name (abfd, section);
  const char *match;
  enum dwarf_section_display_enum i;

  if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
    match = ".debug_info";
  else
    match = name;

  for (i = 0; i < max; i++)
    if (strcmp (debug_displays[i].section.name, match) == 0)
      {
       if (!debug_displays[i].eh_frame)
         {
           struct dwarf_section *sec = &debug_displays [i].section;

           if (load_debug_section (i, abfd))
             {
              debug_displays[i].display (sec, abfd);

              if (i != info && i != abbrev)
                free_debug_section (i);
             }
         }
       break;
      }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_dynamic_relocs ( bfd abfd) [static]

Definition at line 2695 of file objdump.c.

{
  long relsize;
  arelent **relpp;
  long relcount;

  relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
  if (relsize < 0)
    bfd_fatal (bfd_get_filename (abfd));

  printf ("DYNAMIC RELOCATION RECORDS");

  if (relsize == 0)
    printf (" (none)\n\n");
  else
    {
      relpp = xmalloc (relsize);
      relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);

      if (relcount < 0)
       bfd_fatal (bfd_get_filename (abfd));
      else if (relcount == 0)
       printf (" (none)\n\n");
      else
       {
         printf ("\n");
         dump_reloc_set (abfd, NULL, relpp, relcount);
         printf ("\n\n");
       }
      free (relpp);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_headers ( bfd abfd) [static]

Definition at line 379 of file objdump.c.

{
  printf (_("Sections:\n"));

#ifndef BFD64
  printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
#else
  /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
  if (bfd_get_arch_size (abfd) == 32)
    printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
  else
    printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
#endif

  if (wide_output)
    printf (_("  Flags"));
  if (abfd->flags & HAS_LOAD_PAGE)
    printf (_("  Pg"));
  printf ("\n");

  bfd_map_over_sections (abfd, dump_section_header, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_reloc_set ( bfd abfd,
asection sec,
arelent **  relpp,
long  relcount 
) [static]

Definition at line 2536 of file objdump.c.

{
  arelent **p;
  char *last_filename, *last_functionname;
  unsigned int last_line;

  /* Get column headers lined up reasonably.  */
  {
    static int width;

    if (width == 0)
      {
       char buf[30];

       bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
       width = strlen (buf) - 7;
      }
    printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
  }

  last_filename = NULL;
  last_functionname = NULL;
  last_line = 0;

  for (p = relpp; relcount && *p != NULL; p++, relcount--)
    {
      arelent *q = *p;
      const char *filename, *functionname;
      unsigned int line;
      const char *sym_name;
      const char *section_name;

      if (start_address != (bfd_vma) -1
         && q->address < start_address)
       continue;
      if (stop_address != (bfd_vma) -1
         && q->address > stop_address)
       continue;

      if (with_line_numbers
         && sec != NULL
         && bfd_find_nearest_line (abfd, sec, syms, q->address,
                                &filename, &functionname, &line))
       {
         if (functionname != NULL
             && (last_functionname == NULL
                || strcmp (functionname, last_functionname) != 0))
           {
             printf ("%s():\n", functionname);
             if (last_functionname != NULL)
              free (last_functionname);
             last_functionname = xstrdup (functionname);
           }

         if (line > 0
             && (line != last_line
                || (filename != NULL
                    && last_filename != NULL
                    && strcmp (filename, last_filename) != 0)))
           {
             printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
             last_line = line;
             if (last_filename != NULL)
              free (last_filename);
             if (filename == NULL)
              last_filename = NULL;
             else
              last_filename = xstrdup (filename);
           }
       }

      if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
       {
         sym_name = (*(q->sym_ptr_ptr))->name;
         section_name = (*(q->sym_ptr_ptr))->section->name;
       }
      else
       {
         sym_name = NULL;
         section_name = NULL;
       }

      bfd_printf_vma (abfd, q->address);
      if (q->howto == NULL)
       printf (" *unknown*         ");
      else if (q->howto->name)
       printf (" %-16s  ", q->howto->name);
      else
       printf (" %-16d  ", q->howto->type);
      if (sym_name)
       objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
      else
       {
         if (section_name == NULL)
           section_name = "*unknown*";
         printf ("[%s]", section_name);
       }

      if (q->addend)
       {
         printf ("+0x");
         bfd_printf_vma (abfd, q->addend);
       }

      printf ("\n");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_relocs ( bfd abfd) [static]

Definition at line 2689 of file objdump.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_relocs_in_section ( bfd abfd,
asection section,
void *dummy  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2645 of file objdump.c.

{
  arelent **relpp;
  long relcount;
  long relsize;

  if (   bfd_is_abs_section (section)
      || bfd_is_und_section (section)
      || bfd_is_com_section (section)
      || (! process_section_p (section))
      || ((section->flags & SEC_RELOC) == 0))
    return;

  relsize = bfd_get_reloc_upper_bound (abfd, section);
  if (relsize < 0)
    bfd_fatal (bfd_get_filename (abfd));

  printf ("RELOCATION RECORDS FOR [%s]:", section->name);

  if (relsize == 0)
    {
      printf (" (none)\n\n");
      return;
    }

  relpp = xmalloc (relsize);
  relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);

  if (relcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
  else if (relcount == 0)
    printf (" (none)\n\n");
  else
    {
      printf ("\n");
      dump_reloc_set (abfd, section, relpp, relcount);
      printf ("\n\n");
    }
  free (relpp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_section ( bfd abfd,
asection section,
void *dummy  ATTRIBUTE_UNUSED 
) [static]

Definition at line 2343 of file objdump.c.

{
  bfd_byte *data = 0;
  bfd_size_type datasize;
  bfd_size_type addr_offset;
  bfd_size_type start_offset;
  bfd_size_type stop_offset;
  unsigned int opb = bfd_octets_per_byte (abfd);
  /* Bytes per line.  */
  const int onaline = 16;
  char buf[64];
  int count;
  int width;

  if ((section->flags & SEC_HAS_CONTENTS) == 0)
    return;

  if (! process_section_p (section))
    return;
  
  if ((datasize = bfd_section_size (abfd, section)) == 0)
    return;

  printf (_("Contents of section %s:\n"), section->name);

  data = xmalloc (datasize);

  bfd_get_section_contents (abfd, section, data, 0, datasize);

  /* Compute the address range to display.  */
  if (start_address == (bfd_vma) -1
      || start_address < section->vma)
    start_offset = 0;
  else
    start_offset = start_address - section->vma;

  if (stop_address == (bfd_vma) -1)
    stop_offset = datasize / opb;
  else
    {
      if (stop_address < section->vma)
       stop_offset = 0;
      else
       stop_offset = stop_address - section->vma;

      if (stop_offset > datasize / opb)
       stop_offset = datasize / opb;
    }

  width = 4;

  bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
  if (strlen (buf) >= sizeof (buf))
    abort ();

  count = 0;
  while (buf[count] == '0' && buf[count+1] != '\0')
    count++;
  count = strlen (buf) - count;
  if (count > width)
    width = count;

  bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
  if (strlen (buf) >= sizeof (buf))
    abort ();

  count = 0;
  while (buf[count] == '0' && buf[count+1] != '\0')
    count++;
  count = strlen (buf) - count;
  if (count > width)
    width = count;

  for (addr_offset = start_offset;
       addr_offset < stop_offset; addr_offset += onaline / opb)
    {
      bfd_size_type j;

      bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
      count = strlen (buf);
      if ((size_t) count >= sizeof (buf))
       abort ();

      putchar (' ');
      while (count < width)
       {
         putchar ('0');
         count++;
       }
      fputs (buf + count - width, stdout);
      putchar (' ');

      for (j = addr_offset * opb;
          j < addr_offset * opb + onaline; j++)
       {
         if (j < stop_offset * opb)
           printf ("%02x", (unsigned) (data[j]));
         else
           printf ("  ");
         if ((j & 3) == 3)
           printf (" ");
       }

      printf (" ");
      for (j = addr_offset * opb;
          j < addr_offset * opb + onaline; j++)
       {
         if (j >= stop_offset * opb)
           printf (" ");
         else
           printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
       }
      putchar ('\n');
    }
  free (data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_section_header ( bfd abfd,
asection section,
void *ignored  ATTRIBUTE_UNUSED 
) [static]

Definition at line 293 of file objdump.c.

{
  char *comma = "";
  unsigned int opb = bfd_octets_per_byte (abfd);

  /* Ignore linker created section.  See elfNN_ia64_object_p in
     bfd/elfxx-ia64.c.  */
  if (section->flags & SEC_LINKER_CREATED)
    return;

  printf ("%3d %-13s %08lx  ", section->index,
         bfd_get_section_name (abfd, section),
         (unsigned long) bfd_section_size (abfd, section) / opb);
  bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
  printf ("  ");
  bfd_printf_vma (abfd, section->lma);
  printf ("  %08lx  2**%u", (unsigned long) section->filepos,
         bfd_get_section_alignment (abfd, section));
  if (! wide_output)
    printf ("\n                ");
  printf ("  ");

#define PF(x, y) \
  if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }

  PF (SEC_HAS_CONTENTS, "CONTENTS");
  PF (SEC_ALLOC, "ALLOC");
  PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
  PF (SEC_LOAD, "LOAD");
  PF (SEC_RELOC, "RELOC");
  PF (SEC_READONLY, "READONLY");
  PF (SEC_CODE, "CODE");
  PF (SEC_DATA, "DATA");
  PF (SEC_ROM, "ROM");
  PF (SEC_DEBUGGING, "DEBUGGING");
  PF (SEC_NEVER_LOAD, "NEVER_LOAD");
  PF (SEC_EXCLUDE, "EXCLUDE");
  PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
  if (bfd_get_arch (abfd) == bfd_arch_tic54x)
    {
      PF (SEC_TIC54X_BLOCK, "BLOCK");
      PF (SEC_TIC54X_CLINK, "CLINK");
    }
  PF (SEC_SMALL_DATA, "SMALL_DATA");
  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
    PF (SEC_COFF_SHARED, "SHARED");
  PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
  PF (SEC_GROUP, "GROUP");

  if ((section->flags & SEC_LINK_ONCE) != 0)
    {
      const char *ls;
      struct coff_comdat_info *comdat;

      switch (section->flags & SEC_LINK_DUPLICATES)
       {
       default:
         abort ();
       case SEC_LINK_DUPLICATES_DISCARD:
         ls = "LINK_ONCE_DISCARD";
         break;
       case SEC_LINK_DUPLICATES_ONE_ONLY:
         ls = "LINK_ONCE_ONE_ONLY";
         break;
       case SEC_LINK_DUPLICATES_SAME_SIZE:
         ls = "LINK_ONCE_SAME_SIZE";
         break;
       case SEC_LINK_DUPLICATES_SAME_CONTENTS:
         ls = "LINK_ONCE_SAME_CONTENTS";
         break;
       }
      printf ("%s%s", comma, ls);

      comdat = bfd_coff_get_comdat_section (abfd, section);
      if (comdat != NULL)
       printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);

      comma = ", ";
    }

  printf ("\n");
#undef PF
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_stabs ( bfd abfd) [static]

Definition at line 2296 of file objdump.c.

{
  dump_stabs_section (abfd, ".stab", ".stabstr");
  dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
  dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
  dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_stabs_section ( bfd abfd,
char *  stabsect_name,
char *  strsect_name 
) [static]

Definition at line 2279 of file objdump.c.

{
  stab_section_names s;

  s.section_name = stabsect_name;
  s.string_section_name = strsect_name;
  s.string_offset = 0;

  bfd_map_over_sections (abfd, find_stabs_section, & s);

  free (strtab);
  strtab = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_symbols ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_boolean  dynamic 
) [static]

Definition at line 2471 of file objdump.c.

{
  asymbol **current;
  long max;
  long count;

  if (dynamic)
    {
      current = dynsyms;
      max = dynsymcount;
      printf ("DYNAMIC SYMBOL TABLE:\n");
    }
  else
    {
      current = syms;
      max = symcount;
      printf ("SYMBOL TABLE:\n");
    }

  if (max == 0)
    printf (_("no symbols\n"));

  for (count = 0; count < max; count++)
    {
      bfd *cur_bfd;

      if (*current == NULL)
       printf (_("no information for symbol number %ld\n"), count);

      else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
       printf (_("could not determine the type of symbol number %ld\n"),
              count);

      else if (process_section_p ((* current)->section)
              && (dump_special_syms
                 || !bfd_is_target_special_symbol (cur_bfd, *current)))
       {
         const char *name = (*current)->name;

         if (do_demangle && name != NULL && *name != '\0')
           {
             char *alloc;

             /* If we want to demangle the name, we demangle it
               here, and temporarily clobber it while calling
               bfd_print_symbol.  FIXME: This is a gross hack.  */
             alloc = demangle (cur_bfd, name);
             (*current)->name = alloc;
             bfd_print_symbol (cur_bfd, stdout, *current,
                            bfd_print_symbol_all);
             (*current)->name = name;
             free (alloc);
           }
         else
           bfd_print_symbol (cur_bfd, stdout, *current,
                           bfd_print_symbol_all);
         printf ("\n");
       }

      current++;
    }
  printf ("\n\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void find_stabs_section ( bfd abfd,
asection section,
void *  names 
) [static]

Definition at line 2248 of file objdump.c.

{
  int len;
  stab_section_names * sought = (stab_section_names *) names;

  /* Check for section names for which stabsect_name is a prefix, to
     handle .stab.N, etc.  */
  len = strlen (sought->section_name);

  /* If the prefix matches, and the files section name ends with a
     nul or a digit, then we match.  I.e., we want either an exact
     match or a section followed by a number.  */
  if (strncmp (sought->section_name, section->name, len) == 0
      && (section->name[len] == 0
         || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
    {
      if (strtab == NULL)
       strtab = read_section_stabs (abfd, sought->string_section_name,
                                 &stabstr_size);
      
      if (strtab)
       {
         stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
                                             &stab_size);
         if (stabs)
           print_section_stabs (abfd, section->name, &sought->string_offset);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static asymbol* find_symbol_for_address ( bfd_vma  vma,
struct disassemble_info info,
long place 
) [static]

Definition at line 672 of file objdump.c.

{
  /* @@ Would it speed things up to cache the last two symbols returned,
     and maybe their address ranges?  For many processors, only one memory
     operand can be present at a time, so the 2-entry cache wouldn't be
     constantly churned by code doing heavy memory accesses.  */

  /* Indices in `sorted_syms'.  */
  long min = 0;
  long max = sorted_symcount;
  long thisplace;
  struct objdump_disasm_info *aux;
  bfd *abfd;
  asection *sec;
  unsigned int opb;

  if (sorted_symcount < 1)
    return NULL;

  aux = (struct objdump_disasm_info *) info->application_data;
  abfd = aux->abfd;
  sec = aux->sec;
  opb = bfd_octets_per_byte (abfd);

  /* Perform a binary search looking for the closest symbol to the
     required value.  We are searching the range (min, max].  */
  while (min + 1 < max)
    {
      asymbol *sym;

      thisplace = (max + min) / 2;
      sym = sorted_syms[thisplace];

      if (bfd_asymbol_value (sym) > vma)
       max = thisplace;
      else if (bfd_asymbol_value (sym) < vma)
       min = thisplace;
      else
       {
         min = thisplace;
         break;
       }
    }

  /* The symbol we want is now in min, the low end of the range we
     were searching.  If there are several symbols with the same
     value, we want the first one.  */
  thisplace = min;
  while (thisplace > 0
        && (bfd_asymbol_value (sorted_syms[thisplace])
            == bfd_asymbol_value (sorted_syms[thisplace - 1])))
    --thisplace;

  /* If the file is relocatable, and the symbol could be from this
     section, prefer a symbol from this section over symbols from
     others, even if the other symbol's value might be closer.

     Note that this may be wrong for some symbol references if the
     sections have overlapping memory ranges, but in that case there's
     no way to tell what's desired without looking at the relocation
     table.  */
  if (sorted_syms[thisplace]->section != sec
      && (aux->require_sec
         || ((abfd->flags & HAS_RELOC) != 0
             && vma >= bfd_get_section_vma (abfd, sec)
             && vma < (bfd_get_section_vma (abfd, sec)
                     + bfd_section_size (abfd, sec) / opb))))
    {
      long i;

      for (i = thisplace + 1; i < sorted_symcount; i++)
       {
         if (bfd_asymbol_value (sorted_syms[i])
             != bfd_asymbol_value (sorted_syms[thisplace]))
           break;
       }

      --i;

      for (; i >= 0; i--)
       {
         if (sorted_syms[i]->section == sec
             && (i == 0
                || sorted_syms[i - 1]->section != sec
                || (bfd_asymbol_value (sorted_syms[i])
                    != bfd_asymbol_value (sorted_syms[i - 1]))))
           {
             thisplace = i;
             break;
           }
       }

      if (sorted_syms[thisplace]->section != sec)
       {
         /* We didn't find a good symbol with a smaller value.
            Look for one with a larger value.  */
         for (i = thisplace + 1; i < sorted_symcount; i++)
           {
             if (sorted_syms[i]->section == sec)
              {
                thisplace = i;
                break;
              }
           }
       }

      if (sorted_syms[thisplace]->section != sec
         && (aux->require_sec
             || ((abfd->flags & HAS_RELOC) != 0
                && vma >= bfd_get_section_vma (abfd, sec)
                && vma < (bfd_get_section_vma (abfd, sec)
                         + bfd_section_size (abfd, sec)))))
       /* There is no suitable symbol.  */
       return NULL;
    }

  /* Give the target a chance to reject the symbol.  */
  while (! info->symbol_is_valid (sorted_syms [thisplace], info))
    {
      ++ thisplace;
      if (thisplace >= sorted_symcount
         || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
       return NULL;
    }

  if (place != NULL)
    *place = thisplace;

  return sorted_syms[thisplace];
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2000 of file objdump.c.

{
  struct dwarf_section *section = &debug_displays [debug].section;

  if (section->start == NULL)
    return;

  free ((char *) section->start);
  section->start = NULL;
  section->address = 0;
  section->size = 0;
}

Here is the call graph for this function:

int load_debug_section ( enum dwarf_section_display_enum  debug,
void *  file 
)

Definition at line 1960 of file objdump.c.

{
  struct dwarf_section *section = &debug_displays [debug].section;
  bfd *abfd = file;
  asection *sec;
  bfd_boolean ret;

  /* If it is already loaded, do nothing.  */
  if (section->start != NULL)
    return 1;

  /* Locate the debug section.  */
  sec = bfd_get_section_by_name (abfd, section->name);
  if (sec == NULL)
    return 0;

  section->address = bfd_get_section_vma (abfd, sec);
  section->size = bfd_get_section_size (sec);
  section->start = xmalloc (section->size);

  if (is_relocatable && debug_displays [debug].relocate)
    ret = bfd_simple_get_relocated_section_contents (abfd,
                                               sec,
                                               section->start,
                                               syms) != NULL;
  else
    ret = bfd_get_section_contents (abfd, sec, section->start, 0,
                                section->size);

  if (!ret)
    {
      free_debug_section (debug);
      printf (_("\nCan't get contents for section '%s'.\n"),
             section->name);
    }

  return ret;
}

Here is the call graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 2955 of file objdump.c.

{
  int c;
  char *target = default_target;
  bfd_boolean seenflag = FALSE;

#if defined (HAVE_SETLOCALE)
#if defined (HAVE_LC_MESSAGES)
  setlocale (LC_MESSAGES, "");
#endif
  setlocale (LC_CTYPE, "");
#endif

  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  program_name = *argv;
  xmalloc_set_program_name (program_name);

  START_PROGRESS (program_name, 0);

  expandargv (&argc, &argv);

  bfd_init ();
  set_default_bfd_target ();

  while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
                        long_options, (int *) 0))
        != EOF)
    {
      switch (c)
       {
       case 0:
         break;             /* We've been given a long option.  */
       case 'm':
         machine = optarg;
         break;
       case 'M':
         if (disassembler_options)
           /* Ignore potential memory leak for now.  */
           disassembler_options = concat (disassembler_options, ",",
                                      optarg, NULL);
         else
           disassembler_options = optarg;
         break;
       case 'j':
         if (only_used == only_size)
           {
             only_size += 8;
             only = xrealloc (only, only_size * sizeof (char *));
           }
         only [only_used++] = optarg;
         break;
       case 'l':
         with_line_numbers = TRUE;
         break;
       case 'b':
         target = optarg;
         break;
       case 'C':
         do_demangle = TRUE;
         if (optarg != NULL)
           {
             enum demangling_styles style;

             style = cplus_demangle_name_to_style (optarg);
             if (style == unknown_demangling)
              fatal (_("unknown demangling style `%s'"),
                     optarg);

             cplus_demangle_set_style (style);
           }
         break;
       case 'w':
         wide_output = TRUE;
         break;
       case OPTION_ADJUST_VMA:
         adjust_section_vma = parse_vma (optarg, "--adjust-vma");
         break;
       case OPTION_START_ADDRESS:
         start_address = parse_vma (optarg, "--start-address");
         break;
       case OPTION_STOP_ADDRESS:
         stop_address = parse_vma (optarg, "--stop-address");
         break;
       case 'E':
         if (strcmp (optarg, "B") == 0)
           endian = BFD_ENDIAN_BIG;
         else if (strcmp (optarg, "L") == 0)
           endian = BFD_ENDIAN_LITTLE;
         else
           {
             non_fatal (_("unrecognized -E option"));
             usage (stderr, 1);
           }
         break;
       case OPTION_ENDIAN:
         if (strncmp (optarg, "big", strlen (optarg)) == 0)
           endian = BFD_ENDIAN_BIG;
         else if (strncmp (optarg, "little", strlen (optarg)) == 0)
           endian = BFD_ENDIAN_LITTLE;
         else
           {
             non_fatal (_("unrecognized --endian type `%s'"), optarg);
             usage (stderr, 1);
           }
         break;

       case 'f':
         dump_file_header = TRUE;
         seenflag = TRUE;
         break;
       case 'i':
         formats_info = TRUE;
         seenflag = TRUE;
         break;
       case 'I':
         add_include_path (optarg);
         break;
       case 'p':
         dump_private_headers = TRUE;
         seenflag = TRUE;
         break;
       case 'x':
         dump_private_headers = TRUE;
         dump_symtab = TRUE;
         dump_reloc_info = TRUE;
         dump_file_header = TRUE;
         dump_ar_hdrs = TRUE;
         dump_section_headers = TRUE;
         seenflag = TRUE;
         break;
       case 't':
         dump_symtab = TRUE;
         seenflag = TRUE;
         break;
       case 'T':
         dump_dynamic_symtab = TRUE;
         seenflag = TRUE;
         break;
       case 'd':
         disassemble = TRUE;
         seenflag = TRUE;
         break;
       case 'z':
         disassemble_zeroes = TRUE;
         break;
       case 'D':
         disassemble = TRUE;
         disassemble_all = TRUE;
         seenflag = TRUE;
         break;
       case 'S':
         disassemble = TRUE;
         with_source_code = TRUE;
         seenflag = TRUE;
         break;
       case 'g':
         dump_debugging = 1;
         seenflag = TRUE;
         break;
       case 'e':
         dump_debugging = 1;
         dump_debugging_tags = 1;
         do_demangle = TRUE;
         seenflag = TRUE;
         break;
       case 'W':
         dump_dwarf_section_info = TRUE;
         seenflag = TRUE;
         do_debug_info = 1;
         do_debug_abbrevs = 1;
         do_debug_lines = 1;
         do_debug_pubnames = 1;
         do_debug_aranges = 1;
         do_debug_ranges = 1;
         do_debug_frames = 1;
         do_debug_macinfo = 1;
         do_debug_str = 1;
         do_debug_loc = 1;
         break;
       case 'G':
         dump_stab_section_info = TRUE;
         seenflag = TRUE;
         break;
       case 's':
         dump_section_contents = TRUE;
         seenflag = TRUE;
         break;
       case 'r':
         dump_reloc_info = TRUE;
         seenflag = TRUE;
         break;
       case 'R':
         dump_dynamic_reloc_info = TRUE;
         seenflag = TRUE;
         break;
       case 'a':
         dump_ar_hdrs = TRUE;
         seenflag = TRUE;
         break;
       case 'h':
         dump_section_headers = TRUE;
         seenflag = TRUE;
         break;
       case 'H':
         usage (stdout, 0);
         seenflag = TRUE;
       case 'v':
       case 'V':
         show_version = TRUE;
         seenflag = TRUE;
         break;

       default:
         usage (stderr, 1);
       }
    }

  if (show_version)
    print_version ("objdump");

  if (!seenflag)
    usage (stderr, 2);

  if (formats_info)
    exit_status = display_info ();
  else
    {
      if (optind == argc)
       display_file ("a.out", target);
      else
       for (; optind < argc;)
         display_file (argv[optind++], target);
    }

  END_PROGRESS (program_name);

  return exit_status;
}

Here is the call graph for this function:

static void nonfatal ( const char *  msg) [static]

Definition at line 286 of file objdump.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void objdump_print_addr ( bfd_vma  vma,
struct disassemble_info info,
bfd_boolean  skip_zeroes 
) [static]

Definition at line 855 of file objdump.c.

{
  struct objdump_disasm_info *aux;
  asymbol *sym = NULL; /* Initialize to avoid compiler warning.  */
  bfd_boolean skip_find = FALSE;

  if (sorted_symcount < 1)
    {
      (*info->fprintf_func) (info->stream, "0x");
      objdump_print_value (vma, info, skip_zeroes);
      return;
    }

  aux = (struct objdump_disasm_info *) info->application_data;

  if (aux->reloc != NULL
      && aux->reloc->sym_ptr_ptr != NULL
      && * aux->reloc->sym_ptr_ptr != NULL)
    {
      sym = * aux->reloc->sym_ptr_ptr;

      /* Adjust the vma to the reloc.  */
      vma += bfd_asymbol_value (sym);

      if (bfd_is_und_section (bfd_get_section (sym)))
       skip_find = TRUE;
    }

  if (!skip_find)
    sym = find_symbol_for_address (vma, info, NULL);

  objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
                            skip_zeroes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void objdump_print_addr_with_sym ( bfd abfd,
asection sec,
asymbol sym,
bfd_vma  vma,
struct disassemble_info info,
bfd_boolean  skip_zeroes 
) [static]

Definition at line 808 of file objdump.c.

{
  objdump_print_value (vma, info, skip_zeroes);

  if (sym == NULL)
    {
      bfd_vma secaddr;

      (*info->fprintf_func) (info->stream, " <%s",
                          bfd_get_section_name (abfd, sec));
      secaddr = bfd_get_section_vma (abfd, sec);
      if (vma < secaddr)
       {
         (*info->fprintf_func) (info->stream, "-0x");
         objdump_print_value (secaddr - vma, info, TRUE);
       }
      else if (vma > secaddr)
       {
         (*info->fprintf_func) (info->stream, "+0x");
         objdump_print_value (vma - secaddr, info, TRUE);
       }
      (*info->fprintf_func) (info->stream, ">");
    }
  else
    {
      (*info->fprintf_func) (info->stream, " <");
      objdump_print_symname (abfd, info, sym);
      if (bfd_asymbol_value (sym) > vma)
       {
         (*info->fprintf_func) (info->stream, "-0x");
         objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
       }
      else if (vma > bfd_asymbol_value (sym))
       {
         (*info->fprintf_func) (info->stream, "+0x");
         objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
       }
      (*info->fprintf_func) (info->stream, ">");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void objdump_print_address ( bfd_vma  vma,
struct disassemble_info info 
) [static]

Definition at line 896 of file objdump.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void objdump_print_symname ( bfd abfd,
struct disassemble_info info,
asymbol sym 
) [static]

Definition at line 641 of file objdump.c.

{
  char *alloc;
  const char *name;

  alloc = NULL;
  name = bfd_asymbol_name (sym);
  if (do_demangle && name[0] != '\0')
    {
      /* Demangle the name.  */
      alloc = demangle (abfd, name);
      name = alloc;
    }

  if (info != NULL)
    (*info->fprintf_func) (info->stream, "%s", name);
  else
    printf ("%s", name);

  if (alloc != NULL)
    free (alloc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void objdump_print_value ( bfd_vma  vma,
struct disassemble_info info,
bfd_boolean  skip_zeroes 
) [static]

Definition at line 617 of file objdump.c.

{
  char buf[30];
  char *p;
  struct objdump_disasm_info *aux;

  aux = (struct objdump_disasm_info *) info->application_data;
  bfd_sprintf_vma (aux->abfd, buf, vma);
  if (! skip_zeroes)
    p = buf;
  else
    {
      for (p = buf; *p == '0'; ++p)
       ;
      if (*p == '\0')
       --p;
    }
  (*info->fprintf_func) (info->stream, "%s", p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ATTRIBUTE_PRINTF_2 objdump_sprintf ( SFILE f,
const char *  format,
  ... 
) [static]

Definition at line 1186 of file objdump.c.

{
  size_t n;
  va_list args;

  while (1)
    {
      size_t space = f->alloc - f->pos;
  
      va_start (args, format);
      n = vsnprintf (f->buffer + f->pos, space, format, args);
      va_end (args);

      if (space > n)
       break;
      
      f->alloc = (f->alloc + n) * 2;
      f->buffer = xrealloc (f->buffer, f->alloc);
    }
  f->pos += n;
  
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int objdump_symbol_at_address ( bfd_vma  vma,
struct disassemble_info info 
) [static]

Definition at line 904 of file objdump.c.

{
  asymbol * sym;

  sym = find_symbol_for_address (vma, info, NULL);

  return (sym != NULL && (bfd_asymbol_value (sym) == vma));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_section_stabs ( bfd abfd,
const char *  stabsect_name,
unsigned string_offset_ptr 
) [static]

Definition at line 2170 of file objdump.c.

{
  int i;
  unsigned file_string_table_offset = 0;
  unsigned next_file_string_table_offset = *string_offset_ptr;
  bfd_byte *stabp, *stabs_end;

  stabp = stabs;
  stabs_end = stabp + stab_size;

  printf (_("Contents of %s section:\n\n"), stabsect_name);
  printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");

  /* Loop through all symbols and print them.

     We start the index at -1 because there is a dummy symbol on
     the front of stabs-in-{coff,elf} sections that supplies sizes.  */
  for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
    {
      const char *name;
      unsigned long strx;
      unsigned char type, other;
      unsigned short desc;
      bfd_vma value;

      strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
      type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
      other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
      desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
      value = bfd_h_get_32 (abfd, stabp + VALOFF);

      printf ("\n%-6d ", i);
      /* Either print the stab name, or, if unnamed, print its number
        again (makes consistent formatting for tools like awk).  */
      name = bfd_get_stab_name (type);
      if (name != NULL)
       printf ("%-6s", name);
      else if (type == N_UNDF)
       printf ("HdrSym");
      else
       printf ("%-6d", type);
      printf (" %-6d %-6d ", other, desc);
      bfd_printf_vma (abfd, value);
      printf (" %-6lu", strx);

      /* Symbols with type == 0 (N_UNDF) specify the length of the
        string table associated with this file.  We use that info
        to know how to relocate the *next* file's string table indices.  */
      if (type == N_UNDF)
       {
         file_string_table_offset = next_file_string_table_offset;
         next_file_string_table_offset += value;
       }
      else
       {
         /* Using the (possibly updated) string table offset, print the
            string (if any) associated with this symbol.  */
         if ((strx + file_string_table_offset) < stabstr_size)
           printf (" %s", &strtab[strx + file_string_table_offset]);
         else
           printf (" *");
       }
    }
  printf ("\n\n");
  *string_offset_ptr = next_file_string_table_offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean process_section_p ( asection section) [static]

Definition at line 1213 of file objdump.c.

{
  size_t i;

  if (only == NULL)
    return TRUE;

  for (i = 0; i < only_used; i++)
    if (strcmp (only [i], section->name) == 0)
      return TRUE;

  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* read_section_stabs ( bfd abfd,
const char *  sect_name,
bfd_size_type size_ptr 
) [static]

Definition at line 2120 of file objdump.c.

{
  asection *stabsect;
  bfd_size_type size;
  char *contents;

  stabsect = bfd_get_section_by_name (abfd, sect_name);
  if (stabsect == NULL)
    {
      printf (_("No %s section present\n\n"), sect_name);
      return FALSE;
    }

  size = bfd_section_size (abfd, stabsect);
  contents  = xmalloc (size);

  if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
    {
      non_fatal (_("Reading %s section of %s failed: %s"),
               sect_name, bfd_get_filename (abfd),
               bfd_errmsg (bfd_get_error ()));
      free (contents);
      exit_status = 1;
      return NULL;
    }

  *size_ptr = size;

  return contents;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long remove_useless_symbols ( asymbol **  symbols,
long  count 
) [static]

Definition at line 460 of file objdump.c.

{
  asymbol **in_ptr = symbols, **out_ptr = symbols;

  while (--count >= 0)
    {
      asymbol *sym = *in_ptr++;

      if (sym->name == NULL || sym->name[0] == '\0')
       continue;
      if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
       continue;
      if (bfd_is_und_section (sym->section)
         || bfd_is_com_section (sym->section))
       continue;

      *out_ptr++ = sym;
    }
  return out_ptr - symbols;
}

Here is the caller graph for this function:

static void show_line ( bfd abfd,
asection section,
bfd_vma  addr_offset 
) [static]

Definition at line 1052 of file objdump.c.

{
  const char *filename;
  const char *functionname;
  unsigned int line;

  if (! with_line_numbers && ! with_source_code)
    return;

  if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
                            &functionname, &line))
    return;

  if (filename != NULL && *filename == '\0')
    filename = NULL;
  if (functionname != NULL && *functionname == '\0')
    functionname = NULL;

  if (with_line_numbers)
    {
      if (functionname != NULL
         && (prev_functionname == NULL
             || strcmp (functionname, prev_functionname) != 0))
       printf ("%s():\n", functionname);
      if (line > 0 && line != prev_line)
       printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
    }

  if (with_source_code
      && filename != NULL
      && line > 0)
    {
      struct print_file_list **pp, *p;

      for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
       if (strcmp ((*pp)->filename, filename) == 0)
         break;
      p = *pp;

      if (p != NULL)
       {
         if (p != print_files)
           {
             int l;

             /* We have reencountered a file name which we saw
               earlier.  This implies that either we are dumping out
               code from an included file, or the same file was
               linked in more than once.  There are two common cases
               of an included file: inline functions in a header
               file, and a bison or flex skeleton file.  In the
               former case we want to just start printing (but we
               back up a few lines to give context); in the latter
               case we want to continue from where we left off.  I
               can't think of a good way to distinguish the cases,
               so I used a heuristic based on the file name.  */
             if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
              l = p->line;
             else
              {
                l = line - SHOW_PRECEDING_CONTEXT_LINES;
                if (l < 0)
                  l = 0;
              }

             if (p->f == NULL)
              {
                p->f = fopen (p->modname, "r");
                p->line = 0;
              }
             if (p->f != NULL)
              skip_to_line (p, l, FALSE);

             if (print_files->f != NULL)
              {
                fclose (print_files->f);
                print_files->f = NULL;
              }
           }

         if (p->f != NULL)
           {
             skip_to_line (p, line, TRUE);
             *pp = p->next;
             p->next = print_files;
             print_files = p;
           }
       }
      else
       {
         p = update_source_path (filename);

         if (p != NULL)
           {
             int l;

             if (file_start_context)
              l = 0;
             else
              l = line - SHOW_PRECEDING_CONTEXT_LINES;
             if (l < 0)
              l = 0;
             skip_to_line (p, l, FALSE);
             if (p->f != NULL)
              skip_to_line (p, line, TRUE);
           }
       }
    }

  if (functionname != NULL
      && (prev_functionname == NULL
         || strcmp (functionname, prev_functionname) != 0))
    {
      if (prev_functionname != NULL)
       free (prev_functionname);
      prev_functionname = xmalloc (strlen (functionname) + 1);
      strcpy (prev_functionname, functionname);
    }

  if (line > 0 && line != prev_line)
    prev_line = line;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void skip_to_line ( struct print_file_list p,
unsigned int  line,
bfd_boolean  show 
) [static]

Definition at line 1026 of file objdump.c.

{
  while (p->line < line)
    {
      char buf[100];

      if (fgets (buf, sizeof buf, p->f) == NULL)
       {
         fclose (p->f);
         p->f = NULL;
         break;
       }

      if (show)
       printf ("%s", buf);

      if (strchr (buf, '\n') != NULL)
       ++p->line;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static asymbol** slurp_dynamic_symtab ( bfd abfd) [static]

Definition at line 429 of file objdump.c.

{
  asymbol **sy = NULL;
  long storage;

  storage = bfd_get_dynamic_symtab_upper_bound (abfd);
  if (storage < 0)
    {
      if (!(bfd_get_file_flags (abfd) & DYNAMIC))
       {
         non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
         dynsymcount = 0;
         return NULL;
       }

      bfd_fatal (bfd_get_filename (abfd));
    }
  if (storage)
    sy = xmalloc (storage);

  dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
  if (dynsymcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
  return sy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static asymbol** slurp_symtab ( bfd abfd) [static]

Definition at line 403 of file objdump.c.

{
  asymbol **sy = NULL;
  long storage;

  if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
    {
      symcount = 0;
      return NULL;
    }

  storage = bfd_get_symtab_upper_bound (abfd);
  if (storage < 0)
    bfd_fatal (bfd_get_filename (abfd));
  if (storage)
    sy = xmalloc (storage);

  symcount = bfd_canonicalize_symtab (abfd, sy);
  if (symcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
  return sy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct print_file_list* try_print_file_open ( const char *  origname,
const char *  modname 
) [static, read]

Definition at line 943 of file objdump.c.

{
  struct print_file_list *p;
  FILE *f;

  f = fopen (modname, "r");
  if (f == NULL)
    return NULL;

  if (print_files != NULL && print_files->f != NULL)
    {
      fclose (print_files->f);
      print_files->f = NULL;
    }

  p = xmalloc (sizeof (struct print_file_list));
  p->filename = origname;
  p->modname = modname;
  p->line = 0;
  p->f = f;
  p->next = print_files;
  print_files = p;
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct print_file_list* update_source_path ( const char *  filename) [static, read]

Definition at line 973 of file objdump.c.

{
  struct print_file_list *p;
  const char *fname;
  int i;

  if (filename == NULL)
    return NULL;

  p = try_print_file_open (filename, filename);
  if (p != NULL)
    return p;

  if (include_path_count == 0)
    return NULL;

  /* Get the name of the file.  */
  fname = strrchr (filename, '/');
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
  {
    /* We could have a mixed forward/back slash case.  */
    char *backslash = strrchr (filename, '\\');
    if (fname == NULL || (backslash != NULL && backslash > fname))
      fname = backslash;
    if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
      fname = filename + 1;
  }
#endif
  if (fname == NULL)
    fname = filename;
  else
    ++fname;

  /* If file exists under a new path, we need to add it to the list
     so that show_line knows about it.  */
  for (i = 0; i < include_path_count; i++)
    {
      char *modname = concat (include_paths[i], "/", fname, (const char *) 0);

      p = try_print_file_open (filename, modname);
      if (p)
       return p;

      free (modname);
    }

  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static enum static bfd_endian asymbol** static syms long static symcount asymbol** static sorted_syms long static sorted_symcount asymbol** static dynsyms asymbol* static synthsyms long static synthcount long static dynsymcount bfd_byte* static stabs bfd_size_type static stab_size char* static strtab bfd_size_type static stabstr_size void usage ( FILE *  stream,
int  status 
) [static, abstract]

Definition at line 168 of file objdump.c.

{
  fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
  fprintf (stream, _(" Display information from object <file(s)>.\n"));
  fprintf (stream, _(" At least one of the following switches must be given:\n"));
  fprintf (stream, _("\
  -a, --archive-headers    Display archive header information\n\
  -f, --file-headers       Display the contents of the overall file header\n\
  -p, --private-headers    Display object format specific file header contents\n\
  -h, --[section-]headers  Display the contents of the section headers\n\
  -x, --all-headers        Display the contents of all headers\n\
  -d, --disassemble        Display assembler contents of executable sections\n\
  -D, --disassemble-all    Display assembler contents of all sections\n\
  -S, --source             Intermix source code with disassembly\n\
  -s, --full-contents      Display the full contents of all sections requested\n\
  -g, --debugging          Display debug information in object file\n\
  -e, --debugging-tags     Display debug information using ctags style\n\
  -G, --stabs              Display (in raw form) any STABS info in the file\n\
  -W, --dwarf              Display DWARF info in the file\n\
  -t, --syms               Display the contents of the symbol table(s)\n\
  -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
  -r, --reloc              Display the relocation entries in the file\n\
  -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
  @<file>                  Read options from <file>\n\
  -v, --version            Display this program's version number\n\
  -i, --info               List object formats and architectures supported\n\
  -H, --help               Display this information\n\
"));
  if (status != 2)
    {
      fprintf (stream, _("\n The following switches are optional:\n"));
      fprintf (stream, _("\
  -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
  -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
  -j, --section=NAME             Only display information for section NAME\n\
  -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
  -EB --endian=big               Assume big endian format when disassembling\n\
  -EL --endian=little            Assume little endian format when disassembling\n\
      --file-start-context       Include context from start of file (with -S)\n\
  -I, --include=DIR              Add DIR to search list for source files\n\
  -l, --line-numbers             Include line numbers and filenames in output\n\
  -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
                                  The STYLE, if specified, can be `auto', `gnu',\n\
                                  `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
                                  or `gnat'\n\
  -w, --wide                     Format output for more than 80 columns\n\
  -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
      --start-address=ADDR       Only process data whose address is >= ADDR\n\
      --stop-address=ADDR        Only process data whose address is <= ADDR\n\
      --prefix-addresses         Print complete address alongside disassembly\n\
      --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
      --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
      --special-syms             Include special symbols in symbol dumps\n\
\n"));
      list_supported_targets (program_name, stream);
      list_supported_architectures (program_name, stream);

      disassembler_usage (stream);
    }
  if (REPORT_BUGS_TO[0] && status == 0)
    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
  exit (status);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 102 of file objdump.c.

char* default_target = NULL [static]

Definition at line 71 of file objdump.c.

Definition at line 92 of file objdump.c.

Definition at line 93 of file objdump.c.

Definition at line 94 of file objdump.c.

char* disassembler_options = NULL [static]

Definition at line 134 of file objdump.c.

int do_demangle [static]

Definition at line 91 of file objdump.c.

int dump_ar_hdrs [static]

Definition at line 83 of file objdump.c.

int dump_debugging [static]

Definition at line 99 of file objdump.c.

Definition at line 100 of file objdump.c.

Definition at line 89 of file objdump.c.

Definition at line 82 of file objdump.c.

Definition at line 80 of file objdump.c.

Definition at line 78 of file objdump.c.

Definition at line 84 of file objdump.c.

int dump_reloc_info [static]

Definition at line 81 of file objdump.c.

Definition at line 76 of file objdump.c.

Definition at line 77 of file objdump.c.

int dump_special_syms = 0 [static]

Definition at line 101 of file objdump.c.

Definition at line 90 of file objdump.c.

int dump_symtab [static]

Definition at line 79 of file objdump.c.

int exit_status = 0 [static]

Definition at line 69 of file objdump.c.

int file_start_context = 0 [static]

Definition at line 103 of file objdump.c.

Definition at line 95 of file objdump.c.

const char* generic_dwarf_sections[max] [static]

Definition at line 2064 of file objdump.c.

Definition at line 115 of file objdump.c.

const char** include_paths [static]

Definition at line 114 of file objdump.c.

const char* mach_o_dwarf_sections[] [static]
Initial value:
 {
  "LC_SEGMENT.__DWARFA.__debug_abbrev",          
  "LC_SEGMENT.__DWARFA.__debug_aranges",  
  "LC_SEGMENT.__DWARFA.__debug_frame",           
  "LC_SEGMENT.__DWARFA.__debug_info",            
  "LC_SEGMENT.__DWARFA.__debug_line",            
  "LC_SEGMENT.__DWARFA.__debug_pubnames", 
  ".eh_frame",                                   
  "LC_SEGMENT.__DWARFA.__debug_macinfo",  
  "LC_SEGMENT.__DWARFA.__debug_str",             
  "LC_SEGMENT.__DWARFA.__debug_loc",             
  "LC_SEGMENT.__DWARFA.__debug_pubtypes", 
  "LC_SEGMENT.__DWARFA.__debug_ranges",          
  "LC_SEGMENT.__DWARFA.__debug_static_func",     
  "LC_SEGMENT.__DWARFA.__debug_static_vars",     
  "LC_SEGMENT.__DWARFA.__debug_types",           
  "LC_SEGMENT.__DWARFA.__debug_weaknames" 
}

Definition at line 2045 of file objdump.c.

char* machine = NULL [static]

Definition at line 131 of file objdump.c.

char** only [static]

Definition at line 107 of file objdump.c.

size_t only_size = 0 [static]

Definition at line 109 of file objdump.c.

size_t only_used = 0 [static]

Definition at line 111 of file objdump.c.

struct option[] [static]

Definition at line 241 of file objdump.c.

Definition at line 85 of file objdump.c.

char* prev_functionname [static]

Definition at line 916 of file objdump.c.

Definition at line 917 of file objdump.c.

Definition at line 932 of file objdump.c.

int show_raw_insn [static]

Definition at line 88 of file objdump.c.

int show_version = 0 [static]

Definition at line 75 of file objdump.c.

bfd_vma start_address = (bfd_vma) -1 [static]

Definition at line 97 of file objdump.c.

bfd_vma stop_address = (bfd_vma) -1 [static]

Definition at line 98 of file objdump.c.

int wide_output [static]

Definition at line 96 of file objdump.c.

Definition at line 86 of file objdump.c.

Definition at line 87 of file objdump.c.