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