Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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