2009-12-02 Rafael Avila de Espindola <espindola@google.com>
[binutils.git] / bfd / cofflink.c
bloba29b68795049c613d865f8133a02dcded1485cbf
1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009 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)
202 bfd_size_type symesz;
203 bfd_byte *esym;
204 bfd_byte *esym_end;
206 *pneeded = FALSE;
208 symesz = bfd_coff_symesz (abfd);
209 esym = (bfd_byte *) obj_coff_external_syms (abfd);
210 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
211 while (esym < esym_end)
213 struct internal_syment sym;
214 enum coff_symbol_classification classification;
216 bfd_coff_swap_sym_in (abfd, esym, &sym);
218 classification = bfd_coff_classify_symbol (abfd, &sym);
219 if (classification == COFF_SYMBOL_GLOBAL
220 || classification == COFF_SYMBOL_COMMON)
222 const char *name;
223 char buf[SYMNMLEN + 1];
224 struct bfd_link_hash_entry *h;
226 /* This symbol is externally visible, and is defined by this
227 object file. */
228 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
229 if (name == NULL)
230 return FALSE;
231 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
233 /* Auto import. */
234 if (!h
235 && info->pei386_auto_import
236 && CONST_STRNEQ (name, "__imp_"))
237 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
239 /* We are only interested in symbols that are currently
240 undefined. If a symbol is currently known to be common,
241 COFF linkers do not bring in an object file which defines
242 it. */
243 if (h != (struct bfd_link_hash_entry *) NULL
244 && h->type == bfd_link_hash_undefined)
246 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
247 return FALSE;
248 *pneeded = TRUE;
249 return TRUE;
253 esym += (sym.n_numaux + 1) * symesz;
256 /* We do not need this object file. */
257 return TRUE;
260 /* Check a single archive element to see if we need to include it in
261 the link. *PNEEDED is set according to whether this element is
262 needed in the link or not. This is called via
263 _bfd_generic_link_add_archive_symbols. */
265 static bfd_boolean
266 coff_link_check_archive_element (bfd *abfd,
267 struct bfd_link_info *info,
268 bfd_boolean *pneeded)
270 if (! _bfd_coff_get_external_symbols (abfd))
271 return FALSE;
273 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
274 return FALSE;
276 if (*pneeded
277 && ! coff_link_add_symbols (abfd, info))
278 return FALSE;
280 if ((! info->keep_memory || ! *pneeded)
281 && ! _bfd_coff_free_symbols (abfd))
282 return FALSE;
284 return TRUE;
287 /* Add all the symbols from an object file to the hash table. */
289 static bfd_boolean
290 coff_link_add_symbols (bfd *abfd,
291 struct bfd_link_info *info)
293 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
294 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
295 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
296 bfd_boolean keep_syms;
297 bfd_boolean default_copy;
298 bfd_size_type symcount;
299 struct coff_link_hash_entry **sym_hash;
300 bfd_size_type symesz;
301 bfd_byte *esym;
302 bfd_byte *esym_end;
303 bfd_size_type amt;
305 symcount = obj_raw_syment_count (abfd);
307 if (symcount == 0)
308 return TRUE; /* Nothing to do. */
310 /* Keep the symbols during this function, in case the linker needs
311 to read the generic symbols in order to report an error message. */
312 keep_syms = obj_coff_keep_syms (abfd);
313 obj_coff_keep_syms (abfd) = TRUE;
315 if (info->keep_memory)
316 default_copy = FALSE;
317 else
318 default_copy = TRUE;
320 /* We keep a list of the linker hash table entries that correspond
321 to particular symbols. */
322 amt = symcount * sizeof (struct coff_link_hash_entry *);
323 sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
324 if (sym_hash == NULL)
325 goto error_return;
326 obj_coff_sym_hashes (abfd) = sym_hash;
328 symesz = bfd_coff_symesz (abfd);
329 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
330 esym = (bfd_byte *) obj_coff_external_syms (abfd);
331 esym_end = esym + symcount * symesz;
332 while (esym < esym_end)
334 struct internal_syment sym;
335 enum coff_symbol_classification classification;
336 bfd_boolean copy;
338 bfd_coff_swap_sym_in (abfd, esym, &sym);
340 classification = bfd_coff_classify_symbol (abfd, &sym);
341 if (classification != COFF_SYMBOL_LOCAL)
343 const char *name;
344 char buf[SYMNMLEN + 1];
345 flagword flags;
346 asection *section;
347 bfd_vma value;
348 bfd_boolean addit;
350 /* This symbol is externally visible. */
352 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
353 if (name == NULL)
354 goto error_return;
356 /* We must copy the name into memory if we got it from the
357 syment itself, rather than the string table. */
358 copy = default_copy;
359 if (sym._n._n_n._n_zeroes != 0
360 || sym._n._n_n._n_offset == 0)
361 copy = TRUE;
363 value = sym.n_value;
365 switch (classification)
367 default:
368 abort ();
370 case COFF_SYMBOL_GLOBAL:
371 flags = BSF_EXPORT | BSF_GLOBAL;
372 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
373 if (! obj_pe (abfd))
374 value -= section->vma;
375 break;
377 case COFF_SYMBOL_UNDEFINED:
378 flags = 0;
379 section = bfd_und_section_ptr;
380 break;
382 case COFF_SYMBOL_COMMON:
383 flags = BSF_GLOBAL;
384 section = bfd_com_section_ptr;
385 break;
387 case COFF_SYMBOL_PE_SECTION:
388 flags = BSF_SECTION_SYM | BSF_GLOBAL;
389 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
390 break;
393 if (IS_WEAK_EXTERNAL (abfd, sym))
394 flags = BSF_WEAK;
396 addit = TRUE;
398 /* In the PE format, section symbols actually refer to the
399 start of the output section. We handle them specially
400 here. */
401 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
403 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
404 name, FALSE, copy, FALSE);
405 if (*sym_hash != NULL)
407 if (((*sym_hash)->coff_link_hash_flags
408 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
409 && (*sym_hash)->root.type != bfd_link_hash_undefined
410 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
411 (*_bfd_error_handler)
412 ("Warning: symbol `%s' is both section and non-section",
413 name);
415 addit = FALSE;
419 /* The Microsoft Visual C compiler does string pooling by
420 hashing the constants to an internal symbol name, and
421 relying on the linker comdat support to discard
422 duplicate names. However, if one string is a literal and
423 one is a data initializer, one will end up in the .data
424 section and one will end up in the .rdata section. The
425 Microsoft linker will combine them into the .data
426 section, which seems to be wrong since it might cause the
427 literal to change.
429 As long as there are no external references to the
430 symbols, which there shouldn't be, we can treat the .data
431 and .rdata instances as separate symbols. The comdat
432 code in the linker will do the appropriate merging. Here
433 we avoid getting a multiple definition error for one of
434 these special symbols.
436 FIXME: I don't think this will work in the case where
437 there are two object files which use the constants as a
438 literal and two object files which use it as a data
439 initializer. One or the other of the second object files
440 is going to wind up with an inappropriate reference. */
441 if (obj_pe (abfd)
442 && (classification == COFF_SYMBOL_GLOBAL
443 || classification == COFF_SYMBOL_PE_SECTION)
444 && coff_section_data (abfd, section) != NULL
445 && coff_section_data (abfd, section)->comdat != NULL
446 && CONST_STRNEQ (name, "??_")
447 && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
449 if (*sym_hash == NULL)
450 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
451 name, FALSE, copy, FALSE);
452 if (*sym_hash != NULL
453 && (*sym_hash)->root.type == bfd_link_hash_defined
454 && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
455 && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
456 coff_section_data (abfd, section)->comdat->name) == 0)
457 addit = FALSE;
460 if (addit)
462 if (! (bfd_coff_link_add_one_symbol
463 (info, abfd, name, flags, section, value,
464 (const char *) NULL, copy, FALSE,
465 (struct bfd_link_hash_entry **) sym_hash)))
466 goto error_return;
469 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
470 (*sym_hash)->coff_link_hash_flags |=
471 COFF_LINK_HASH_PE_SECTION_SYMBOL;
473 /* Limit the alignment of a common symbol to the possible
474 alignment of a section. There is no point to permitting
475 a higher alignment for a common symbol: we can not
476 guarantee it, and it may cause us to allocate extra space
477 in the common section. */
478 if (section == bfd_com_section_ptr
479 && (*sym_hash)->root.type == bfd_link_hash_common
480 && ((*sym_hash)->root.u.c.p->alignment_power
481 > bfd_coff_default_section_alignment_power (abfd)))
482 (*sym_hash)->root.u.c.p->alignment_power
483 = bfd_coff_default_section_alignment_power (abfd);
485 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))
487 /* If we don't have any symbol information currently in
488 the hash table, or if we are looking at a symbol
489 definition, then update the symbol class and type in
490 the hash table. */
491 if (((*sym_hash)->symbol_class == C_NULL
492 && (*sym_hash)->type == T_NULL)
493 || sym.n_scnum != 0
494 || (sym.n_value != 0
495 && (*sym_hash)->root.type != bfd_link_hash_defined
496 && (*sym_hash)->root.type != bfd_link_hash_defweak))
498 (*sym_hash)->symbol_class = sym.n_sclass;
499 if (sym.n_type != T_NULL)
501 /* We want to warn if the type changed, but not
502 if it changed from an unspecified type.
503 Testing the whole type byte may work, but the
504 change from (e.g.) a function of unspecified
505 type to function of known type also wants to
506 skip the warning. */
507 if ((*sym_hash)->type != T_NULL
508 && (*sym_hash)->type != sym.n_type
509 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
510 && (BTYPE ((*sym_hash)->type) == T_NULL
511 || BTYPE (sym.n_type) == T_NULL)))
512 (*_bfd_error_handler)
513 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
514 abfd, name, (*sym_hash)->type, sym.n_type);
516 /* We don't want to change from a meaningful
517 base type to a null one, but if we know
518 nothing, take what little we might now know. */
519 if (BTYPE (sym.n_type) != T_NULL
520 || (*sym_hash)->type == T_NULL)
521 (*sym_hash)->type = sym.n_type;
523 (*sym_hash)->auxbfd = abfd;
524 if (sym.n_numaux != 0)
526 union internal_auxent *alloc;
527 unsigned int i;
528 bfd_byte *eaux;
529 union internal_auxent *iaux;
531 (*sym_hash)->numaux = sym.n_numaux;
532 alloc = ((union internal_auxent *)
533 bfd_hash_allocate (&info->hash->table,
534 (sym.n_numaux
535 * sizeof (*alloc))));
536 if (alloc == NULL)
537 goto error_return;
538 for (i = 0, eaux = esym + symesz, iaux = alloc;
539 i < sym.n_numaux;
540 i++, eaux += symesz, iaux++)
541 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
542 sym.n_sclass, (int) i,
543 sym.n_numaux, iaux);
544 (*sym_hash)->aux = alloc;
549 if (classification == COFF_SYMBOL_PE_SECTION
550 && (*sym_hash)->numaux != 0)
552 /* Some PE sections (such as .bss) have a zero size in
553 the section header, but a non-zero size in the AUX
554 record. Correct that here.
556 FIXME: This is not at all the right place to do this.
557 For example, it won't help objdump. This needs to be
558 done when we swap in the section header. */
559 BFD_ASSERT ((*sym_hash)->numaux == 1);
560 if (section->size == 0)
561 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
563 /* FIXME: We could test whether the section sizes
564 matches the size in the aux entry, but apparently
565 that sometimes fails unexpectedly. */
569 esym += (sym.n_numaux + 1) * symesz;
570 sym_hash += sym.n_numaux + 1;
573 /* If this is a non-traditional, non-relocatable link, try to
574 optimize the handling of any .stab/.stabstr sections. */
575 if (! info->relocatable
576 && ! info->traditional_format
577 && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)
578 && (info->strip != strip_all && info->strip != strip_debugger))
580 asection *stabstr;
582 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
584 if (stabstr != NULL)
586 bfd_size_type string_offset = 0;
587 asection *stab;
589 for (stab = abfd->sections; stab; stab = stab->next)
590 if (CONST_STRNEQ (stab->name, ".stab")
591 && (!stab->name[5]
592 || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
594 struct coff_link_hash_table *table;
595 struct coff_section_tdata *secdata
596 = coff_section_data (abfd, stab);
598 if (secdata == NULL)
600 amt = sizeof (struct coff_section_tdata);
601 stab->used_by_bfd = bfd_zalloc (abfd, amt);
602 if (stab->used_by_bfd == NULL)
603 goto error_return;
604 secdata = coff_section_data (abfd, stab);
607 table = coff_hash_table (info);
609 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
610 stab, stabstr,
611 &secdata->stab_info,
612 &string_offset))
613 goto error_return;
618 obj_coff_keep_syms (abfd) = keep_syms;
620 return TRUE;
622 error_return:
623 obj_coff_keep_syms (abfd) = keep_syms;
624 return FALSE;
627 /* Do the final link step. */
629 bfd_boolean
630 _bfd_coff_final_link (bfd *abfd,
631 struct bfd_link_info *info)
633 bfd_size_type symesz;
634 struct coff_final_link_info finfo;
635 bfd_boolean debug_merge_allocated;
636 bfd_boolean long_section_names;
637 asection *o;
638 struct bfd_link_order *p;
639 bfd_size_type max_sym_count;
640 bfd_size_type max_lineno_count;
641 bfd_size_type max_reloc_count;
642 bfd_size_type max_output_reloc_count;
643 bfd_size_type max_contents_size;
644 file_ptr rel_filepos;
645 unsigned int relsz;
646 file_ptr line_filepos;
647 unsigned int linesz;
648 bfd *sub;
649 bfd_byte *external_relocs = NULL;
650 char strbuf[STRING_SIZE_SIZE];
651 bfd_size_type amt;
653 symesz = bfd_coff_symesz (abfd);
655 finfo.info = info;
656 finfo.output_bfd = abfd;
657 finfo.strtab = NULL;
658 finfo.section_info = NULL;
659 finfo.last_file_index = -1;
660 finfo.last_bf_index = -1;
661 finfo.internal_syms = NULL;
662 finfo.sec_ptrs = NULL;
663 finfo.sym_indices = NULL;
664 finfo.outsyms = NULL;
665 finfo.linenos = NULL;
666 finfo.contents = NULL;
667 finfo.external_relocs = NULL;
668 finfo.internal_relocs = NULL;
669 finfo.global_to_static = FALSE;
670 debug_merge_allocated = FALSE;
672 coff_data (abfd)->link_info = info;
674 finfo.strtab = _bfd_stringtab_init ();
675 if (finfo.strtab == NULL)
676 goto error_return;
678 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
679 goto error_return;
680 debug_merge_allocated = TRUE;
682 /* Compute the file positions for all the sections. */
683 if (! abfd->output_has_begun)
685 if (! bfd_coff_compute_section_file_positions (abfd))
686 goto error_return;
689 /* Count the line numbers and relocation entries required for the
690 output file. Set the file positions for the relocs. */
691 rel_filepos = obj_relocbase (abfd);
692 relsz = bfd_coff_relsz (abfd);
693 max_contents_size = 0;
694 max_lineno_count = 0;
695 max_reloc_count = 0;
697 long_section_names = FALSE;
698 for (o = abfd->sections; o != NULL; o = o->next)
700 o->reloc_count = 0;
701 o->lineno_count = 0;
702 for (p = o->map_head.link_order; p != NULL; p = p->next)
704 if (p->type == bfd_indirect_link_order)
706 asection *sec;
708 sec = p->u.indirect.section;
710 /* Mark all sections which are to be included in the
711 link. This will normally be every section. We need
712 to do this so that we can identify any sections which
713 the linker has decided to not include. */
714 sec->linker_mark = TRUE;
716 if (info->strip == strip_none
717 || info->strip == strip_some)
718 o->lineno_count += sec->lineno_count;
720 if (info->relocatable)
721 o->reloc_count += sec->reloc_count;
723 if (sec->rawsize > max_contents_size)
724 max_contents_size = sec->rawsize;
725 if (sec->size > max_contents_size)
726 max_contents_size = sec->size;
727 if (sec->lineno_count > max_lineno_count)
728 max_lineno_count = sec->lineno_count;
729 if (sec->reloc_count > max_reloc_count)
730 max_reloc_count = sec->reloc_count;
732 else if (info->relocatable
733 && (p->type == bfd_section_reloc_link_order
734 || p->type == bfd_symbol_reloc_link_order))
735 ++o->reloc_count;
737 if (o->reloc_count == 0)
738 o->rel_filepos = 0;
739 else
741 o->flags |= SEC_RELOC;
742 o->rel_filepos = rel_filepos;
743 rel_filepos += o->reloc_count * relsz;
744 /* In PE COFF, if there are at least 0xffff relocations an
745 extra relocation will be written out to encode the count. */
746 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
747 rel_filepos += relsz;
750 if (bfd_coff_long_section_names (abfd)
751 && strlen (o->name) > SCNNMLEN)
753 /* This section has a long name which must go in the string
754 table. This must correspond to the code in
755 coff_write_object_contents which puts the string index
756 into the s_name field of the section header. That is why
757 we pass hash as FALSE. */
758 if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
759 == (bfd_size_type) -1)
760 goto error_return;
761 long_section_names = TRUE;
765 /* If doing a relocatable link, allocate space for the pointers we
766 need to keep. */
767 if (info->relocatable)
769 unsigned int i;
771 /* We use section_count + 1, rather than section_count, because
772 the target_index fields are 1 based. */
773 amt = abfd->section_count + 1;
774 amt *= sizeof (struct coff_link_section_info);
775 finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
776 if (finfo.section_info == NULL)
777 goto error_return;
778 for (i = 0; i <= abfd->section_count; i++)
780 finfo.section_info[i].relocs = NULL;
781 finfo.section_info[i].rel_hashes = NULL;
785 /* We now know the size of the relocs, so we can determine the file
786 positions of the line numbers. */
787 line_filepos = rel_filepos;
788 linesz = bfd_coff_linesz (abfd);
789 max_output_reloc_count = 0;
790 for (o = abfd->sections; o != NULL; o = o->next)
792 if (o->lineno_count == 0)
793 o->line_filepos = 0;
794 else
796 o->line_filepos = line_filepos;
797 line_filepos += o->lineno_count * linesz;
800 if (o->reloc_count != 0)
802 /* We don't know the indices of global symbols until we have
803 written out all the local symbols. For each section in
804 the output file, we keep an array of pointers to hash
805 table entries. Each entry in the array corresponds to a
806 reloc. When we find a reloc against a global symbol, we
807 set the corresponding entry in this array so that we can
808 fix up the symbol index after we have written out all the
809 local symbols.
811 Because of this problem, we also keep the relocs in
812 memory until the end of the link. This wastes memory,
813 but only when doing a relocatable link, which is not the
814 common case. */
815 BFD_ASSERT (info->relocatable);
816 amt = o->reloc_count;
817 amt *= sizeof (struct internal_reloc);
818 finfo.section_info[o->target_index].relocs =
819 (struct internal_reloc *) bfd_malloc (amt);
820 amt = o->reloc_count;
821 amt *= sizeof (struct coff_link_hash_entry *);
822 finfo.section_info[o->target_index].rel_hashes =
823 (struct coff_link_hash_entry **) bfd_malloc (amt);
824 if (finfo.section_info[o->target_index].relocs == NULL
825 || finfo.section_info[o->target_index].rel_hashes == NULL)
826 goto error_return;
828 if (o->reloc_count > max_output_reloc_count)
829 max_output_reloc_count = o->reloc_count;
832 /* Reset the reloc and lineno counts, so that we can use them to
833 count the number of entries we have output so far. */
834 o->reloc_count = 0;
835 o->lineno_count = 0;
838 obj_sym_filepos (abfd) = line_filepos;
840 /* Figure out the largest number of symbols in an input BFD. Take
841 the opportunity to clear the output_has_begun fields of all the
842 input BFD's. */
843 max_sym_count = 0;
844 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
846 size_t sz;
848 sub->output_has_begun = FALSE;
849 sz = obj_raw_syment_count (sub);
850 if (sz > max_sym_count)
851 max_sym_count = sz;
854 /* Allocate some buffers used while linking. */
855 amt = max_sym_count * sizeof (struct internal_syment);
856 finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
857 amt = max_sym_count * sizeof (asection *);
858 finfo.sec_ptrs = (asection **) bfd_malloc (amt);
859 amt = max_sym_count * sizeof (long);
860 finfo.sym_indices = (long int *) bfd_malloc (amt);
861 finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
862 amt = max_lineno_count * bfd_coff_linesz (abfd);
863 finfo.linenos = (bfd_byte *) bfd_malloc (amt);
864 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
865 amt = max_reloc_count * relsz;
866 finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
867 if (! info->relocatable)
869 amt = max_reloc_count * sizeof (struct internal_reloc);
870 finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
872 if ((finfo.internal_syms == NULL && max_sym_count > 0)
873 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
874 || (finfo.sym_indices == NULL && max_sym_count > 0)
875 || finfo.outsyms == NULL
876 || (finfo.linenos == NULL && max_lineno_count > 0)
877 || (finfo.contents == NULL && max_contents_size > 0)
878 || (finfo.external_relocs == NULL && max_reloc_count > 0)
879 || (! info->relocatable
880 && finfo.internal_relocs == NULL
881 && max_reloc_count > 0))
882 goto error_return;
884 /* We now know the position of everything in the file, except that
885 we don't know the size of the symbol table and therefore we don't
886 know where the string table starts. We just build the string
887 table in memory as we go along. We process all the relocations
888 for a single input file at once. */
889 obj_raw_syment_count (abfd) = 0;
891 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
893 if (! bfd_coff_start_final_link (abfd, info))
894 goto error_return;
897 for (o = abfd->sections; o != NULL; o = o->next)
899 for (p = o->map_head.link_order; p != NULL; p = p->next)
901 if (p->type == bfd_indirect_link_order
902 && bfd_family_coff (p->u.indirect.section->owner))
904 sub = p->u.indirect.section->owner;
905 if (! bfd_coff_link_output_has_begun (sub, & finfo))
907 if (! _bfd_coff_link_input_bfd (&finfo, sub))
908 goto error_return;
909 sub->output_has_begun = TRUE;
912 else if (p->type == bfd_section_reloc_link_order
913 || p->type == bfd_symbol_reloc_link_order)
915 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
916 goto error_return;
918 else
920 if (! _bfd_default_link_order (abfd, info, o, p))
921 goto error_return;
926 if (! bfd_coff_final_link_postscript (abfd, & finfo))
927 goto error_return;
929 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
931 coff_debug_merge_hash_table_free (&finfo.debug_merge);
932 debug_merge_allocated = FALSE;
934 if (finfo.internal_syms != NULL)
936 free (finfo.internal_syms);
937 finfo.internal_syms = NULL;
939 if (finfo.sec_ptrs != NULL)
941 free (finfo.sec_ptrs);
942 finfo.sec_ptrs = NULL;
944 if (finfo.sym_indices != NULL)
946 free (finfo.sym_indices);
947 finfo.sym_indices = NULL;
949 if (finfo.linenos != NULL)
951 free (finfo.linenos);
952 finfo.linenos = NULL;
954 if (finfo.contents != NULL)
956 free (finfo.contents);
957 finfo.contents = NULL;
959 if (finfo.external_relocs != NULL)
961 free (finfo.external_relocs);
962 finfo.external_relocs = NULL;
964 if (finfo.internal_relocs != NULL)
966 free (finfo.internal_relocs);
967 finfo.internal_relocs = NULL;
970 /* The value of the last C_FILE symbol is supposed to be the symbol
971 index of the first external symbol. Write it out again if
972 necessary. */
973 if (finfo.last_file_index != -1
974 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
976 file_ptr pos;
978 finfo.last_file.n_value = obj_raw_syment_count (abfd);
979 bfd_coff_swap_sym_out (abfd, &finfo.last_file,
980 finfo.outsyms);
982 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
983 if (bfd_seek (abfd, pos, SEEK_SET) != 0
984 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
985 return FALSE;
988 /* If doing task linking (ld --task-link) then make a pass through the
989 global symbols, writing out any that are defined, and making them
990 static. */
991 if (info->task_link)
993 finfo.failed = FALSE;
994 coff_link_hash_traverse (coff_hash_table (info),
995 _bfd_coff_write_task_globals, &finfo);
996 if (finfo.failed)
997 goto error_return;
1000 /* Write out the global symbols. */
1001 finfo.failed = FALSE;
1002 coff_link_hash_traverse (coff_hash_table (info),
1003 _bfd_coff_write_global_sym, &finfo);
1004 if (finfo.failed)
1005 goto error_return;
1007 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1008 if (finfo.outsyms != NULL)
1010 free (finfo.outsyms);
1011 finfo.outsyms = NULL;
1014 if (info->relocatable && max_output_reloc_count > 0)
1016 /* Now that we have written out all the global symbols, we know
1017 the symbol indices to use for relocs against them, and we can
1018 finally write out the relocs. */
1019 amt = max_output_reloc_count * relsz;
1020 external_relocs = (bfd_byte *) bfd_malloc (amt);
1021 if (external_relocs == NULL)
1022 goto error_return;
1024 for (o = abfd->sections; o != NULL; o = o->next)
1026 struct internal_reloc *irel;
1027 struct internal_reloc *irelend;
1028 struct coff_link_hash_entry **rel_hash;
1029 bfd_byte *erel;
1031 if (o->reloc_count == 0)
1032 continue;
1034 irel = finfo.section_info[o->target_index].relocs;
1035 irelend = irel + o->reloc_count;
1036 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1037 erel = external_relocs;
1038 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1040 if (*rel_hash != NULL)
1042 BFD_ASSERT ((*rel_hash)->indx >= 0);
1043 irel->r_symndx = (*rel_hash)->indx;
1045 bfd_coff_swap_reloc_out (abfd, irel, erel);
1048 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1049 goto error_return;
1050 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1052 /* In PE COFF, write the count of relocs as the first
1053 reloc. The header overflow bit will be set
1054 elsewhere. */
1055 struct internal_reloc incount;
1056 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1058 memset (&incount, 0, sizeof (incount));
1059 incount.r_vaddr = o->reloc_count + 1;
1060 bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
1061 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1062 /* We'll leak, but it's an error anyway. */
1063 goto error_return;
1064 free (excount);
1066 if (bfd_bwrite (external_relocs,
1067 (bfd_size_type) relsz * o->reloc_count, abfd)
1068 != (bfd_size_type) relsz * o->reloc_count)
1069 goto error_return;
1072 free (external_relocs);
1073 external_relocs = NULL;
1076 /* Free up the section information. */
1077 if (finfo.section_info != NULL)
1079 unsigned int i;
1081 for (i = 0; i < abfd->section_count; i++)
1083 if (finfo.section_info[i].relocs != NULL)
1084 free (finfo.section_info[i].relocs);
1085 if (finfo.section_info[i].rel_hashes != NULL)
1086 free (finfo.section_info[i].rel_hashes);
1088 free (finfo.section_info);
1089 finfo.section_info = NULL;
1092 /* If we have optimized stabs strings, output them. */
1093 if (coff_hash_table (info)->stab_info.stabstr != NULL)
1095 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1096 return FALSE;
1099 /* Write out the string table. */
1100 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1102 file_ptr pos;
1104 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1105 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1106 return FALSE;
1108 #if STRING_SIZE_SIZE == 4
1109 H_PUT_32 (abfd,
1110 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1111 strbuf);
1112 #else
1113 #error Change H_PUT_32 above
1114 #endif
1116 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1117 != STRING_SIZE_SIZE)
1118 return FALSE;
1120 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1121 return FALSE;
1123 obj_coff_strings_written (abfd) = TRUE;
1126 _bfd_stringtab_free (finfo.strtab);
1128 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1129 not try to write out the symbols. */
1130 bfd_get_symcount (abfd) = 0;
1132 return TRUE;
1134 error_return:
1135 if (debug_merge_allocated)
1136 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1137 if (finfo.strtab != NULL)
1138 _bfd_stringtab_free (finfo.strtab);
1139 if (finfo.section_info != NULL)
1141 unsigned int i;
1143 for (i = 0; i < abfd->section_count; i++)
1145 if (finfo.section_info[i].relocs != NULL)
1146 free (finfo.section_info[i].relocs);
1147 if (finfo.section_info[i].rel_hashes != NULL)
1148 free (finfo.section_info[i].rel_hashes);
1150 free (finfo.section_info);
1152 if (finfo.internal_syms != NULL)
1153 free (finfo.internal_syms);
1154 if (finfo.sec_ptrs != NULL)
1155 free (finfo.sec_ptrs);
1156 if (finfo.sym_indices != NULL)
1157 free (finfo.sym_indices);
1158 if (finfo.outsyms != NULL)
1159 free (finfo.outsyms);
1160 if (finfo.linenos != NULL)
1161 free (finfo.linenos);
1162 if (finfo.contents != NULL)
1163 free (finfo.contents);
1164 if (finfo.external_relocs != NULL)
1165 free (finfo.external_relocs);
1166 if (finfo.internal_relocs != NULL)
1167 free (finfo.internal_relocs);
1168 if (external_relocs != NULL)
1169 free (external_relocs);
1170 return FALSE;
1173 /* Parse out a -heap <reserved>,<commit> line. */
1175 static char *
1176 dores_com (char *ptr, bfd *output_bfd, int heap)
1178 if (coff_data(output_bfd)->pe)
1180 int val = strtoul (ptr, &ptr, 0);
1182 if (heap)
1183 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1184 else
1185 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1187 if (ptr[0] == ',')
1189 val = strtoul (ptr+1, &ptr, 0);
1190 if (heap)
1191 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1192 else
1193 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1196 return ptr;
1199 static char *
1200 get_name (char *ptr, char **dst)
1202 while (*ptr == ' ')
1203 ptr++;
1204 *dst = ptr;
1205 while (*ptr && *ptr != ' ')
1206 ptr++;
1207 *ptr = 0;
1208 return ptr+1;
1211 /* Process any magic embedded commands in a section called .drectve. */
1213 static int
1214 process_embedded_commands (bfd *output_bfd,
1215 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1216 bfd *abfd)
1218 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1219 char *s;
1220 char *e;
1221 bfd_byte *copy;
1223 if (!sec)
1224 return 1;
1226 if (!bfd_malloc_and_get_section (abfd, sec, &copy))
1228 if (copy != NULL)
1229 free (copy);
1230 return 0;
1232 e = (char *) copy + sec->size;
1234 for (s = (char *) copy; s < e ; )
1236 if (s[0] != '-')
1238 s++;
1239 continue;
1241 if (CONST_STRNEQ (s, "-attr"))
1243 char *name;
1244 char *attribs;
1245 asection *asec;
1246 int loop = 1;
1247 int had_write = 0;
1248 int had_exec= 0;
1250 s += 5;
1251 s = get_name (s, &name);
1252 s = get_name (s, &attribs);
1254 while (loop)
1256 switch (*attribs++)
1258 case 'W':
1259 had_write = 1;
1260 break;
1261 case 'R':
1262 break;
1263 case 'S':
1264 break;
1265 case 'X':
1266 had_exec = 1;
1267 break;
1268 default:
1269 loop = 0;
1272 asec = bfd_get_section_by_name (abfd, name);
1273 if (asec)
1275 if (had_exec)
1276 asec->flags |= SEC_CODE;
1277 if (!had_write)
1278 asec->flags |= SEC_READONLY;
1281 else if (CONST_STRNEQ (s, "-heap"))
1282 s = dores_com (s + 5, output_bfd, 1);
1284 else if (CONST_STRNEQ (s, "-stack"))
1285 s = dores_com (s + 6, output_bfd, 0);
1287 /* GNU extension for aligned commons. */
1288 else if (CONST_STRNEQ (s, "-aligncomm:"))
1290 /* Common symbols must be aligned on reading, as it
1291 is too late to do anything here, after they have
1292 already been allocated, so just skip the directive. */
1293 s += 11;
1296 else
1297 s++;
1299 free (copy);
1300 return 1;
1303 /* Place a marker against all symbols which are used by relocations.
1304 This marker can be picked up by the 'do we skip this symbol ?'
1305 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1306 that symbol. */
1308 static void
1309 mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
1311 asection * a;
1313 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1314 return;
1316 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1318 struct internal_reloc * internal_relocs;
1319 struct internal_reloc * irel;
1320 struct internal_reloc * irelend;
1322 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1323 continue;
1324 /* Don't mark relocs in excluded sections. */
1325 if (a->output_section == bfd_abs_section_ptr)
1326 continue;
1328 /* Read in the relocs. */
1329 internal_relocs = _bfd_coff_read_internal_relocs
1330 (input_bfd, a, FALSE,
1331 finfo->external_relocs,
1332 finfo->info->relocatable,
1333 (finfo->info->relocatable
1334 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1335 : finfo->internal_relocs)
1338 if (internal_relocs == NULL)
1339 continue;
1341 irel = internal_relocs;
1342 irelend = irel + a->reloc_count;
1344 /* Place a mark in the sym_indices array (whose entries have
1345 been initialised to 0) for all of the symbols that are used
1346 in the relocation table. This will then be picked up in the
1347 skip/don't-skip pass. */
1348 for (; irel < irelend; irel++)
1349 finfo->sym_indices[ irel->r_symndx ] = -1;
1353 /* Link an input file into the linker output file. This function
1354 handles all the sections and relocations of the input file at once. */
1356 bfd_boolean
1357 _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
1359 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1360 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1361 bfd_boolean (*adjust_symndx)
1362 (bfd *, struct bfd_link_info *, bfd *, asection *,
1363 struct internal_reloc *, bfd_boolean *);
1364 bfd *output_bfd;
1365 const char *strings;
1366 bfd_size_type syment_base;
1367 bfd_boolean copy, hash;
1368 bfd_size_type isymesz;
1369 bfd_size_type osymesz;
1370 bfd_size_type linesz;
1371 bfd_byte *esym;
1372 bfd_byte *esym_end;
1373 struct internal_syment *isymp;
1374 asection **secpp;
1375 long *indexp;
1376 unsigned long output_index;
1377 bfd_byte *outsym;
1378 struct coff_link_hash_entry **sym_hash;
1379 asection *o;
1381 /* Move all the symbols to the output file. */
1383 output_bfd = finfo->output_bfd;
1384 strings = NULL;
1385 syment_base = obj_raw_syment_count (output_bfd);
1386 isymesz = bfd_coff_symesz (input_bfd);
1387 osymesz = bfd_coff_symesz (output_bfd);
1388 linesz = bfd_coff_linesz (input_bfd);
1389 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1391 copy = FALSE;
1392 if (! finfo->info->keep_memory)
1393 copy = TRUE;
1394 hash = TRUE;
1395 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1396 hash = FALSE;
1398 if (! _bfd_coff_get_external_symbols (input_bfd))
1399 return FALSE;
1401 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1402 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1403 isymp = finfo->internal_syms;
1404 secpp = finfo->sec_ptrs;
1405 indexp = finfo->sym_indices;
1406 output_index = syment_base;
1407 outsym = finfo->outsyms;
1409 if (coff_data (output_bfd)->pe
1410 && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1411 return FALSE;
1413 /* If we are going to perform relocations and also strip/discard some
1414 symbols then we must make sure that we do not strip/discard those
1415 symbols that are going to be involved in the relocations. */
1416 if (( finfo->info->strip != strip_none
1417 || finfo->info->discard != discard_none)
1418 && finfo->info->relocatable)
1420 /* Mark the symbol array as 'not-used'. */
1421 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1423 mark_relocs (finfo, input_bfd);
1426 while (esym < esym_end)
1428 struct internal_syment isym;
1429 enum coff_symbol_classification classification;
1430 bfd_boolean skip;
1431 bfd_boolean global;
1432 bfd_boolean dont_skip_symbol;
1433 int add;
1435 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1437 /* Make a copy of *isymp so that the relocate_section function
1438 always sees the original values. This is more reliable than
1439 always recomputing the symbol value even if we are stripping
1440 the symbol. */
1441 isym = *isymp;
1443 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1444 switch (classification)
1446 default:
1447 abort ();
1448 case COFF_SYMBOL_GLOBAL:
1449 case COFF_SYMBOL_PE_SECTION:
1450 case COFF_SYMBOL_LOCAL:
1451 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1452 break;
1453 case COFF_SYMBOL_COMMON:
1454 *secpp = bfd_com_section_ptr;
1455 break;
1456 case COFF_SYMBOL_UNDEFINED:
1457 *secpp = bfd_und_section_ptr;
1458 break;
1461 /* Extract the flag indicating if this symbol is used by a
1462 relocation. */
1463 if ((finfo->info->strip != strip_none
1464 || finfo->info->discard != discard_none)
1465 && finfo->info->relocatable)
1466 dont_skip_symbol = *indexp;
1467 else
1468 dont_skip_symbol = FALSE;
1470 *indexp = -1;
1472 skip = FALSE;
1473 global = FALSE;
1474 add = 1 + isym.n_numaux;
1476 /* If we are stripping all symbols, we want to skip this one. */
1477 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1478 skip = TRUE;
1480 if (! skip)
1482 switch (classification)
1484 default:
1485 abort ();
1486 case COFF_SYMBOL_GLOBAL:
1487 case COFF_SYMBOL_COMMON:
1488 case COFF_SYMBOL_PE_SECTION:
1489 /* This is a global symbol. Global symbols come at the
1490 end of the symbol table, so skip them for now.
1491 Locally defined function symbols, however, are an
1492 exception, and are not moved to the end. */
1493 global = TRUE;
1494 if (! ISFCN (isym.n_type))
1495 skip = TRUE;
1496 break;
1498 case COFF_SYMBOL_UNDEFINED:
1499 /* Undefined symbols are left for the end. */
1500 global = TRUE;
1501 skip = TRUE;
1502 break;
1504 case COFF_SYMBOL_LOCAL:
1505 /* This is a local symbol. Skip it if we are discarding
1506 local symbols. */
1507 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1508 skip = TRUE;
1509 break;
1513 #ifndef COFF_WITH_PE
1514 /* Skip section symbols for sections which are not going to be
1515 emitted. */
1516 if (!skip
1517 && !dont_skip_symbol
1518 && isym.n_sclass == C_STAT
1519 && isym.n_type == T_NULL
1520 && isym.n_numaux > 0
1521 && ((*secpp)->output_section == bfd_abs_section_ptr
1522 || bfd_section_removed_from_list (output_bfd,
1523 (*secpp)->output_section)))
1524 skip = TRUE;
1525 #endif
1527 /* If we stripping debugging symbols, and this is a debugging
1528 symbol, then skip it. FIXME: gas sets the section to N_ABS
1529 for some types of debugging symbols; I don't know if this is
1530 a bug or not. In any case, we handle it here. */
1531 if (! skip
1532 && finfo->info->strip == strip_debugger
1533 && ! dont_skip_symbol
1534 && (isym.n_scnum == N_DEBUG
1535 || (isym.n_scnum == N_ABS
1536 && (isym.n_sclass == C_AUTO
1537 || isym.n_sclass == C_REG
1538 || isym.n_sclass == C_MOS
1539 || isym.n_sclass == C_MOE
1540 || isym.n_sclass == C_MOU
1541 || isym.n_sclass == C_ARG
1542 || isym.n_sclass == C_REGPARM
1543 || isym.n_sclass == C_FIELD
1544 || isym.n_sclass == C_EOS))))
1545 skip = TRUE;
1547 /* If some symbols are stripped based on the name, work out the
1548 name and decide whether to skip this symbol. */
1549 if (! skip
1550 && (finfo->info->strip == strip_some
1551 || finfo->info->discard == discard_l))
1553 const char *name;
1554 char buf[SYMNMLEN + 1];
1556 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1557 if (name == NULL)
1558 return FALSE;
1560 if (! dont_skip_symbol
1561 && ((finfo->info->strip == strip_some
1562 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
1563 FALSE) == NULL))
1564 || (! global
1565 && finfo->info->discard == discard_l
1566 && bfd_is_local_label_name (input_bfd, name))))
1567 skip = TRUE;
1570 /* If this is an enum, struct, or union tag, see if we have
1571 already output an identical type. */
1572 if (! skip
1573 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1574 && (isym.n_sclass == C_ENTAG
1575 || isym.n_sclass == C_STRTAG
1576 || isym.n_sclass == C_UNTAG)
1577 && isym.n_numaux == 1)
1579 const char *name;
1580 char buf[SYMNMLEN + 1];
1581 struct coff_debug_merge_hash_entry *mh;
1582 struct coff_debug_merge_type *mt;
1583 union internal_auxent aux;
1584 struct coff_debug_merge_element **epp;
1585 bfd_byte *esl, *eslend;
1586 struct internal_syment *islp;
1587 bfd_size_type amt;
1589 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1590 if (name == NULL)
1591 return FALSE;
1593 /* Ignore fake names invented by compiler; treat them all as
1594 the same name. */
1595 if (*name == '~' || *name == '.' || *name == '$'
1596 || (*name == bfd_get_symbol_leading_char (input_bfd)
1597 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1598 name = "";
1600 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1601 TRUE, TRUE);
1602 if (mh == NULL)
1603 return FALSE;
1605 /* Allocate memory to hold type information. If this turns
1606 out to be a duplicate, we pass this address to
1607 bfd_release. */
1608 amt = sizeof (struct coff_debug_merge_type);
1609 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1610 if (mt == NULL)
1611 return FALSE;
1612 mt->type_class = isym.n_sclass;
1614 /* Pick up the aux entry, which points to the end of the tag
1615 entries. */
1616 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1617 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1618 &aux);
1620 /* Gather the elements. */
1621 epp = &mt->elements;
1622 mt->elements = NULL;
1623 islp = isymp + 2;
1624 esl = esym + 2 * isymesz;
1625 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1626 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1627 while (esl < eslend)
1629 const char *elename;
1630 char elebuf[SYMNMLEN + 1];
1631 char *name_copy;
1633 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1635 amt = sizeof (struct coff_debug_merge_element);
1636 *epp = (struct coff_debug_merge_element *)
1637 bfd_alloc (input_bfd, amt);
1638 if (*epp == NULL)
1639 return FALSE;
1641 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1642 elebuf);
1643 if (elename == NULL)
1644 return FALSE;
1646 amt = strlen (elename) + 1;
1647 name_copy = (char *) bfd_alloc (input_bfd, amt);
1648 if (name_copy == NULL)
1649 return FALSE;
1650 strcpy (name_copy, elename);
1652 (*epp)->name = name_copy;
1653 (*epp)->type = islp->n_type;
1654 (*epp)->tagndx = 0;
1655 if (islp->n_numaux >= 1
1656 && islp->n_type != T_NULL
1657 && islp->n_sclass != C_EOS)
1659 union internal_auxent eleaux;
1660 long indx;
1662 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1663 islp->n_type, islp->n_sclass, 0,
1664 islp->n_numaux, &eleaux);
1665 indx = eleaux.x_sym.x_tagndx.l;
1667 /* FIXME: If this tagndx entry refers to a symbol
1668 defined later in this file, we just ignore it.
1669 Handling this correctly would be tedious, and may
1670 not be required. */
1671 if (indx > 0
1672 && (indx
1673 < ((esym -
1674 (bfd_byte *) obj_coff_external_syms (input_bfd))
1675 / (long) isymesz)))
1677 (*epp)->tagndx = finfo->sym_indices[indx];
1678 if ((*epp)->tagndx < 0)
1679 (*epp)->tagndx = 0;
1682 epp = &(*epp)->next;
1683 *epp = NULL;
1685 esl += (islp->n_numaux + 1) * isymesz;
1686 islp += islp->n_numaux + 1;
1689 /* See if we already have a definition which matches this
1690 type. We always output the type if it has no elements,
1691 for simplicity. */
1692 if (mt->elements == NULL)
1693 bfd_release (input_bfd, mt);
1694 else
1696 struct coff_debug_merge_type *mtl;
1698 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1700 struct coff_debug_merge_element *me, *mel;
1702 if (mtl->type_class != mt->type_class)
1703 continue;
1705 for (me = mt->elements, mel = mtl->elements;
1706 me != NULL && mel != NULL;
1707 me = me->next, mel = mel->next)
1709 if (strcmp (me->name, mel->name) != 0
1710 || me->type != mel->type
1711 || me->tagndx != mel->tagndx)
1712 break;
1715 if (me == NULL && mel == NULL)
1716 break;
1719 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1721 /* This is the first definition of this type. */
1722 mt->indx = output_index;
1723 mt->next = mh->types;
1724 mh->types = mt;
1726 else
1728 /* This is a redefinition which can be merged. */
1729 bfd_release (input_bfd, mt);
1730 *indexp = mtl->indx;
1731 add = (eslend - esym) / isymesz;
1732 skip = TRUE;
1737 /* We now know whether we are to skip this symbol or not. */
1738 if (! skip)
1740 /* Adjust the symbol in order to output it. */
1742 if (isym._n._n_n._n_zeroes == 0
1743 && isym._n._n_n._n_offset != 0)
1745 const char *name;
1746 bfd_size_type indx;
1748 /* This symbol has a long name. Enter it in the string
1749 table we are building. Note that we do not check
1750 bfd_coff_symname_in_debug. That is only true for
1751 XCOFF, and XCOFF requires different linking code
1752 anyhow. */
1753 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1754 if (name == NULL)
1755 return FALSE;
1756 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1757 if (indx == (bfd_size_type) -1)
1758 return FALSE;
1759 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1762 switch (isym.n_sclass)
1764 case C_AUTO:
1765 case C_MOS:
1766 case C_EOS:
1767 case C_MOE:
1768 case C_MOU:
1769 case C_UNTAG:
1770 case C_STRTAG:
1771 case C_ENTAG:
1772 case C_TPDEF:
1773 case C_ARG:
1774 case C_USTATIC:
1775 case C_REG:
1776 case C_REGPARM:
1777 case C_FIELD:
1778 /* The symbol value should not be modified. */
1779 break;
1781 case C_FCN:
1782 if (obj_pe (input_bfd)
1783 && strcmp (isym.n_name, ".bf") != 0
1784 && isym.n_scnum > 0)
1786 /* For PE, .lf and .ef get their value left alone,
1787 while .bf gets relocated. However, they all have
1788 "real" section numbers, and need to be moved into
1789 the new section. */
1790 isym.n_scnum = (*secpp)->output_section->target_index;
1791 break;
1793 /* Fall through. */
1794 default:
1795 case C_LABEL: /* Not completely sure about these 2 */
1796 case C_EXTDEF:
1797 case C_BLOCK:
1798 case C_EFCN:
1799 case C_NULL:
1800 case C_EXT:
1801 case C_STAT:
1802 case C_SECTION:
1803 case C_NT_WEAK:
1804 /* Compute new symbol location. */
1805 if (isym.n_scnum > 0)
1807 isym.n_scnum = (*secpp)->output_section->target_index;
1808 isym.n_value += (*secpp)->output_offset;
1809 if (! obj_pe (input_bfd))
1810 isym.n_value -= (*secpp)->vma;
1811 if (! obj_pe (finfo->output_bfd))
1812 isym.n_value += (*secpp)->output_section->vma;
1814 break;
1816 case C_FILE:
1817 /* The value of a C_FILE symbol is the symbol index of
1818 the next C_FILE symbol. The value of the last C_FILE
1819 symbol is the symbol index to the first external
1820 symbol (actually, coff_renumber_symbols does not get
1821 this right--it just sets the value of the last C_FILE
1822 symbol to zero--and nobody has ever complained about
1823 it). We try to get this right, below, just before we
1824 write the symbols out, but in the general case we may
1825 have to write the symbol out twice. */
1826 if (finfo->last_file_index != -1
1827 && finfo->last_file.n_value != (bfd_vma) output_index)
1829 /* We must correct the value of the last C_FILE
1830 entry. */
1831 finfo->last_file.n_value = output_index;
1832 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1834 /* The last C_FILE symbol is in this input file. */
1835 bfd_coff_swap_sym_out (output_bfd,
1836 &finfo->last_file,
1837 (finfo->outsyms
1838 + ((finfo->last_file_index
1839 - syment_base)
1840 * osymesz)));
1842 else
1844 file_ptr pos;
1846 /* We have already written out the last C_FILE
1847 symbol. We need to write it out again. We
1848 borrow *outsym temporarily. */
1849 bfd_coff_swap_sym_out (output_bfd,
1850 &finfo->last_file, outsym);
1851 pos = obj_sym_filepos (output_bfd);
1852 pos += finfo->last_file_index * osymesz;
1853 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1854 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1855 return FALSE;
1859 finfo->last_file_index = output_index;
1860 finfo->last_file = isym;
1861 break;
1864 /* If doing task linking, convert normal global function symbols to
1865 static functions. */
1866 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1867 isym.n_sclass = C_STAT;
1869 /* Output the symbol. */
1870 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1872 *indexp = output_index;
1874 if (global)
1876 long indx;
1877 struct coff_link_hash_entry *h;
1879 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1880 / isymesz);
1881 h = obj_coff_sym_hashes (input_bfd)[indx];
1882 if (h == NULL)
1884 /* This can happen if there were errors earlier in
1885 the link. */
1886 bfd_set_error (bfd_error_bad_value);
1887 return FALSE;
1889 h->indx = output_index;
1892 output_index += add;
1893 outsym += add * osymesz;
1896 esym += add * isymesz;
1897 isymp += add;
1898 ++secpp;
1899 ++indexp;
1900 for (--add; add > 0; --add)
1902 *secpp++ = NULL;
1903 *indexp++ = -1;
1907 /* Fix up the aux entries. This must be done in a separate pass,
1908 because we don't know the correct symbol indices until we have
1909 already decided which symbols we are going to keep. */
1910 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1911 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1912 isymp = finfo->internal_syms;
1913 indexp = finfo->sym_indices;
1914 sym_hash = obj_coff_sym_hashes (input_bfd);
1915 outsym = finfo->outsyms;
1917 while (esym < esym_end)
1919 int add;
1921 add = 1 + isymp->n_numaux;
1923 if ((*indexp < 0
1924 || (bfd_size_type) *indexp < syment_base)
1925 && (*sym_hash == NULL
1926 || (*sym_hash)->auxbfd != input_bfd))
1927 esym += add * isymesz;
1928 else
1930 struct coff_link_hash_entry *h;
1931 int i;
1933 h = NULL;
1934 if (*indexp < 0)
1936 h = *sym_hash;
1938 /* The m68k-motorola-sysv assembler will sometimes
1939 generate two symbols with the same name, but only one
1940 will have aux entries. */
1941 BFD_ASSERT (isymp->n_numaux == 0
1942 || h->numaux == 0
1943 || h->numaux == isymp->n_numaux);
1946 esym += isymesz;
1948 if (h == NULL)
1949 outsym += osymesz;
1951 /* Handle the aux entries. This handling is based on
1952 coff_pointerize_aux. I don't know if it always correct. */
1953 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1955 union internal_auxent aux;
1956 union internal_auxent *auxp;
1958 if (h != NULL && h->aux != NULL && (h->numaux > i))
1959 auxp = h->aux + i;
1960 else
1962 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
1963 isymp->n_sclass, i, isymp->n_numaux, &aux);
1964 auxp = &aux;
1967 if (isymp->n_sclass == C_FILE)
1969 /* If this is a long filename, we must put it in the
1970 string table. */
1971 if (auxp->x_file.x_n.x_zeroes == 0
1972 && auxp->x_file.x_n.x_offset != 0)
1974 const char *filename;
1975 bfd_size_type indx;
1977 BFD_ASSERT (auxp->x_file.x_n.x_offset
1978 >= STRING_SIZE_SIZE);
1979 if (strings == NULL)
1981 strings = _bfd_coff_read_string_table (input_bfd);
1982 if (strings == NULL)
1983 return FALSE;
1985 filename = strings + auxp->x_file.x_n.x_offset;
1986 indx = _bfd_stringtab_add (finfo->strtab, filename,
1987 hash, copy);
1988 if (indx == (bfd_size_type) -1)
1989 return FALSE;
1990 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1993 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1994 && isymp->n_sclass != C_NT_WEAK)
1996 unsigned long indx;
1998 if (ISFCN (isymp->n_type)
1999 || ISTAG (isymp->n_sclass)
2000 || isymp->n_sclass == C_BLOCK
2001 || isymp->n_sclass == C_FCN)
2003 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2004 if (indx > 0
2005 && indx < obj_raw_syment_count (input_bfd))
2007 /* We look forward through the symbol for
2008 the index of the next symbol we are going
2009 to include. I don't know if this is
2010 entirely right. */
2011 while ((finfo->sym_indices[indx] < 0
2012 || ((bfd_size_type) finfo->sym_indices[indx]
2013 < syment_base))
2014 && indx < obj_raw_syment_count (input_bfd))
2015 ++indx;
2016 if (indx >= obj_raw_syment_count (input_bfd))
2017 indx = output_index;
2018 else
2019 indx = finfo->sym_indices[indx];
2020 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2024 indx = auxp->x_sym.x_tagndx.l;
2025 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2027 long symindx;
2029 symindx = finfo->sym_indices[indx];
2030 if (symindx < 0)
2031 auxp->x_sym.x_tagndx.l = 0;
2032 else
2033 auxp->x_sym.x_tagndx.l = symindx;
2036 /* The .bf symbols are supposed to be linked through
2037 the endndx field. We need to carry this list
2038 across object files. */
2039 if (i == 0
2040 && h == NULL
2041 && isymp->n_sclass == C_FCN
2042 && (isymp->_n._n_n._n_zeroes != 0
2043 || isymp->_n._n_n._n_offset == 0)
2044 && isymp->_n._n_name[0] == '.'
2045 && isymp->_n._n_name[1] == 'b'
2046 && isymp->_n._n_name[2] == 'f'
2047 && isymp->_n._n_name[3] == '\0')
2049 if (finfo->last_bf_index != -1)
2051 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2052 *indexp;
2054 if ((bfd_size_type) finfo->last_bf_index
2055 >= syment_base)
2057 void *auxout;
2059 /* The last .bf symbol is in this input
2060 file. This will only happen if the
2061 assembler did not set up the .bf
2062 endndx symbols correctly. */
2063 auxout = (finfo->outsyms
2064 + ((finfo->last_bf_index
2065 - syment_base)
2066 * osymesz));
2068 bfd_coff_swap_aux_out (output_bfd,
2069 &finfo->last_bf,
2070 isymp->n_type,
2071 isymp->n_sclass,
2072 0, isymp->n_numaux,
2073 auxout);
2075 else
2077 file_ptr pos;
2079 /* We have already written out the last
2080 .bf aux entry. We need to write it
2081 out again. We borrow *outsym
2082 temporarily. FIXME: This case should
2083 be made faster. */
2084 bfd_coff_swap_aux_out (output_bfd,
2085 &finfo->last_bf,
2086 isymp->n_type,
2087 isymp->n_sclass,
2088 0, isymp->n_numaux,
2089 outsym);
2090 pos = obj_sym_filepos (output_bfd);
2091 pos += finfo->last_bf_index * osymesz;
2092 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2093 || (bfd_bwrite (outsym, osymesz, output_bfd)
2094 != osymesz))
2095 return FALSE;
2099 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2100 finfo->last_bf_index = -1;
2101 else
2103 /* The endndx field of this aux entry must
2104 be updated with the symbol number of the
2105 next .bf symbol. */
2106 finfo->last_bf = *auxp;
2107 finfo->last_bf_index = (((outsym - finfo->outsyms)
2108 / osymesz)
2109 + syment_base);
2114 if (h == NULL)
2116 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2117 isymp->n_sclass, i, isymp->n_numaux,
2118 outsym);
2119 outsym += osymesz;
2122 esym += isymesz;
2126 indexp += add;
2127 isymp += add;
2128 sym_hash += add;
2131 /* Relocate the line numbers, unless we are stripping them. */
2132 if (finfo->info->strip == strip_none
2133 || finfo->info->strip == strip_some)
2135 for (o = input_bfd->sections; o != NULL; o = o->next)
2137 bfd_vma offset;
2138 bfd_byte *eline;
2139 bfd_byte *elineend;
2140 bfd_byte *oeline;
2141 bfd_boolean skipping;
2142 file_ptr pos;
2143 bfd_size_type amt;
2145 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2146 build_link_order in ldwrite.c will not have created a
2147 link order, which means that we will not have seen this
2148 input section in _bfd_coff_final_link, which means that
2149 we will not have allocated space for the line numbers of
2150 this section. I don't think line numbers can be
2151 meaningful for a section which does not have
2152 SEC_HAS_CONTENTS set, but, if they do, this must be
2153 changed. */
2154 if (o->lineno_count == 0
2155 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2156 continue;
2158 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2159 || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2160 input_bfd) != linesz * o->lineno_count)
2161 return FALSE;
2163 offset = o->output_section->vma + o->output_offset - o->vma;
2164 eline = finfo->linenos;
2165 oeline = finfo->linenos;
2166 elineend = eline + linesz * o->lineno_count;
2167 skipping = FALSE;
2168 for (; eline < elineend; eline += linesz)
2170 struct internal_lineno iline;
2172 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2174 if (iline.l_lnno != 0)
2175 iline.l_addr.l_paddr += offset;
2176 else if (iline.l_addr.l_symndx >= 0
2177 && ((unsigned long) iline.l_addr.l_symndx
2178 < obj_raw_syment_count (input_bfd)))
2180 long indx;
2182 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2184 if (indx < 0)
2186 /* These line numbers are attached to a symbol
2187 which we are stripping. We must discard the
2188 line numbers because reading them back with
2189 no associated symbol (or associating them all
2190 with symbol #0) will fail. We can't regain
2191 the space in the output file, but at least
2192 they're dense. */
2193 skipping = TRUE;
2195 else
2197 struct internal_syment is;
2198 union internal_auxent ia;
2200 /* Fix up the lnnoptr field in the aux entry of
2201 the symbol. It turns out that we can't do
2202 this when we modify the symbol aux entries,
2203 because gas sometimes screws up the lnnoptr
2204 field and makes it an offset from the start
2205 of the line numbers rather than an absolute
2206 file index. */
2207 bfd_coff_swap_sym_in (output_bfd,
2208 (finfo->outsyms
2209 + ((indx - syment_base)
2210 * osymesz)), &is);
2211 if ((ISFCN (is.n_type)
2212 || is.n_sclass == C_BLOCK)
2213 && is.n_numaux >= 1)
2215 void *auxptr;
2217 auxptr = (finfo->outsyms
2218 + ((indx - syment_base + 1)
2219 * osymesz));
2220 bfd_coff_swap_aux_in (output_bfd, auxptr,
2221 is.n_type, is.n_sclass,
2222 0, is.n_numaux, &ia);
2223 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2224 (o->output_section->line_filepos
2225 + o->output_section->lineno_count * linesz
2226 + eline - finfo->linenos);
2227 bfd_coff_swap_aux_out (output_bfd, &ia,
2228 is.n_type, is.n_sclass, 0,
2229 is.n_numaux, auxptr);
2232 skipping = FALSE;
2235 iline.l_addr.l_symndx = indx;
2238 if (!skipping)
2240 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2241 oeline += linesz;
2245 pos = o->output_section->line_filepos;
2246 pos += o->output_section->lineno_count * linesz;
2247 amt = oeline - finfo->linenos;
2248 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2249 || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2250 return FALSE;
2252 o->output_section->lineno_count += amt / linesz;
2256 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2257 symbol will be the first symbol in the next input file. In the
2258 normal case, this will save us from writing out the C_FILE symbol
2259 again. */
2260 if (finfo->last_file_index != -1
2261 && (bfd_size_type) finfo->last_file_index >= syment_base)
2263 finfo->last_file.n_value = output_index;
2264 bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
2265 (finfo->outsyms
2266 + ((finfo->last_file_index - syment_base)
2267 * osymesz)));
2270 /* Write the modified symbols to the output file. */
2271 if (outsym > finfo->outsyms)
2273 file_ptr pos;
2274 bfd_size_type amt;
2276 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2277 amt = outsym - finfo->outsyms;
2278 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2279 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2280 return FALSE;
2282 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2283 + (outsym - finfo->outsyms) / osymesz)
2284 == output_index);
2286 obj_raw_syment_count (output_bfd) = output_index;
2289 /* Relocate the contents of each section. */
2290 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2291 for (o = input_bfd->sections; o != NULL; o = o->next)
2293 bfd_byte *contents;
2294 struct coff_section_tdata *secdata;
2296 if (! o->linker_mark)
2297 /* This section was omitted from the link. */
2298 continue;
2300 if ((o->flags & SEC_LINKER_CREATED) != 0)
2301 continue;
2303 if ((o->flags & SEC_HAS_CONTENTS) == 0
2304 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2306 if ((o->flags & SEC_RELOC) != 0
2307 && o->reloc_count != 0)
2309 (*_bfd_error_handler)
2310 (_("%B: relocs in section `%A', but it has no contents"),
2311 input_bfd, o);
2312 bfd_set_error (bfd_error_no_contents);
2313 return FALSE;
2316 continue;
2319 secdata = coff_section_data (input_bfd, o);
2320 if (secdata != NULL && secdata->contents != NULL)
2321 contents = secdata->contents;
2322 else
2324 bfd_size_type x = o->rawsize ? o->rawsize : o->size;
2325 if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
2326 return FALSE;
2327 contents = finfo->contents;
2330 if ((o->flags & SEC_RELOC) != 0)
2332 int target_index;
2333 struct internal_reloc *internal_relocs;
2334 struct internal_reloc *irel;
2336 /* Read in the relocs. */
2337 target_index = o->output_section->target_index;
2338 internal_relocs = (_bfd_coff_read_internal_relocs
2339 (input_bfd, o, FALSE, finfo->external_relocs,
2340 finfo->info->relocatable,
2341 (finfo->info->relocatable
2342 ? (finfo->section_info[target_index].relocs
2343 + o->output_section->reloc_count)
2344 : finfo->internal_relocs)));
2345 if (internal_relocs == NULL)
2346 return FALSE;
2348 /* Call processor specific code to relocate the section
2349 contents. */
2350 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2351 input_bfd, o,
2352 contents,
2353 internal_relocs,
2354 finfo->internal_syms,
2355 finfo->sec_ptrs))
2356 return FALSE;
2358 if (finfo->info->relocatable)
2360 bfd_vma offset;
2361 struct internal_reloc *irelend;
2362 struct coff_link_hash_entry **rel_hash;
2364 offset = o->output_section->vma + o->output_offset - o->vma;
2365 irel = internal_relocs;
2366 irelend = irel + o->reloc_count;
2367 rel_hash = (finfo->section_info[target_index].rel_hashes
2368 + o->output_section->reloc_count);
2369 for (; irel < irelend; irel++, rel_hash++)
2371 struct coff_link_hash_entry *h;
2372 bfd_boolean adjusted;
2374 *rel_hash = NULL;
2376 /* Adjust the reloc address and symbol index. */
2377 irel->r_vaddr += offset;
2379 if (irel->r_symndx == -1)
2380 continue;
2382 if (adjust_symndx)
2384 if (! (*adjust_symndx) (output_bfd, finfo->info,
2385 input_bfd, o, irel,
2386 &adjusted))
2387 return FALSE;
2388 if (adjusted)
2389 continue;
2392 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2393 if (h != NULL)
2395 /* This is a global symbol. */
2396 if (h->indx >= 0)
2397 irel->r_symndx = h->indx;
2398 else
2400 /* This symbol is being written at the end
2401 of the file, and we do not yet know the
2402 symbol index. We save the pointer to the
2403 hash table entry in the rel_hash list.
2404 We set the indx field to -2 to indicate
2405 that this symbol must not be stripped. */
2406 *rel_hash = h;
2407 h->indx = -2;
2410 else
2412 long indx;
2414 indx = finfo->sym_indices[irel->r_symndx];
2415 if (indx != -1)
2416 irel->r_symndx = indx;
2417 else
2419 struct internal_syment *is;
2420 const char *name;
2421 char buf[SYMNMLEN + 1];
2423 /* This reloc is against a symbol we are
2424 stripping. This should have been handled
2425 by the 'dont_skip_symbol' code in the while
2426 loop at the top of this function. */
2427 is = finfo->internal_syms + irel->r_symndx;
2429 name = (_bfd_coff_internal_syment_name
2430 (input_bfd, is, buf));
2431 if (name == NULL)
2432 return FALSE;
2434 if (! ((*finfo->info->callbacks->unattached_reloc)
2435 (finfo->info, name, input_bfd, o,
2436 irel->r_vaddr)))
2437 return FALSE;
2442 o->output_section->reloc_count += o->reloc_count;
2446 /* Write out the modified section contents. */
2447 if (secdata == NULL || secdata->stab_info == NULL)
2449 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2450 if (! bfd_set_section_contents (output_bfd, o->output_section,
2451 contents, loc, o->size))
2452 return FALSE;
2454 else
2456 if (! (_bfd_write_section_stabs
2457 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2458 o, &secdata->stab_info, contents)))
2459 return FALSE;
2463 if (! finfo->info->keep_memory
2464 && ! _bfd_coff_free_symbols (input_bfd))
2465 return FALSE;
2467 return TRUE;
2470 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2472 bfd_boolean
2473 _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
2475 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2476 bfd *output_bfd;
2477 struct internal_syment isym;
2478 bfd_size_type symesz;
2479 unsigned int i;
2480 file_ptr pos;
2482 output_bfd = finfo->output_bfd;
2484 if (h->root.type == bfd_link_hash_warning)
2486 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2487 if (h->root.type == bfd_link_hash_new)
2488 return TRUE;
2491 if (h->indx >= 0)
2492 return TRUE;
2494 if (h->indx != -2
2495 && (finfo->info->strip == strip_all
2496 || (finfo->info->strip == strip_some
2497 && (bfd_hash_lookup (finfo->info->keep_hash,
2498 h->root.root.string, FALSE, FALSE)
2499 == NULL))))
2500 return TRUE;
2502 switch (h->root.type)
2504 default:
2505 case bfd_link_hash_new:
2506 case bfd_link_hash_warning:
2507 abort ();
2508 return FALSE;
2510 case bfd_link_hash_undefined:
2511 case bfd_link_hash_undefweak:
2512 isym.n_scnum = N_UNDEF;
2513 isym.n_value = 0;
2514 break;
2516 case bfd_link_hash_defined:
2517 case bfd_link_hash_defweak:
2519 asection *sec;
2521 sec = h->root.u.def.section->output_section;
2522 if (bfd_is_abs_section (sec))
2523 isym.n_scnum = N_ABS;
2524 else
2525 isym.n_scnum = sec->target_index;
2526 isym.n_value = (h->root.u.def.value
2527 + h->root.u.def.section->output_offset);
2528 if (! obj_pe (finfo->output_bfd))
2529 isym.n_value += sec->vma;
2531 break;
2533 case bfd_link_hash_common:
2534 isym.n_scnum = N_UNDEF;
2535 isym.n_value = h->root.u.c.size;
2536 break;
2538 case bfd_link_hash_indirect:
2539 /* Just ignore these. They can't be handled anyhow. */
2540 return TRUE;
2543 if (strlen (h->root.root.string) <= SYMNMLEN)
2544 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2545 else
2547 bfd_boolean hash;
2548 bfd_size_type indx;
2550 hash = TRUE;
2551 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2552 hash = FALSE;
2553 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2554 FALSE);
2555 if (indx == (bfd_size_type) -1)
2557 finfo->failed = TRUE;
2558 return FALSE;
2560 isym._n._n_n._n_zeroes = 0;
2561 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2564 isym.n_sclass = h->symbol_class;
2565 isym.n_type = h->type;
2567 if (isym.n_sclass == C_NULL)
2568 isym.n_sclass = C_EXT;
2570 /* If doing task linking and this is the pass where we convert
2571 defined globals to statics, then do that conversion now. If the
2572 symbol is not being converted, just ignore it and it will be
2573 output during a later pass. */
2574 if (finfo->global_to_static)
2576 if (! IS_EXTERNAL (output_bfd, isym))
2577 return TRUE;
2579 isym.n_sclass = C_STAT;
2582 /* When a weak symbol is not overridden by a strong one,
2583 turn it into an external symbol when not building a
2584 shared or relocatable object. */
2585 if (! finfo->info->shared
2586 && ! finfo->info->relocatable
2587 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2588 isym.n_sclass = C_EXT;
2590 isym.n_numaux = h->numaux;
2592 bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
2594 symesz = bfd_coff_symesz (output_bfd);
2596 pos = obj_sym_filepos (output_bfd);
2597 pos += obj_raw_syment_count (output_bfd) * symesz;
2598 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2599 || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2601 finfo->failed = TRUE;
2602 return FALSE;
2605 h->indx = obj_raw_syment_count (output_bfd);
2607 ++obj_raw_syment_count (output_bfd);
2609 /* Write out any associated aux entries. Most of the aux entries
2610 will have been modified in _bfd_coff_link_input_bfd. We have to
2611 handle section aux entries here, now that we have the final
2612 relocation and line number counts. */
2613 for (i = 0; i < isym.n_numaux; i++)
2615 union internal_auxent *auxp;
2617 auxp = h->aux + i;
2619 /* Look for a section aux entry here using the same tests that
2620 coff_swap_aux_out uses. */
2621 if (i == 0
2622 && (isym.n_sclass == C_STAT
2623 || isym.n_sclass == C_HIDDEN)
2624 && isym.n_type == T_NULL
2625 && (h->root.type == bfd_link_hash_defined
2626 || h->root.type == bfd_link_hash_defweak))
2628 asection *sec;
2630 sec = h->root.u.def.section->output_section;
2631 if (sec != NULL)
2633 auxp->x_scn.x_scnlen = sec->size;
2635 /* For PE, an overflow on the final link reportedly does
2636 not matter. FIXME: Why not? */
2637 if (sec->reloc_count > 0xffff
2638 && (! obj_pe (output_bfd)
2639 || finfo->info->relocatable))
2640 (*_bfd_error_handler)
2641 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2642 bfd_get_filename (output_bfd),
2643 bfd_get_section_name (output_bfd, sec),
2644 sec->reloc_count);
2646 if (sec->lineno_count > 0xffff
2647 && (! obj_pe (output_bfd)
2648 || finfo->info->relocatable))
2649 (*_bfd_error_handler)
2650 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2651 bfd_get_filename (output_bfd),
2652 bfd_get_section_name (output_bfd, sec),
2653 sec->lineno_count);
2655 auxp->x_scn.x_nreloc = sec->reloc_count;
2656 auxp->x_scn.x_nlinno = sec->lineno_count;
2657 auxp->x_scn.x_checksum = 0;
2658 auxp->x_scn.x_associated = 0;
2659 auxp->x_scn.x_comdat = 0;
2663 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2664 isym.n_sclass, (int) i, isym.n_numaux,
2665 finfo->outsyms);
2666 if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2668 finfo->failed = TRUE;
2669 return FALSE;
2671 ++obj_raw_syment_count (output_bfd);
2674 return TRUE;
2677 /* Write out task global symbols, converting them to statics. Called
2678 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2679 the dirty work, if the symbol we are processing needs conversion. */
2681 bfd_boolean
2682 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2684 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2685 bfd_boolean rtnval = TRUE;
2686 bfd_boolean save_global_to_static;
2688 if (h->root.type == bfd_link_hash_warning)
2689 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2691 if (h->indx < 0)
2693 switch (h->root.type)
2695 case bfd_link_hash_defined:
2696 case bfd_link_hash_defweak:
2697 save_global_to_static = finfo->global_to_static;
2698 finfo->global_to_static = TRUE;
2699 rtnval = _bfd_coff_write_global_sym (h, data);
2700 finfo->global_to_static = save_global_to_static;
2701 break;
2702 default:
2703 break;
2706 return (rtnval);
2709 /* Handle a link order which is supposed to generate a reloc. */
2711 bfd_boolean
2712 _bfd_coff_reloc_link_order (bfd *output_bfd,
2713 struct coff_final_link_info *finfo,
2714 asection *output_section,
2715 struct bfd_link_order *link_order)
2717 reloc_howto_type *howto;
2718 struct internal_reloc *irel;
2719 struct coff_link_hash_entry **rel_hash_ptr;
2721 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2722 if (howto == NULL)
2724 bfd_set_error (bfd_error_bad_value);
2725 return FALSE;
2728 if (link_order->u.reloc.p->addend != 0)
2730 bfd_size_type size;
2731 bfd_byte *buf;
2732 bfd_reloc_status_type rstat;
2733 bfd_boolean ok;
2734 file_ptr loc;
2736 size = bfd_get_reloc_size (howto);
2737 buf = (bfd_byte *) bfd_zmalloc (size);
2738 if (buf == NULL)
2739 return FALSE;
2741 rstat = _bfd_relocate_contents (howto, output_bfd,
2742 (bfd_vma) link_order->u.reloc.p->addend,\
2743 buf);
2744 switch (rstat)
2746 case bfd_reloc_ok:
2747 break;
2748 default:
2749 case bfd_reloc_outofrange:
2750 abort ();
2751 case bfd_reloc_overflow:
2752 if (! ((*finfo->info->callbacks->reloc_overflow)
2753 (finfo->info, NULL,
2754 (link_order->type == bfd_section_reloc_link_order
2755 ? bfd_section_name (output_bfd,
2756 link_order->u.reloc.p->u.section)
2757 : link_order->u.reloc.p->u.name),
2758 howto->name, link_order->u.reloc.p->addend,
2759 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2761 free (buf);
2762 return FALSE;
2764 break;
2766 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2767 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2768 loc, size);
2769 free (buf);
2770 if (! ok)
2771 return FALSE;
2774 /* Store the reloc information in the right place. It will get
2775 swapped and written out at the end of the final_link routine. */
2776 irel = (finfo->section_info[output_section->target_index].relocs
2777 + output_section->reloc_count);
2778 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2779 + output_section->reloc_count);
2781 memset (irel, 0, sizeof (struct internal_reloc));
2782 *rel_hash_ptr = NULL;
2784 irel->r_vaddr = output_section->vma + link_order->offset;
2786 if (link_order->type == bfd_section_reloc_link_order)
2788 /* We need to somehow locate a symbol in the right section. The
2789 symbol must either have a value of zero, or we must adjust
2790 the addend by the value of the symbol. FIXME: Write this
2791 when we need it. The old linker couldn't handle this anyhow. */
2792 abort ();
2793 *rel_hash_ptr = NULL;
2794 irel->r_symndx = 0;
2796 else
2798 struct coff_link_hash_entry *h;
2800 h = ((struct coff_link_hash_entry *)
2801 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2802 link_order->u.reloc.p->u.name,
2803 FALSE, FALSE, TRUE));
2804 if (h != NULL)
2806 if (h->indx >= 0)
2807 irel->r_symndx = h->indx;
2808 else
2810 /* Set the index to -2 to force this symbol to get
2811 written out. */
2812 h->indx = -2;
2813 *rel_hash_ptr = h;
2814 irel->r_symndx = 0;
2817 else
2819 if (! ((*finfo->info->callbacks->unattached_reloc)
2820 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2821 (asection *) NULL, (bfd_vma) 0)))
2822 return FALSE;
2823 irel->r_symndx = 0;
2827 /* FIXME: Is this always right? */
2828 irel->r_type = howto->type;
2830 /* r_size is only used on the RS/6000, which needs its own linker
2831 routines anyhow. r_extern is only used for ECOFF. */
2833 /* FIXME: What is the right value for r_offset? Is zero OK? */
2834 ++output_section->reloc_count;
2836 return TRUE;
2839 /* A basic reloc handling routine which may be used by processors with
2840 simple relocs. */
2842 bfd_boolean
2843 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2844 struct bfd_link_info *info,
2845 bfd *input_bfd,
2846 asection *input_section,
2847 bfd_byte *contents,
2848 struct internal_reloc *relocs,
2849 struct internal_syment *syms,
2850 asection **sections)
2852 struct internal_reloc *rel;
2853 struct internal_reloc *relend;
2855 rel = relocs;
2856 relend = rel + input_section->reloc_count;
2857 for (; rel < relend; rel++)
2859 long symndx;
2860 struct coff_link_hash_entry *h;
2861 struct internal_syment *sym;
2862 bfd_vma addend;
2863 bfd_vma val;
2864 reloc_howto_type *howto;
2865 bfd_reloc_status_type rstat;
2867 symndx = rel->r_symndx;
2869 if (symndx == -1)
2871 h = NULL;
2872 sym = NULL;
2874 else if (symndx < 0
2875 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2877 (*_bfd_error_handler)
2878 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2879 return FALSE;
2881 else
2883 h = obj_coff_sym_hashes (input_bfd)[symndx];
2884 sym = syms + symndx;
2887 /* COFF treats common symbols in one of two ways. Either the
2888 size of the symbol is included in the section contents, or it
2889 is not. We assume that the size is not included, and force
2890 the rtype_to_howto function to adjust the addend as needed. */
2891 if (sym != NULL && sym->n_scnum != 0)
2892 addend = - sym->n_value;
2893 else
2894 addend = 0;
2896 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2897 sym, &addend);
2898 if (howto == NULL)
2899 return FALSE;
2901 /* If we are doing a relocatable link, then we can just ignore
2902 a PC relative reloc that is pcrel_offset. It will already
2903 have the correct value. If this is not a relocatable link,
2904 then we should ignore the symbol value. */
2905 if (howto->pc_relative && howto->pcrel_offset)
2907 if (info->relocatable)
2908 continue;
2909 if (sym != NULL && sym->n_scnum != 0)
2910 addend += sym->n_value;
2913 val = 0;
2915 if (h == NULL)
2917 asection *sec;
2919 if (symndx == -1)
2921 sec = bfd_abs_section_ptr;
2922 val = 0;
2924 else
2926 sec = sections[symndx];
2927 val = (sec->output_section->vma
2928 + sec->output_offset
2929 + sym->n_value);
2930 if (! obj_pe (input_bfd))
2931 val -= sec->vma;
2934 else
2936 if (h->root.type == bfd_link_hash_defined
2937 || h->root.type == bfd_link_hash_defweak)
2939 /* Defined weak symbols are a GNU extension. */
2940 asection *sec;
2942 sec = h->root.u.def.section;
2943 val = (h->root.u.def.value
2944 + sec->output_section->vma
2945 + sec->output_offset);
2948 else if (h->root.type == bfd_link_hash_undefweak)
2950 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2952 /* See _Microsoft Portable Executable and Common Object
2953 File Format Specification_, section 5.5.3.
2954 Note that weak symbols without aux records are a GNU
2955 extension.
2956 FIXME: All weak externals are treated as having
2957 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
2958 These behave as per SVR4 ABI: A library member
2959 will resolve a weak external only if a normal
2960 external causes the library member to be linked.
2961 See also linker.c: generic_link_check_archive_element. */
2962 asection *sec;
2963 struct coff_link_hash_entry *h2 =
2964 h->auxbfd->tdata.coff_obj_data->sym_hashes[
2965 h->aux->x_sym.x_tagndx.l];
2967 if (!h2 || h2->root.type == bfd_link_hash_undefined)
2969 sec = bfd_abs_section_ptr;
2970 val = 0;
2972 else
2974 sec = h2->root.u.def.section;
2975 val = h2->root.u.def.value
2976 + sec->output_section->vma + sec->output_offset;
2979 else
2980 /* This is a GNU extension. */
2981 val = 0;
2984 else if (! info->relocatable)
2986 if (! ((*info->callbacks->undefined_symbol)
2987 (info, h->root.root.string, input_bfd, input_section,
2988 rel->r_vaddr - input_section->vma, TRUE)))
2989 return FALSE;
2993 if (info->base_file)
2995 /* Emit a reloc if the backend thinks it needs it. */
2996 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2998 /* Relocation to a symbol in a section which isn't
2999 absolute. We output the address here to a file.
3000 This file is then read by dlltool when generating the
3001 reloc section. Note that the base file is not
3002 portable between systems. We write out a bfd_vma here,
3003 and dlltool reads in a bfd_vma. */
3004 bfd_vma addr = (rel->r_vaddr
3005 - input_section->vma
3006 + input_section->output_offset
3007 + input_section->output_section->vma);
3008 if (coff_data (output_bfd)->pe)
3009 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3010 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
3011 != sizeof (bfd_vma))
3013 bfd_set_error (bfd_error_system_call);
3014 return FALSE;
3019 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3020 contents,
3021 rel->r_vaddr - input_section->vma,
3022 val, addend);
3024 switch (rstat)
3026 default:
3027 abort ();
3028 case bfd_reloc_ok:
3029 break;
3030 case bfd_reloc_outofrange:
3031 (*_bfd_error_handler)
3032 (_("%B: bad reloc address 0x%lx in section `%A'"),
3033 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3034 return FALSE;
3035 case bfd_reloc_overflow:
3037 const char *name;
3038 char buf[SYMNMLEN + 1];
3040 if (symndx == -1)
3041 name = "*ABS*";
3042 else if (h != NULL)
3043 name = NULL;
3044 else
3046 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3047 if (name == NULL)
3048 return FALSE;
3051 if (! ((*info->callbacks->reloc_overflow)
3052 (info, (h ? &h->root : NULL), name, howto->name,
3053 (bfd_vma) 0, input_bfd, input_section,
3054 rel->r_vaddr - input_section->vma)))
3055 return FALSE;
3059 return TRUE;