Subversion Repositories Kolibri OS

Rev

Rev 5197 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /* COFF specific linker code.
  2.    Copyright (C) 1994-2015 Free Software Foundation, Inc.
  3.    Written by Ian Lance Taylor, Cygnus Support.
  4.  
  5.    This file is part of BFD, the Binary File Descriptor library.
  6.  
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.
  11.  
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20.    MA 02110-1301, USA.  */
  21.  
  22. /* This file contains the COFF backend linker code.  */
  23.  
  24. #include "sysdep.h"
  25. #include "bfd.h"
  26. #include "bfdlink.h"
  27. #include "libbfd.h"
  28. #include "coff/internal.h"
  29. #include "libcoff.h"
  30. #include "safe-ctype.h"
  31.  
  32. static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
  33. static bfd_boolean coff_link_check_archive_element
  34.   (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
  35.    bfd_boolean *);
  36. static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);
  37.  
  38. /* Return TRUE if SYM is a weak, external symbol.  */
  39. #define IS_WEAK_EXTERNAL(abfd, sym)                     \
  40.   ((sym).n_sclass == C_WEAKEXT                          \
  41.    || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
  42.  
  43. /* Return TRUE if SYM is an external symbol.  */
  44. #define IS_EXTERNAL(abfd, sym)                          \
  45.   ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
  46.  
  47. /* Define macros so that the ISFCN, et. al., macros work correctly.
  48.    These macros are defined in include/coff/internal.h in terms of
  49.    N_TMASK, etc.  These definitions require a user to define local
  50.    variables with the appropriate names, and with values from the
  51.    coff_data (abfd) structure.  */
  52.  
  53. #define N_TMASK n_tmask
  54. #define N_BTSHFT n_btshft
  55. #define N_BTMASK n_btmask
  56.  
  57. /* Create an entry in a COFF linker hash table.  */
  58.  
  59. struct bfd_hash_entry *
  60. _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
  61.                              struct bfd_hash_table *table,
  62.                              const char *string)
  63. {
  64.   struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
  65.  
  66.   /* Allocate the structure if it has not already been allocated by a
  67.      subclass.  */
  68.   if (ret == (struct coff_link_hash_entry *) NULL)
  69.     ret = ((struct coff_link_hash_entry *)
  70.            bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
  71.   if (ret == (struct coff_link_hash_entry *) NULL)
  72.     return (struct bfd_hash_entry *) ret;
  73.  
  74.   /* Call the allocation method of the superclass.  */
  75.   ret = ((struct coff_link_hash_entry *)
  76.          _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
  77.                                  table, string));
  78.   if (ret != (struct coff_link_hash_entry *) NULL)
  79.     {
  80.       /* Set local fields.  */
  81.       ret->indx = -1;
  82.       ret->type = T_NULL;
  83.       ret->symbol_class = C_NULL;
  84.       ret->numaux = 0;
  85.       ret->auxbfd = NULL;
  86.       ret->aux = NULL;
  87.     }
  88.  
  89.   return (struct bfd_hash_entry *) ret;
  90. }
  91.  
  92. /* Initialize a COFF linker hash table.  */
  93.  
  94. bfd_boolean
  95. _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
  96.                                 bfd *abfd,
  97.                                 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
  98.                                                                    struct bfd_hash_table *,
  99.                                                                    const char *),
  100.                                 unsigned int entsize)
  101. {
  102.   memset (&table->stab_info, 0, sizeof (table->stab_info));
  103.   return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
  104. }
  105.  
  106. /* Create a COFF linker hash table.  */
  107.  
  108. struct bfd_link_hash_table *
  109. _bfd_coff_link_hash_table_create (bfd *abfd)
  110. {
  111.   struct coff_link_hash_table *ret;
  112.   bfd_size_type amt = sizeof (struct coff_link_hash_table);
  113.  
  114.   ret = (struct coff_link_hash_table *) bfd_malloc (amt);
  115.   if (ret == NULL)
  116.     return NULL;
  117.  
  118.   if (! _bfd_coff_link_hash_table_init (ret, abfd,
  119.                                         _bfd_coff_link_hash_newfunc,
  120.                                         sizeof (struct coff_link_hash_entry)))
  121.     {
  122.       free (ret);
  123.       return (struct bfd_link_hash_table *) NULL;
  124.     }
  125.   return &ret->root;
  126. }
  127.  
  128. /* Create an entry in a COFF debug merge hash table.  */
  129.  
  130. struct bfd_hash_entry *
  131. _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
  132.                                     struct bfd_hash_table *table,
  133.                                     const char *string)
  134. {
  135.   struct coff_debug_merge_hash_entry *ret =
  136.     (struct coff_debug_merge_hash_entry *) entry;
  137.  
  138.   /* Allocate the structure if it has not already been allocated by a
  139.      subclass.  */
  140.   if (ret == (struct coff_debug_merge_hash_entry *) NULL)
  141.     ret = ((struct coff_debug_merge_hash_entry *)
  142.            bfd_hash_allocate (table,
  143.                               sizeof (struct coff_debug_merge_hash_entry)));
  144.   if (ret == (struct coff_debug_merge_hash_entry *) NULL)
  145.     return (struct bfd_hash_entry *) ret;
  146.  
  147.   /* Call the allocation method of the superclass.  */
  148.   ret = ((struct coff_debug_merge_hash_entry *)
  149.          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
  150.   if (ret != (struct coff_debug_merge_hash_entry *) NULL)
  151.     {
  152.       /* Set local fields.  */
  153.       ret->types = NULL;
  154.     }
  155.  
  156.   return (struct bfd_hash_entry *) ret;
  157. }
  158.  
  159. /* Given a COFF BFD, add symbols to the global hash table as
  160.    appropriate.  */
  161.  
  162. bfd_boolean
  163. _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
  164. {
  165.   switch (bfd_get_format (abfd))
  166.     {
  167.     case bfd_object:
  168.       return coff_link_add_object_symbols (abfd, info);
  169.     case bfd_archive:
  170.       return _bfd_generic_link_add_archive_symbols
  171.         (abfd, info, coff_link_check_archive_element);
  172.     default:
  173.       bfd_set_error (bfd_error_wrong_format);
  174.       return FALSE;
  175.     }
  176. }
  177.  
  178. /* Add symbols from a COFF object file.  */
  179.  
  180. static bfd_boolean
  181. coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
  182. {
  183.   if (! _bfd_coff_get_external_symbols (abfd))
  184.     return FALSE;
  185.   if (! coff_link_add_symbols (abfd, info))
  186.     return FALSE;
  187.  
  188.   if (! info->keep_memory
  189.       && ! _bfd_coff_free_symbols (abfd))
  190.     return FALSE;
  191.  
  192.   return TRUE;
  193. }
  194.  
  195. /* Check a single archive element to see if we need to include it in
  196.    the link.  *PNEEDED is set according to whether this element is
  197.    needed in the link or not.  This is called via
  198.    _bfd_generic_link_add_archive_symbols.  */
  199.  
  200. static bfd_boolean
  201. coff_link_check_archive_element (bfd *abfd,
  202.                                  struct bfd_link_info *info,
  203.                                  struct bfd_link_hash_entry *h,
  204.                                  const char *name,
  205.                                  bfd_boolean *pneeded)
  206. {
  207.   *pneeded = FALSE;
  208.  
  209.   /* We are only interested in symbols that are currently undefined.
  210.      If a symbol is currently known to be common, COFF linkers do not
  211.      bring in an object file which defines it.  */
  212.   if (h->type != bfd_link_hash_undefined)
  213.     return TRUE;
  214.  
  215.   if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))
  216.     return FALSE;
  217.   *pneeded = TRUE;
  218.  
  219.   return coff_link_add_object_symbols (abfd, info);
  220. }
  221.  
  222. /* Add all the symbols from an object file to the hash table.  */
  223.  
  224. static bfd_boolean
  225. coff_link_add_symbols (bfd *abfd,
  226.                        struct bfd_link_info *info)
  227. {
  228.   unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
  229.   unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
  230.   unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
  231.   bfd_boolean keep_syms;
  232.   bfd_boolean default_copy;
  233.   bfd_size_type symcount;
  234.   struct coff_link_hash_entry **sym_hash;
  235.   bfd_size_type symesz;
  236.   bfd_byte *esym;
  237.   bfd_byte *esym_end;
  238.   bfd_size_type amt;
  239.  
  240.   symcount = obj_raw_syment_count (abfd);
  241.  
  242.   if (symcount == 0)
  243.     return TRUE;                /* Nothing to do.  */
  244.  
  245.   /* Keep the symbols during this function, in case the linker needs
  246.      to read the generic symbols in order to report an error message.  */
  247.   keep_syms = obj_coff_keep_syms (abfd);
  248.   obj_coff_keep_syms (abfd) = TRUE;
  249.  
  250.   if (info->keep_memory)
  251.     default_copy = FALSE;
  252.   else
  253.     default_copy = TRUE;
  254.  
  255.   /* We keep a list of the linker hash table entries that correspond
  256.      to particular symbols.  */
  257.   amt = symcount * sizeof (struct coff_link_hash_entry *);
  258.   sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
  259.   if (sym_hash == NULL)
  260.     goto error_return;
  261.   obj_coff_sym_hashes (abfd) = sym_hash;
  262.  
  263.   symesz = bfd_coff_symesz (abfd);
  264.   BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
  265.   esym = (bfd_byte *) obj_coff_external_syms (abfd);
  266.   esym_end = esym + symcount * symesz;
  267.   while (esym < esym_end)
  268.     {
  269.       struct internal_syment sym;
  270.       enum coff_symbol_classification classification;
  271.       bfd_boolean copy;
  272.  
  273.       bfd_coff_swap_sym_in (abfd, esym, &sym);
  274.  
  275.       classification = bfd_coff_classify_symbol (abfd, &sym);
  276.       if (classification != COFF_SYMBOL_LOCAL)
  277.         {
  278.           const char *name;
  279.           char buf[SYMNMLEN + 1];
  280.           flagword flags;
  281.           asection *section;
  282.           bfd_vma value;
  283.           bfd_boolean addit;
  284.  
  285.           /* This symbol is externally visible.  */
  286.  
  287.           name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
  288.           if (name == NULL)
  289.             goto error_return;
  290.  
  291.           /* We must copy the name into memory if we got it from the
  292.              syment itself, rather than the string table.  */
  293.           copy = default_copy;
  294.           if (sym._n._n_n._n_zeroes != 0
  295.               || sym._n._n_n._n_offset == 0)
  296.             copy = TRUE;
  297.  
  298.           value = sym.n_value;
  299.  
  300.           switch (classification)
  301.             {
  302.             default:
  303.               abort ();
  304.  
  305.             case COFF_SYMBOL_GLOBAL:
  306.               flags = BSF_EXPORT | BSF_GLOBAL;
  307.               section = coff_section_from_bfd_index (abfd, sym.n_scnum);
  308.               if (! obj_pe (abfd))
  309.                 value -= section->vma;
  310.               break;
  311.  
  312.             case COFF_SYMBOL_UNDEFINED:
  313.               flags = 0;
  314.               section = bfd_und_section_ptr;
  315.               break;
  316.  
  317.             case COFF_SYMBOL_COMMON:
  318.               flags = BSF_GLOBAL;
  319.               section = bfd_com_section_ptr;
  320.               break;
  321.  
  322.             case COFF_SYMBOL_PE_SECTION:
  323.               flags = BSF_SECTION_SYM | BSF_GLOBAL;
  324.               section = coff_section_from_bfd_index (abfd, sym.n_scnum);
  325.               break;
  326.             }
  327.  
  328.           if (IS_WEAK_EXTERNAL (abfd, sym))
  329.             flags = BSF_WEAK;
  330.  
  331.           addit = TRUE;
  332.  
  333.           /* In the PE format, section symbols actually refer to the
  334.              start of the output section.  We handle them specially
  335.              here.  */
  336.           if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
  337.             {
  338.               *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
  339.                                                  name, FALSE, copy, FALSE);
  340.               if (*sym_hash != NULL)
  341.                 {
  342.                   if (((*sym_hash)->coff_link_hash_flags
  343.                        & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
  344.                       && (*sym_hash)->root.type != bfd_link_hash_undefined
  345.                       && (*sym_hash)->root.type != bfd_link_hash_undefweak)
  346.                     (*_bfd_error_handler)
  347.                       ("Warning: symbol `%s' is both section and non-section",
  348.                        name);
  349.  
  350.                   addit = FALSE;
  351.                 }
  352.             }
  353.  
  354.           /* The Microsoft Visual C compiler does string pooling by
  355.              hashing the constants to an internal symbol name, and
  356.              relying on the linker comdat support to discard
  357.              duplicate names.  However, if one string is a literal and
  358.              one is a data initializer, one will end up in the .data
  359.              section and one will end up in the .rdata section.  The
  360.              Microsoft linker will combine them into the .data
  361.              section, which seems to be wrong since it might cause the
  362.              literal to change.
  363.  
  364.              As long as there are no external references to the
  365.              symbols, which there shouldn't be, we can treat the .data
  366.              and .rdata instances as separate symbols.  The comdat
  367.              code in the linker will do the appropriate merging.  Here
  368.              we avoid getting a multiple definition error for one of
  369.              these special symbols.
  370.  
  371.              FIXME: I don't think this will work in the case where
  372.              there are two object files which use the constants as a
  373.              literal and two object files which use it as a data
  374.              initializer.  One or the other of the second object files
  375.              is going to wind up with an inappropriate reference.  */
  376.           if (obj_pe (abfd)
  377.               && (classification == COFF_SYMBOL_GLOBAL
  378.                   || classification == COFF_SYMBOL_PE_SECTION)
  379.               && coff_section_data (abfd, section) != NULL
  380.               && coff_section_data (abfd, section)->comdat != NULL
  381.               && CONST_STRNEQ (name, "??_")
  382.               && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
  383.             {
  384.               if (*sym_hash == NULL)
  385.                 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
  386.                                                    name, FALSE, copy, FALSE);
  387.               if (*sym_hash != NULL
  388.                   && (*sym_hash)->root.type == bfd_link_hash_defined
  389.                   && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
  390.                   && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
  391.                              coff_section_data (abfd, section)->comdat->name) == 0)
  392.                 addit = FALSE;
  393.             }
  394.  
  395.           if (addit)
  396.             {
  397.               if (! (bfd_coff_link_add_one_symbol
  398.                      (info, abfd, name, flags, section, value,
  399.                       (const char *) NULL, copy, FALSE,
  400.                       (struct bfd_link_hash_entry **) sym_hash)))
  401.                 goto error_return;
  402.             }
  403.  
  404.           if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
  405.             (*sym_hash)->coff_link_hash_flags |=
  406.               COFF_LINK_HASH_PE_SECTION_SYMBOL;
  407.  
  408.           /* Limit the alignment of a common symbol to the possible
  409.              alignment of a section.  There is no point to permitting
  410.              a higher alignment for a common symbol: we can not
  411.              guarantee it, and it may cause us to allocate extra space
  412.              in the common section.  */
  413.           if (section == bfd_com_section_ptr
  414.               && (*sym_hash)->root.type == bfd_link_hash_common
  415.               && ((*sym_hash)->root.u.c.p->alignment_power
  416.                   > bfd_coff_default_section_alignment_power (abfd)))
  417.             (*sym_hash)->root.u.c.p->alignment_power
  418.               = bfd_coff_default_section_alignment_power (abfd);
  419.  
  420.           if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
  421.             {
  422.               /* If we don't have any symbol information currently in
  423.                  the hash table, or if we are looking at a symbol
  424.                  definition, then update the symbol class and type in
  425.                  the hash table.  */
  426.               if (((*sym_hash)->symbol_class == C_NULL
  427.                    && (*sym_hash)->type == T_NULL)
  428.                   || sym.n_scnum != 0
  429.                   || (sym.n_value != 0
  430.                       && (*sym_hash)->root.type != bfd_link_hash_defined
  431.                       && (*sym_hash)->root.type != bfd_link_hash_defweak))
  432.                 {
  433.                   (*sym_hash)->symbol_class = sym.n_sclass;
  434.                   if (sym.n_type != T_NULL)
  435.                     {
  436.                       /* We want to warn if the type changed, but not
  437.                          if it changed from an unspecified type.
  438.                          Testing the whole type byte may work, but the
  439.                          change from (e.g.) a function of unspecified
  440.                          type to function of known type also wants to
  441.                          skip the warning.  */
  442.                       if ((*sym_hash)->type != T_NULL
  443.                           && (*sym_hash)->type != sym.n_type
  444.                           && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
  445.                                && (BTYPE ((*sym_hash)->type) == T_NULL
  446.                                    || BTYPE (sym.n_type) == T_NULL)))
  447.                         (*_bfd_error_handler)
  448.                           (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
  449.                            abfd, name, (*sym_hash)->type, sym.n_type);
  450.  
  451.                       /* We don't want to change from a meaningful
  452.                          base type to a null one, but if we know
  453.                          nothing, take what little we might now know.  */
  454.                       if (BTYPE (sym.n_type) != T_NULL
  455.                           || (*sym_hash)->type == T_NULL)
  456.                         (*sym_hash)->type = sym.n_type;
  457.                     }
  458.                   (*sym_hash)->auxbfd = abfd;
  459.                   if (sym.n_numaux != 0)
  460.                     {
  461.                       union internal_auxent *alloc;
  462.                       unsigned int i;
  463.                       bfd_byte *eaux;
  464.                       union internal_auxent *iaux;
  465.  
  466.                       (*sym_hash)->numaux = sym.n_numaux;
  467.                       alloc = ((union internal_auxent *)
  468.                                bfd_hash_allocate (&info->hash->table,
  469.                                                   (sym.n_numaux
  470.                                                    * sizeof (*alloc))));
  471.                       if (alloc == NULL)
  472.                         goto error_return;
  473.                       for (i = 0, eaux = esym + symesz, iaux = alloc;
  474.                            i < sym.n_numaux;
  475.                            i++, eaux += symesz, iaux++)
  476.                         bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
  477.                                               sym.n_sclass, (int) i,
  478.                                               sym.n_numaux, iaux);
  479.                       (*sym_hash)->aux = alloc;
  480.                     }
  481.                 }
  482.             }
  483.  
  484.           if (classification == COFF_SYMBOL_PE_SECTION
  485.               && (*sym_hash)->numaux != 0)
  486.             {
  487.               /* Some PE sections (such as .bss) have a zero size in
  488.                  the section header, but a non-zero size in the AUX
  489.                  record.  Correct that here.
  490.  
  491.                  FIXME: This is not at all the right place to do this.
  492.                  For example, it won't help objdump.  This needs to be
  493.                  done when we swap in the section header.  */
  494.               BFD_ASSERT ((*sym_hash)->numaux == 1);
  495.               if (section->size == 0)
  496.                 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
  497.  
  498.               /* FIXME: We could test whether the section sizes
  499.                  matches the size in the aux entry, but apparently
  500.                  that sometimes fails unexpectedly.  */
  501.             }
  502.         }
  503.  
  504.       esym += (sym.n_numaux + 1) * symesz;
  505.       sym_hash += sym.n_numaux + 1;
  506.     }
  507.  
  508.   /* If this is a non-traditional, non-relocatable link, try to
  509.      optimize the handling of any .stab/.stabstr sections.  */
  510.   if (! bfd_link_relocatable (info)
  511.       && ! info->traditional_format
  512.       && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
  513.       && (info->strip != strip_all && info->strip != strip_debugger))
  514.     {
  515.       asection *stabstr;
  516.  
  517.       stabstr = bfd_get_section_by_name (abfd, ".stabstr");
  518.  
  519.       if (stabstr != NULL)
  520.         {
  521.           bfd_size_type string_offset = 0;
  522.           asection *stab;
  523.  
  524.           for (stab = abfd->sections; stab; stab = stab->next)
  525.             if (CONST_STRNEQ (stab->name, ".stab")
  526.                 && (!stab->name[5]
  527.                     || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
  528.             {
  529.               struct coff_link_hash_table *table;
  530.               struct coff_section_tdata *secdata
  531.                 = coff_section_data (abfd, stab);
  532.  
  533.               if (secdata == NULL)
  534.                 {
  535.                   amt = sizeof (struct coff_section_tdata);
  536.                   stab->used_by_bfd = bfd_zalloc (abfd, amt);
  537.                   if (stab->used_by_bfd == NULL)
  538.                     goto error_return;
  539.                   secdata = coff_section_data (abfd, stab);
  540.                 }
  541.  
  542.               table = coff_hash_table (info);
  543.  
  544.               if (! _bfd_link_section_stabs (abfd, &table->stab_info,
  545.                                              stab, stabstr,
  546.                                              &secdata->stab_info,
  547.                                              &string_offset))
  548.                 goto error_return;
  549.             }
  550.         }
  551.     }
  552.  
  553.   obj_coff_keep_syms (abfd) = keep_syms;
  554.  
  555.   return TRUE;
  556.  
  557.  error_return:
  558.   obj_coff_keep_syms (abfd) = keep_syms;
  559.   return FALSE;
  560. }
  562. /* Do the final link step.  */
  563.  
  564. bfd_boolean
  565. _bfd_coff_final_link (bfd *abfd,
  566.                       struct bfd_link_info *info)
  567. {
  568.   bfd_size_type symesz;
  569.   struct coff_final_link_info flaginfo;
  570.   bfd_boolean debug_merge_allocated;
  571.   bfd_boolean long_section_names;
  572.   asection *o;
  573.   struct bfd_link_order *p;
  574.   bfd_size_type max_sym_count;
  575.   bfd_size_type max_lineno_count;
  576.   bfd_size_type max_reloc_count;
  577.   bfd_size_type max_output_reloc_count;
  578.   bfd_size_type max_contents_size;
  579.   file_ptr rel_filepos;
  580.   unsigned int relsz;
  581.   file_ptr line_filepos;
  582.   unsigned int linesz;
  583.   bfd *sub;
  584.   bfd_byte *external_relocs = NULL;
  585.   char strbuf[STRING_SIZE_SIZE];
  586.   bfd_size_type amt;
  587.  
  588.   symesz = bfd_coff_symesz (abfd);
  589.  
  590.   flaginfo.info = info;
  591.   flaginfo.output_bfd = abfd;
  592.   flaginfo.strtab = NULL;
  593.   flaginfo.section_info = NULL;
  594.   flaginfo.last_file_index = -1;
  595.   flaginfo.last_bf_index = -1;
  596.   flaginfo.internal_syms = NULL;
  597.   flaginfo.sec_ptrs = NULL;
  598.   flaginfo.sym_indices = NULL;
  599.   flaginfo.outsyms = NULL;
  600.   flaginfo.linenos = NULL;
  601.   flaginfo.contents = NULL;
  602.   flaginfo.external_relocs = NULL;
  603.   flaginfo.internal_relocs = NULL;
  604.   flaginfo.global_to_static = FALSE;
  605.   debug_merge_allocated = FALSE;
  606.  
  607.   coff_data (abfd)->link_info = info;
  608.  
  609.   flaginfo.strtab = _bfd_stringtab_init ();
  610.   if (flaginfo.strtab == NULL)
  611.     goto error_return;
  612.  
  613.   if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
  614.     goto error_return;
  615.   debug_merge_allocated = TRUE;
  616.  
  617.   /* Compute the file positions for all the sections.  */
  618.   if (! abfd->output_has_begun)
  619.     {
  620.       if (! bfd_coff_compute_section_file_positions (abfd))
  621.         goto error_return;
  622.     }
  623.  
  624.   /* Count the line numbers and relocation entries required for the
  625.      output file.  Set the file positions for the relocs.  */
  626.   rel_filepos = obj_relocbase (abfd);
  627.   relsz = bfd_coff_relsz (abfd);
  628.   max_contents_size = 0;
  629.   max_lineno_count = 0;
  630.   max_reloc_count = 0;
  631.  
  632.   long_section_names = FALSE;
  633.   for (o = abfd->sections; o != NULL; o = o->next)
  634.     {
  635.       o->reloc_count = 0;
  636.       o->lineno_count = 0;
  637.       for (p = o->map_head.link_order; p != NULL; p = p->next)
  638.         {
  639.           if (p->type == bfd_indirect_link_order)
  640.             {
  641.               asection *sec;
  642.  
  643.               sec = p->u.indirect.section;
  644.  
  645.               /* Mark all sections which are to be included in the
  646.                  link.  This will normally be every section.  We need
  647.                  to do this so that we can identify any sections which
  648.                  the linker has decided to not include.  */
  649.               sec->linker_mark = TRUE;
  650.  
  651.               if (info->strip == strip_none
  652.                   || info->strip == strip_some)
  653.                 o->lineno_count += sec->lineno_count;
  654.  
  655.               if (bfd_link_relocatable (info))
  656.                 o->reloc_count += sec->reloc_count;
  657.  
  658.               if (sec->rawsize > max_contents_size)
  659.                 max_contents_size = sec->rawsize;
  660.               if (sec->size > max_contents_size)
  661.                 max_contents_size = sec->size;
  662.               if (sec->lineno_count > max_lineno_count)
  663.                 max_lineno_count = sec->lineno_count;
  664.               if (sec->reloc_count > max_reloc_count)
  665.                 max_reloc_count = sec->reloc_count;
  666.             }
  667.           else if (bfd_link_relocatable (info)
  668.                    && (p->type == bfd_section_reloc_link_order
  669.                        || p->type == bfd_symbol_reloc_link_order))
  670.             ++o->reloc_count;
  671.         }
  672.       if (o->reloc_count == 0)
  673.         o->rel_filepos = 0;
  674.       else
  675.         {
  676.           o->flags |= SEC_RELOC;
  677.           o->rel_filepos = rel_filepos;
  678.           rel_filepos += o->reloc_count * relsz;
  679.           /* In PE COFF, if there are at least 0xffff relocations an
  680.              extra relocation will be written out to encode the count.  */
  681.           if (obj_pe (abfd) && o->reloc_count >= 0xffff)
  682.             rel_filepos += relsz;
  683.         }
  684.  
  685.       if (bfd_coff_long_section_names (abfd)
  686.           && strlen (o->name) > SCNNMLEN)
  687.         {
  688.           /* This section has a long name which must go in the string
  689.              table.  This must correspond to the code in
  690.              coff_write_object_contents which puts the string index
  691.              into the s_name field of the section header.  That is why
  692.              we pass hash as FALSE.  */
  693.           if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)
  694.               == (bfd_size_type) -1)
  695.             goto error_return;
  696.           long_section_names = TRUE;
  697.         }
  698.     }
  699.  
  700.   /* If doing a relocatable link, allocate space for the pointers we
  701.      need to keep.  */
  702.   if (bfd_link_relocatable (info))
  703.     {
  704.       unsigned int i;
  705.  
  706.       /* We use section_count + 1, rather than section_count, because
  707.          the target_index fields are 1 based.  */
  708.       amt = abfd->section_count + 1;
  709.       amt *= sizeof (struct coff_link_section_info);
  710.       flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
  711.       if (flaginfo.section_info == NULL)
  712.         goto error_return;
  713.       for (i = 0; i <= abfd->section_count; i++)
  714.         {
  715.           flaginfo.section_info[i].relocs = NULL;
  716.           flaginfo.section_info[i].rel_hashes = NULL;
  717.         }
  718.     }
  719.  
  720.   /* We now know the size of the relocs, so we can determine the file
  721.      positions of the line numbers.  */
  722.   line_filepos = rel_filepos;
  723.   linesz = bfd_coff_linesz (abfd);
  724.   max_output_reloc_count = 0;
  725.   for (o = abfd->sections; o != NULL; o = o->next)
  726.     {
  727.       if (o->lineno_count == 0)
  728.         o->line_filepos = 0;
  729.       else
  730.         {
  731.           o->line_filepos = line_filepos;
  732.           line_filepos += o->lineno_count * linesz;
  733.         }
  734.  
  735.       if (o->reloc_count != 0)
  736.         {
  737.           /* We don't know the indices of global symbols until we have
  738.              written out all the local symbols.  For each section in
  739.              the output file, we keep an array of pointers to hash
  740.              table entries.  Each entry in the array corresponds to a
  741.              reloc.  When we find a reloc against a global symbol, we
  742.              set the corresponding entry in this array so that we can
  743.              fix up the symbol index after we have written out all the
  744.              local symbols.
  745.  
  746.              Because of this problem, we also keep the relocs in
  747.              memory until the end of the link.  This wastes memory,
  748.              but only when doing a relocatable link, which is not the
  749.              common case.  */
  750.           BFD_ASSERT (bfd_link_relocatable (info));
  751.           amt = o->reloc_count;
  752.           amt *= sizeof (struct internal_reloc);
  753.           flaginfo.section_info[o->target_index].relocs =
  754.               (struct internal_reloc *) bfd_malloc (amt);
  755.           amt = o->reloc_count;
  756.           amt *= sizeof (struct coff_link_hash_entry *);
  757.           flaginfo.section_info[o->target_index].rel_hashes =
  758.               (struct coff_link_hash_entry **) bfd_malloc (amt);
  759.           if (flaginfo.section_info[o->target_index].relocs == NULL
  760.               || flaginfo.section_info[o->target_index].rel_hashes == NULL)
  761.             goto error_return;
  762.  
  763.           if (o->reloc_count > max_output_reloc_count)
  764.             max_output_reloc_count = o->reloc_count;
  765.         }
  766.  
  767.       /* Reset the reloc and lineno counts, so that we can use them to
  768.          count the number of entries we have output so far.  */
  769.       o->reloc_count = 0;
  770.       o->lineno_count = 0;
  771.     }
  772.  
  773.   obj_sym_filepos (abfd) = line_filepos;
  774.  
  775.   /* Figure out the largest number of symbols in an input BFD.  Take
  776.      the opportunity to clear the output_has_begun fields of all the
  777.      input BFD's.  */
  778.   max_sym_count = 0;
  779.   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
  780.     {
  781.       size_t sz;
  782.  
  783.       sub->output_has_begun = FALSE;
  784.       sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;
  785.       if (sz > max_sym_count)
  786.         max_sym_count = sz;
  787.     }
  788.  
  789.   /* Allocate some buffers used while linking.  */
  790.   amt = max_sym_count * sizeof (struct internal_syment);
  791.   flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
  792.   amt = max_sym_count * sizeof (asection *);
  793.   flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
  794.   amt = max_sym_count * sizeof (long);
  795.   flaginfo.sym_indices = (long int *) bfd_malloc (amt);
  796.   flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
  797.   amt = max_lineno_count * bfd_coff_linesz (abfd);
  798.   flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
  799.   flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
  800.   amt = max_reloc_count * relsz;
  801.   flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
  802.   if (! bfd_link_relocatable (info))
  803.     {
  804.       amt = max_reloc_count * sizeof (struct internal_reloc);
  805.       flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
  806.     }
  807.   if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
  808.       || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
  809.       || (flaginfo.sym_indices == NULL && max_sym_count > 0)
  810.       || flaginfo.outsyms == NULL
  811.       || (flaginfo.linenos == NULL && max_lineno_count > 0)
  812.       || (flaginfo.contents == NULL && max_contents_size > 0)
  813.       || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
  814.       || (! bfd_link_relocatable (info)
  815.           && flaginfo.internal_relocs == NULL
  816.           && max_reloc_count > 0))
  817.     goto error_return;
  818.  
  819.   /* We now know the position of everything in the file, except that
  820.      we don't know the size of the symbol table and therefore we don't
  821.      know where the string table starts.  We just build the string
  822.      table in memory as we go along.  We process all the relocations
  823.      for a single input file at once.  */
  824.   obj_raw_syment_count (abfd) = 0;
  825.  
  826.   if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
  827.     {
  828.       if (! bfd_coff_start_final_link (abfd, info))
  829.         goto error_return;
  830.     }
  831.  
  832.   for (o = abfd->sections; o != NULL; o = o->next)
  833.     {
  834.       for (p = o->map_head.link_order; p != NULL; p = p->next)
  835.         {
  836.           if (p->type == bfd_indirect_link_order
  837.               && bfd_family_coff (p->u.indirect.section->owner))
  838.             {
  839.               sub = p->u.indirect.section->owner;
  840.               if (! bfd_coff_link_output_has_begun (sub, & flaginfo))
  841.                 {
  842.                   if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
  843.                     goto error_return;
  844.                   sub->output_has_begun = TRUE;
  845.                 }
  846.             }
  847.           else if (p->type == bfd_section_reloc_link_order
  848.                    || p->type == bfd_symbol_reloc_link_order)
  849.             {
  850.               if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
  851.                 goto error_return;
  852.             }
  853.           else
  854.             {
  855.               if (! _bfd_default_link_order (abfd, info, o, p))
  856.                 goto error_return;
  857.             }
  858.         }
  859.     }
  860.  
  861.   if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
  862.     {
  863.       /* Add local symbols from foreign inputs.  */
  864.       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
  865.         {
  866.           unsigned int i;
  867.  
  868.           if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))
  869.             continue;
  870.           for (i = 0; i < bfd_get_symcount (sub); ++i)
  871.             {
  872.               asymbol *sym = bfd_get_outsymbols (sub) [i];
  873.               file_ptr pos;
  874.               struct internal_syment isym;
  875.               bfd_size_type string_size = 0;
  876.               bfd_vma written = 0;
  877.               bfd_boolean rewrite = FALSE;
  878.  
  879.               if (! (sym->flags & BSF_LOCAL)
  880.                   || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC
  881.                                     | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC
  882.                                     | BSF_SYNTHETIC))
  883.                   || ((sym->flags & BSF_DEBUGGING)
  884.                       && ! (sym->flags & BSF_FILE)))
  885.                 continue;
  886.  
  887.               /* See if we are discarding symbols with this name.  */
  888.               if ((flaginfo.info->strip == strip_some
  889.                    && (bfd_hash_lookup (flaginfo.info->keep_hash,
  890.                                         bfd_asymbol_name(sym), FALSE, FALSE)
  891.                        == NULL))
  892.                   || (((flaginfo.info->discard == discard_sec_merge
  893.                         && (bfd_get_section (sym)->flags & SEC_MERGE)
  894.                         && ! bfd_link_relocatable (flaginfo.info))
  895.                        || flaginfo.info->discard == discard_l)
  896.                       && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
  897.                 continue;
  898.  
  899.               pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)
  900.                                              * symesz;
  901.               if (bfd_seek (abfd, pos, SEEK_SET) != 0)
  902.                 goto error_return;
  903.               if (! coff_write_alien_symbol(abfd, sym, &isym, &written,
  904.                                             &string_size, NULL, NULL))
  905.                 goto error_return;
  906.  
  907.               if (string_size)
  908.                 {
  909.                   bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT);
  910.                   bfd_size_type indx;
  911.  
  912.                   indx = _bfd_stringtab_add (flaginfo.strtab,
  913.                                              bfd_asymbol_name (sym), hash,
  914.                                              FALSE);
  915.                   if (indx == (bfd_size_type) -1)
  916.                     goto error_return;
  917.                   isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
  918.                   bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
  919.                   rewrite = TRUE;
  920.                 }
  921.  
  922.               if (isym.n_sclass == C_FILE)
  923.                 {
  924.                   if (flaginfo.last_file_index != -1)
  925.                     {
  926.                       flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
  927.                       bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
  928.                                              flaginfo.outsyms);
  929.                       pos = obj_sym_filepos (abfd) + flaginfo.last_file_index
  930.                                                      * symesz;
  931.                       rewrite = TRUE;
  932.                     }
  933.                   flaginfo.last_file_index = obj_raw_syment_count (abfd);
  934.                   flaginfo.last_file = isym;
  935.                 }
  936.  
  937.               if (rewrite
  938.                   && (bfd_seek (abfd, pos, SEEK_SET) != 0
  939.                       || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
  940.                 goto error_return;
  941.  
  942.               obj_raw_syment_count (abfd) += written;
  943.             }
  944.         }
  945.     }
  946.  
  947.   if (! bfd_coff_final_link_postscript (abfd, & flaginfo))
  948.     goto error_return;
  949.  
  950.   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
  951.  
  952.   coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
  953.   debug_merge_allocated = FALSE;
  954.  
  955.   if (flaginfo.internal_syms != NULL)
  956.     {
  957.       free (flaginfo.internal_syms);
  958.       flaginfo.internal_syms = NULL;
  959.     }
  960.   if (flaginfo.sec_ptrs != NULL)
  961.     {
  962.       free (flaginfo.sec_ptrs);
  963.       flaginfo.sec_ptrs = NULL;
  964.     }
  965.   if (flaginfo.sym_indices != NULL)
  966.     {
  967.       free (flaginfo.sym_indices);
  968.       flaginfo.sym_indices = NULL;
  969.     }
  970.   if (flaginfo.linenos != NULL)
  971.     {
  972.       free (flaginfo.linenos);
  973.       flaginfo.linenos = NULL;
  974.     }
  975.   if (flaginfo.contents != NULL)
  976.     {
  977.       free (flaginfo.contents);
  978.       flaginfo.contents = NULL;
  979.     }
  980.   if (flaginfo.external_relocs != NULL)
  981.     {
  982.       free (flaginfo.external_relocs);
  983.       flaginfo.external_relocs = NULL;
  984.     }
  985.   if (flaginfo.internal_relocs != NULL)
  986.     {
  987.       free (flaginfo.internal_relocs);
  988.       flaginfo.internal_relocs = NULL;
  989.     }
  990.  
  991.   /* The value of the last C_FILE symbol is supposed to be the symbol
  992.      index of the first external symbol.  Write it out again if
  993.      necessary.  */
  994.   if (flaginfo.last_file_index != -1
  995.       && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
  996.     {
  997.       file_ptr pos;
  998.  
  999.       flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
  1000.       bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
  1001.                              flaginfo.outsyms);
  1002.  
  1003.       pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
  1004.       if (bfd_seek (abfd, pos, SEEK_SET) != 0
  1005.           || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
  1006.         return FALSE;
  1007.     }
  1008.  
  1009.   /* If doing task linking (ld --task-link) then make a pass through the
  1010.      global symbols, writing out any that are defined, and making them
  1011.      static.  */
  1012.   if (info->task_link)
  1013.     {
  1014.       flaginfo.failed = FALSE;
  1015.       coff_link_hash_traverse (coff_hash_table (info),
  1016.                                _bfd_coff_write_task_globals, &flaginfo);
  1017.       if (flaginfo.failed)
  1018.         goto error_return;
  1019.     }
  1020.  
  1021.   /* Write out the global symbols.  */
  1022.   flaginfo.failed = FALSE;
  1023.   bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
  1024.   if (flaginfo.failed)
  1025.     goto error_return;
  1026.  
  1027.   /* The outsyms buffer is used by _bfd_coff_write_global_sym.  */
  1028.   if (flaginfo.outsyms != NULL)
  1029.     {
  1030.       free (flaginfo.outsyms);
  1031.       flaginfo.outsyms = NULL;
  1032.     }
  1033.  
  1034.   if (bfd_link_relocatable (info) && max_output_reloc_count > 0)
  1035.     {
  1036.       /* Now that we have written out all the global symbols, we know
  1037.          the symbol indices to use for relocs against them, and we can
  1038.          finally write out the relocs.  */
  1039.       amt = max_output_reloc_count * relsz;
  1040.       external_relocs = (bfd_byte *) bfd_malloc (amt);
  1041.       if (external_relocs == NULL)
  1042.         goto error_return;
  1043.  
  1044.       for (o = abfd->sections; o != NULL; o = o->next)
  1045.         {
  1046.           struct internal_reloc *irel;
  1047.           struct internal_reloc *irelend;
  1048.           struct coff_link_hash_entry **rel_hash;
  1049.           bfd_byte *erel;
  1050.  
  1051.           if (o->reloc_count == 0)
  1052.             continue;
  1053.  
  1054.           irel = flaginfo.section_info[o->target_index].relocs;
  1055.           irelend = irel + o->reloc_count;
  1056.           rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
  1057.           erel = external_relocs;
  1058.           for (; irel < irelend; irel++, rel_hash++, erel += relsz)
  1059.             {
  1060.               if (*rel_hash != NULL)
  1061.                 {
  1062.                   BFD_ASSERT ((*rel_hash)->indx >= 0);
  1063.                   irel->r_symndx = (*rel_hash)->indx;
  1064.                 }
  1065.               bfd_coff_swap_reloc_out (abfd, irel, erel);
  1066.             }
  1067.  
  1068.           if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
  1069.             goto error_return;
  1070.           if (obj_pe (abfd) && o->reloc_count >= 0xffff)
  1071.             {
  1072.               /* In PE COFF, write the count of relocs as the first
  1073.                  reloc.  The header overflow bit will be set
  1074.                  elsewhere. */
  1075.               struct internal_reloc incount;
  1076.               bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
  1077.  
  1078.               memset (&incount, 0, sizeof (incount));
  1079.               incount.r_vaddr = o->reloc_count + 1;
  1080.               bfd_coff_swap_reloc_out (abfd, &incount, excount);
  1081.               if (bfd_bwrite (excount, relsz, abfd) != relsz)
  1082.                 /* We'll leak, but it's an error anyway. */
  1083.                 goto error_return;
  1084.               free (excount);
  1085.             }
  1086.           if (bfd_bwrite (external_relocs,
  1087.                           (bfd_size_type) relsz * o->reloc_count, abfd)
  1088.               != (bfd_size_type) relsz * o->reloc_count)
  1089.             goto error_return;
  1090.         }
  1091.  
  1092.       free (external_relocs);
  1093.       external_relocs = NULL;
  1094.     }
  1095.  
  1096.   /* Free up the section information.  */
  1097.   if (flaginfo.section_info != NULL)
  1098.     {
  1099.       unsigned int i;
  1100.  
  1101.       for (i = 0; i < abfd->section_count; i++)
  1102.         {
  1103.           if (flaginfo.section_info[i].relocs != NULL)
  1104.             free (flaginfo.section_info[i].relocs);
  1105.           if (flaginfo.section_info[i].rel_hashes != NULL)
  1106.             free (flaginfo.section_info[i].rel_hashes);
  1107.         }
  1108.       free (flaginfo.section_info);
  1109.       flaginfo.section_info = NULL;
  1110.     }
  1111.  
  1112.   /* If we have optimized stabs strings, output them.  */
  1113.   if (coff_hash_table (info)->stab_info.stabstr != NULL)
  1114.     {
  1115.       if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
  1116.         return FALSE;
  1117.     }
  1118.  
  1119.   /* Write out the string table.  */
  1120.   if (obj_raw_syment_count (abfd) != 0 || long_section_names)
  1121.     {
  1122.       file_ptr pos;
  1123.  
  1124.       pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
  1125.       if (bfd_seek (abfd, pos, SEEK_SET) != 0)
  1126.         return FALSE;
  1127.  
  1128. #if STRING_SIZE_SIZE == 4
  1129.       H_PUT_32 (abfd,
  1130.                 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
  1131.                 strbuf);
  1132. #else
  1133.  #error Change H_PUT_32 above
  1134. #endif
  1135.  
  1136.       if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
  1137.           != STRING_SIZE_SIZE)
  1138.         return FALSE;
  1139.  
  1140.       if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
  1141.         return FALSE;
  1142.  
  1143.       obj_coff_strings_written (abfd) = TRUE;
  1144.     }
  1145.  
  1146.   _bfd_stringtab_free (flaginfo.strtab);
  1147.  
  1148.   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
  1149.      not try to write out the symbols.  */
  1150.   bfd_get_symcount (abfd) = 0;
  1151.  
  1152.   return TRUE;
  1153.  
  1154.  error_return:
  1155.   if (debug_merge_allocated)
  1156.     coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
  1157.   if (flaginfo.strtab != NULL)
  1158.     _bfd_stringtab_free (flaginfo.strtab);
  1159.   if (flaginfo.section_info != NULL)
  1160.     {
  1161.       unsigned int i;
  1162.  
  1163.       for (i = 0; i < abfd->section_count; i++)
  1164.         {
  1165.           if (flaginfo.section_info[i].relocs != NULL)
  1166.             free (flaginfo.section_info[i].relocs);
  1167.           if (flaginfo.section_info[i].rel_hashes != NULL)
  1168.             free (flaginfo.section_info[i].rel_hashes);
  1169.         }
  1170.       free (flaginfo.section_info);
  1171.     }
  1172.   if (flaginfo.internal_syms != NULL)
  1173.     free (flaginfo.internal_syms);
  1174.   if (flaginfo.sec_ptrs != NULL)
  1175.     free (flaginfo.sec_ptrs);
  1176.   if (flaginfo.sym_indices != NULL)
  1177.     free (flaginfo.sym_indices);
  1178.   if (flaginfo.outsyms != NULL)
  1179.     free (flaginfo.outsyms);
  1180.   if (flaginfo.linenos != NULL)
  1181.     free (flaginfo.linenos);
  1182.   if (flaginfo.contents != NULL)
  1183.     free (flaginfo.contents);
  1184.   if (flaginfo.external_relocs != NULL)
  1185.     free (flaginfo.external_relocs);
  1186.   if (flaginfo.internal_relocs != NULL)
  1187.     free (flaginfo.internal_relocs);
  1188.   if (external_relocs != NULL)
  1189.     free (external_relocs);
  1190.   return FALSE;
  1191. }
  1192.  
  1193. /* Parse out a -heap <reserved>,<commit> line.  */
  1194.  
  1195. static char *
  1196. dores_com (char *ptr, bfd *output_bfd, int heap)
  1197. {
  1198.   if (coff_data(output_bfd)->pe)
  1199.     {
  1200.       int val = strtoul (ptr, &ptr, 0);
  1201.  
  1202.       if (heap)
  1203.         pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
  1204.       else
  1205.         pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
  1206.  
  1207.       if (ptr[0] == ',')
  1208.         {
  1209.           val = strtoul (ptr+1, &ptr, 0);
  1210.           if (heap)
  1211.             pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
  1212.           else
  1213.             pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
  1214.         }
  1215.     }
  1216.   return ptr;
  1217. }
  1218.  
  1219. static char *
  1220. get_name (char *ptr, char **dst)
  1221. {
  1222.   while (*ptr == ' ')
  1223.     ptr++;
  1224.   *dst = ptr;
  1225.   while (*ptr && *ptr != ' ')
  1226.     ptr++;
  1227.   *ptr = 0;
  1228.   return ptr+1;
  1229. }
  1230.  
  1231. /* Process any magic embedded commands in a section called .drectve.  */
  1232.  
  1233. static int
  1234. process_embedded_commands (bfd *output_bfd,
  1235.                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
  1236.                            bfd *abfd)
  1237. {
  1238.   asection *sec = bfd_get_section_by_name (abfd, ".drectve");
  1239.   char *s;
  1240.   char *e;
  1241.   bfd_byte *copy;
  1242.  
  1243.   if (!sec)
  1244.     return 1;
  1245.  
  1246.   if (!bfd_malloc_and_get_section (abfd, sec, &copy))
  1247.     {
  1248.       if (copy != NULL)
  1249.         free (copy);
  1250.       return 0;
  1251.     }
  1252.   e = (char *) copy + sec->size;
  1253.  
  1254.   for (s = (char *) copy; s < e ; )
  1255.     {
  1256.       if (s[0] != '-')
  1257.         {
  1258.           s++;
  1259.           continue;
  1260.         }
  1261.       if (CONST_STRNEQ (s, "-attr"))
  1262.         {
  1263.           char *name;
  1264.           char *attribs;
  1265.           asection *asec;
  1266.           int loop = 1;
  1267.           int had_write = 0;
  1268.           int had_exec= 0;
  1269.  
  1270.           s += 5;
  1271.           s = get_name (s, &name);
  1272.           s = get_name (s, &attribs);
  1273.  
  1274.           while (loop)
  1275.             {
  1276.               switch (*attribs++)
  1277.                 {
  1278.                 case 'W':
  1279.                   had_write = 1;
  1280.                   break;
  1281.                 case 'R':
  1282.                   break;
  1283.                 case 'S':
  1284.                   break;
  1285.                 case 'X':
  1286.                   had_exec = 1;
  1287.                   break;
  1288.                 default:
  1289.                   loop = 0;
  1290.                 }
  1291.             }
  1292.           asec = bfd_get_section_by_name (abfd, name);
  1293.           if (asec)
  1294.             {
  1295.               if (had_exec)
  1296.                 asec->flags |= SEC_CODE;
  1297.               if (!had_write)
  1298.                 asec->flags |= SEC_READONLY;
  1299.             }
  1300.         }
  1301.       else if (CONST_STRNEQ (s, "-heap"))
  1302.         s = dores_com (s + 5, output_bfd, 1);
  1303.  
  1304.       else if (CONST_STRNEQ (s, "-stack"))
  1305.         s = dores_com (s + 6, output_bfd, 0);
  1306.  
  1307.       /* GNU extension for aligned commons.  */
  1308.       else if (CONST_STRNEQ (s, "-aligncomm:"))
  1309.         {
  1310.           /* Common symbols must be aligned on reading, as it
  1311.           is too late to do anything here, after they have
  1312.           already been allocated, so just skip the directive.  */
  1313.           s += 11;
  1314.         }
  1315.  
  1316.       else
  1317.         s++;
  1318.     }
  1319.   free (copy);
  1320.   return 1;
  1321. }
  1322.  
  1323. /* Place a marker against all symbols which are used by relocations.
  1324.    This marker can be picked up by the 'do we skip this symbol ?'
  1325.    loop in _bfd_coff_link_input_bfd() and used to prevent skipping
  1326.    that symbol.  */
  1327.  
  1328. static void
  1329. mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)
  1330. {
  1331.   asection * a;
  1332.  
  1333.   if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
  1334.     return;
  1335.  
  1336.   for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
  1337.     {
  1338.       struct internal_reloc *   internal_relocs;
  1339.       struct internal_reloc *   irel;
  1340.       struct internal_reloc *   irelend;
  1341.  
  1342.       if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1
  1343.           || a->linker_mark == 0)
  1344.         continue;
  1345.       /* Don't mark relocs in excluded sections.  */
  1346.       if (a->output_section == bfd_abs_section_ptr)
  1347.         continue;
  1348.  
  1349.       /* Read in the relocs.  */
  1350.       internal_relocs = _bfd_coff_read_internal_relocs
  1351.         (input_bfd, a, FALSE,
  1352.          flaginfo->external_relocs,
  1353.          bfd_link_relocatable (flaginfo->info),
  1354.          (bfd_link_relocatable (flaginfo->info)
  1355.           ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
  1356.           : flaginfo->internal_relocs)
  1357.         );
  1358.  
  1359.       if (internal_relocs == NULL)
  1360.         continue;
  1361.  
  1362.       irel     = internal_relocs;
  1363.       irelend  = irel + a->reloc_count;
  1364.  
  1365.       /* Place a mark in the sym_indices array (whose entries have
  1366.          been initialised to 0) for all of the symbols that are used
  1367.          in the relocation table.  This will then be picked up in the
  1368.          skip/don't-skip pass.  */
  1369.       for (; irel < irelend; irel++)
  1370.         flaginfo->sym_indices[ irel->r_symndx ] = -1;
  1371.     }
  1372. }
  1373.  
  1374. /* Link an input file into the linker output file.  This function
  1375.    handles all the sections and relocations of the input file at once.  */
  1376.  
  1377. bfd_boolean
  1378. _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
  1379. {
  1380.   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
  1381.   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
  1382.   bfd_boolean (*adjust_symndx)
  1383.     (bfd *, struct bfd_link_info *, bfd *, asection *,
  1384.      struct internal_reloc *, bfd_boolean *);
  1385.   bfd *output_bfd;
  1386.   const char *strings;
  1387.   bfd_size_type syment_base;
  1388.   bfd_boolean copy, hash;
  1389.   bfd_size_type isymesz;
  1390.   bfd_size_type osymesz;
  1391.   bfd_size_type linesz;
  1392.   bfd_byte *esym;
  1393.   bfd_byte *esym_end;
  1394.   struct internal_syment *isymp;
  1395.   asection **secpp;
  1396.   long *indexp;
  1397.   unsigned long output_index;
  1398.   bfd_byte *outsym;
  1399.   struct coff_link_hash_entry **sym_hash;
  1400.   asection *o;
  1401.  
  1402.   /* Move all the symbols to the output file.  */
  1403.  
  1404.   output_bfd = flaginfo->output_bfd;
  1405.   strings = NULL;
  1406.   syment_base = obj_raw_syment_count (output_bfd);
  1407.   isymesz = bfd_coff_symesz (input_bfd);
  1408.   osymesz = bfd_coff_symesz (output_bfd);
  1409.   linesz = bfd_coff_linesz (input_bfd);
  1410.   BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
  1411.  
  1412.   copy = FALSE;
  1413.   if (! flaginfo->info->keep_memory)
  1414.     copy = TRUE;
  1415.   hash = TRUE;
  1416.   if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
  1417.     hash = FALSE;
  1418.  
  1419.   if (! _bfd_coff_get_external_symbols (input_bfd))
  1420.     return FALSE;
  1421.  
  1422.   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
  1423.   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
  1424.   isymp = flaginfo->internal_syms;
  1425.   secpp = flaginfo->sec_ptrs;
  1426.   indexp = flaginfo->sym_indices;
  1427.   output_index = syment_base;
  1428.   outsym = flaginfo->outsyms;
  1429.  
  1430.   if (coff_data (output_bfd)->pe
  1431.       && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
  1432.     return FALSE;
  1433.  
  1434.   /* If we are going to perform relocations and also strip/discard some
  1435.      symbols then we must make sure that we do not strip/discard those
  1436.      symbols that are going to be involved in the relocations.  */
  1437.   if ((   flaginfo->info->strip   != strip_none
  1438.        || flaginfo->info->discard != discard_none)
  1439.       && bfd_link_relocatable (flaginfo->info))
  1440.     {
  1441.       /* Mark the symbol array as 'not-used'.  */
  1442.       memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
  1443.  
  1444.       mark_relocs (flaginfo, input_bfd);
  1445.     }
  1446.  
  1447.   while (esym < esym_end)
  1448.     {
  1449.       struct internal_syment isym;
  1450.       enum coff_symbol_classification classification;
  1451.       bfd_boolean skip;
  1452.       bfd_boolean global;
  1453.       bfd_boolean dont_skip_symbol;
  1454.       int add;
  1455.  
  1456.       bfd_coff_swap_sym_in (input_bfd, esym, isymp);
  1457.  
  1458.       /* Make a copy of *isymp so that the relocate_section function
  1459.          always sees the original values.  This is more reliable than
  1460.          always recomputing the symbol value even if we are stripping
  1461.          the symbol.  */
  1462.       isym = *isymp;
  1463.  
  1464.       classification = bfd_coff_classify_symbol (input_bfd, &isym);
  1465.       switch (classification)
  1466.         {
  1467.         default:
  1468.           abort ();
  1469.         case COFF_SYMBOL_GLOBAL:
  1470.         case COFF_SYMBOL_PE_SECTION:
  1471.         case COFF_SYMBOL_LOCAL:
  1472.           *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
  1473.           break;
  1474.         case COFF_SYMBOL_COMMON:
  1475.           *secpp = bfd_com_section_ptr;
  1476.           break;
  1477.         case COFF_SYMBOL_UNDEFINED:
  1478.           *secpp = bfd_und_section_ptr;
  1479.           break;
  1480.         }
  1481.  
  1482.       /* Extract the flag indicating if this symbol is used by a
  1483.          relocation.  */
  1484.       if ((flaginfo->info->strip != strip_none
  1485.            || flaginfo->info->discard != discard_none)
  1486.           && bfd_link_relocatable (flaginfo->info))
  1487.         dont_skip_symbol = *indexp;
  1488.       else
  1489.         dont_skip_symbol = FALSE;
  1490.  
  1491.       *indexp = -1;
  1492.  
  1493.       skip = FALSE;
  1494.       global = FALSE;
  1495.       add = 1 + isym.n_numaux;
  1496.  
  1497.       /* If we are stripping all symbols, we want to skip this one.  */
  1498.       if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
  1499.         skip = TRUE;
  1500.  
  1501.       if (! skip)
  1502.         {
  1503.           switch (classification)
  1504.             {
  1505.             default:
  1506.               abort ();
  1507.             case COFF_SYMBOL_GLOBAL:
  1508.             case COFF_SYMBOL_COMMON:
  1509.             case COFF_SYMBOL_PE_SECTION:
  1510.               /* This is a global symbol.  Global symbols come at the
  1511.                  end of the symbol table, so skip them for now.
  1512.                  Locally defined function symbols, however, are an
  1513.                  exception, and are not moved to the end.  */
  1514.               global = TRUE;
  1515.               if (! ISFCN (isym.n_type))
  1516.                 skip = TRUE;
  1517.               break;
  1518.  
  1519.             case COFF_SYMBOL_UNDEFINED:
  1520.               /* Undefined symbols are left for the end.  */
  1521.               global = TRUE;
  1522.               skip = TRUE;
  1523.               break;
  1524.  
  1525.             case COFF_SYMBOL_LOCAL:
  1526.               /* This is a local symbol.  Skip it if we are discarding
  1527.                  local symbols.  */
  1528.               if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
  1529.                 skip = TRUE;
  1530.               break;
  1531.             }
  1532.         }
  1533.  
  1534. #ifndef COFF_WITH_PE
  1535.       /* Skip section symbols for sections which are not going to be
  1536.          emitted.  */
  1537.       if (!skip
  1538.           && !dont_skip_symbol
  1539.           && isym.n_sclass == C_STAT
  1540.           && isym.n_type == T_NULL
  1541.           && isym.n_numaux > 0
  1542.           && ((*secpp)->output_section == bfd_abs_section_ptr
  1543.               || bfd_section_removed_from_list (output_bfd,
  1544.                                                 (*secpp)->output_section)))
  1545.         skip = TRUE;
  1546. #endif
  1547.  
  1548.       /* If we stripping debugging symbols, and this is a debugging
  1549.          symbol, then skip it.  FIXME: gas sets the section to N_ABS
  1550.          for some types of debugging symbols; I don't know if this is
  1551.          a bug or not.  In any case, we handle it here.  */
  1552.       if (! skip
  1553.           && flaginfo->info->strip == strip_debugger
  1554.           && ! dont_skip_symbol
  1555.           && (isym.n_scnum == N_DEBUG
  1556.               || (isym.n_scnum == N_ABS
  1557.                   && (isym.n_sclass == C_AUTO
  1558.                       || isym.n_sclass == C_REG
  1559.                       || isym.n_sclass == C_MOS
  1560.                       || isym.n_sclass == C_MOE
  1561.                       || isym.n_sclass == C_MOU
  1562.                       || isym.n_sclass == C_ARG
  1563.                       || isym.n_sclass == C_REGPARM
  1564.                       || isym.n_sclass == C_FIELD
  1565.                       || isym.n_sclass == C_EOS))))
  1566.         skip = TRUE;
  1567.  
  1568.       /* If some symbols are stripped based on the name, work out the
  1569.          name and decide whether to skip this symbol.  */
  1570.       if (! skip
  1571.           && (flaginfo->info->strip == strip_some
  1572.               || flaginfo->info->discard == discard_l))
  1573.         {
  1574.           const char *name;
  1575.           char buf[SYMNMLEN + 1];
  1576.  
  1577.           name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
  1578.           if (name == NULL)
  1579.             return FALSE;
  1580.  
  1581.           if (! dont_skip_symbol
  1582.               && ((flaginfo->info->strip == strip_some
  1583.                    && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
  1584.                                     FALSE) == NULL))
  1585.                    || (! global
  1586.                        && flaginfo->info->discard == discard_l
  1587.                        && bfd_is_local_label_name (input_bfd, name))))
  1588.             skip = TRUE;
  1589.         }
  1590.  
  1591.       /* If this is an enum, struct, or union tag, see if we have
  1592.          already output an identical type.  */
  1593.       if (! skip
  1594.           && (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
  1595.           && (isym.n_sclass == C_ENTAG
  1596.               || isym.n_sclass == C_STRTAG
  1597.               || isym.n_sclass == C_UNTAG)
  1598.           && isym.n_numaux == 1)
  1599.         {
  1600.           const char *name;
  1601.           char buf[SYMNMLEN + 1];
  1602.           struct coff_debug_merge_hash_entry *mh;
  1603.           struct coff_debug_merge_type *mt;
  1604.           union internal_auxent aux;
  1605.           struct coff_debug_merge_element **epp;
  1606.           bfd_byte *esl, *eslend;
  1607.           struct internal_syment *islp;
  1608.           bfd_size_type amt;
  1609.  
  1610.           name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
  1611.           if (name == NULL)
  1612.             return FALSE;
  1613.  
  1614.           /* Ignore fake names invented by compiler; treat them all as
  1615.              the same name.  */
  1616.           if (*name == '~' || *name == '.' || *name == '$'
  1617.               || (*name == bfd_get_symbol_leading_char (input_bfd)
  1618.                   && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
  1619.             name = "";
  1620.  
  1621.           mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
  1622.                                              TRUE, TRUE);
  1623.           if (mh == NULL)
  1624.             return FALSE;
  1625.  
  1626.           /* Allocate memory to hold type information.  If this turns
  1627.              out to be a duplicate, we pass this address to
  1628.              bfd_release.  */
  1629.           amt = sizeof (struct coff_debug_merge_type);
  1630.           mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
  1631.           if (mt == NULL)
  1632.             return FALSE;
  1633.           mt->type_class = isym.n_sclass;
  1634.  
  1635.           /* Pick up the aux entry, which points to the end of the tag
  1636.              entries.  */
  1637.           bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
  1638.                                 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
  1639.                                 &aux);
  1640.  
  1641.           /* Gather the elements.  */
  1642.           epp = &mt->elements;
  1643.           mt->elements = NULL;
  1644.           islp = isymp + 2;
  1645.           esl = esym + 2 * isymesz;
  1646.           eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
  1647.                     + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
  1648.           while (esl < eslend)
  1649.             {
  1650.               const char *elename;
  1651.               char elebuf[SYMNMLEN + 1];
  1652.               char *name_copy;
  1653.  
  1654.               bfd_coff_swap_sym_in (input_bfd, esl, islp);
  1655.  
  1656.               amt = sizeof (struct coff_debug_merge_element);
  1657.               *epp = (struct coff_debug_merge_element *)
  1658.                   bfd_alloc (input_bfd, amt);
  1659.               if (*epp == NULL)
  1660.                 return FALSE;
  1661.  
  1662.               elename = _bfd_coff_internal_syment_name (input_bfd, islp,
  1663.                                                         elebuf);
  1664.               if (elename == NULL)
  1665.                 return FALSE;
  1666.  
  1667.               amt = strlen (elename) + 1;
  1668.               name_copy = (char *) bfd_alloc (input_bfd, amt);
  1669.               if (name_copy == NULL)
  1670.                 return FALSE;
  1671.               strcpy (name_copy, elename);
  1672.  
  1673.               (*epp)->name = name_copy;
  1674.               (*epp)->type = islp->n_type;
  1675.               (*epp)->tagndx = 0;
  1676.               if (islp->n_numaux >= 1
  1677.                   && islp->n_type != T_NULL
  1678.                   && islp->n_sclass != C_EOS)
  1679.                 {
  1680.                   union internal_auxent eleaux;
  1681.                   long indx;
  1682.  
  1683.                   bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
  1684.                                         islp->n_type, islp->n_sclass, 0,
  1685.                                         islp->n_numaux, &eleaux);
  1686.                   indx = eleaux.x_sym.x_tagndx.l;
  1687.  
  1688.                   /* FIXME: If this tagndx entry refers to a symbol
  1689.                      defined later in this file, we just ignore it.
  1690.                      Handling this correctly would be tedious, and may
  1691.                      not be required.  */
  1692.                   if (indx > 0
  1693.                       && (indx
  1694.                           < ((esym -
  1695.                               (bfd_byte *) obj_coff_external_syms (input_bfd))
  1696.                              / (long) isymesz)))
  1697.                     {
  1698.                       (*epp)->tagndx = flaginfo->sym_indices[indx];
  1699.                       if ((*epp)->tagndx < 0)
  1700.                         (*epp)->tagndx = 0;
  1701.                     }
  1702.                 }
  1703.               epp = &(*epp)->next;
  1704.               *epp = NULL;
  1705.  
  1706.               esl += (islp->n_numaux + 1) * isymesz;
  1707.               islp += islp->n_numaux + 1;
  1708.             }
  1709.  
  1710.           /* See if we already have a definition which matches this
  1711.              type.  We always output the type if it has no elements,
  1712.              for simplicity.  */
  1713.           if (mt->elements == NULL)
  1714.             bfd_release (input_bfd, mt);
  1715.           else
  1716.             {
  1717.               struct coff_debug_merge_type *mtl;
  1718.  
  1719.               for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
  1720.                 {
  1721.                   struct coff_debug_merge_element *me, *mel;
  1722.  
  1723.                   if (mtl->type_class != mt->type_class)
  1724.                     continue;
  1725.  
  1726.                   for (me = mt->elements, mel = mtl->elements;
  1727.                        me != NULL && mel != NULL;
  1728.                        me = me->next, mel = mel->next)
  1729.                     {
  1730.                       if (strcmp (me->name, mel->name) != 0
  1731.                           || me->type != mel->type
  1732.                           || me->tagndx != mel->tagndx)
  1733.                         break;
  1734.                     }
  1735.  
  1736.                   if (me == NULL && mel == NULL)
  1737.                     break;
  1738.                 }
  1739.  
  1740.               if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
  1741.                 {
  1742.                   /* This is the first definition of this type.  */
  1743.                   mt->indx = output_index;
  1744.                   mt->next = mh->types;
  1745.                   mh->types = mt;
  1746.                 }
  1747.               else
  1748.                 {
  1749.                   /* This is a redefinition which can be merged.  */
  1750.                   bfd_release (input_bfd, mt);
  1751.                   *indexp = mtl->indx;
  1752.                   add = (eslend - esym) / isymesz;
  1753.                   skip = TRUE;
  1754.                 }
  1755.             }
  1756.         }
  1757.  
  1758.       /* We now know whether we are to skip this symbol or not.  */
  1759.       if (! skip)
  1760.         {
  1761.           /* Adjust the symbol in order to output it.  */
  1762.  
  1763.           if (isym._n._n_n._n_zeroes == 0
  1764.               && isym._n._n_n._n_offset != 0)
  1765.             {
  1766.               const char *name;
  1767.               bfd_size_type indx;
  1768.  
  1769.               /* This symbol has a long name.  Enter it in the string
  1770.                  table we are building.  Note that we do not check
  1771.                  bfd_coff_symname_in_debug.  That is only true for
  1772.                  XCOFF, and XCOFF requires different linking code
  1773.                  anyhow.  */
  1774.               name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
  1775.               if (name == NULL)
  1776.                 return FALSE;
  1777.               indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
  1778.               if (indx == (bfd_size_type) -1)
  1779.                 return FALSE;
  1780.               isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
  1781.             }
  1782.  
  1783.           switch (isym.n_sclass)
  1784.             {
  1785.             case C_AUTO:
  1786.             case C_MOS:
  1787.             case C_EOS:
  1788.             case C_MOE:
  1789.             case C_MOU:
  1790.             case C_UNTAG:
  1791.             case C_STRTAG:
  1792.             case C_ENTAG:
  1793.             case C_TPDEF:
  1794.             case C_ARG:
  1795.             case C_USTATIC:
  1796.             case C_REG:
  1797.             case C_REGPARM:
  1798.             case C_FIELD:
  1799.               /* The symbol value should not be modified.  */
  1800.               break;
  1801.  
  1802.             case C_FCN:
  1803.               if (obj_pe (input_bfd)
  1804.                   && strcmp (isym.n_name, ".bf") != 0
  1805.                   && isym.n_scnum > 0)
  1806.                 {
  1807.                   /* For PE, .lf and .ef get their value left alone,
  1808.                      while .bf gets relocated.  However, they all have
  1809.                      "real" section numbers, and need to be moved into
  1810.                      the new section.  */
  1811.                   isym.n_scnum = (*secpp)->output_section->target_index;
  1812.                   break;
  1813.                 }
  1814.               /* Fall through.  */
  1815.             default:
  1816.             case C_LABEL:  /* Not completely sure about these 2 */
  1817.             case C_EXTDEF:
  1818.             case C_BLOCK:
  1819.             case C_EFCN:
  1820.             case C_NULL:
  1821.             case C_EXT:
  1822.             case C_STAT:
  1823.             case C_SECTION:
  1824.             case C_NT_WEAK:
  1825.               /* Compute new symbol location.  */
  1826.             if (isym.n_scnum > 0)
  1827.               {
  1828.                 isym.n_scnum = (*secpp)->output_section->target_index;
  1829.                 isym.n_value += (*secpp)->output_offset;
  1830.                 if (! obj_pe (input_bfd))
  1831.                   isym.n_value -= (*secpp)->vma;
  1832.                 if (! obj_pe (flaginfo->output_bfd))
  1833.                   isym.n_value += (*secpp)->output_section->vma;
  1834.               }
  1835.             break;
  1836.  
  1837.             case C_FILE:
  1838.               /* The value of a C_FILE symbol is the symbol index of
  1839.                  the next C_FILE symbol.  The value of the last C_FILE
  1840.                  symbol is the symbol index to the first external
  1841.                  symbol (actually, coff_renumber_symbols does not get
  1842.                  this right--it just sets the value of the last C_FILE
  1843.                  symbol to zero--and nobody has ever complained about
  1844.                  it).  We try to get this right, below, just before we
  1845.                  write the symbols out, but in the general case we may
  1846.                  have to write the symbol out twice.  */
  1847.               if (flaginfo->last_file_index != -1
  1848.                   && flaginfo->last_file.n_value != (bfd_vma) output_index)
  1849.                 {
  1850.                   /* We must correct the value of the last C_FILE
  1851.                      entry.  */
  1852.                   flaginfo->last_file.n_value = output_index;
  1853.                   if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
  1854.                     {
  1855.                       /* The last C_FILE symbol is in this input file.  */
  1856.                       bfd_coff_swap_sym_out (output_bfd,
  1857.                                              &flaginfo->last_file,
  1858.                                              (flaginfo->outsyms
  1859.                                               + ((flaginfo->last_file_index
  1860.                                                   - syment_base)
  1861.                                                  * osymesz)));
  1862.                     }
  1863.                   else
  1864.                     {
  1865.                       file_ptr pos;
  1866.  
  1867.                       /* We have already written out the last C_FILE
  1868.                          symbol.  We need to write it out again.  We
  1869.                          borrow *outsym temporarily.  */
  1870.                       bfd_coff_swap_sym_out (output_bfd,
  1871.                                              &flaginfo->last_file, outsym);
  1872.                       pos = obj_sym_filepos (output_bfd);
  1873.                       pos += flaginfo->last_file_index * osymesz;
  1874.                       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
  1875.                           || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
  1876.                         return FALSE;
  1877.                     }
  1878.                 }
  1879.  
  1880.               flaginfo->last_file_index = output_index;
  1881.               flaginfo->last_file = isym;
  1882.               break;
  1883.             }
  1884.  
  1885.           /* If doing task linking, convert normal global function symbols to
  1886.              static functions.  */
  1887.           if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
  1888.             isym.n_sclass = C_STAT;
  1889.  
  1890.           /* Output the symbol.  */
  1891.           bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
  1892.  
  1893.           *indexp = output_index;
  1894.  
  1895.           if (global)
  1896.             {
  1897.               long indx;
  1898.               struct coff_link_hash_entry *h;
  1899.  
  1900.               indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
  1901.                       / isymesz);
  1902.               h = obj_coff_sym_hashes (input_bfd)[indx];
  1903.               if (h == NULL)
  1904.                 {
  1905.                   /* This can happen if there were errors earlier in
  1906.                      the link.  */
  1907.                   bfd_set_error (bfd_error_bad_value);
  1908.                   return FALSE;
  1909.                 }
  1910.               h->indx = output_index;
  1911.             }
  1912.  
  1913.           output_index += add;
  1914.           outsym += add * osymesz;
  1915.         }
  1916.  
  1917.       esym += add * isymesz;
  1918.       isymp += add;
  1919.       ++secpp;
  1920.       ++indexp;
  1921.       for (--add; add > 0; --add)
  1922.         {
  1923.           *secpp++ = NULL;
  1924.           *indexp++ = -1;
  1925.         }
  1926.     }
  1927.  
  1928.   /* Fix up the aux entries.  This must be done in a separate pass,
  1929.      because we don't know the correct symbol indices until we have
  1930.      already decided which symbols we are going to keep.  */
  1931.   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
  1932.   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
  1933.   isymp = flaginfo->internal_syms;
  1934.   indexp = flaginfo->sym_indices;
  1935.   sym_hash = obj_coff_sym_hashes (input_bfd);
  1936.   outsym = flaginfo->outsyms;
  1937.  
  1938.   while (esym < esym_end)
  1939.     {
  1940.       int add;
  1941.  
  1942.       add = 1 + isymp->n_numaux;
  1943.  
  1944.       if ((*indexp < 0
  1945.            || (bfd_size_type) *indexp < syment_base)
  1946.           && (*sym_hash == NULL
  1947.               || (*sym_hash)->auxbfd != input_bfd))
  1948.         esym += add * isymesz;
  1949.       else
  1950.         {
  1951.           struct coff_link_hash_entry *h;
  1952.           int i;
  1953.  
  1954.           h = NULL;
  1955.           if (*indexp < 0)
  1956.             {
  1957.               h = *sym_hash;
  1958.  
  1959.               /* The m68k-motorola-sysv assembler will sometimes
  1960.                  generate two symbols with the same name, but only one
  1961.                  will have aux entries.  */
  1962.               BFD_ASSERT (isymp->n_numaux == 0
  1963.                           || h->numaux == 0
  1964.                           || h->numaux == isymp->n_numaux);
  1965.             }
  1966.  
  1967.           esym += isymesz;
  1968.  
  1969.           if (h == NULL)
  1970.             outsym += osymesz;
  1971.  
  1972.           /* Handle the aux entries.  This handling is based on
  1973.              coff_pointerize_aux.  I don't know if it always correct.  */
  1974.           for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
  1975.             {
  1976.               union internal_auxent aux;
  1977.               union internal_auxent *auxp;
  1978.  
  1979.               if (h != NULL && h->aux != NULL && (h->numaux > i))
  1980.                 auxp = h->aux + i;
  1981.               else
  1982.                 {
  1983.                   bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
  1984.                                         isymp->n_sclass, i, isymp->n_numaux, &aux);
  1985.                   auxp = &aux;
  1986.                 }
  1987.  
  1988.               if (isymp->n_sclass == C_FILE)
  1989.                 {
  1990.                   /* If this is a long filename, we must put it in the
  1991.                      string table.  */
  1992.                   if (auxp->x_file.x_n.x_zeroes == 0
  1993.                       && auxp->x_file.x_n.x_offset != 0)
  1994.                     {
  1995.                       const char *filename;
  1996.                       bfd_size_type indx;
  1997.  
  1998.                       BFD_ASSERT (auxp->x_file.x_n.x_offset
  1999.                                   >= STRING_SIZE_SIZE);
  2000.                       if (strings == NULL)
  2001.                         {
  2002.                           strings = _bfd_coff_read_string_table (input_bfd);
  2003.                           if (strings == NULL)
  2004.                             return FALSE;
  2005.                         }
  2006.                       if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
  2007.                         filename = _("<corrupt>");
  2008.                       else
  2009.                       filename = strings + auxp->x_file.x_n.x_offset;
  2010.                       indx = _bfd_stringtab_add (flaginfo->strtab, filename,
  2011.                                                  hash, copy);
  2012.                       if (indx == (bfd_size_type) -1)
  2013.                         return FALSE;
  2014.                       auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
  2015.                     }
  2016.                 }
  2017.               else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
  2018.                        && isymp->n_sclass != C_NT_WEAK)
  2019.                 {
  2020.                   unsigned long indx;
  2021.  
  2022.                   if (ISFCN (isymp->n_type)
  2023.                       || ISTAG (isymp->n_sclass)
  2024.                       || isymp->n_sclass == C_BLOCK
  2025.                       || isymp->n_sclass == C_FCN)
  2026.                     {
  2027.                       indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
  2028.                       if (indx > 0
  2029.                           && indx < obj_raw_syment_count (input_bfd))
  2030.                         {
  2031.                           /* We look forward through the symbol for
  2032.                              the index of the next symbol we are going
  2033.                              to include.  I don't know if this is
  2034.                              entirely right.  */
  2035.                           while ((flaginfo->sym_indices[indx] < 0
  2036.                                   || ((bfd_size_type) flaginfo->sym_indices[indx]
  2037.                                       < syment_base))
  2038.                                  && indx < obj_raw_syment_count (input_bfd))
  2039.                             ++indx;
  2040.                           if (indx >= obj_raw_syment_count (input_bfd))
  2041.                             indx = output_index;
  2042.                           else
  2043.                             indx = flaginfo->sym_indices[indx];
  2044.                           auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
  2045.                         }
  2046.                     }
  2047.  
  2048.                   indx = auxp->x_sym.x_tagndx.l;
  2049.                   if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
  2050.                     {
  2051.                       long symindx;
  2052.  
  2053.                       symindx = flaginfo->sym_indices[indx];
  2054.                       if (symindx < 0)
  2055.                         auxp->x_sym.x_tagndx.l = 0;
  2056.                       else
  2057.                         auxp->x_sym.x_tagndx.l = symindx;
  2058.                     }
  2059.  
  2060.                   /* The .bf symbols are supposed to be linked through
  2061.                      the endndx field.  We need to carry this list
  2062.                      across object files.  */
  2063.                   if (i == 0
  2064.                       && h == NULL
  2065.                       && isymp->n_sclass == C_FCN
  2066.                       && (isymp->_n._n_n._n_zeroes != 0
  2067.                           || isymp->_n._n_n._n_offset == 0)
  2068.                       && isymp->_n._n_name[0] == '.'
  2069.                       && isymp->_n._n_name[1] == 'b'
  2070.                       && isymp->_n._n_name[2] == 'f'
  2071.                       && isymp->_n._n_name[3] == '\0')
  2072.                     {
  2073.                       if (flaginfo->last_bf_index != -1)
  2074.                         {
  2075.                           flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
  2076.                             *indexp;
  2077.  
  2078.                           if ((bfd_size_type) flaginfo->last_bf_index
  2079.                               >= syment_base)
  2080.                             {
  2081.                               void *auxout;
  2082.  
  2083.                               /* The last .bf symbol is in this input
  2084.                                  file.  This will only happen if the
  2085.                                  assembler did not set up the .bf
  2086.                                  endndx symbols correctly.  */
  2087.                               auxout = (flaginfo->outsyms
  2088.                                         + ((flaginfo->last_bf_index
  2089.                                             - syment_base)
  2090.                                            * osymesz));
  2091.  
  2092.                               bfd_coff_swap_aux_out (output_bfd,
  2093.                                                      &flaginfo->last_bf,
  2094.                                                      isymp->n_type,
  2095.                                                      isymp->n_sclass,
  2096.                                                      0, isymp->n_numaux,
  2097.                                                      auxout);
  2098.                             }
  2099.                           else
  2100.                             {
  2101.                               file_ptr pos;
  2102.  
  2103.                               /* We have already written out the last
  2104.                                  .bf aux entry.  We need to write it
  2105.                                  out again.  We borrow *outsym
  2106.                                  temporarily.  FIXME: This case should
  2107.                                  be made faster.  */
  2108.                               bfd_coff_swap_aux_out (output_bfd,
  2109.                                                      &flaginfo->last_bf,
  2110.                                                      isymp->n_type,
  2111.                                                      isymp->n_sclass,
  2112.                                                      0, isymp->n_numaux,
  2113.                                                      outsym);
  2114.                               pos = obj_sym_filepos (output_bfd);
  2115.                               pos += flaginfo->last_bf_index * osymesz;
  2116.                               if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
  2117.                                   || (bfd_bwrite (outsym, osymesz, output_bfd)
  2118.                                       != osymesz))
  2119.                                 return FALSE;
  2120.                             }
  2121.                         }
  2122.  
  2123.                       if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
  2124.                         flaginfo->last_bf_index = -1;
  2125.                       else
  2126.                         {
  2127.                           /* The endndx field of this aux entry must
  2128.                              be updated with the symbol number of the
  2129.                              next .bf symbol.  */
  2130.                           flaginfo->last_bf = *auxp;
  2131.                           flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
  2132.                                                    / osymesz)
  2133.                                                   + syment_base);
  2134.                         }
  2135.                     }
  2136.                 }
  2137.  
  2138.               if (h == NULL)
  2139.                 {
  2140.                   bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
  2141.                                          isymp->n_sclass, i, isymp->n_numaux,
  2142.                                          outsym);
  2143.                   outsym += osymesz;
  2144.                 }
  2145.  
  2146.               esym += isymesz;
  2147.             }
  2148.         }
  2149.  
  2150.       indexp += add;
  2151.       isymp += add;
  2152.       sym_hash += add;
  2153.     }
  2154.  
  2155.   /* Relocate the line numbers, unless we are stripping them.  */
  2156.   if (flaginfo->info->strip == strip_none
  2157.       || flaginfo->info->strip == strip_some)
  2158.     {
  2159.       for (o = input_bfd->sections; o != NULL; o = o->next)
  2160.         {
  2161.           bfd_vma offset;
  2162.           bfd_byte *eline;
  2163.           bfd_byte *elineend;
  2164.           bfd_byte *oeline;
  2165.           bfd_boolean skipping;
  2166.           file_ptr pos;
  2167.           bfd_size_type amt;
  2168.  
  2169.           /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
  2170.              build_link_order in ldwrite.c will not have created a
  2171.              link order, which means that we will not have seen this
  2172.              input section in _bfd_coff_final_link, which means that
  2173.              we will not have allocated space for the line numbers of
  2174.              this section.  I don't think line numbers can be
  2175.              meaningful for a section which does not have
  2176.              SEC_HAS_CONTENTS set, but, if they do, this must be
  2177.              changed.  */
  2178.           if (o->lineno_count == 0
  2179.               || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
  2180.             continue;
  2181.  
  2182.           if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
  2183.               || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
  2184.                            input_bfd) != linesz * o->lineno_count)
  2185.             return FALSE;
  2186.  
  2187.           offset = o->output_section->vma + o->output_offset - o->vma;
  2188.           eline = flaginfo->linenos;
  2189.           oeline = flaginfo->linenos;
  2190.           elineend = eline + linesz * o->lineno_count;
  2191.           skipping = FALSE;
  2192.           for (; eline < elineend; eline += linesz)
  2193.             {
  2194.               struct internal_lineno iline;
  2195.  
  2196.               bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
  2197.  
  2198.               if (iline.l_lnno != 0)
  2199.                 iline.l_addr.l_paddr += offset;
  2200.               else if (iline.l_addr.l_symndx >= 0
  2201.                        && ((unsigned long) iline.l_addr.l_symndx
  2202.                            < obj_raw_syment_count (input_bfd)))
  2203.                 {
  2204.                   long indx;
  2205.  
  2206.                   indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
  2207.  
  2208.                   if (indx < 0)
  2209.                     {
  2210.                       /* These line numbers are attached to a symbol
  2211.                          which we are stripping.  We must discard the
  2212.                          line numbers because reading them back with
  2213.                          no associated symbol (or associating them all
  2214.                          with symbol #0) will fail.  We can't regain
  2215.                          the space in the output file, but at least
  2216.                          they're dense.  */
  2217.                       skipping = TRUE;
  2218.                     }
  2219.                   else
  2220.                     {
  2221.                       struct internal_syment is;
  2222.                       union internal_auxent ia;
  2223.  
  2224.                       /* Fix up the lnnoptr field in the aux entry of
  2225.                          the symbol.  It turns out that we can't do
  2226.                          this when we modify the symbol aux entries,
  2227.                          because gas sometimes screws up the lnnoptr
  2228.                          field and makes it an offset from the start
  2229.                          of the line numbers rather than an absolute
  2230.                          file index.  */
  2231.                       bfd_coff_swap_sym_in (output_bfd,
  2232.                                             (flaginfo->outsyms
  2233.                                              + ((indx - syment_base)
  2234.                                                 * osymesz)), &is);
  2235.                       if ((ISFCN (is.n_type)
  2236.                            || is.n_sclass == C_BLOCK)
  2237.                           && is.n_numaux >= 1)
  2238.                         {
  2239.                           void *auxptr;
  2240.  
  2241.                           auxptr = (flaginfo->outsyms
  2242.                                     + ((indx - syment_base + 1)
  2243.                                        * osymesz));
  2244.                           bfd_coff_swap_aux_in (output_bfd, auxptr,
  2245.                                                 is.n_type, is.n_sclass,
  2246.                                                 0, is.n_numaux, &ia);
  2247.                           ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
  2248.                             (o->output_section->line_filepos
  2249.                              + o->output_section->lineno_count * linesz
  2250.                              + eline - flaginfo->linenos);
  2251.                           bfd_coff_swap_aux_out (output_bfd, &ia,
  2252.                                                  is.n_type, is.n_sclass, 0,
  2253.                                                  is.n_numaux, auxptr);
  2254.                         }
  2255.  
  2256.                       skipping = FALSE;
  2257.                     }
  2258.  
  2259.                   iline.l_addr.l_symndx = indx;
  2260.                 }
  2261.  
  2262.               if (!skipping)
  2263.                 {
  2264.                   bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
  2265.                   oeline += linesz;
  2266.                 }
  2267.             }
  2268.  
  2269.           pos = o->output_section->line_filepos;
  2270.           pos += o->output_section->lineno_count * linesz;
  2271.           amt = oeline - flaginfo->linenos;
  2272.           if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
  2273.               || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
  2274.             return FALSE;
  2275.  
  2276.           o->output_section->lineno_count += amt / linesz;
  2277.         }
  2278.     }
  2279.  
  2280.   /* If we swapped out a C_FILE symbol, guess that the next C_FILE
  2281.      symbol will be the first symbol in the next input file.  In the
  2282.      normal case, this will save us from writing out the C_FILE symbol
  2283.      again.  */
  2284.   if (flaginfo->last_file_index != -1
  2285.       && (bfd_size_type) flaginfo->last_file_index >= syment_base)
  2286.     {
  2287.       flaginfo->last_file.n_value = output_index;
  2288.       bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
  2289.                              (flaginfo->outsyms
  2290.                               + ((flaginfo->last_file_index - syment_base)
  2291.                                  * osymesz)));
  2292.     }
  2293.  
  2294.   /* Write the modified symbols to the output file.  */
  2295.   if (outsym > flaginfo->outsyms)
  2296.     {
  2297.       file_ptr pos;
  2298.       bfd_size_type amt;
  2299.  
  2300.       pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
  2301.       amt = outsym - flaginfo->outsyms;
  2302.       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
  2303.           || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
  2304.         return FALSE;
  2305.  
  2306.       BFD_ASSERT ((obj_raw_syment_count (output_bfd)
  2307.                    + (outsym - flaginfo->outsyms) / osymesz)
  2308.                   == output_index);
  2309.  
  2310.       obj_raw_syment_count (output_bfd) = output_index;
  2311.     }
  2312.  
  2313.   /* Relocate the contents of each section.  */
  2314.   adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
  2315.   for (o = input_bfd->sections; o != NULL; o = o->next)
  2316.     {
  2317.       bfd_byte *contents;
  2318.       struct coff_section_tdata *secdata;
  2319.  
  2320.       if (! o->linker_mark)
  2321.         /* This section was omitted from the link.  */
  2322.         continue;
  2323.  
  2324.       if ((o->flags & SEC_LINKER_CREATED) != 0)
  2325.         continue;
  2326.  
  2327.       if ((o->flags & SEC_HAS_CONTENTS) == 0
  2328.           || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
  2329.         {
  2330.           if ((o->flags & SEC_RELOC) != 0
  2331.               && o->reloc_count != 0)
  2332.             {
  2333.               (*_bfd_error_handler)
  2334.                 (_("%B: relocs in section `%A', but it has no contents"),
  2335.                  input_bfd, o);
  2336.               bfd_set_error (bfd_error_no_contents);
  2337.               return FALSE;
  2338.             }
  2339.  
  2340.           continue;
  2341.         }
  2342.  
  2343.       secdata = coff_section_data (input_bfd, o);
  2344.       if (secdata != NULL && secdata->contents != NULL)
  2345.         contents = secdata->contents;
  2346.       else
  2347.         {
  2348.           contents = flaginfo->contents;
  2349.           if (! bfd_get_full_section_contents (input_bfd, o, &contents))
  2350.             return FALSE;
  2351.         }
  2352.  
  2353.       if ((o->flags & SEC_RELOC) != 0)
  2354.         {
  2355.           int target_index;
  2356.           struct internal_reloc *internal_relocs;
  2357.           struct internal_reloc *irel;
  2358.  
  2359.           /* Read in the relocs.  */
  2360.           target_index = o->output_section->target_index;
  2361.           internal_relocs = (_bfd_coff_read_internal_relocs
  2362.                              (input_bfd, o, FALSE, flaginfo->external_relocs,
  2363.                               bfd_link_relocatable (flaginfo->info),
  2364.                               (bfd_link_relocatable (flaginfo->info)
  2365.                                ? (flaginfo->section_info[target_index].relocs
  2366.                                   + o->output_section->reloc_count)
  2367.                                : flaginfo->internal_relocs)));
  2368.           if (internal_relocs == NULL
  2369.               && o->reloc_count > 0)
  2370.             return FALSE;
  2371.  
  2372.           /* Run through the relocs looking for relocs against symbols
  2373.              coming from discarded sections and complain about them.  */
  2374.           irel = internal_relocs;
  2375.           for (; irel < &internal_relocs[o->reloc_count]; irel++)
  2376.             {
  2377.               struct coff_link_hash_entry *h;
  2378.               asection *ps = NULL;
  2379.               long symndx = irel->r_symndx;
  2380.               if (symndx < 0)
  2381.                 continue;
  2382.               h = obj_coff_sym_hashes (input_bfd)[symndx];
  2383.               if (h == NULL)
  2384.                 continue;
  2385.               while (h->root.type == bfd_link_hash_indirect
  2386.                      || h->root.type == bfd_link_hash_warning)
  2387.                 h = (struct coff_link_hash_entry *) h->root.u.i.link;
  2388.               if (h->root.type == bfd_link_hash_defined
  2389.                   || h->root.type == bfd_link_hash_defweak)
  2390.                 ps = h->root.u.def.section;
  2391.               if (ps == NULL)
  2392.                 continue;
  2393.               /* Complain if definition comes from an excluded section.  */
  2394.               if (ps->flags & SEC_EXCLUDE)
  2395.                 (*flaginfo->info->callbacks->einfo)
  2396.                   (_("%X`%s' referenced in section `%A' of %B: "
  2397.                      "defined in discarded section `%A' of %B\n"),
  2398.                    h->root.root.string, o, input_bfd, ps, ps->owner);
  2399.             }
  2400.  
  2401.           /* Call processor specific code to relocate the section
  2402.              contents.  */
  2403.           if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
  2404.                                            input_bfd, o,
  2405.                                            contents,
  2406.                                            internal_relocs,
  2407.                                            flaginfo->internal_syms,
  2408.                                            flaginfo->sec_ptrs))
  2409.             return FALSE;
  2410.  
  2411.           if (bfd_link_relocatable (flaginfo->info))
  2412.             {
  2413.               bfd_vma offset;
  2414.               struct internal_reloc *irelend;
  2415.               struct coff_link_hash_entry **rel_hash;
  2416.  
  2417.               offset = o->output_section->vma + o->output_offset - o->vma;
  2418.               irel = internal_relocs;
  2419.               irelend = irel + o->reloc_count;
  2420.               rel_hash = (flaginfo->section_info[target_index].rel_hashes
  2421.                           + o->output_section->reloc_count);
  2422.               for (; irel < irelend; irel++, rel_hash++)
  2423.                 {
  2424.                   struct coff_link_hash_entry *h;
  2425.                   bfd_boolean adjusted;
  2426.  
  2427.                   *rel_hash = NULL;
  2428.  
  2429.                   /* Adjust the reloc address and symbol index.  */
  2430.                   irel->r_vaddr += offset;
  2431.  
  2432.                   if (irel->r_symndx == -1)
  2433.                     continue;
  2434.  
  2435.                   if (adjust_symndx)
  2436.                     {
  2437.                       if (! (*adjust_symndx) (output_bfd, flaginfo->info,
  2438.                                               input_bfd, o, irel,
  2439.                                               &adjusted))
  2440.                         return FALSE;
  2441.                       if (adjusted)
  2442.                         continue;
  2443.                     }
  2444.  
  2445.                   h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
  2446.                   if (h != NULL)
  2447.                     {
  2448.                       /* This is a global symbol.  */
  2449.                       if (h->indx >= 0)
  2450.                         irel->r_symndx = h->indx;
  2451.                       else
  2452.                         {
  2453.                           /* This symbol is being written at the end
  2454.                              of the file, and we do not yet know the
  2455.                              symbol index.  We save the pointer to the
  2456.                              hash table entry in the rel_hash list.
  2457.                              We set the indx field to -2 to indicate
  2458.                              that this symbol must not be stripped.  */
  2459.                           *rel_hash = h;
  2460.                           h->indx = -2;
  2461.                         }
  2462.                     }
  2463.                   else
  2464.                     {
  2465.                       long indx;
  2466.  
  2467.                       indx = flaginfo->sym_indices[irel->r_symndx];
  2468.                       if (indx != -1)
  2469.                         irel->r_symndx = indx;
  2470.                       else
  2471.                         {
  2472.                           struct internal_syment *is;
  2473.                           const char *name;
  2474.                           char buf[SYMNMLEN + 1];
  2475.  
  2476.                           /* This reloc is against a symbol we are
  2477.                              stripping.  This should have been handled
  2478.                              by the 'dont_skip_symbol' code in the while
  2479.                              loop at the top of this function.  */
  2480.                           is = flaginfo->internal_syms + irel->r_symndx;
  2481.  
  2482.                           name = (_bfd_coff_internal_syment_name
  2483.                                   (input_bfd, is, buf));
  2484.                           if (name == NULL)
  2485.                             return FALSE;
  2486.  
  2487.                           if (! ((*flaginfo->info->callbacks->unattached_reloc)
  2488.                                  (flaginfo->info, name, input_bfd, o,
  2489.                                   irel->r_vaddr)))
  2490.                             return FALSE;
  2491.                         }
  2492.                     }
  2493.                 }
  2494.  
  2495.               o->output_section->reloc_count += o->reloc_count;
  2496.             }
  2497.         }
  2498.  
  2499.       /* Write out the modified section contents.  */
  2500.       if (secdata == NULL || secdata->stab_info == NULL)
  2501.         {
  2502.           file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
  2503.           if (! bfd_set_section_contents (output_bfd, o->output_section,
  2504.                                           contents, loc, o->size))
  2505.             return FALSE;
  2506.         }
  2507.       else
  2508.         {
  2509.           if (! (_bfd_write_section_stabs
  2510.                  (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
  2511.                   o, &secdata->stab_info, contents)))
  2512.             return FALSE;
  2513.         }
  2514.     }
  2515.  
  2516.   if (! flaginfo->info->keep_memory
  2517.       && ! _bfd_coff_free_symbols (input_bfd))
  2518.     return FALSE;
  2519.  
  2520.   return TRUE;
  2521. }
  2522.  
  2523. /* Write out a global symbol.  Called via bfd_hash_traverse.  */
  2524.  
  2525. bfd_boolean
  2526. _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
  2527. {
  2528.   struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
  2529.   struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
  2530.   bfd *output_bfd;
  2531.   struct internal_syment isym;
  2532.   bfd_size_type symesz;
  2533.   unsigned int i;
  2534.   file_ptr pos;
  2535.  
  2536.   output_bfd = flaginfo->output_bfd;
  2537.  
  2538.   if (h->root.type == bfd_link_hash_warning)
  2539.     {
  2540.       h = (struct coff_link_hash_entry *) h->root.u.i.link;
  2541.       if (h->root.type == bfd_link_hash_new)
  2542.         return TRUE;
  2543.     }
  2544.  
  2545.   if (h->indx >= 0)
  2546.     return TRUE;
  2547.  
  2548.   if (h->indx != -2
  2549.       && (flaginfo->info->strip == strip_all
  2550.           || (flaginfo->info->strip == strip_some
  2551.               && (bfd_hash_lookup (flaginfo->info->keep_hash,
  2552.                                    h->root.root.string, FALSE, FALSE)
  2553.                   == NULL))))
  2554.     return TRUE;
  2555.  
  2556.   switch (h->root.type)
  2557.     {
  2558.     default:
  2559.     case bfd_link_hash_new:
  2560.     case bfd_link_hash_warning:
  2561.       abort ();
  2562.       return FALSE;
  2563.  
  2564.     case bfd_link_hash_undefined:
  2565.     case bfd_link_hash_undefweak:
  2566.       isym.n_scnum = N_UNDEF;
  2567.       isym.n_value = 0;
  2568.       break;
  2569.  
  2570.     case bfd_link_hash_defined:
  2571.     case bfd_link_hash_defweak:
  2572.       {
  2573.         asection *sec;
  2574.  
  2575.         sec = h->root.u.def.section->output_section;
  2576.         if (bfd_is_abs_section (sec))
  2577.           isym.n_scnum = N_ABS;
  2578.         else
  2579.           isym.n_scnum = sec->target_index;
  2580.         isym.n_value = (h->root.u.def.value
  2581.                         + h->root.u.def.section->output_offset);
  2582.         if (! obj_pe (flaginfo->output_bfd))
  2583.           isym.n_value += sec->vma;
  2584.       }
  2585.       break;
  2586.  
  2587.     case bfd_link_hash_common:
  2588.       isym.n_scnum = N_UNDEF;
  2589.       isym.n_value = h->root.u.c.size;
  2590.       break;
  2591.  
  2592.     case bfd_link_hash_indirect:
  2593.       /* Just ignore these.  They can't be handled anyhow.  */
  2594.       return TRUE;
  2595.     }
  2596.  
  2597.   if (strlen (h->root.root.string) <= SYMNMLEN)
  2598.     strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
  2599.   else
  2600.     {
  2601.       bfd_boolean hash;
  2602.       bfd_size_type indx;
  2603.  
  2604.       hash = TRUE;
  2605.       if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
  2606.         hash = FALSE;
  2607.       indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
  2608.                                  FALSE);
  2609.       if (indx == (bfd_size_type) -1)
  2610.         {
  2611.           flaginfo->failed = TRUE;
  2612.           return FALSE;
  2613.         }
  2614.       isym._n._n_n._n_zeroes = 0;
  2615.       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
  2616.     }
  2617.  
  2618.   isym.n_sclass = h->symbol_class;
  2619.   isym.n_type = h->type;
  2620.  
  2621.   if (isym.n_sclass == C_NULL)
  2622.     isym.n_sclass = C_EXT;
  2623.  
  2624.   /* If doing task linking and this is the pass where we convert
  2625.      defined globals to statics, then do that conversion now.  If the
  2626.      symbol is not being converted, just ignore it and it will be
  2627.      output during a later pass.  */
  2628.   if (flaginfo->global_to_static)
  2629.     {
  2630.       if (! IS_EXTERNAL (output_bfd, isym))
  2631.         return TRUE;
  2632.  
  2633.       isym.n_sclass = C_STAT;
  2634.     }
  2635.  
  2636.   /* When a weak symbol is not overridden by a strong one,
  2637.      turn it into an external symbol when not building a
  2638.      shared or relocatable object.  */
  2639.   if (! bfd_link_pic (flaginfo->info)
  2640.       && ! bfd_link_relocatable (flaginfo->info)
  2641.       && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
  2642.     isym.n_sclass = C_EXT;
  2643.  
  2644.   isym.n_numaux = h->numaux;
  2645.  
  2646.   bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
  2647.  
  2648.   symesz = bfd_coff_symesz (output_bfd);
  2649.  
  2650.   pos = obj_sym_filepos (output_bfd);
  2651.   pos += obj_raw_syment_count (output_bfd) * symesz;
  2652.   if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
  2653.       || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
  2654.     {
  2655.       flaginfo->failed = TRUE;
  2656.       return FALSE;
  2657.     }
  2658.  
  2659.   h->indx = obj_raw_syment_count (output_bfd);
  2660.  
  2661.   ++obj_raw_syment_count (output_bfd);
  2662.  
  2663.   /* Write out any associated aux entries.  Most of the aux entries
  2664.      will have been modified in _bfd_coff_link_input_bfd.  We have to
  2665.      handle section aux entries here, now that we have the final
  2666.      relocation and line number counts.  */
  2667.   for (i = 0; i < isym.n_numaux; i++)
  2668.     {
  2669.       union internal_auxent *auxp;
  2670.  
  2671.       auxp = h->aux + i;
  2672.  
  2673.       /* Look for a section aux entry here using the same tests that
  2674.          coff_swap_aux_out uses.  */
  2675.       if (i == 0
  2676.           && (isym.n_sclass == C_STAT
  2677.               || isym.n_sclass == C_HIDDEN)
  2678.           && isym.n_type == T_NULL
  2679.           && (h->root.type == bfd_link_hash_defined
  2680.               || h->root.type == bfd_link_hash_defweak))
  2681.         {
  2682.           asection *sec;
  2683.  
  2684.           sec = h->root.u.def.section->output_section;
  2685.           if (sec != NULL)
  2686.             {
  2687.               auxp->x_scn.x_scnlen = sec->size;
  2688.  
  2689.               /* For PE, an overflow on the final link reportedly does
  2690.                  not matter.  FIXME: Why not?  */
  2691.               if (sec->reloc_count > 0xffff
  2692.                   && (! obj_pe (output_bfd)
  2693.                       || bfd_link_relocatable (flaginfo->info)))
  2694.                 (*_bfd_error_handler)
  2695.                   (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
  2696.                    bfd_get_filename (output_bfd),
  2697.                    bfd_get_section_name (output_bfd, sec),
  2698.                    sec->reloc_count);
  2699.  
  2700.               if (sec->lineno_count > 0xffff
  2701.                   && (! obj_pe (output_bfd)
  2702.                       || bfd_link_relocatable (flaginfo->info)))
  2703.                 (*_bfd_error_handler)
  2704.                   (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
  2705.                    bfd_get_filename (output_bfd),
  2706.                    bfd_get_section_name (output_bfd, sec),
  2707.                    sec->lineno_count);
  2708.  
  2709.               auxp->x_scn.x_nreloc = sec->reloc_count;
  2710.               auxp->x_scn.x_nlinno = sec->lineno_count;
  2711.               auxp->x_scn.x_checksum = 0;
  2712.               auxp->x_scn.x_associated = 0;
  2713.               auxp->x_scn.x_comdat = 0;
  2714.             }
  2715.         }
  2716.  
  2717.       bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
  2718.                              isym.n_sclass, (int) i, isym.n_numaux,
  2719.                              flaginfo->outsyms);
  2720.       if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
  2721.         {
  2722.           flaginfo->failed = TRUE;
  2723.           return FALSE;
  2724.         }
  2725.       ++obj_raw_syment_count (output_bfd);
  2726.     }
  2727.  
  2728.   return TRUE;
  2729. }
  2730.  
  2731. /* Write out task global symbols, converting them to statics.  Called
  2732.    via coff_link_hash_traverse.  Calls bfd_coff_write_global_sym to do
  2733.    the dirty work, if the symbol we are processing needs conversion.  */
  2734.  
  2735. bfd_boolean
  2736. _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
  2737. {
  2738.   struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
  2739.   bfd_boolean rtnval = TRUE;
  2740.   bfd_boolean save_global_to_static;
  2741.  
  2742.   if (h->root.type == bfd_link_hash_warning)
  2743.     h = (struct coff_link_hash_entry *) h->root.u.i.link;
  2744.  
  2745.   if (h->indx < 0)
  2746.     {
  2747.       switch (h->root.type)
  2748.         {
  2749.         case bfd_link_hash_defined:
  2750.         case bfd_link_hash_defweak:
  2751.           save_global_to_static = flaginfo->global_to_static;
  2752.           flaginfo->global_to_static = TRUE;
  2753.           rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
  2754.           flaginfo->global_to_static = save_global_to_static;
  2755.           break;
  2756.         default:
  2757.           break;
  2758.         }
  2759.     }
  2760.   return (rtnval);
  2761. }
  2762.  
  2763. /* Handle a link order which is supposed to generate a reloc.  */
  2764.  
  2765. bfd_boolean
  2766. _bfd_coff_reloc_link_order (bfd *output_bfd,
  2767.                             struct coff_final_link_info *flaginfo,
  2768.                             asection *output_section,
  2769.                             struct bfd_link_order *link_order)
  2770. {
  2771.   reloc_howto_type *howto;
  2772.   struct internal_reloc *irel;
  2773.   struct coff_link_hash_entry **rel_hash_ptr;
  2774.  
  2775.   howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
  2776.   if (howto == NULL)
  2777.     {
  2778.       bfd_set_error (bfd_error_bad_value);
  2779.       return FALSE;
  2780.     }
  2781.  
  2782.   if (link_order->u.reloc.p->addend != 0)
  2783.     {
  2784.       bfd_size_type size;
  2785.       bfd_byte *buf;
  2786.       bfd_reloc_status_type rstat;
  2787.       bfd_boolean ok;
  2788.       file_ptr loc;
  2789.  
  2790.       size = bfd_get_reloc_size (howto);
  2791.       buf = (bfd_byte *) bfd_zmalloc (size);
  2792.       if (buf == NULL && size != 0)
  2793.         return FALSE;
  2794.  
  2795.       rstat = _bfd_relocate_contents (howto, output_bfd,
  2796.                                       (bfd_vma) link_order->u.reloc.p->addend,\
  2797.                                       buf);
  2798.       switch (rstat)
  2799.         {
  2800.         case bfd_reloc_ok:
  2801.           break;
  2802.         default:
  2803.         case bfd_reloc_outofrange:
  2804.           abort ();
  2805.         case bfd_reloc_overflow:
  2806.           if (! ((*flaginfo->info->callbacks->reloc_overflow)
  2807.                  (flaginfo->info, NULL,
  2808.                   (link_order->type == bfd_section_reloc_link_order
  2809.                    ? bfd_section_name (output_bfd,
  2810.                                        link_order->u.reloc.p->u.section)
  2811.                    : link_order->u.reloc.p->u.name),
  2812.                   howto->name, link_order->u.reloc.p->addend,
  2813.                   (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
  2814.             {
  2815.               free (buf);
  2816.               return FALSE;
  2817.             }
  2818.           break;
  2819.         }
  2820.       loc = link_order->offset * bfd_octets_per_byte (output_bfd);
  2821.       ok = bfd_set_section_contents (output_bfd, output_section, buf,
  2822.                                      loc, size);
  2823.       free (buf);
  2824.       if (! ok)
  2825.         return FALSE;
  2826.     }
  2827.  
  2828.   /* Store the reloc information in the right place.  It will get
  2829.      swapped and written out at the end of the final_link routine.  */
  2830.   irel = (flaginfo->section_info[output_section->target_index].relocs
  2831.           + output_section->reloc_count);
  2832.   rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
  2833.                   + output_section->reloc_count);
  2834.  
  2835.   memset (irel, 0, sizeof (struct internal_reloc));
  2836.   *rel_hash_ptr = NULL;
  2837.  
  2838.   irel->r_vaddr = output_section->vma + link_order->offset;
  2839.  
  2840.   if (link_order->type == bfd_section_reloc_link_order)
  2841.     {
  2842.       /* We need to somehow locate a symbol in the right section.  The
  2843.          symbol must either have a value of zero, or we must adjust
  2844.          the addend by the value of the symbol.  FIXME: Write this
  2845.          when we need it.  The old linker couldn't handle this anyhow.  */
  2846.       abort ();
  2847.       *rel_hash_ptr = NULL;
  2848.       irel->r_symndx = 0;
  2849.     }
  2850.   else
  2851.     {
  2852.       struct coff_link_hash_entry *h;
  2853.  
  2854.       h = ((struct coff_link_hash_entry *)
  2855.            bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
  2856.                                          link_order->u.reloc.p->u.name,
  2857.                                          FALSE, FALSE, TRUE));
  2858.       if (h != NULL)
  2859.         {
  2860.           if (h->indx >= 0)
  2861.             irel->r_symndx = h->indx;
  2862.           else
  2863.             {
  2864.               /* Set the index to -2 to force this symbol to get
  2865.                  written out.  */
  2866.               h->indx = -2;
  2867.               *rel_hash_ptr = h;
  2868.               irel->r_symndx = 0;
  2869.             }
  2870.         }
  2871.       else
  2872.         {
  2873.           if (! ((*flaginfo->info->callbacks->unattached_reloc)
  2874.                  (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
  2875.                   (asection *) NULL, (bfd_vma) 0)))
  2876.             return FALSE;
  2877.           irel->r_symndx = 0;
  2878.         }
  2879.     }
  2880.  
  2881.   /* FIXME: Is this always right?  */
  2882.   irel->r_type = howto->type;
  2883.  
  2884.   /* r_size is only used on the RS/6000, which needs its own linker
  2885.      routines anyhow.  r_extern is only used for ECOFF.  */
  2886.  
  2887.   /* FIXME: What is the right value for r_offset?  Is zero OK?  */
  2888.   ++output_section->reloc_count;
  2889.  
  2890.   return TRUE;
  2891. }
  2892.  
  2893. /* A basic reloc handling routine which may be used by processors with
  2894.    simple relocs.  */
  2895.  
  2896. bfd_boolean
  2897. _bfd_coff_generic_relocate_section (bfd *output_bfd,
  2898.                                     struct bfd_link_info *info,
  2899.                                     bfd *input_bfd,
  2900.                                     asection *input_section,
  2901.                                     bfd_byte *contents,
  2902.                                     struct internal_reloc *relocs,
  2903.                                     struct internal_syment *syms,
  2904.                                     asection **sections)
  2905. {
  2906.   struct internal_reloc *rel;
  2907.   struct internal_reloc *relend;
  2908.  
  2909.   rel = relocs;
  2910.   relend = rel + input_section->reloc_count;
  2911.   for (; rel < relend; rel++)
  2912.     {
  2913.       long symndx;
  2914.       struct coff_link_hash_entry *h;
  2915.       struct internal_syment *sym;
  2916.       bfd_vma addend;
  2917.       bfd_vma val;
  2918.       asection *sec;
  2919.       reloc_howto_type *howto;
  2920.       bfd_reloc_status_type rstat;
  2921.  
  2922.       symndx = rel->r_symndx;
  2923.  
  2924.       if (symndx == -1)
  2925.         {
  2926.           h = NULL;
  2927.           sym = NULL;
  2928.         }
  2929.       else if (symndx < 0
  2930.                || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
  2931.         {
  2932.           (*_bfd_error_handler)
  2933.             ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
  2934.           return FALSE;
  2935.         }
  2936.       else
  2937.         {
  2938.           h = obj_coff_sym_hashes (input_bfd)[symndx];
  2939.           sym = syms + symndx;
  2940.         }
  2941.  
  2942.       /* COFF treats common symbols in one of two ways.  Either the
  2943.          size of the symbol is included in the section contents, or it
  2944.          is not.  We assume that the size is not included, and force
  2945.          the rtype_to_howto function to adjust the addend as needed.  */
  2946.       if (sym != NULL && sym->n_scnum != 0)
  2947.         addend = - sym->n_value;
  2948.       else
  2949.         addend = 0;
  2950.  
  2951.       howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
  2952.                                        sym, &addend);
  2953.       if (howto == NULL)
  2954.         return FALSE;
  2955.  
  2956.       /* If we are doing a relocatable link, then we can just ignore
  2957.          a PC relative reloc that is pcrel_offset.  It will already
  2958.          have the correct value.  If this is not a relocatable link,
  2959.          then we should ignore the symbol value.  */
  2960.       if (howto->pc_relative && howto->pcrel_offset)
  2961.         {
  2962.           if (bfd_link_relocatable (info))
  2963.             continue;
  2964.           if (sym != NULL && sym->n_scnum != 0)
  2965.             addend += sym->n_value;
  2966.         }
  2967.  
  2968.       val = 0;
  2969.       sec = NULL;
  2970.       if (h == NULL)
  2971.         {
  2972.           if (symndx == -1)
  2973.             {
  2974.               sec = bfd_abs_section_ptr;
  2975.               val = 0;
  2976.             }
  2977.           else
  2978.             {
  2979.               sec = sections[symndx];
  2980.               val = (sec->output_section->vma
  2981.                      + sec->output_offset
  2982.                      + sym->n_value);
  2983.               if (! obj_pe (input_bfd))
  2984.                 val -= sec->vma;
  2985.             }
  2986.         }
  2987.       else
  2988.         {
  2989.           if (h->root.type == bfd_link_hash_defined
  2990.               || h->root.type == bfd_link_hash_defweak)
  2991.             {
  2992.               /* Defined weak symbols are a GNU extension. */
  2993.               sec = h->root.u.def.section;
  2994.               val = (h->root.u.def.value
  2995.                      + sec->output_section->vma
  2996.                      + sec->output_offset);
  2997.             }
  2998.  
  2999.           else if (h->root.type == bfd_link_hash_undefweak)
  3000.             {
  3001.               if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
  3002.                 {
  3003.                   /* See _Microsoft Portable Executable and Common Object
  3004.                      File Format Specification_, section 5.5.3.
  3005.                      Note that weak symbols without aux records are a GNU
  3006.                      extension.
  3007.                      FIXME: All weak externals are treated as having
  3008.                      characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
  3009.                      These behave as per SVR4 ABI:  A library member
  3010.                      will resolve a weak external only if a normal
  3011.                      external causes the library member to be linked.
  3012.                      See also linker.c: generic_link_check_archive_element. */
  3013.                   struct coff_link_hash_entry *h2 =
  3014.                     h->auxbfd->tdata.coff_obj_data->sym_hashes[
  3015.                     h->aux->x_sym.x_tagndx.l];
  3016.  
  3017.                   if (!h2 || h2->root.type == bfd_link_hash_undefined)
  3018.                     {
  3019.                       sec = bfd_abs_section_ptr;
  3020.                       val = 0;
  3021.                     }
  3022.                   else
  3023.                     {
  3024.                       sec = h2->root.u.def.section;
  3025.                       val = h2->root.u.def.value
  3026.                         + sec->output_section->vma + sec->output_offset;
  3027.                     }
  3028.                 }
  3029.               else
  3030.                 /* This is a GNU extension.  */
  3031.                 val = 0;
  3032.             }
  3033.  
  3034.           else if (! bfd_link_relocatable (info))
  3035.             {
  3036.               if (! ((*info->callbacks->undefined_symbol)
  3037.                      (info, h->root.root.string, input_bfd, input_section,
  3038.                       rel->r_vaddr - input_section->vma, TRUE)))
  3039.                 return FALSE;
  3040.             }
  3041.         }
  3042.  
  3043.       /* If the input section defining the symbol has been discarded
  3044.          then zero this reloc field.  */
  3045.       if (sec != NULL && discarded_section (sec))
  3046.         {
  3047.           _bfd_clear_contents (howto, input_bfd, input_section,
  3048.                                contents + (rel->r_vaddr - input_section->vma));
  3049.           continue;
  3050.         }
  3051.  
  3052.       if (info->base_file)
  3053.         {
  3054.           /* Emit a reloc if the backend thinks it needs it.  */
  3055.           if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
  3056.             {
  3057.               /* Relocation to a symbol in a section which isn't
  3058.                  absolute.  We output the address here to a file.
  3059.                  This file is then read by dlltool when generating the
  3060.                  reloc section.  Note that the base file is not
  3061.                  portable between systems.  We write out a bfd_vma here,
  3062.                  and dlltool reads in a bfd_vma.  */
  3063.               bfd_vma addr = (rel->r_vaddr
  3064.                            - input_section->vma
  3065.                            + input_section->output_offset
  3066.                            + input_section->output_section->vma);
  3067.               if (coff_data (output_bfd)->pe)
  3068.                 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
  3069.               if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
  3070.                   != sizeof (bfd_vma))
  3071.                 {
  3072.                   bfd_set_error (bfd_error_system_call);
  3073.                   return FALSE;
  3074.                 }
  3075.             }
  3076.         }
  3077.  
  3078.       rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
  3079.                                         contents,
  3080.                                         rel->r_vaddr - input_section->vma,
  3081.                                         val, addend);
  3082.  
  3083.       switch (rstat)
  3084.         {
  3085.         default:
  3086.           abort ();
  3087.         case bfd_reloc_ok:
  3088.           break;
  3089.         case bfd_reloc_outofrange:
  3090.           (*_bfd_error_handler)
  3091.             (_("%B: bad reloc address 0x%lx in section `%A'"),
  3092.              input_bfd, input_section, (unsigned long) rel->r_vaddr);
  3093.           return FALSE;
  3094.         case bfd_reloc_overflow:
  3095.           {
  3096.             const char *name;
  3097.             char buf[SYMNMLEN + 1];
  3098.  
  3099.             if (symndx == -1)
  3100.               name = "*ABS*";
  3101.             else if (h != NULL)
  3102.               name = NULL;
  3103.             else
  3104.               {
  3105.                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
  3106.                 if (name == NULL)
  3107.                   return FALSE;
  3108.               }
  3109.  
  3110.             if (! ((*info->callbacks->reloc_overflow)
  3111.                    (info, (h ? &h->root : NULL), name, howto->name,
  3112.                     (bfd_vma) 0, input_bfd, input_section,
  3113.                     rel->r_vaddr - input_section->vma)))
  3114.               return FALSE;
  3115.           }
  3116.         }
  3117.     }
  3118.   return TRUE;
  3119. }
  3120.