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