Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
bfd.c File Reference
#include "bfd.h"
#include "bfdver.h"
#include "sysdep.h"
#include <stdarg.h>
#include "libiberty.h"
#include "safe-ctype.h"
#include "bfdlink.h"
#include "libbfd.h"
#include "coff/internal.h"
#include "coff/sym.h"
#include "libcoff.h"
#include "libecoff.h"
#include "elf-bfd.h"

Go to the source code of this file.

Defines

#define EXIT_FAILURE   1

Functions

bfd_error_type bfd_get_error (void)
void bfd_set_error (bfd_error_type error_tag,...)
const char * bfd_errmsg (bfd_error_type error_tag)
void bfd_perror (const char *message)
void _bfd_default_error_handler (const char *fmt,...)
bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type pnew)
void bfd_set_error_program_name (const char *name)
bfd_error_handler_type bfd_get_error_handler (void)
long bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
long bfd_canonicalize_reloc (bfd *abfd, sec_ptr asect, arelent **location, asymbol **symbols)
void bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED, sec_ptr asect, arelent **location, unsigned int count)
bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags)
void bfd_assert (const char *file, int line)
void _bfd_abort (const char *file, int line, const char *fn)
int bfd_get_arch_size (bfd *abfd)
int bfd_get_sign_extend_vma (bfd *abfd)
bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma)
unsigned int bfd_get_gp_size (bfd *abfd)
void bfd_set_gp_size (bfd *abfd, unsigned int i)
bfd_vma _bfd_get_gp_value (bfd *abfd)
void _bfd_set_gp_value (bfd *abfd, bfd_vma v)
bfd_vma bfd_scan_vma (const char *string, const char **end, int base)
bfd_bytebfd_get_relocated_section_contents (bfd *abfd, struct bfd_link_info *link_info, struct bfd_link_order *link_order, bfd_byte *data, bfd_boolean relocatable, asymbol **symbols)
bfd_boolean bfd_record_phdr (bfd *abfd, unsigned long type, bfd_boolean flags_valid, flagword flags, bfd_boolean at_valid, bfd_vma at, bfd_boolean includes_filehdr, bfd_boolean includes_phdrs, unsigned int count, asection **secs)
void bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value)
void bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value)
bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative)
bfd_boolean bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
void bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
void bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
bfd_vma bfd_emul_get_maxpagesize (const char *emul)
static void bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size, int offset, const bfd_target *orig_target)
void bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
bfd_vma bfd_emul_get_commonpagesize (const char *emul)
void bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)

Variables

static bfd_error_type bfd_error = bfd_error_no_error
static bfdinput_bfd = NULL
static bfd_error_type input_error = bfd_error_no_error
const char *const bfd_errmsgs []
static const char * _bfd_error_program_name
bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler

Define Documentation

#define EXIT_FAILURE   1

Definition at line 221 of file bfd.c.


Function Documentation

void _bfd_abort ( const char *  file,
int  line,
const char *  fn 
)

Definition at line 836 of file bfd.c.

{
  if (fn != NULL)
    (*_bfd_error_handler)
      (_("BFD %s internal error, aborting at %s line %d in %s\n"),
       BFD_VERSION_STRING, file, line, fn);
  else
    (*_bfd_error_handler)
      (_("BFD %s internal error, aborting at %s line %d\n"),
       BFD_VERSION_STRING, file, line);
  (*_bfd_error_handler) (_("Please report this bug.\n"));
  _exit (EXIT_FAILURE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _bfd_default_error_handler ( const char *  fmt,
  ... 
)

Definition at line 469 of file bfd.c.

{
  va_list ap;
  char *bufp;
  const char *new_fmt, *p;
  size_t avail = 1000;
  char buf[1000];

  if (_bfd_error_program_name != NULL)
    fprintf (stderr, "%s: ", _bfd_error_program_name);
  else
    fprintf (stderr, "BFD: ");

  va_start (ap, fmt);
  new_fmt = fmt;
  bufp = buf;

  /* Reserve enough space for the existing format string.  */
  avail -= strlen (fmt) + 1;
  if (avail > 1000)
    _exit (EXIT_FAILURE);

  p = fmt;
  while (1)
    {
      char *q;
      size_t len, extra, trim;

      p = strchr (p, '%');
      if (p == NULL || p[1] == '\0')
       {
         if (new_fmt == buf)
           {
             len = strlen (fmt);
             memcpy (bufp, fmt, len + 1);
           }
         break;
       }

      if (p[1] == 'A' || p[1] == 'B')
       {
         len = p - fmt;
         memcpy (bufp, fmt, len);
         bufp += len;
         fmt = p + 2;
         new_fmt = buf;

         /* If we run out of space, tough, you lose your ridiculously
            long file or section name.  It's not safe to try to alloc
            memory here;  We might be printing an out of memory message.  */
         if (avail == 0)
           {
             *bufp++ = '*';
             *bufp++ = '*';
             *bufp = '\0';
           }
         else
           {
             if (p[1] == 'B')
              {
                bfd *abfd = va_arg (ap, bfd *);

                if (abfd == NULL)
                  /* Invoking %B with a null bfd pointer is an internal error.  */
                  abort ();
                else if (abfd->my_archive)
                  snprintf (bufp, avail, "%s(%s)",
                           abfd->my_archive->filename, abfd->filename);
                else
                  snprintf (bufp, avail, "%s", abfd->filename);
              }
             else
              {
                asection *sec = va_arg (ap, asection *);
                bfd *abfd;
                const char *group = NULL;
                struct coff_comdat_info *ci;

                if (sec == NULL)
                  /* Invoking %A with a null section pointer is an internal error.  */
                  abort ();
                abfd = sec->owner;
                if (abfd != NULL
                    && bfd_get_flavour (abfd) == bfd_target_elf_flavour
                    && elf_next_in_group (sec) != NULL
                    && (sec->flags & SEC_GROUP) == 0)
                  group = elf_group_name (sec);
                else if (abfd != NULL
                        && bfd_get_flavour (abfd) == bfd_target_coff_flavour
                        && (ci = bfd_coff_get_comdat_section (sec->owner,
                                                         sec)) != NULL)
                  group = ci->name;
                if (group != NULL)
                  snprintf (bufp, avail, "%s[%s]", sec->name, group);
                else
                  snprintf (bufp, avail, "%s", sec->name);
              }
             len = strlen (bufp);
             avail = avail - len + 2;

             /* We need to replace any '%' we printed by "%%".
               First count how many.  */
             q = bufp;
             bufp += len;
             extra = 0;
             while ((q = strchr (q, '%')) != NULL)
              {
                ++q;
                ++extra;
              }

             /* If there isn't room, trim off the end of the string.  */
             q = bufp;
             bufp += extra;
             if (extra > avail)
              {
                trim = extra - avail;
                bufp -= trim;
                do
                  {
                    if (*--q == '%')
                     --extra;
                  }
                while (--trim != 0);
                *q = '\0';
                avail = extra;
              }
             avail -= extra;

             /* Now double all '%' chars, shuffling the string as we go.  */
             while (extra != 0)
              {
                while ((q[extra] = *q) != '%')
                  --q;
                q[--extra] = '%';
                --q;
              }
           }
       }
      p = p + 2;
    }

  vfprintf (stderr, new_fmt, ap);
  va_end (ap);

  putc ('\n', stderr);
}

Here is the call graph for this function:

Definition at line 1000 of file bfd.c.

{
  if (! abfd)
    return 0;
  if (abfd->format != bfd_object)
    return 0;

  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
    return ecoff_data (abfd)->gp;
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
    return elf_gp (abfd);

  return 0;
}

Here is the caller graph for this function:

void _bfd_set_gp_value ( bfd abfd,
bfd_vma  v 
)

Definition at line 1018 of file bfd.c.

{
  if (! abfd)
    BFD_FAIL ();
  if (abfd->format != bfd_object)
    return;

  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
    ecoff_data (abfd)->gp = v;
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
    elf_gp (abfd) = v;
}

Here is the caller graph for this function:

bfd_boolean bfd_alt_mach_code ( bfd abfd,
int  alternative 
)

Definition at line 1412 of file bfd.c.

{
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
    {
      int code;

      switch (alternative)
       {
       case 0:
         code = get_elf_backend_data (abfd)->elf_machine_code;
         break;

       case 1:
         code = get_elf_backend_data (abfd)->elf_machine_alt1;
         if (code == 0)
           return FALSE;
         break;

       case 2:
         code = get_elf_backend_data (abfd)->elf_machine_alt2;
         if (code == 0)
           return FALSE;
         break;

       default:
         return FALSE;
       }

      elf_elfheader (abfd)->e_machine = code;

      return TRUE;
    }

  return FALSE;
}
void bfd_assert ( const char *  file,
int  line 
)

Definition at line 826 of file bfd.c.

{
  (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"),
                      BFD_VERSION_STRING, file, line);
}
long bfd_canonicalize_reloc ( bfd abfd,
sec_ptr  asect,
arelent **  location,
asymbol **  symbols 
)

Definition at line 740 of file bfd.c.

{
  if (abfd->format != bfd_object)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return -1;
    }

  return BFD_SEND (abfd, _bfd_canonicalize_reloc,
                 (abfd, asect, location, symbols));
}

Here is the call graph for this function:

static void bfd_elf_set_pagesize ( const bfd_target target,
bfd_vma  size,
int  offset,
const bfd_target orig_target 
) [static]

Definition at line 1601 of file bfd.c.

{
  if (target->flavour == bfd_target_elf_flavour)
    {
      const struct elf_backend_data *bed;

      bed = xvec_get_elf_backend_data (target);
      *((bfd_vma *) ((char *) bed + offset)) = size;
    }

  if (target->alternative_target
      && target->alternative_target != orig_target)
    bfd_elf_set_pagesize (target->alternative_target, size, offset,
                       orig_target);
}

Here is the caller graph for this function:

Definition at line 1659 of file bfd.c.

{
  const bfd_target *target;

  target = bfd_find_target (emul, NULL);
  if (target != NULL
      && target->flavour == bfd_target_elf_flavour)
    return xvec_get_elf_backend_data (target)->commonpagesize;

  abort ();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1587 of file bfd.c.

{
  const bfd_target *target;

  target = bfd_find_target (emul, NULL);
  if (target != NULL
      && target->flavour == bfd_target_elf_flavour)
    return xvec_get_elf_backend_data (target)->maxpagesize;

  abort ();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_emul_set_commonpagesize ( const char *  emul,
bfd_vma  size 
)

Definition at line 1686 of file bfd.c.

{
  const bfd_target *target;

  target = bfd_find_target (emul, NULL);
  if (target)
    bfd_elf_set_pagesize (target, size,
                       offsetof (struct elf_backend_data,
                                commonpagesize), target);
}

Here is the call graph for this function:

void bfd_emul_set_maxpagesize ( const char *  emul,
bfd_vma  size 
)

Definition at line 1632 of file bfd.c.

{
  const bfd_target *target;

  target = bfd_find_target (emul, NULL);
  if (target)
    bfd_elf_set_pagesize (target, size,
                       offsetof (struct elf_backend_data,
                                maxpagesize), target);
}

Here is the call graph for this function:

const char* bfd_errmsg ( bfd_error_type  error_tag)

Definition at line 373 of file bfd.c.

{
#ifndef errno
  extern int errno;
#endif
  if (error_tag == bfd_error_on_input)
    {
      char *buf;
      const char *msg = bfd_errmsg (input_error);

      if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
         != -1)
       return buf;

      /* Ick, what to do on out of memory?  */
      return msg;
    }

  if (error_tag == bfd_error_system_call)
    return xstrerror (errno);

  if (error_tag > bfd_error_invalid_error_code)
    error_tag = bfd_error_invalid_error_code;    /* sanity check */

  return _(bfd_errmsgs [error_tag]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_fprintf_vma ( bfd abfd,
void *  stream,
bfd_vma  value 
)

Definition at line 1387 of file bfd.c.

{
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
    get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value);
  else
    fprintf_vma ((FILE *) stream, value);
}

Here is the caller graph for this function:

int bfd_get_arch_size ( bfd abfd)

Definition at line 867 of file bfd.c.

{
  if (abfd->xvec->flavour == bfd_target_elf_flavour)
    return get_elf_backend_data (abfd)->s->arch_size;

  return -1;
}

Here is the caller graph for this function:

Definition at line 322 of file bfd.c.

{
  return bfd_error;
}

Definition at line 679 of file bfd.c.

{
  return _bfd_error_handler;
}

Definition at line 957 of file bfd.c.

{
  if (abfd->format == bfd_object)
    {
      if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
       return ecoff_data (abfd)->gp_size;
      else if (abfd->xvec->flavour == bfd_target_elf_flavour)
       return elf_gp_size (abfd);
    }
  return 0;
}

Here is the caller graph for this function:

long bfd_get_reloc_upper_bound ( bfd abfd,
sec_ptr  asect 
)

Definition at line 707 of file bfd.c.

{
  if (abfd->format != bfd_object)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return -1;
    }

  return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
}

Here is the call graph for this function:

bfd_byte* bfd_get_relocated_section_contents ( bfd abfd,
struct bfd_link_info link_info,
struct bfd_link_order link_order,
bfd_byte data,
bfd_boolean  relocatable,
asymbol **  symbols 
)

Definition at line 1308 of file bfd.c.

{
  bfd *abfd2;
  bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
                 bfd_byte *, bfd_boolean, asymbol **);

  if (link_order->type == bfd_indirect_link_order)
    {
      abfd2 = link_order->u.indirect.section->owner;
      if (abfd2 == NULL)
       abfd2 = abfd;
    }
  else
    abfd2 = abfd;

  fn = abfd2->xvec->_bfd_get_relocated_section_contents;

  return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 897 of file bfd.c.

{
  char *name;

  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
    return get_elf_backend_data (abfd)->sign_extend_vma;

  name = bfd_get_target (abfd);

  /* Return a proper value for DJGPP & PE COFF.
     This function is required for DWARF2 support, but there is
     no place to store this information in the COFF back end.
     Should enough other COFF targets add support for DWARF2,
     a place will have to be found.  Until then, this hack will do.  */
  if (CONST_STRNEQ (name, "coff-go32")
      || strcmp (name, "pe-i386") == 0
      || strcmp (name, "pei-i386") == 0
      || strcmp (name, "pe-arm-wince-little") == 0
      || strcmp (name, "pei-arm-wince-little") == 0)
    return 1;

  bfd_set_error (bfd_error_wrong_format);
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_perror ( const char *  message)

Definition at line 416 of file bfd.c.

{
  if (message == NULL || *message == '\0')
    fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
  else
    fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_preserve_finish ( bfd *abfd  ATTRIBUTE_UNUSED,
struct bfd_preserve preserve 
)

Definition at line 1561 of file bfd.c.

{
  /* It would be nice to be able to free more memory here, eg. old
     tdata, but that's not possible since these blocks are sitting
     inside bfd_alloc'd memory.  The section hash is on a separate
     objalloc.  */
  bfd_hash_table_free (&preserve->section_htab);
}

Here is the call graph for this function:

void bfd_preserve_restore ( bfd abfd,
struct bfd_preserve preserve 
)

Definition at line 1525 of file bfd.c.

{
  bfd_hash_table_free (&abfd->section_htab);

  abfd->tdata.any = preserve->tdata;
  abfd->arch_info = preserve->arch_info;
  abfd->flags = preserve->flags;
  abfd->section_htab = preserve->section_htab;
  abfd->sections = preserve->sections;
  abfd->section_last = preserve->section_last;
  abfd->section_count = preserve->section_count;

  /* bfd_release frees all memory more recently bfd_alloc'd than
     its arg, as well as its arg.  */
  if (preserve->marker != NULL)
    {
      bfd_release (abfd, preserve->marker);
      preserve->marker = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean bfd_preserve_save ( bfd abfd,
struct bfd_preserve preserve 
)

Definition at line 1486 of file bfd.c.

{
  preserve->tdata = abfd->tdata.any;
  preserve->arch_info = abfd->arch_info;
  preserve->flags = abfd->flags;
  preserve->sections = abfd->sections;
  preserve->section_last = abfd->section_last;
  preserve->section_count = abfd->section_count;
  preserve->section_htab = abfd->section_htab;

  if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
                          sizeof (struct section_hash_entry)))
    return FALSE;

  abfd->tdata.any = NULL;
  abfd->arch_info = &bfd_default_arch_struct;
  abfd->flags &= BFD_IN_MEMORY;
  abfd->sections = NULL;
  abfd->section_last = NULL;
  abfd->section_count = 0;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_boolean bfd_record_phdr ( bfd abfd,
unsigned long  type,
bfd_boolean  flags_valid,
flagword  flags,
bfd_boolean  at_valid,
bfd_vma  at,
bfd_boolean  includes_filehdr,
bfd_boolean  includes_phdrs,
unsigned int  count,
asection **  secs 
)

Definition at line 1336 of file bfd.c.

{
  struct elf_segment_map *m, **pm;
  bfd_size_type amt;

  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
    return TRUE;

  amt = sizeof (struct elf_segment_map);
  amt += ((bfd_size_type) count - 1) * sizeof (asection *);
  m = bfd_zalloc (abfd, amt);
  if (m == NULL)
    return FALSE;

  m->p_type = type;
  m->p_flags = flags;
  m->p_paddr = at;
  m->p_flags_valid = flags_valid;
  m->p_paddr_valid = at_valid;
  m->includes_filehdr = includes_filehdr;
  m->includes_phdrs = includes_phdrs;
  m->count = count;
  if (count > 0)
    memcpy (m->sections, secs, count * sizeof (asection *));

  for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
    ;
  *pm = m;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bfd_vma bfd_scan_vma ( const char *  string,
const char **  end,
int  base 
)

Definition at line 1053 of file bfd.c.

{
  bfd_vma value;
  bfd_vma cutoff;
  unsigned int cutlim;
  int overflow;

  /* Let the host do it if possible.  */
  if (sizeof (bfd_vma) <= sizeof (unsigned long))
    return strtoul (string, (char **) end, base);

#ifdef HAVE_STRTOULL
  if (sizeof (bfd_vma) <= sizeof (unsigned long long))
    return strtoull (string, (char **) end, base);
#endif

  if (base == 0)
    {
      if (string[0] == '0')
       {
         if ((string[1] == 'x') || (string[1] == 'X'))
           base = 16;
         else
           base = 8;
       }
    }

  if ((base < 2) || (base > 36))
    base = 10;

  if (base == 16
      && string[0] == '0'
      && (string[1] == 'x' || string[1] == 'X')
      && ISXDIGIT (string[2]))
    {
      string += 2;
    }

  cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
  cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
  value = 0;
  overflow = 0;
  while (1)
    {
      unsigned int digit;

      digit = *string;
      if (ISDIGIT (digit))
       digit = digit - '0';
      else if (ISALPHA (digit))
       digit = TOUPPER (digit) - 'A' + 10;
      else
       break;
      if (digit >= (unsigned int) base)
       break;
      if (value > cutoff || (value == cutoff && digit > cutlim))
       overflow = 1;
      value = value * base + digit;
      ++string;
    }

  if (overflow)
    value = ~ (bfd_vma) 0;

  if (end != NULL)
    *end = string;

  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_set_error ( bfd_error_type  error_tag,
  ... 
)

Definition at line 342 of file bfd.c.

{
  bfd_error = error_tag;
  if (error_tag == bfd_error_on_input)
    {
      /* This is an error that occurred during bfd_close when
        writing an archive, but on one of the input files.  */
      va_list ap;

      va_start (ap, error_tag);
      input_bfd = va_arg (ap, bfd *);
      input_error = va_arg (ap, int);
      if (input_error >= bfd_error_on_input)
       abort ();
      va_end (ap);
    }
}

Definition at line 638 of file bfd.c.

{
  bfd_error_handler_type pold;

  pold = _bfd_error_handler;
  _bfd_error_handler = pnew;
  return pold;
}

Here is the caller graph for this function:

void bfd_set_error_program_name ( const char *  name)

Definition at line 662 of file bfd.c.

Here is the caller graph for this function:

bfd_boolean bfd_set_file_flags ( bfd abfd,
flagword  flags 
)

Definition at line 801 of file bfd.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void bfd_set_gp_size ( bfd abfd,
unsigned int  i 
)

Definition at line 983 of file bfd.c.

{
  /* Don't try to set GP size on an archive or core file!  */
  if (abfd->format != bfd_object)
    return;

  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
    ecoff_data (abfd)->gp_size = i;
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
    elf_gp_size (abfd) = i;
}

Here is the caller graph for this function:

void bfd_set_reloc ( bfd *ignore_abfd  ATTRIBUTE_UNUSED,
sec_ptr  asect,
arelent **  location,
unsigned int  count 
)

Definition at line 771 of file bfd.c.

{
  asect->orelocation = location;
  asect->reloc_count = count;
}

Here is the call graph for this function:

Definition at line 937 of file bfd.c.

{
  abfd->start_address = vma;
  return TRUE;
}

Here is the caller graph for this function:

void bfd_sprintf_vma ( bfd abfd,
char *  buf,
bfd_vma  value 
)

Definition at line 1378 of file bfd.c.

{
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
    get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value);
  else
    sprintf_vma (buf, value);
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 623 of file bfd.c.

Definition at line 442 of file bfd.c.

Initial value:
{
  N_("No error"),
  N_("System call error"),
  N_("Invalid bfd target"),
  N_("File in wrong format"),
  N_("Archive object file in wrong format"),
  N_("Invalid operation"),
  N_("Memory exhausted"),
  N_("No symbols"),
  N_("Archive has no index; run ranlib to add one"),
  N_("No more archived files"),
  N_("Malformed archive"),
  N_("File format not recognized"),
  N_("File format is ambiguous"),
  N_("Section has no contents"),
  N_("Nonrepresentable section on output"),
  N_("Symbol needs debug section which does not exist"),
  N_("Bad value"),
  N_("File truncated"),
  N_("File too big"),
  N_("Error reading %s: %s"),

}

Definition at line 285 of file bfd.c.

Definition at line 281 of file bfd.c.

bfd* input_bfd = NULL [static]

Definition at line 282 of file bfd.c.

Definition at line 283 of file bfd.c.