Subversion Repositories openrisc

/* Support for the generic parts of COFF, for BFD.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Written by Cygnus Support.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.

   Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */

/* This file contains COFF code that is not dependent on any

   particular COFF target.  There is only one version of this file in

   libbfd.a, so no target specific code may be put in here.  Or, to

   put it another way,

   ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********

   If you need to add some target specific behaviour, add a new hook

   function to bfd_coff_backend_data.

   Some of these functions are also called by the ECOFF routines.

   Those functions may not use any COFF specific information, such as

   coff_data (abfd).  */

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#include "coff/internal.h"

#include "libcoff.h"

/* Take a section header read from a coff file (in HOST byte order),

   and make a BFD "section" out of it.  This is used by ECOFF.  */

static bfd_boolean

make_a_section_from_file (bfd *abfd,

                          struct internal_scnhdr *hdr,

                          unsigned int target_index)

{

  asection *return_section;

  char *name;

  bfd_boolean result = TRUE;

  flagword flags;

  name = NULL;

  /* Handle long section names as in PE.  On reading, we want to

    accept long names if the format permits them at all, regardless

    of the current state of the flag that dictates if we would generate

    them in outputs; this construct checks if that is the case by

    attempting to set the flag, without changing its state; the call

    will fail for formats that do not support long names at all.  */

  if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))

      && hdr->s_name[0] == '/')

    {

      char buf[SCNNMLEN];

      long strindex;

      char *p;

      const char *strings;

      /* Flag that this BFD uses long names, even though the format might

         expect them to be off by default.  This won't directly affect the

         format of any output BFD created from this one, but the information

         can be used to decide what to do.  */

      bfd_coff_set_long_section_names (abfd, TRUE);

      memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);

      buf[SCNNMLEN - 1] = '\0';

      strindex = strtol (buf, &p, 10);

      if (*p == '\0' && strindex >= 0)

        {

          strings = _bfd_coff_read_string_table (abfd);

          if (strings == NULL)

            return FALSE;

          /* FIXME: For extra safety, we should make sure that

             strindex does not run us past the end, but right now we

             don't know the length of the string table.  */

          strings += strindex;

          name = (char *) bfd_alloc (abfd,

                                     (bfd_size_type) strlen (strings) + 1);

          if (name == NULL)

            return FALSE;

          strcpy (name, strings);

        }

    }

  if (name == NULL)

    {

      /* Assorted wastage to null-terminate the name, thanks AT&T! */

      name = (char *) bfd_alloc (abfd,

                                 (bfd_size_type) sizeof (hdr->s_name) + 1);

      if (name == NULL)

        return FALSE;

      strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));

      name[sizeof (hdr->s_name)] = 0;

    }

  return_section = bfd_make_section_anyway (abfd, name);

  if (return_section == NULL)

    return FALSE;

  return_section->vma = hdr->s_vaddr;

  return_section->lma = hdr->s_paddr;

  return_section->size = hdr->s_size;

  return_section->filepos = hdr->s_scnptr;

  return_section->rel_filepos = hdr->s_relptr;

  return_section->reloc_count = hdr->s_nreloc;

  bfd_coff_set_alignment_hook (abfd, return_section, hdr);

  return_section->line_filepos = hdr->s_lnnoptr;

  return_section->lineno_count = hdr->s_nlnno;

  return_section->userdata = NULL;

  return_section->next = NULL;

  return_section->target_index = target_index;

  if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,

                                         & flags))

    result = FALSE;

  return_section->flags = flags;

  /* At least on i386-coff, the line number count for a shared library

     section must be ignored.  */

  if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)

    return_section->lineno_count = 0;

  if (hdr->s_nreloc != 0)

    return_section->flags |= SEC_RELOC;

  /* FIXME: should this check 'hdr->s_size > 0'.  */

  if (hdr->s_scnptr != 0)

    return_section->flags |= SEC_HAS_CONTENTS;

  return result;

}

/* Read in a COFF object and make it into a BFD.  This is used by

   ECOFF as well.  */

static const bfd_target *

coff_real_object_p (bfd *abfd,

                    unsigned nscns,

                    struct internal_filehdr *internal_f,

                    struct internal_aouthdr *internal_a)

{

  flagword oflags = abfd->flags;

  bfd_vma ostart = bfd_get_start_address (abfd);

  void * tdata;

  void * tdata_save;

  bfd_size_type readsize;       /* Length of file_info.  */

  unsigned int scnhsz;

  char *external_sections;

  if (!(internal_f->f_flags & F_RELFLG))

    abfd->flags |= HAS_RELOC;

  if ((internal_f->f_flags & F_EXEC))

    abfd->flags |= EXEC_P;

  if (!(internal_f->f_flags & F_LNNO))

    abfd->flags |= HAS_LINENO;

  if (!(internal_f->f_flags & F_LSYMS))

    abfd->flags |= HAS_LOCALS;

  /* FIXME: How can we set D_PAGED correctly?  */

  if ((internal_f->f_flags & F_EXEC) != 0)

    abfd->flags |= D_PAGED;

  bfd_get_symcount (abfd) = internal_f->f_nsyms;

  if (internal_f->f_nsyms)

    abfd->flags |= HAS_SYMS;

  if (internal_a != (struct internal_aouthdr *) NULL)

    bfd_get_start_address (abfd) = internal_a->entry;

  else

    bfd_get_start_address (abfd) = 0;

  /* Set up the tdata area.  ECOFF uses its own routine, and overrides

     abfd->flags.  */

  tdata_save = abfd->tdata.any;

  tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);

  if (tdata == NULL)

    goto fail2;

  scnhsz = bfd_coff_scnhsz (abfd);

  readsize = (bfd_size_type) nscns * scnhsz;

  external_sections = (char *) bfd_alloc (abfd, readsize);

  if (!external_sections)

    goto fail;

  if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)

    goto fail;

  /* Set the arch/mach *before* swapping in sections; section header swapping

     may depend on arch/mach info.  */

  if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))

    goto fail;

  /* Now copy data as required; construct all asections etc.  */

  if (nscns != 0)

    {

      unsigned int i;

      for (i = 0; i < nscns; i++)

        {

          struct internal_scnhdr tmp;

          bfd_coff_swap_scnhdr_in (abfd,

                                   (void *) (external_sections + i * scnhsz),

                                   (void *) & tmp);

          if (! make_a_section_from_file (abfd, &tmp, i + 1))

            goto fail;

        }

    }

  return abfd->xvec;

 fail:

  bfd_release (abfd, tdata);

 fail2:

  abfd->tdata.any = tdata_save;

  abfd->flags = oflags;

  bfd_get_start_address (abfd) = ostart;

  return (const bfd_target *) NULL;

}

/* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is

   not a COFF file.  This is also used by ECOFF.  */

const bfd_target *

coff_object_p (bfd *abfd)

{

  bfd_size_type filhsz;

  bfd_size_type aoutsz;

  unsigned int nscns;

  void * filehdr;

  struct internal_filehdr internal_f;

  struct internal_aouthdr internal_a;

  /* Figure out how much to read.  */

  filhsz = bfd_coff_filhsz (abfd);

  aoutsz = bfd_coff_aoutsz (abfd);

  filehdr = bfd_alloc (abfd, filhsz);

  if (filehdr == NULL)

    return NULL;

  if (bfd_bread (filehdr, filhsz, abfd) != filhsz)

    {

      if (bfd_get_error () != bfd_error_system_call)

        bfd_set_error (bfd_error_wrong_format);

      bfd_release (abfd, filehdr);

      return NULL;

    }

  bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);

  bfd_release (abfd, filehdr);

  /* The XCOFF format has two sizes for the f_opthdr.  SMALL_AOUTSZ

     (less than aoutsz) used in object files and AOUTSZ (equal to

     aoutsz) in executables.  The bfd_coff_swap_aouthdr_in function

     expects this header to be aoutsz bytes in length, so we use that

     value in the call to bfd_alloc below.  But we must be careful to

     only read in f_opthdr bytes in the call to bfd_bread.  We should

     also attempt to catch corrupt or non-COFF binaries with a strange

     value for f_opthdr.  */

  if (! bfd_coff_bad_format_hook (abfd, &internal_f)

      || internal_f.f_opthdr > aoutsz)

    {

      bfd_set_error (bfd_error_wrong_format);

      return NULL;

    }

  nscns = internal_f.f_nscns;

  if (internal_f.f_opthdr)

    {

      void * opthdr;

      opthdr = bfd_alloc (abfd, aoutsz);

      if (opthdr == NULL)

        return NULL;

      if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)

          != internal_f.f_opthdr)

        {

          bfd_release (abfd, opthdr);

          return NULL;

        }

      bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);

      bfd_release (abfd, opthdr);

    }

  return coff_real_object_p (abfd, nscns, &internal_f,

                             (internal_f.f_opthdr != 0

                              ? &internal_a

                              : (struct internal_aouthdr *) NULL));

}

/* Get the BFD section from a COFF symbol section number.  */

asection *

coff_section_from_bfd_index (bfd *abfd, int index)

{

  struct bfd_section *answer = abfd->sections;

  if (index == N_ABS)

    return bfd_abs_section_ptr;

  if (index == N_UNDEF)

    return bfd_und_section_ptr;

  if (index == N_DEBUG)

    return bfd_abs_section_ptr;

  while (answer)

    {

      if (answer->target_index == index)

        return answer;

      answer = answer->next;

    }

  /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a

     has a bad symbol table in biglitpow.o.  */

  return bfd_und_section_ptr;

}

/* Get the upper bound of a COFF symbol table.  */

long

coff_get_symtab_upper_bound (bfd *abfd)

{

  if (!bfd_coff_slurp_symbol_table (abfd))

    return -1;

  return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));

}

/* Canonicalize a COFF symbol table.  */

long

coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)

{

  unsigned int counter;

  coff_symbol_type *symbase;

  coff_symbol_type **location = (coff_symbol_type **) alocation;

  if (!bfd_coff_slurp_symbol_table (abfd))

    return -1;

  symbase = obj_symbols (abfd);

  counter = bfd_get_symcount (abfd);

  while (counter-- > 0)

    *location++ = symbase++;

  *location = NULL;

  return bfd_get_symcount (abfd);

}

/* Get the name of a symbol.  The caller must pass in a buffer of size

   >= SYMNMLEN + 1.  */

const char *

_bfd_coff_internal_syment_name (bfd *abfd,

                                const struct internal_syment *sym,

                                char *buf)

{

  /* FIXME: It's not clear this will work correctly if sizeof

     (_n_zeroes) != 4.  */

  if (sym->_n._n_n._n_zeroes != 0

      || sym->_n._n_n._n_offset == 0)

    {

      memcpy (buf, sym->_n._n_name, SYMNMLEN);

      buf[SYMNMLEN] = '\0';

      return buf;

    }

  else

    {

      const char *strings;

      BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);

      strings = obj_coff_strings (abfd);

      if (strings == NULL)

        {

          strings = _bfd_coff_read_string_table (abfd);

          if (strings == NULL)

            return NULL;

        }

      return strings + sym->_n._n_n._n_offset;

    }

}

/* Read in and swap the relocs.  This returns a buffer holding the

   relocs for section SEC in file ABFD.  If CACHE is TRUE and

   INTERNAL_RELOCS is NULL, the relocs read in will be saved in case

   the function is called again.  If EXTERNAL_RELOCS is not NULL, it

   is a buffer large enough to hold the unswapped relocs.  If

   INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold

   the swapped relocs.  If REQUIRE_INTERNAL is TRUE, then the return

   value must be INTERNAL_RELOCS.  The function returns NULL on error.  */

struct internal_reloc *

_bfd_coff_read_internal_relocs (bfd *abfd,

                                asection *sec,

                                bfd_boolean cache,

                                bfd_byte *external_relocs,

                                bfd_boolean require_internal,

                                struct internal_reloc *internal_relocs)

{

  bfd_size_type relsz;

  bfd_byte *free_external = NULL;

  struct internal_reloc *free_internal = NULL;

  bfd_byte *erel;

  bfd_byte *erel_end;

  struct internal_reloc *irel;

  bfd_size_type amt;

  if (sec->reloc_count == 0)

    return internal_relocs;     /* Nothing to do.  */

  if (coff_section_data (abfd, sec) != NULL

      && coff_section_data (abfd, sec)->relocs != NULL)

    {

      if (! require_internal)

        return coff_section_data (abfd, sec)->relocs;

      memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,

              sec->reloc_count * sizeof (struct internal_reloc));

      return internal_relocs;

    }

  relsz = bfd_coff_relsz (abfd);

  amt = sec->reloc_count * relsz;

  if (external_relocs == NULL)

    {

      free_external = (bfd_byte *) bfd_malloc (amt);

      if (free_external == NULL)

        goto error_return;

      external_relocs = free_external;

    }

  if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0

      || bfd_bread (external_relocs, amt, abfd) != amt)

    goto error_return;

  if (internal_relocs == NULL)

    {

      amt = sec->reloc_count;

      amt *= sizeof (struct internal_reloc);

      free_internal = (struct internal_reloc *) bfd_malloc (amt);

      if (free_internal == NULL)

        goto error_return;

      internal_relocs = free_internal;

    }

  /* Swap in the relocs.  */

  erel = external_relocs;

  erel_end = erel + relsz * sec->reloc_count;

  irel = internal_relocs;

  for (; erel < erel_end; erel += relsz, irel++)

    bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);

  if (free_external != NULL)

    {

      free (free_external);

      free_external = NULL;

    }

  if (cache && free_internal != NULL)

    {

      if (coff_section_data (abfd, sec) == NULL)

        {

          amt = sizeof (struct coff_section_tdata);

          sec->used_by_bfd = bfd_zalloc (abfd, amt);

          if (sec->used_by_bfd == NULL)

            goto error_return;

          coff_section_data (abfd, sec)->contents = NULL;

        }

      coff_section_data (abfd, sec)->relocs = free_internal;

    }

  return internal_relocs;

 error_return:

  if (free_external != NULL)

    free (free_external);

  if (free_internal != NULL)

    free (free_internal);

  return NULL;

}

/* Set lineno_count for the output sections of a COFF file.  */

int

coff_count_linenumbers (bfd *abfd)

{

  unsigned int limit = bfd_get_symcount (abfd);

  unsigned int i;

  int total = 0;

  asymbol **p;

  asection *s;

  if (limit == 0)

    {

      /* This may be from the backend linker, in which case the

         lineno_count in the sections is correct.  */

      for (s = abfd->sections; s != NULL; s = s->next)

        total += s->lineno_count;

      return total;

    }

  for (s = abfd->sections; s != NULL; s = s->next)

    BFD_ASSERT (s->lineno_count == 0);

  for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)

    {

      asymbol *q_maybe = *p;

      if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))

        {

          coff_symbol_type *q = coffsymbol (q_maybe);

          /* The AIX 4.1 compiler can sometimes generate line numbers

             attached to debugging symbols.  We try to simply ignore

             those here.  */

          if (q->lineno != NULL

              && q->symbol.section->owner != NULL)

            {

              /* This symbol has line numbers.  Increment the owning

                 section's linenumber count.  */

              alent *l = q->lineno;

              do

                {

                  asection * sec = q->symbol.section->output_section;

                  /* Do not try to update fields in read-only sections.  */

                  if (! bfd_is_const_section (sec))

                    sec->lineno_count ++;

                  ++total;

                  ++l;

                }

              while (l->line_number != 0);

            }

        }

    }

  return total;

}

/* Takes a bfd and a symbol, returns a pointer to the coff specific

   area of the symbol if there is one.  */

coff_symbol_type *

coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED,

                  asymbol *symbol)

{

  if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))

    return (coff_symbol_type *) NULL;

  if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)

    return (coff_symbol_type *) NULL;

  return (coff_symbol_type *) symbol;

}

static void

fixup_symbol_value (bfd *abfd,

                    coff_symbol_type *coff_symbol_ptr,

                    struct internal_syment *syment)

{

  /* Normalize the symbol flags.  */

  if (coff_symbol_ptr->symbol.section

      && bfd_is_com_section (coff_symbol_ptr->symbol.section))

    {

      /* A common symbol is undefined with a value.  */

      syment->n_scnum = N_UNDEF;

      syment->n_value = coff_symbol_ptr->symbol.value;

    }

  else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0

           && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)

    {

      syment->n_value = coff_symbol_ptr->symbol.value;

    }

  else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))

    {

      syment->n_scnum = N_UNDEF;

      syment->n_value = 0;

    }

  /* FIXME: Do we need to handle the absolute section here?  */

  else

    {

      if (coff_symbol_ptr->symbol.section)

        {

          syment->n_scnum =

            coff_symbol_ptr->symbol.section->output_section->target_index;

          syment->n_value = (coff_symbol_ptr->symbol.value

                             + coff_symbol_ptr->symbol.section->output_offset);

          if (! obj_pe (abfd))

            {

              syment->n_value += (syment->n_sclass == C_STATLAB)

                ? coff_symbol_ptr->symbol.section->output_section->lma

                : coff_symbol_ptr->symbol.section->output_section->vma;

            }

        }

      else

        {

          BFD_ASSERT (0);

          /* This can happen, but I don't know why yet (steve@cygnus.com) */

          syment->n_scnum = N_ABS;

          syment->n_value = coff_symbol_ptr->symbol.value;

        }

    }

}

/* Run through all the symbols in the symbol table and work out what

   their indexes into the symbol table will be when output.

   Coff requires that each C_FILE symbol points to the next one in the

   chain, and that the last one points to the first external symbol. We

   do that here too.  */

bfd_boolean

coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)

{

  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);

  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;

  unsigned int native_index = 0;

  struct internal_syment *last_file = NULL;

  unsigned int symbol_index;

  /* COFF demands that undefined symbols come after all other symbols.

     Since we don't need to impose this extra knowledge on all our

     client programs, deal with that here.  Sort the symbol table;

     just move the undefined symbols to the end, leaving the rest

     alone.  The O'Reilly book says that defined global symbols come

     at the end before the undefined symbols, so we do that here as

     well.  */

  /* @@ Do we have some condition we could test for, so we don't always

     have to do this?  I don't think relocatability is quite right, but

     I'm not certain.  [raeburn:19920508.1711EST]  */

  {

    asymbol **newsyms;

    unsigned int i;

    bfd_size_type amt;

    amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);

    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);

    if (!newsyms)

      return FALSE;

    bfd_ptr->outsymbols = newsyms;

    for (i = 0; i < symbol_count; i++)

      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0

          || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)

              && !bfd_is_com_section (symbol_ptr_ptr[i]->section)

              && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0

                  || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))

                      == 0))))

        *newsyms++ = symbol_ptr_ptr[i];

    for (i = 0; i < symbol_count; i++)

      if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0

          && !bfd_is_und_section (symbol_ptr_ptr[i]->section)

          && (bfd_is_com_section (symbol_ptr_ptr[i]->section)

              || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0

                  && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))

                      != 0))))