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

   Copyright (C) 1990-2026 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 <limits.h>

#include "bfd.h"

#include "libbfd.h"

#include "coff/internal.h"

#include "libcoff.h"

#include "elf-bfd.h"

#include "hashtab.h"

#include "safe-ctype.h"

/* Extract a long section name at STRINDEX and copy it to the bfd objstack.

   Return NULL in case of error.  */

static char *

extract_long_section_name(bfd *abfd, unsigned long strindex)

{

  const char *strings;

  char *name;

  strings = _bfd_coff_read_string_table (abfd);

  if (strings == NULL)

    return NULL;

  if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))

    return NULL;

  strings += strindex;

  name = (char *) bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);

  if (name == NULL)

    return NULL;

  strcpy (name, strings);

  return name;

}

/* Decode a base 64 coded string at STR of length LEN, and write the result

   to RES.  Return true on success.

   Return false in case of invalid character or overflow.  */

static bool

decode_base64 (const char *str, unsigned len, uint32_t *res)

{

  unsigned i;

  uint32_t val;

  val = 0;

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

    {

      char c = str[i];

      unsigned d;

      if (c >= 'A' && c <= 'Z')

  d = c - 'A';

      else if (c >= 'a' && c <= 'z')

  d = c - 'a' + 26;

      else if (c >= '0' && c <= '9')

  d = c - '0' + 52;

      else if (c == '+')

  d = 62;

      else if (c == '/')

  d = 63;

      else

  return false;

      /* Check for overflow. */

      if ((val >> 26) != 0)

  return false;

      val = (val << 6) + d;

    }

  *res = val;

  return true;

}

/* 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 bool

make_a_section_from_file (bfd *abfd,

        struct internal_scnhdr *hdr,

        unsigned int target_index)

{

  asection *newsect;

  char *name;

  bool 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] == '/')

    {

      /* 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);

      if (hdr->s_name[1] == '/')

  {

    /* LLVM extension: the '/' is followed by another '/' and then by

       the index in the strtab encoded in base64 without NUL at the

       end.  */

    uint32_t strindex;

    /* Decode the index.  No overflow is expected as the string table

       length is at most 2^32 - 1 (the length is written on the first

       four bytes).

       Also, contrary to RFC 4648, all the characters must be decoded,

       there is no padding.  */

    if (!decode_base64 (hdr->s_name + 2, SCNNMLEN - 2, &strindex))

      return false;

    name = extract_long_section_name (abfd, strindex);

    if (name == NULL)

      return false;

  }

      else

  {

    /* PE classic long section name.  The '/' is followed by the index

       in the strtab.  The index is formatted as a decimal string.  */

    char buf[SCNNMLEN];

    long strindex;

    char *p;

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

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

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

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

      {

        name = extract_long_section_name (abfd, strindex);

        if (name == NULL)

    return false;

      }

  }

    }

  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 + 1);

      if (name == NULL)

  return false;

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

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

    }

  newsect = bfd_make_section_anyway (abfd, name);

  if (newsect == NULL)

    return false;

  newsect->vma = hdr->s_vaddr;

  newsect->lma = hdr->s_paddr;

  newsect->size = hdr->s_size;

  newsect->filepos = hdr->s_scnptr;

  newsect->rel_filepos = hdr->s_relptr;

  newsect->reloc_count = hdr->s_nreloc;

  bfd_coff_set_alignment_hook (abfd, newsect, hdr);

  newsect->line_filepos = hdr->s_lnnoptr;

  newsect->lineno_count = hdr->s_nlnno;

  newsect->userdata = NULL;

  newsect->next = NULL;

  newsect->target_index = target_index;

  if (!bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, newsect, &flags))

    result = false;

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

     section must be ignored.  */

  if ((flags & SEC_COFF_SHARED_LIBRARY) != 0)

    newsect->lineno_count = 0;

  if (hdr->s_nreloc != 0)

    flags |= SEC_RELOC;

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

  if (hdr->s_scnptr != 0)

    flags |= SEC_HAS_CONTENTS;

  newsect->flags = flags;

  /* Compress/decompress DWARF debug sections.  */

  if ((flags & SEC_DEBUGGING) != 0

      && (flags & SEC_HAS_CONTENTS) != 0

      && (startswith (name, ".debug_")

    || startswith (name, ".zdebug_")

    || startswith (name, ".gnu.debuglto_.debug_")

    || startswith (name, ".gnu.linkonce.wi.")))

    {

      enum { nothing, compress, decompress } action = nothing;

      if (bfd_is_section_compressed (abfd, newsect))

  {

    /* Compressed section.  Check if we should decompress.  */

    if ((abfd->flags & BFD_DECOMPRESS))

      action = decompress;

  }

      else

  {

    /* Normal section.  Check if we should compress.  */

    if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)

      action = compress;

  }

      if (action == compress)

  {

    if (!bfd_init_section_compress_status (abfd, newsect))

      {

        _bfd_error_handler

    /* xgettext:c-format */

    (_("%pB: unable to compress section %s"), abfd, name);

        return false;

      }

  }

      else if (action == decompress)

  {

    if (!bfd_init_section_decompress_status (abfd, newsect))

      {

        _bfd_error_handler

    /* xgettext:c-format */

    (_("%pB: unable to decompress section %s"), abfd, name);

        return false;

      }

    if (abfd->is_linker_input

        && name[1] == 'z')

      {

        /* Rename section from .zdebug_* to .debug_* so that ld

     scripts will see this section as a debug section.  */

        char *new_name = bfd_zdebug_name_to_debug (abfd, name);

        if (new_name == NULL)

    return false;

        bfd_rename_section (newsect, new_name);

      }

  }

    }

  return result;

}

void

coff_object_cleanup (bfd *abfd)

{

  struct coff_tdata *td = coff_data (abfd);

  if (td != NULL)

    {

      if (td->section_by_index)

  htab_delete (td->section_by_index);

      if (td->section_by_target_index)

  htab_delete (td->section_by_target_index);

      if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)

  htab_delete (pe_data (abfd)->comdat_hash);

    }

}

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

   ECOFF as well.  */

bfd_cleanup

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;

  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;

  abfd->symcount = internal_f->f_nsyms;

  if (internal_f->f_nsyms)

    abfd->flags |= HAS_SYMS;

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

    abfd->start_address = internal_a->entry;

  else

    abfd->start_address = 0;

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

     abfd->flags.  */

  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_and_read (abfd, readsize, readsize);

  if (!external_sections)

    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;

  }

    }

  _bfd_coff_free_symbols (abfd);

  return coff_object_cleanup;

 fail:

  coff_object_cleanup (abfd);

  _bfd_coff_free_symbols (abfd);

  bfd_release (abfd, tdata);

 fail2:

  abfd->flags = oflags;

  abfd->start_address = ostart;

  return 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.  */

bfd_cleanup

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_and_read (abfd, filhsz, filhsz);

  if (filehdr == NULL)

    {

      if (bfd_get_error () != bfd_error_system_call)

  bfd_set_error (bfd_error_wrong_format);

      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_read.  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_and_read (abfd, aoutsz, internal_f.f_opthdr);

      if (opthdr == NULL)

  return NULL;

      /* PR 17512: file: 11056-1136-0.004.  */

      if (internal_f.f_opthdr < aoutsz)

  memset (((char *) opthdr) + internal_f.f_opthdr, 0,

    aoutsz - internal_f.f_opthdr);

      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));

}

static hashval_t

htab_hash_section_target_index (const void * entry)

{

  const struct bfd_section * sec = entry;

  return sec->target_index;

}

static int

htab_eq_section_target_index (const void * e1, const void * e2)

{

  const struct bfd_section * sec1 = e1;

  const struct bfd_section * sec2 = e2;

  return sec1->target_index == sec2->target_index;

}

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

asection *

coff_section_from_bfd_index (bfd *abfd, int section_index)

{

  if (section_index == N_ABS)

    return bfd_abs_section_ptr;

  if (section_index == N_UNDEF)

    return bfd_und_section_ptr;

  if (section_index == N_DEBUG)

    return bfd_abs_section_ptr;

  struct bfd_section *answer;

  htab_t table = coff_data (abfd)->section_by_target_index;

  if (!table)

    {

      table = htab_create (10, htab_hash_section_target_index,

         htab_eq_section_target_index, NULL);

      if (table == NULL)

  return bfd_und_section_ptr;

      coff_data (abfd)->section_by_target_index = table;

    }

  if (htab_elements (table) == 0)

    {

      for (answer = abfd->sections; answer; answer = answer->next)

  {

    void **slot = htab_find_slot (table, answer, INSERT);

    if (slot == NULL)

      return bfd_und_section_ptr;

    *slot = answer;

  }

    }

  struct bfd_section needle;

  needle.target_index = section_index;

  answer = htab_find (table, &needle);

  if (answer != NULL)

    return answer;

  /* Cover the unlikely case of sections added after the first call to

     this function.  */

  for (answer = abfd->sections; answer; answer = answer->next)

    if (answer->target_index == section_index)

      {

  void **slot = htab_find_slot (table, answer, INSERT);

  if (slot != NULL)

    *slot = answer;

  return answer;

      }

  /* 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;

  }

      if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))

  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,

             bool cache,

             bfd_byte *external_relocs,

             bool 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_read (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);

  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:

  free (free_external);

  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_asymbol_bfd (q_maybe) != NULL

    && 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;

}

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.  */

bool

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))))

  *newsyms++ = symbol_ptr_ptr[i];

    *first_undef = newsyms - bfd_ptr->outsymbols;

    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))

  *newsyms++ = symbol_ptr_ptr[i];

    *newsyms = (asymbol *) NULL;

    symbol_ptr_ptr = bfd_ptr->outsymbols;

  }

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

    {

      coff_symbol_type *coff_symbol_ptr;

      coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);

      symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;

      if (coff_symbol_ptr && coff_symbol_ptr->native)

  {

    combined_entry_type *s = coff_symbol_ptr->native;

    int i;

    BFD_ASSERT (s->is_sym);

    if (s->u.syment.n_sclass == C_FILE)

      {

        if (last_file != NULL)

    last_file->n_value = native_index;

        last_file = &(s->u.syment);

      }

    else

      /* Modify the symbol values according to their section and

         type.  */

      fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));

    for (i = 0; i < s->u.syment.n_numaux + 1; i++)

      s[i].offset = native_index++;

  }

      else

  native_index++;

    }

  obj_conv_table_size (bfd_ptr) = native_index;

  return true;

}

/* Run thorough the symbol table again, and fix it so that all

   pointers to entries are changed to the entries' index in the output

   symbol table.  */

void

coff_mangle_symbols (bfd *bfd_ptr)

{

  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);

  asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;

  unsigned int symbol_index;

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

    {

      coff_symbol_type *coff_symbol_ptr;

      coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);

      if (coff_symbol_ptr && coff_symbol_ptr->native)

  {

    int i;

    combined_entry_type *s = coff_symbol_ptr->native;

    BFD_ASSERT (s->is_sym);

    if (s->fix_value)

      {

        /* FIXME: We should use a union here.  */

        s->u.syment.n_value =

    (uintptr_t) ((combined_entry_type *)

           (uintptr_t) s->u.syment.n_value)->offset;

        s->fix_value = 0;

      }

    if (s->fix_line)

      {

        /* The value is the offset into the line number entries

     for the symbol's section.  On output, the symbol's

     section should be N_DEBUG.  */

        s->u.syment.n_value =

    (coff_symbol_ptr->symbol.section->output_section->line_filepos

     + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));

        coff_symbol_ptr->symbol.section =

    coff_section_from_bfd_index (bfd_ptr, N_DEBUG);

        BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);

      }

    for (i = 0; i < s->u.syment.n_numaux; i++)

      {

        combined_entry_type *a = s + i + 1;

        BFD_ASSERT (! a->is_sym);

        if (a->fix_tag)

    {

      a->u.auxent.x_sym.x_tagndx.u32 =

        a->u.auxent.x_sym.x_tagndx.p->offset;

      a->fix_tag = 0;

    }

        if (a->fix_end)

    {

      a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 =

        a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;

      a->fix_end = 0;

    }

        if (a->fix_scnlen)

    {

      a->u.auxent.x_csect.x_scnlen.u64 =

        a->u.auxent.x_csect.x_scnlen.p->offset;

      a->fix_scnlen = 0;

    }

      }

  }

    }

}

static bool

coff_write_auxent_fname (bfd *abfd,

       char *str,

       union internal_auxent *auxent,

       struct bfd_strtab_hash *strtab,

       bool hash)

{

  unsigned int str_length = strlen (str);

  unsigned int filnmlen = bfd_coff_filnmlen (abfd);

  if (bfd_coff_long_filenames (abfd))

    {

      if (str_length <= filnmlen)

  strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);

      else

  {

    bfd_size_type indx = _bfd_stringtab_add (strtab, str, hash, false);

    if (indx == (bfd_size_type) -1)

      return false;

    auxent->x_file.x_n.x_n.x_offset = STRING_SIZE_SIZE + indx;

    auxent->x_file.x_n.x_n.x_zeroes = 0;

  }

    }

  else

    {

      strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);

      if (str_length > filnmlen)

  str[filnmlen] = '\0';

    }

  return true;

}

static bool

coff_fix_symbol_name (bfd *abfd,

          asymbol *symbol,

          combined_entry_type *native,

          struct bfd_strtab_hash *strtab,

          bool hash,

          asection **debug_string_section_p,

          bfd_size_type *debug_string_size_p)

{

  unsigned int name_length;

  char *name = (char *) (symbol->name);

  bfd_size_type indx;

  if (name == NULL)

    {

      /* COFF symbols always have names, so we'll make one up.  */