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