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