daily update
[binutils.git] / bfd / cofflink.c
bloba99a5b3fe6be9f59149d84ae0e42784fe6b4fd8f
1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005 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 2 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, MA 02110-1301, USA. */
22 /* This file contains the COFF backend linker code. */
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "coff/internal.h"
29 #include "libcoff.h"
30 #include "safe-ctype.h"
32 static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
33 static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
34 static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
36 /* Return TRUE if SYM is a weak, external symbol. */
37 #define IS_WEAK_EXTERNAL(abfd, sym) \
38 ((sym).n_sclass == C_WEAKEXT \
39 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
41 /* Return TRUE if SYM is an external symbol. */
42 #define IS_EXTERNAL(abfd, sym) \
43 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
45 /* Define macros so that the ISFCN, et. al., macros work correctly.
46 These macros are defined in include/coff/internal.h in terms of
47 N_TMASK, etc. These definitions require a user to define local
48 variables with the appropriate names, and with values from the
49 coff_data (abfd) structure. */
51 #define N_TMASK n_tmask
52 #define N_BTSHFT n_btshft
53 #define N_BTMASK n_btmask
55 /* Create an entry in a COFF linker hash table. */
57 struct bfd_hash_entry *
58 _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
59 struct bfd_hash_table *table,
60 const char *string)
62 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
64 /* Allocate the structure if it has not already been allocated by a
65 subclass. */
66 if (ret == (struct coff_link_hash_entry *) NULL)
67 ret = ((struct coff_link_hash_entry *)
68 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
69 if (ret == (struct coff_link_hash_entry *) NULL)
70 return (struct bfd_hash_entry *) ret;
72 /* Call the allocation method of the superclass. */
73 ret = ((struct coff_link_hash_entry *)
74 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
75 table, string));
76 if (ret != (struct coff_link_hash_entry *) NULL)
78 /* Set local fields. */
79 ret->indx = -1;
80 ret->type = T_NULL;
81 ret->class = C_NULL;
82 ret->numaux = 0;
83 ret->auxbfd = NULL;
84 ret->aux = NULL;
87 return (struct bfd_hash_entry *) ret;
90 /* Initialize a COFF linker hash table. */
92 bfd_boolean
93 _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
94 bfd *abfd,
95 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
96 struct bfd_hash_table *,
97 const char *))
99 memset (&table->stab_info, 0, sizeof (table->stab_info));
100 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
103 /* Create a COFF linker hash table. */
105 struct bfd_link_hash_table *
106 _bfd_coff_link_hash_table_create (bfd *abfd)
108 struct coff_link_hash_table *ret;
109 bfd_size_type amt = sizeof (struct coff_link_hash_table);
111 ret = bfd_malloc (amt);
112 if (ret == NULL)
113 return NULL;
115 if (! _bfd_coff_link_hash_table_init (ret, abfd,
116 _bfd_coff_link_hash_newfunc))
118 free (ret);
119 return (struct bfd_link_hash_table *) NULL;
121 return &ret->root;
124 /* Create an entry in a COFF debug merge hash table. */
126 struct bfd_hash_entry *
127 _bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry,
128 struct bfd_hash_table *table,
129 const char *string)
131 struct coff_debug_merge_hash_entry *ret =
132 (struct coff_debug_merge_hash_entry *) entry;
134 /* Allocate the structure if it has not already been allocated by a
135 subclass. */
136 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
137 ret = ((struct coff_debug_merge_hash_entry *)
138 bfd_hash_allocate (table,
139 sizeof (struct coff_debug_merge_hash_entry)));
140 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
141 return (struct bfd_hash_entry *) ret;
143 /* Call the allocation method of the superclass. */
144 ret = ((struct coff_debug_merge_hash_entry *)
145 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
146 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
148 /* Set local fields. */
149 ret->types = NULL;
152 return (struct bfd_hash_entry *) ret;
155 /* Given a COFF BFD, add symbols to the global hash table as
156 appropriate. */
158 bfd_boolean
159 _bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
161 switch (bfd_get_format (abfd))
163 case bfd_object:
164 return coff_link_add_object_symbols (abfd, info);
165 case bfd_archive:
166 return _bfd_generic_link_add_archive_symbols
167 (abfd, info, coff_link_check_archive_element);
168 default:
169 bfd_set_error (bfd_error_wrong_format);
170 return FALSE;
174 /* Add symbols from a COFF object file. */
176 static bfd_boolean
177 coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
179 if (! _bfd_coff_get_external_symbols (abfd))
180 return FALSE;
181 if (! coff_link_add_symbols (abfd, info))
182 return FALSE;
184 if (! info->keep_memory
185 && ! _bfd_coff_free_symbols (abfd))
186 return FALSE;
188 return TRUE;
191 /* Look through the symbols to see if this object file should be
192 included in the link. */
194 static bfd_boolean
195 coff_link_check_ar_symbols (bfd *abfd,
196 struct bfd_link_info *info,
197 bfd_boolean *pneeded)
199 bfd_size_type symesz;
200 bfd_byte *esym;
201 bfd_byte *esym_end;
203 *pneeded = FALSE;
205 symesz = bfd_coff_symesz (abfd);
206 esym = (bfd_byte *) obj_coff_external_syms (abfd);
207 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
208 while (esym < esym_end)
210 struct internal_syment sym;
211 enum coff_symbol_classification classification;
213 bfd_coff_swap_sym_in (abfd, esym, &sym);
215 classification = bfd_coff_classify_symbol (abfd, &sym);
216 if (classification == COFF_SYMBOL_GLOBAL
217 || classification == COFF_SYMBOL_COMMON)
219 const char *name;
220 char buf[SYMNMLEN + 1];
221 struct bfd_link_hash_entry *h;
223 /* This symbol is externally visible, and is defined by this
224 object file. */
225 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
226 if (name == NULL)
227 return FALSE;
228 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
230 /* Auto import. */
231 if (!h
232 && info->pei386_auto_import
233 && !strncmp (name,"__imp_", 6))
234 h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
236 /* We are only interested in symbols that are currently
237 undefined. If a symbol is currently known to be common,
238 COFF linkers do not bring in an object file which defines
239 it. */
240 if (h != (struct bfd_link_hash_entry *) NULL
241 && h->type == bfd_link_hash_undefined)
243 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
244 return FALSE;
245 *pneeded = TRUE;
246 return TRUE;
250 esym += (sym.n_numaux + 1) * symesz;
253 /* We do not need this object file. */
254 return TRUE;
257 /* Check a single archive element to see if we need to include it in
258 the link. *PNEEDED is set according to whether this element is
259 needed in the link or not. This is called via
260 _bfd_generic_link_add_archive_symbols. */
262 static bfd_boolean
263 coff_link_check_archive_element (bfd *abfd,
264 struct bfd_link_info *info,
265 bfd_boolean *pneeded)
267 if (! _bfd_coff_get_external_symbols (abfd))
268 return FALSE;
270 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
271 return FALSE;
273 if (*pneeded
274 && ! coff_link_add_symbols (abfd, info))
275 return FALSE;
277 if ((! info->keep_memory || ! *pneeded)
278 && ! _bfd_coff_free_symbols (abfd))
279 return FALSE;
281 return TRUE;
284 /* Add all the symbols from an object file to the hash table. */
286 static bfd_boolean
287 coff_link_add_symbols (bfd *abfd,
288 struct bfd_link_info *info)
290 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
291 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
292 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
293 bfd_boolean keep_syms;
294 bfd_boolean default_copy;
295 bfd_size_type symcount;
296 struct coff_link_hash_entry **sym_hash;
297 bfd_size_type symesz;
298 bfd_byte *esym;
299 bfd_byte *esym_end;
300 bfd_size_type amt;
302 /* Keep the symbols during this function, in case the linker needs
303 to read the generic symbols in order to report an error message. */
304 keep_syms = obj_coff_keep_syms (abfd);
305 obj_coff_keep_syms (abfd) = TRUE;
307 if (info->keep_memory)
308 default_copy = FALSE;
309 else
310 default_copy = TRUE;
312 symcount = obj_raw_syment_count (abfd);
314 /* We keep a list of the linker hash table entries that correspond
315 to particular symbols. */
316 amt = symcount * sizeof (struct coff_link_hash_entry *);
317 sym_hash = bfd_zalloc (abfd, amt);
318 if (sym_hash == NULL && symcount != 0)
319 goto error_return;
320 obj_coff_sym_hashes (abfd) = sym_hash;
322 symesz = bfd_coff_symesz (abfd);
323 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
324 esym = (bfd_byte *) obj_coff_external_syms (abfd);
325 esym_end = esym + symcount * symesz;
326 while (esym < esym_end)
328 struct internal_syment sym;
329 enum coff_symbol_classification classification;
330 bfd_boolean copy;
332 bfd_coff_swap_sym_in (abfd, esym, &sym);
334 classification = bfd_coff_classify_symbol (abfd, &sym);
335 if (classification != COFF_SYMBOL_LOCAL)
337 const char *name;
338 char buf[SYMNMLEN + 1];
339 flagword flags;
340 asection *section;
341 bfd_vma value;
342 bfd_boolean addit;
344 /* This symbol is externally visible. */
346 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
347 if (name == NULL)
348 goto error_return;
350 /* We must copy the name into memory if we got it from the
351 syment itself, rather than the string table. */
352 copy = default_copy;
353 if (sym._n._n_n._n_zeroes != 0
354 || sym._n._n_n._n_offset == 0)
355 copy = TRUE;
357 value = sym.n_value;
359 switch (classification)
361 default:
362 abort ();
364 case COFF_SYMBOL_GLOBAL:
365 flags = BSF_EXPORT | BSF_GLOBAL;
366 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
367 if (! obj_pe (abfd))
368 value -= section->vma;
369 break;
371 case COFF_SYMBOL_UNDEFINED:
372 flags = 0;
373 section = bfd_und_section_ptr;
374 break;
376 case COFF_SYMBOL_COMMON:
377 flags = BSF_GLOBAL;
378 section = bfd_com_section_ptr;
379 break;
381 case COFF_SYMBOL_PE_SECTION:
382 flags = BSF_SECTION_SYM | BSF_GLOBAL;
383 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
384 break;
387 if (IS_WEAK_EXTERNAL (abfd, sym))
388 flags = BSF_WEAK;
390 addit = TRUE;
392 /* In the PE format, section symbols actually refer to the
393 start of the output section. We handle them specially
394 here. */
395 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
397 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
398 name, FALSE, copy, FALSE);
399 if (*sym_hash != NULL)
401 if (((*sym_hash)->coff_link_hash_flags
402 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
403 && (*sym_hash)->root.type != bfd_link_hash_undefined
404 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
405 (*_bfd_error_handler)
406 ("Warning: symbol `%s' is both section and non-section",
407 name);
409 addit = FALSE;
413 /* The Microsoft Visual C compiler does string pooling by
414 hashing the constants to an internal symbol name, and
415 relying on the linker comdat support to discard
416 duplicate names. However, if one string is a literal and
417 one is a data initializer, one will end up in the .data
418 section and one will end up in the .rdata section. The
419 Microsoft linker will combine them into the .data
420 section, which seems to be wrong since it might cause the
421 literal to change.
423 As long as there are no external references to the
424 symbols, which there shouldn't be, we can treat the .data
425 and .rdata instances as separate symbols. The comdat
426 code in the linker will do the appropriate merging. Here
427 we avoid getting a multiple definition error for one of
428 these special symbols.
430 FIXME: I don't think this will work in the case where
431 there are two object files which use the constants as a
432 literal and two object files which use it as a data
433 initializer. One or the other of the second object files
434 is going to wind up with an inappropriate reference. */
435 if (obj_pe (abfd)
436 && (classification == COFF_SYMBOL_GLOBAL
437 || classification == COFF_SYMBOL_PE_SECTION)
438 && coff_section_data (abfd, section) != NULL
439 && coff_section_data (abfd, section)->comdat != NULL
440 && strncmp (name, "??_", 3) == 0
441 && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
443 if (*sym_hash == NULL)
444 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
445 name, FALSE, copy, FALSE);
446 if (*sym_hash != NULL
447 && (*sym_hash)->root.type == bfd_link_hash_defined
448 && coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL
449 && strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name,
450 coff_section_data (abfd, section)->comdat->name) == 0)
451 addit = FALSE;
454 if (addit)
456 if (! (bfd_coff_link_add_one_symbol
457 (info, abfd, name, flags, section, value,
458 (const char *) NULL, copy, FALSE,
459 (struct bfd_link_hash_entry **) sym_hash)))
460 goto error_return;
463 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
464 (*sym_hash)->coff_link_hash_flags |=
465 COFF_LINK_HASH_PE_SECTION_SYMBOL;
467 /* Limit the alignment of a common symbol to the possible
468 alignment of a section. There is no point to permitting
469 a higher alignment for a common symbol: we can not
470 guarantee it, and it may cause us to allocate extra space
471 in the common section. */
472 if (section == bfd_com_section_ptr
473 && (*sym_hash)->root.type == bfd_link_hash_common
474 && ((*sym_hash)->root.u.c.p->alignment_power
475 > bfd_coff_default_section_alignment_power (abfd)))
476 (*sym_hash)->root.u.c.p->alignment_power
477 = bfd_coff_default_section_alignment_power (abfd);
479 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
481 /* If we don't have any symbol information currently in
482 the hash table, or if we are looking at a symbol
483 definition, then update the symbol class and type in
484 the hash table. */
485 if (((*sym_hash)->class == C_NULL
486 && (*sym_hash)->type == T_NULL)
487 || sym.n_scnum != 0
488 || (sym.n_value != 0
489 && (*sym_hash)->root.type != bfd_link_hash_defined
490 && (*sym_hash)->root.type != bfd_link_hash_defweak))
492 (*sym_hash)->class = sym.n_sclass;
493 if (sym.n_type != T_NULL)
495 /* We want to warn if the type changed, but not
496 if it changed from an unspecified type.
497 Testing the whole type byte may work, but the
498 change from (e.g.) a function of unspecified
499 type to function of known type also wants to
500 skip the warning. */
501 if ((*sym_hash)->type != T_NULL
502 && (*sym_hash)->type != sym.n_type
503 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
504 && (BTYPE ((*sym_hash)->type) == T_NULL
505 || BTYPE (sym.n_type) == T_NULL)))
506 (*_bfd_error_handler)
507 (_("Warning: type of symbol `%s' changed from %d to %d in %B"),
508 abfd, name, (*sym_hash)->type, sym.n_type);
510 /* We don't want to change from a meaningful
511 base type to a null one, but if we know
512 nothing, take what little we might now know. */
513 if (BTYPE (sym.n_type) != T_NULL
514 || (*sym_hash)->type == T_NULL)
515 (*sym_hash)->type = sym.n_type;
517 (*sym_hash)->auxbfd = abfd;
518 if (sym.n_numaux != 0)
520 union internal_auxent *alloc;
521 unsigned int i;
522 bfd_byte *eaux;
523 union internal_auxent *iaux;
525 (*sym_hash)->numaux = sym.n_numaux;
526 alloc = ((union internal_auxent *)
527 bfd_hash_allocate (&info->hash->table,
528 (sym.n_numaux
529 * sizeof (*alloc))));
530 if (alloc == NULL)
531 goto error_return;
532 for (i = 0, eaux = esym + symesz, iaux = alloc;
533 i < sym.n_numaux;
534 i++, eaux += symesz, iaux++)
535 bfd_coff_swap_aux_in (abfd, eaux, sym.n_type,
536 sym.n_sclass, (int) i,
537 sym.n_numaux, iaux);
538 (*sym_hash)->aux = alloc;
543 if (classification == COFF_SYMBOL_PE_SECTION
544 && (*sym_hash)->numaux != 0)
546 /* Some PE sections (such as .bss) have a zero size in
547 the section header, but a non-zero size in the AUX
548 record. Correct that here.
550 FIXME: This is not at all the right place to do this.
551 For example, it won't help objdump. This needs to be
552 done when we swap in the section header. */
553 BFD_ASSERT ((*sym_hash)->numaux == 1);
554 if (section->size == 0)
555 section->size = (*sym_hash)->aux[0].x_scn.x_scnlen;
557 /* FIXME: We could test whether the section sizes
558 matches the size in the aux entry, but apparently
559 that sometimes fails unexpectedly. */
563 esym += (sym.n_numaux + 1) * symesz;
564 sym_hash += sym.n_numaux + 1;
567 /* If this is a non-traditional, non-relocatable link, try to
568 optimize the handling of any .stab/.stabstr sections. */
569 if (! info->relocatable
570 && ! info->traditional_format
571 && info->hash->creator->flavour == bfd_get_flavour (abfd)
572 && (info->strip != strip_all && info->strip != strip_debugger))
574 asection *stabstr;
576 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
578 if (stabstr != NULL)
580 bfd_size_type string_offset = 0;
581 asection *stab;
583 for (stab = abfd->sections; stab; stab = stab->next)
584 if (strncmp (".stab", stab->name, 5) == 0
585 && (!stab->name[5]
586 || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
588 struct coff_link_hash_table *table;
589 struct coff_section_tdata *secdata
590 = coff_section_data (abfd, stab);
592 if (secdata == NULL)
594 amt = sizeof (struct coff_section_tdata);
595 stab->used_by_bfd = bfd_zalloc (abfd, amt);
596 if (stab->used_by_bfd == NULL)
597 goto error_return;
598 secdata = coff_section_data (abfd, stab);
601 table = coff_hash_table (info);
603 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
604 stab, stabstr,
605 &secdata->stab_info,
606 &string_offset))
607 goto error_return;
612 obj_coff_keep_syms (abfd) = keep_syms;
614 return TRUE;
616 error_return:
617 obj_coff_keep_syms (abfd) = keep_syms;
618 return FALSE;
621 /* Do the final link step. */
623 bfd_boolean
624 _bfd_coff_final_link (bfd *abfd,
625 struct bfd_link_info *info)
627 bfd_size_type symesz;
628 struct coff_final_link_info finfo;
629 bfd_boolean debug_merge_allocated;
630 bfd_boolean long_section_names;
631 asection *o;
632 struct bfd_link_order *p;
633 bfd_size_type max_sym_count;
634 bfd_size_type max_lineno_count;
635 bfd_size_type max_reloc_count;
636 bfd_size_type max_output_reloc_count;
637 bfd_size_type max_contents_size;
638 file_ptr rel_filepos;
639 unsigned int relsz;
640 file_ptr line_filepos;
641 unsigned int linesz;
642 bfd *sub;
643 bfd_byte *external_relocs = NULL;
644 char strbuf[STRING_SIZE_SIZE];
645 bfd_size_type amt;
647 symesz = bfd_coff_symesz (abfd);
649 finfo.info = info;
650 finfo.output_bfd = abfd;
651 finfo.strtab = NULL;
652 finfo.section_info = NULL;
653 finfo.last_file_index = -1;
654 finfo.last_bf_index = -1;
655 finfo.internal_syms = NULL;
656 finfo.sec_ptrs = NULL;
657 finfo.sym_indices = NULL;
658 finfo.outsyms = NULL;
659 finfo.linenos = NULL;
660 finfo.contents = NULL;
661 finfo.external_relocs = NULL;
662 finfo.internal_relocs = NULL;
663 finfo.global_to_static = FALSE;
664 debug_merge_allocated = FALSE;
666 coff_data (abfd)->link_info = info;
668 finfo.strtab = _bfd_stringtab_init ();
669 if (finfo.strtab == NULL)
670 goto error_return;
672 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
673 goto error_return;
674 debug_merge_allocated = TRUE;
676 /* Compute the file positions for all the sections. */
677 if (! abfd->output_has_begun)
679 if (! bfd_coff_compute_section_file_positions (abfd))
680 goto error_return;
683 /* Count the line numbers and relocation entries required for the
684 output file. Set the file positions for the relocs. */
685 rel_filepos = obj_relocbase (abfd);
686 relsz = bfd_coff_relsz (abfd);
687 max_contents_size = 0;
688 max_lineno_count = 0;
689 max_reloc_count = 0;
691 long_section_names = FALSE;
692 for (o = abfd->sections; o != NULL; o = o->next)
694 o->reloc_count = 0;
695 o->lineno_count = 0;
696 for (p = o->map_head.link_order; p != NULL; p = p->next)
698 if (p->type == bfd_indirect_link_order)
700 asection *sec;
702 sec = p->u.indirect.section;
704 /* Mark all sections which are to be included in the
705 link. This will normally be every section. We need
706 to do this so that we can identify any sections which
707 the linker has decided to not include. */
708 sec->linker_mark = TRUE;
710 if (info->strip == strip_none
711 || info->strip == strip_some)
712 o->lineno_count += sec->lineno_count;
714 if (info->relocatable)
715 o->reloc_count += sec->reloc_count;
717 if (sec->rawsize > max_contents_size)
718 max_contents_size = sec->rawsize;
719 if (sec->size > max_contents_size)
720 max_contents_size = sec->size;
721 if (sec->lineno_count > max_lineno_count)
722 max_lineno_count = sec->lineno_count;
723 if (sec->reloc_count > max_reloc_count)
724 max_reloc_count = sec->reloc_count;
726 else if (info->relocatable
727 && (p->type == bfd_section_reloc_link_order
728 || p->type == bfd_symbol_reloc_link_order))
729 ++o->reloc_count;
731 if (o->reloc_count == 0)
732 o->rel_filepos = 0;
733 else
735 o->flags |= SEC_RELOC;
736 o->rel_filepos = rel_filepos;
737 rel_filepos += o->reloc_count * relsz;
738 /* In PE COFF, if there are at least 0xffff relocations an
739 extra relocation will be written out to encode the count. */
740 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
741 rel_filepos += relsz;
744 if (bfd_coff_long_section_names (abfd)
745 && strlen (o->name) > SCNNMLEN)
747 /* This section has a long name which must go in the string
748 table. This must correspond to the code in
749 coff_write_object_contents which puts the string index
750 into the s_name field of the section header. That is why
751 we pass hash as FALSE. */
752 if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
753 == (bfd_size_type) -1)
754 goto error_return;
755 long_section_names = TRUE;
759 /* If doing a relocatable link, allocate space for the pointers we
760 need to keep. */
761 if (info->relocatable)
763 unsigned int i;
765 /* We use section_count + 1, rather than section_count, because
766 the target_index fields are 1 based. */
767 amt = abfd->section_count + 1;
768 amt *= sizeof (struct coff_link_section_info);
769 finfo.section_info = bfd_malloc (amt);
770 if (finfo.section_info == NULL)
771 goto error_return;
772 for (i = 0; i <= abfd->section_count; i++)
774 finfo.section_info[i].relocs = NULL;
775 finfo.section_info[i].rel_hashes = NULL;
779 /* We now know the size of the relocs, so we can determine the file
780 positions of the line numbers. */
781 line_filepos = rel_filepos;
782 linesz = bfd_coff_linesz (abfd);
783 max_output_reloc_count = 0;
784 for (o = abfd->sections; o != NULL; o = o->next)
786 if (o->lineno_count == 0)
787 o->line_filepos = 0;
788 else
790 o->line_filepos = line_filepos;
791 line_filepos += o->lineno_count * linesz;
794 if (o->reloc_count != 0)
796 /* We don't know the indices of global symbols until we have
797 written out all the local symbols. For each section in
798 the output file, we keep an array of pointers to hash
799 table entries. Each entry in the array corresponds to a
800 reloc. When we find a reloc against a global symbol, we
801 set the corresponding entry in this array so that we can
802 fix up the symbol index after we have written out all the
803 local symbols.
805 Because of this problem, we also keep the relocs in
806 memory until the end of the link. This wastes memory,
807 but only when doing a relocatable link, which is not the
808 common case. */
809 BFD_ASSERT (info->relocatable);
810 amt = o->reloc_count;
811 amt *= sizeof (struct internal_reloc);
812 finfo.section_info[o->target_index].relocs = bfd_malloc (amt);
813 amt = o->reloc_count;
814 amt *= sizeof (struct coff_link_hash_entry *);
815 finfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt);
816 if (finfo.section_info[o->target_index].relocs == NULL
817 || finfo.section_info[o->target_index].rel_hashes == NULL)
818 goto error_return;
820 if (o->reloc_count > max_output_reloc_count)
821 max_output_reloc_count = o->reloc_count;
824 /* Reset the reloc and lineno counts, so that we can use them to
825 count the number of entries we have output so far. */
826 o->reloc_count = 0;
827 o->lineno_count = 0;
830 obj_sym_filepos (abfd) = line_filepos;
832 /* Figure out the largest number of symbols in an input BFD. Take
833 the opportunity to clear the output_has_begun fields of all the
834 input BFD's. */
835 max_sym_count = 0;
836 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
838 size_t sz;
840 sub->output_has_begun = FALSE;
841 sz = obj_raw_syment_count (sub);
842 if (sz > max_sym_count)
843 max_sym_count = sz;
846 /* Allocate some buffers used while linking. */
847 amt = max_sym_count * sizeof (struct internal_syment);
848 finfo.internal_syms = bfd_malloc (amt);
849 amt = max_sym_count * sizeof (asection *);
850 finfo.sec_ptrs = bfd_malloc (amt);
851 amt = max_sym_count * sizeof (long);
852 finfo.sym_indices = bfd_malloc (amt);
853 finfo.outsyms = bfd_malloc ((max_sym_count + 1) * symesz);
854 amt = max_lineno_count * bfd_coff_linesz (abfd);
855 finfo.linenos = bfd_malloc (amt);
856 finfo.contents = bfd_malloc (max_contents_size);
857 amt = max_reloc_count * relsz;
858 finfo.external_relocs = bfd_malloc (amt);
859 if (! info->relocatable)
861 amt = max_reloc_count * sizeof (struct internal_reloc);
862 finfo.internal_relocs = bfd_malloc (amt);
864 if ((finfo.internal_syms == NULL && max_sym_count > 0)
865 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
866 || (finfo.sym_indices == NULL && max_sym_count > 0)
867 || finfo.outsyms == NULL
868 || (finfo.linenos == NULL && max_lineno_count > 0)
869 || (finfo.contents == NULL && max_contents_size > 0)
870 || (finfo.external_relocs == NULL && max_reloc_count > 0)
871 || (! info->relocatable
872 && finfo.internal_relocs == NULL
873 && max_reloc_count > 0))
874 goto error_return;
876 /* We now know the position of everything in the file, except that
877 we don't know the size of the symbol table and therefore we don't
878 know where the string table starts. We just build the string
879 table in memory as we go along. We process all the relocations
880 for a single input file at once. */
881 obj_raw_syment_count (abfd) = 0;
883 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
885 if (! bfd_coff_start_final_link (abfd, info))
886 goto error_return;
889 for (o = abfd->sections; o != NULL; o = o->next)
891 for (p = o->map_head.link_order; p != NULL; p = p->next)
893 if (p->type == bfd_indirect_link_order
894 && bfd_family_coff (p->u.indirect.section->owner))
896 sub = p->u.indirect.section->owner;
897 if (! bfd_coff_link_output_has_begun (sub, & finfo))
899 if (! _bfd_coff_link_input_bfd (&finfo, sub))
900 goto error_return;
901 sub->output_has_begun = TRUE;
904 else if (p->type == bfd_section_reloc_link_order
905 || p->type == bfd_symbol_reloc_link_order)
907 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
908 goto error_return;
910 else
912 if (! _bfd_default_link_order (abfd, info, o, p))
913 goto error_return;
918 if (! bfd_coff_final_link_postscript (abfd, & finfo))
919 goto error_return;
921 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
923 coff_debug_merge_hash_table_free (&finfo.debug_merge);
924 debug_merge_allocated = FALSE;
926 if (finfo.internal_syms != NULL)
928 free (finfo.internal_syms);
929 finfo.internal_syms = NULL;
931 if (finfo.sec_ptrs != NULL)
933 free (finfo.sec_ptrs);
934 finfo.sec_ptrs = NULL;
936 if (finfo.sym_indices != NULL)
938 free (finfo.sym_indices);
939 finfo.sym_indices = NULL;
941 if (finfo.linenos != NULL)
943 free (finfo.linenos);
944 finfo.linenos = NULL;
946 if (finfo.contents != NULL)
948 free (finfo.contents);
949 finfo.contents = NULL;
951 if (finfo.external_relocs != NULL)
953 free (finfo.external_relocs);
954 finfo.external_relocs = NULL;
956 if (finfo.internal_relocs != NULL)
958 free (finfo.internal_relocs);
959 finfo.internal_relocs = NULL;
962 /* The value of the last C_FILE symbol is supposed to be the symbol
963 index of the first external symbol. Write it out again if
964 necessary. */
965 if (finfo.last_file_index != -1
966 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
968 file_ptr pos;
970 finfo.last_file.n_value = obj_raw_syment_count (abfd);
971 bfd_coff_swap_sym_out (abfd, &finfo.last_file,
972 finfo.outsyms);
974 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
975 if (bfd_seek (abfd, pos, SEEK_SET) != 0
976 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
977 return FALSE;
980 /* If doing task linking (ld --task-link) then make a pass through the
981 global symbols, writing out any that are defined, and making them
982 static. */
983 if (info->task_link)
985 finfo.failed = FALSE;
986 coff_link_hash_traverse (coff_hash_table (info),
987 _bfd_coff_write_task_globals, &finfo);
988 if (finfo.failed)
989 goto error_return;
992 /* Write out the global symbols. */
993 finfo.failed = FALSE;
994 coff_link_hash_traverse (coff_hash_table (info),
995 _bfd_coff_write_global_sym, &finfo);
996 if (finfo.failed)
997 goto error_return;
999 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1000 if (finfo.outsyms != NULL)
1002 free (finfo.outsyms);
1003 finfo.outsyms = NULL;
1006 if (info->relocatable && max_output_reloc_count > 0)
1008 /* Now that we have written out all the global symbols, we know
1009 the symbol indices to use for relocs against them, and we can
1010 finally write out the relocs. */
1011 amt = max_output_reloc_count * relsz;
1012 external_relocs = bfd_malloc (amt);
1013 if (external_relocs == NULL)
1014 goto error_return;
1016 for (o = abfd->sections; o != NULL; o = o->next)
1018 struct internal_reloc *irel;
1019 struct internal_reloc *irelend;
1020 struct coff_link_hash_entry **rel_hash;
1021 bfd_byte *erel;
1023 if (o->reloc_count == 0)
1024 continue;
1026 irel = finfo.section_info[o->target_index].relocs;
1027 irelend = irel + o->reloc_count;
1028 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1029 erel = external_relocs;
1030 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1032 if (*rel_hash != NULL)
1034 BFD_ASSERT ((*rel_hash)->indx >= 0);
1035 irel->r_symndx = (*rel_hash)->indx;
1037 bfd_coff_swap_reloc_out (abfd, irel, erel);
1040 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
1041 goto error_return;
1042 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
1044 /* In PE COFF, write the count of relocs as the first
1045 reloc. The header overflow bit will be set
1046 elsewhere. */
1047 struct internal_reloc incount;
1048 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
1050 memset (&incount, 0, sizeof (incount));
1051 incount.r_vaddr = o->reloc_count + 1;
1052 bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
1053 if (bfd_bwrite (excount, relsz, abfd) != relsz)
1054 /* We'll leak, but it's an error anyway. */
1055 goto error_return;
1056 free (excount);
1058 if (bfd_bwrite (external_relocs,
1059 (bfd_size_type) relsz * o->reloc_count, abfd)
1060 != (bfd_size_type) relsz * o->reloc_count)
1061 goto error_return;
1064 free (external_relocs);
1065 external_relocs = NULL;
1068 /* Free up the section information. */
1069 if (finfo.section_info != NULL)
1071 unsigned int i;
1073 for (i = 0; i < abfd->section_count; i++)
1075 if (finfo.section_info[i].relocs != NULL)
1076 free (finfo.section_info[i].relocs);
1077 if (finfo.section_info[i].rel_hashes != NULL)
1078 free (finfo.section_info[i].rel_hashes);
1080 free (finfo.section_info);
1081 finfo.section_info = NULL;
1084 /* If we have optimized stabs strings, output them. */
1085 if (coff_hash_table (info)->stab_info.stabstr != NULL)
1087 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1088 return FALSE;
1091 /* Write out the string table. */
1092 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1094 file_ptr pos;
1096 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1097 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1098 return FALSE;
1100 #if STRING_SIZE_SIZE == 4
1101 H_PUT_32 (abfd,
1102 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1103 strbuf);
1104 #else
1105 #error Change H_PUT_32 above
1106 #endif
1108 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1109 != STRING_SIZE_SIZE)
1110 return FALSE;
1112 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1113 return FALSE;
1115 obj_coff_strings_written (abfd) = TRUE;
1118 _bfd_stringtab_free (finfo.strtab);
1120 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1121 not try to write out the symbols. */
1122 bfd_get_symcount (abfd) = 0;
1124 return TRUE;
1126 error_return:
1127 if (debug_merge_allocated)
1128 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1129 if (finfo.strtab != NULL)
1130 _bfd_stringtab_free (finfo.strtab);
1131 if (finfo.section_info != NULL)
1133 unsigned int i;
1135 for (i = 0; i < abfd->section_count; i++)
1137 if (finfo.section_info[i].relocs != NULL)
1138 free (finfo.section_info[i].relocs);
1139 if (finfo.section_info[i].rel_hashes != NULL)
1140 free (finfo.section_info[i].rel_hashes);
1142 free (finfo.section_info);
1144 if (finfo.internal_syms != NULL)
1145 free (finfo.internal_syms);
1146 if (finfo.sec_ptrs != NULL)
1147 free (finfo.sec_ptrs);
1148 if (finfo.sym_indices != NULL)
1149 free (finfo.sym_indices);
1150 if (finfo.outsyms != NULL)
1151 free (finfo.outsyms);
1152 if (finfo.linenos != NULL)
1153 free (finfo.linenos);
1154 if (finfo.contents != NULL)
1155 free (finfo.contents);
1156 if (finfo.external_relocs != NULL)
1157 free (finfo.external_relocs);
1158 if (finfo.internal_relocs != NULL)
1159 free (finfo.internal_relocs);
1160 if (external_relocs != NULL)
1161 free (external_relocs);
1162 return FALSE;
1165 /* Parse out a -heap <reserved>,<commit> line. */
1167 static char *
1168 dores_com (char *ptr, bfd *output_bfd, int heap)
1170 if (coff_data(output_bfd)->pe)
1172 int val = strtoul (ptr, &ptr, 0);
1174 if (heap)
1175 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1176 else
1177 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1179 if (ptr[0] == ',')
1181 val = strtoul (ptr+1, &ptr, 0);
1182 if (heap)
1183 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1184 else
1185 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1188 return ptr;
1191 static char *
1192 get_name (char *ptr, char **dst)
1194 while (*ptr == ' ')
1195 ptr++;
1196 *dst = ptr;
1197 while (*ptr && *ptr != ' ')
1198 ptr++;
1199 *ptr = 0;
1200 return ptr+1;
1203 /* Process any magic embedded commands in a section called .drectve. */
1205 static int
1206 process_embedded_commands (bfd *output_bfd,
1207 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1208 bfd *abfd)
1210 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1211 char *s;
1212 char *e;
1213 bfd_byte *copy;
1215 if (!sec)
1216 return 1;
1218 if (!bfd_malloc_and_get_section (abfd, sec, &copy))
1220 if (copy != NULL)
1221 free (copy);
1222 return 0;
1224 e = (char *) copy + sec->size;
1226 for (s = (char *) copy; s < e ; )
1228 if (s[0] != '-')
1230 s++;
1231 continue;
1233 if (strncmp (s, "-attr", 5) == 0)
1235 char *name;
1236 char *attribs;
1237 asection *asec;
1238 int loop = 1;
1239 int had_write = 0;
1240 int had_read = 0;
1241 int had_exec= 0;
1242 int had_shared= 0;
1244 s += 5;
1245 s = get_name (s, &name);
1246 s = get_name (s, &attribs);
1248 while (loop)
1250 switch (*attribs++)
1252 case 'W':
1253 had_write = 1;
1254 break;
1255 case 'R':
1256 had_read = 1;
1257 break;
1258 case 'S':
1259 had_shared = 1;
1260 break;
1261 case 'X':
1262 had_exec = 1;
1263 break;
1264 default:
1265 loop = 0;
1268 asec = bfd_get_section_by_name (abfd, name);
1269 if (asec)
1271 if (had_exec)
1272 asec->flags |= SEC_CODE;
1273 if (!had_write)
1274 asec->flags |= SEC_READONLY;
1277 else if (strncmp (s,"-heap", 5) == 0)
1278 s = dores_com (s+5, output_bfd, 1);
1280 else if (strncmp (s,"-stack", 6) == 0)
1281 s = dores_com (s+6, output_bfd, 0);
1283 else
1284 s++;
1286 free (copy);
1287 return 1;
1290 /* Place a marker against all symbols which are used by relocations.
1291 This marker can be picked up by the 'do we skip this symbol ?'
1292 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1293 that symbol. */
1295 static void
1296 mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
1298 asection * a;
1300 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1301 return;
1303 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1305 struct internal_reloc * internal_relocs;
1306 struct internal_reloc * irel;
1307 struct internal_reloc * irelend;
1309 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1310 continue;
1311 /* Don't mark relocs in excluded sections. */
1312 if (a->output_section == bfd_abs_section_ptr)
1313 continue;
1315 /* Read in the relocs. */
1316 internal_relocs = _bfd_coff_read_internal_relocs
1317 (input_bfd, a, FALSE,
1318 finfo->external_relocs,
1319 finfo->info->relocatable,
1320 (finfo->info->relocatable
1321 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1322 : finfo->internal_relocs)
1325 if (internal_relocs == NULL)
1326 continue;
1328 irel = internal_relocs;
1329 irelend = irel + a->reloc_count;
1331 /* Place a mark in the sym_indices array (whose entries have
1332 been initialised to 0) for all of the symbols that are used
1333 in the relocation table. This will then be picked up in the
1334 skip/don't-skip pass. */
1335 for (; irel < irelend; irel++)
1336 finfo->sym_indices[ irel->r_symndx ] = -1;
1340 /* Link an input file into the linker output file. This function
1341 handles all the sections and relocations of the input file at once. */
1343 bfd_boolean
1344 _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
1346 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1347 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1348 bfd_boolean (*adjust_symndx)
1349 (bfd *, struct bfd_link_info *, bfd *, asection *,
1350 struct internal_reloc *, bfd_boolean *);
1351 bfd *output_bfd;
1352 const char *strings;
1353 bfd_size_type syment_base;
1354 bfd_boolean copy, hash;
1355 bfd_size_type isymesz;
1356 bfd_size_type osymesz;
1357 bfd_size_type linesz;
1358 bfd_byte *esym;
1359 bfd_byte *esym_end;
1360 struct internal_syment *isymp;
1361 asection **secpp;
1362 long *indexp;
1363 unsigned long output_index;
1364 bfd_byte *outsym;
1365 struct coff_link_hash_entry **sym_hash;
1366 asection *o;
1368 /* Move all the symbols to the output file. */
1370 output_bfd = finfo->output_bfd;
1371 strings = NULL;
1372 syment_base = obj_raw_syment_count (output_bfd);
1373 isymesz = bfd_coff_symesz (input_bfd);
1374 osymesz = bfd_coff_symesz (output_bfd);
1375 linesz = bfd_coff_linesz (input_bfd);
1376 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1378 copy = FALSE;
1379 if (! finfo->info->keep_memory)
1380 copy = TRUE;
1381 hash = TRUE;
1382 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1383 hash = FALSE;
1385 if (! _bfd_coff_get_external_symbols (input_bfd))
1386 return FALSE;
1388 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1389 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1390 isymp = finfo->internal_syms;
1391 secpp = finfo->sec_ptrs;
1392 indexp = finfo->sym_indices;
1393 output_index = syment_base;
1394 outsym = finfo->outsyms;
1396 if (coff_data (output_bfd)->pe
1397 && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1398 return FALSE;
1400 /* If we are going to perform relocations and also strip/discard some
1401 symbols then we must make sure that we do not strip/discard those
1402 symbols that are going to be involved in the relocations. */
1403 if (( finfo->info->strip != strip_none
1404 || finfo->info->discard != discard_none)
1405 && finfo->info->relocatable)
1407 /* Mark the symbol array as 'not-used'. */
1408 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1410 mark_relocs (finfo, input_bfd);
1413 while (esym < esym_end)
1415 struct internal_syment isym;
1416 enum coff_symbol_classification classification;
1417 bfd_boolean skip;
1418 bfd_boolean global;
1419 bfd_boolean dont_skip_symbol;
1420 int add;
1422 bfd_coff_swap_sym_in (input_bfd, esym, isymp);
1424 /* Make a copy of *isymp so that the relocate_section function
1425 always sees the original values. This is more reliable than
1426 always recomputing the symbol value even if we are stripping
1427 the symbol. */
1428 isym = *isymp;
1430 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1431 switch (classification)
1433 default:
1434 abort ();
1435 case COFF_SYMBOL_GLOBAL:
1436 case COFF_SYMBOL_PE_SECTION:
1437 case COFF_SYMBOL_LOCAL:
1438 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1439 break;
1440 case COFF_SYMBOL_COMMON:
1441 *secpp = bfd_com_section_ptr;
1442 break;
1443 case COFF_SYMBOL_UNDEFINED:
1444 *secpp = bfd_und_section_ptr;
1445 break;
1448 /* Extract the flag indicating if this symbol is used by a
1449 relocation. */
1450 if ((finfo->info->strip != strip_none
1451 || finfo->info->discard != discard_none)
1452 && finfo->info->relocatable)
1453 dont_skip_symbol = *indexp;
1454 else
1455 dont_skip_symbol = FALSE;
1457 *indexp = -1;
1459 skip = FALSE;
1460 global = FALSE;
1461 add = 1 + isym.n_numaux;
1463 /* If we are stripping all symbols, we want to skip this one. */
1464 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1465 skip = TRUE;
1467 if (! skip)
1469 switch (classification)
1471 default:
1472 abort ();
1473 case COFF_SYMBOL_GLOBAL:
1474 case COFF_SYMBOL_COMMON:
1475 case COFF_SYMBOL_PE_SECTION:
1476 /* This is a global symbol. Global symbols come at the
1477 end of the symbol table, so skip them for now.
1478 Locally defined function symbols, however, are an
1479 exception, and are not moved to the end. */
1480 global = TRUE;
1481 if (! ISFCN (isym.n_type))
1482 skip = TRUE;
1483 break;
1485 case COFF_SYMBOL_UNDEFINED:
1486 /* Undefined symbols are left for the end. */
1487 global = TRUE;
1488 skip = TRUE;
1489 break;
1491 case COFF_SYMBOL_LOCAL:
1492 /* This is a local symbol. Skip it if we are discarding
1493 local symbols. */
1494 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1495 skip = TRUE;
1496 break;
1500 #ifndef COFF_WITH_PE
1501 /* Skip section symbols for sections which are not going to be
1502 emitted. */
1503 if (!skip
1504 && dont_skip_symbol == 0
1505 && isym.n_sclass == C_STAT
1506 && isym.n_type == T_NULL
1507 && isym.n_numaux > 0
1508 && (*secpp)->output_section == bfd_abs_section_ptr)
1509 skip = TRUE;
1510 #endif
1512 /* If we stripping debugging symbols, and this is a debugging
1513 symbol, then skip it. FIXME: gas sets the section to N_ABS
1514 for some types of debugging symbols; I don't know if this is
1515 a bug or not. In any case, we handle it here. */
1516 if (! skip
1517 && finfo->info->strip == strip_debugger
1518 && ! dont_skip_symbol
1519 && (isym.n_scnum == N_DEBUG
1520 || (isym.n_scnum == N_ABS
1521 && (isym.n_sclass == C_AUTO
1522 || isym.n_sclass == C_REG
1523 || isym.n_sclass == C_MOS
1524 || isym.n_sclass == C_MOE
1525 || isym.n_sclass == C_MOU
1526 || isym.n_sclass == C_ARG
1527 || isym.n_sclass == C_REGPARM
1528 || isym.n_sclass == C_FIELD
1529 || isym.n_sclass == C_EOS))))
1530 skip = TRUE;
1532 /* If some symbols are stripped based on the name, work out the
1533 name and decide whether to skip this symbol. */
1534 if (! skip
1535 && (finfo->info->strip == strip_some
1536 || finfo->info->discard == discard_l))
1538 const char *name;
1539 char buf[SYMNMLEN + 1];
1541 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1542 if (name == NULL)
1543 return FALSE;
1545 if (! dont_skip_symbol
1546 && ((finfo->info->strip == strip_some
1547 && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
1548 FALSE) == NULL))
1549 || (! global
1550 && finfo->info->discard == discard_l
1551 && bfd_is_local_label_name (input_bfd, name))))
1552 skip = TRUE;
1555 /* If this is an enum, struct, or union tag, see if we have
1556 already output an identical type. */
1557 if (! skip
1558 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1559 && (isym.n_sclass == C_ENTAG
1560 || isym.n_sclass == C_STRTAG
1561 || isym.n_sclass == C_UNTAG)
1562 && isym.n_numaux == 1)
1564 const char *name;
1565 char buf[SYMNMLEN + 1];
1566 struct coff_debug_merge_hash_entry *mh;
1567 struct coff_debug_merge_type *mt;
1568 union internal_auxent aux;
1569 struct coff_debug_merge_element **epp;
1570 bfd_byte *esl, *eslend;
1571 struct internal_syment *islp;
1572 bfd_size_type amt;
1574 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1575 if (name == NULL)
1576 return FALSE;
1578 /* Ignore fake names invented by compiler; treat them all as
1579 the same name. */
1580 if (*name == '~' || *name == '.' || *name == '$'
1581 || (*name == bfd_get_symbol_leading_char (input_bfd)
1582 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1583 name = "";
1585 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1586 TRUE, TRUE);
1587 if (mh == NULL)
1588 return FALSE;
1590 /* Allocate memory to hold type information. If this turns
1591 out to be a duplicate, we pass this address to
1592 bfd_release. */
1593 amt = sizeof (struct coff_debug_merge_type);
1594 mt = bfd_alloc (input_bfd, amt);
1595 if (mt == NULL)
1596 return FALSE;
1597 mt->class = isym.n_sclass;
1599 /* Pick up the aux entry, which points to the end of the tag
1600 entries. */
1601 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz),
1602 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1603 &aux);
1605 /* Gather the elements. */
1606 epp = &mt->elements;
1607 mt->elements = NULL;
1608 islp = isymp + 2;
1609 esl = esym + 2 * isymesz;
1610 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1611 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1612 while (esl < eslend)
1614 const char *elename;
1615 char elebuf[SYMNMLEN + 1];
1616 char *name_copy;
1618 bfd_coff_swap_sym_in (input_bfd, esl, islp);
1620 amt = sizeof (struct coff_debug_merge_element);
1621 *epp = bfd_alloc (input_bfd, amt);
1622 if (*epp == NULL)
1623 return FALSE;
1625 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1626 elebuf);
1627 if (elename == NULL)
1628 return FALSE;
1630 amt = strlen (elename) + 1;
1631 name_copy = bfd_alloc (input_bfd, amt);
1632 if (name_copy == NULL)
1633 return FALSE;
1634 strcpy (name_copy, elename);
1636 (*epp)->name = name_copy;
1637 (*epp)->type = islp->n_type;
1638 (*epp)->tagndx = 0;
1639 if (islp->n_numaux >= 1
1640 && islp->n_type != T_NULL
1641 && islp->n_sclass != C_EOS)
1643 union internal_auxent eleaux;
1644 long indx;
1646 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz),
1647 islp->n_type, islp->n_sclass, 0,
1648 islp->n_numaux, &eleaux);
1649 indx = eleaux.x_sym.x_tagndx.l;
1651 /* FIXME: If this tagndx entry refers to a symbol
1652 defined later in this file, we just ignore it.
1653 Handling this correctly would be tedious, and may
1654 not be required. */
1655 if (indx > 0
1656 && (indx
1657 < ((esym -
1658 (bfd_byte *) obj_coff_external_syms (input_bfd))
1659 / (long) isymesz)))
1661 (*epp)->tagndx = finfo->sym_indices[indx];
1662 if ((*epp)->tagndx < 0)
1663 (*epp)->tagndx = 0;
1666 epp = &(*epp)->next;
1667 *epp = NULL;
1669 esl += (islp->n_numaux + 1) * isymesz;
1670 islp += islp->n_numaux + 1;
1673 /* See if we already have a definition which matches this
1674 type. We always output the type if it has no elements,
1675 for simplicity. */
1676 if (mt->elements == NULL)
1677 bfd_release (input_bfd, mt);
1678 else
1680 struct coff_debug_merge_type *mtl;
1682 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1684 struct coff_debug_merge_element *me, *mel;
1686 if (mtl->class != mt->class)
1687 continue;
1689 for (me = mt->elements, mel = mtl->elements;
1690 me != NULL && mel != NULL;
1691 me = me->next, mel = mel->next)
1693 if (strcmp (me->name, mel->name) != 0
1694 || me->type != mel->type
1695 || me->tagndx != mel->tagndx)
1696 break;
1699 if (me == NULL && mel == NULL)
1700 break;
1703 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1705 /* This is the first definition of this type. */
1706 mt->indx = output_index;
1707 mt->next = mh->types;
1708 mh->types = mt;
1710 else
1712 /* This is a redefinition which can be merged. */
1713 bfd_release (input_bfd, mt);
1714 *indexp = mtl->indx;
1715 add = (eslend - esym) / isymesz;
1716 skip = TRUE;
1721 /* We now know whether we are to skip this symbol or not. */
1722 if (! skip)
1724 /* Adjust the symbol in order to output it. */
1726 if (isym._n._n_n._n_zeroes == 0
1727 && isym._n._n_n._n_offset != 0)
1729 const char *name;
1730 bfd_size_type indx;
1732 /* This symbol has a long name. Enter it in the string
1733 table we are building. Note that we do not check
1734 bfd_coff_symname_in_debug. That is only true for
1735 XCOFF, and XCOFF requires different linking code
1736 anyhow. */
1737 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
1738 if (name == NULL)
1739 return FALSE;
1740 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1741 if (indx == (bfd_size_type) -1)
1742 return FALSE;
1743 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1746 switch (isym.n_sclass)
1748 case C_AUTO:
1749 case C_MOS:
1750 case C_EOS:
1751 case C_MOE:
1752 case C_MOU:
1753 case C_UNTAG:
1754 case C_STRTAG:
1755 case C_ENTAG:
1756 case C_TPDEF:
1757 case C_ARG:
1758 case C_USTATIC:
1759 case C_REG:
1760 case C_REGPARM:
1761 case C_FIELD:
1762 /* The symbol value should not be modified. */
1763 break;
1765 case C_FCN:
1766 if (obj_pe (input_bfd)
1767 && strcmp (isym.n_name, ".bf") != 0
1768 && isym.n_scnum > 0)
1770 /* For PE, .lf and .ef get their value left alone,
1771 while .bf gets relocated. However, they all have
1772 "real" section numbers, and need to be moved into
1773 the new section. */
1774 isym.n_scnum = (*secpp)->output_section->target_index;
1775 break;
1777 /* Fall through. */
1778 default:
1779 case C_LABEL: /* Not completely sure about these 2 */
1780 case C_EXTDEF:
1781 case C_BLOCK:
1782 case C_EFCN:
1783 case C_NULL:
1784 case C_EXT:
1785 case C_STAT:
1786 case C_SECTION:
1787 case C_NT_WEAK:
1788 /* Compute new symbol location. */
1789 if (isym.n_scnum > 0)
1791 isym.n_scnum = (*secpp)->output_section->target_index;
1792 isym.n_value += (*secpp)->output_offset;
1793 if (! obj_pe (input_bfd))
1794 isym.n_value -= (*secpp)->vma;
1795 if (! obj_pe (finfo->output_bfd))
1796 isym.n_value += (*secpp)->output_section->vma;
1798 break;
1800 case C_FILE:
1801 /* The value of a C_FILE symbol is the symbol index of
1802 the next C_FILE symbol. The value of the last C_FILE
1803 symbol is the symbol index to the first external
1804 symbol (actually, coff_renumber_symbols does not get
1805 this right--it just sets the value of the last C_FILE
1806 symbol to zero--and nobody has ever complained about
1807 it). We try to get this right, below, just before we
1808 write the symbols out, but in the general case we may
1809 have to write the symbol out twice. */
1810 if (finfo->last_file_index != -1
1811 && finfo->last_file.n_value != (bfd_vma) output_index)
1813 /* We must correct the value of the last C_FILE
1814 entry. */
1815 finfo->last_file.n_value = output_index;
1816 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1818 /* The last C_FILE symbol is in this input file. */
1819 bfd_coff_swap_sym_out (output_bfd,
1820 &finfo->last_file,
1821 (finfo->outsyms
1822 + ((finfo->last_file_index
1823 - syment_base)
1824 * osymesz)));
1826 else
1828 file_ptr pos;
1830 /* We have already written out the last C_FILE
1831 symbol. We need to write it out again. We
1832 borrow *outsym temporarily. */
1833 bfd_coff_swap_sym_out (output_bfd,
1834 &finfo->last_file, outsym);
1835 pos = obj_sym_filepos (output_bfd);
1836 pos += finfo->last_file_index * osymesz;
1837 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1838 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1839 return FALSE;
1843 finfo->last_file_index = output_index;
1844 finfo->last_file = isym;
1845 break;
1848 /* If doing task linking, convert normal global function symbols to
1849 static functions. */
1850 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1851 isym.n_sclass = C_STAT;
1853 /* Output the symbol. */
1854 bfd_coff_swap_sym_out (output_bfd, &isym, outsym);
1856 *indexp = output_index;
1858 if (global)
1860 long indx;
1861 struct coff_link_hash_entry *h;
1863 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1864 / isymesz);
1865 h = obj_coff_sym_hashes (input_bfd)[indx];
1866 if (h == NULL)
1868 /* This can happen if there were errors earlier in
1869 the link. */
1870 bfd_set_error (bfd_error_bad_value);
1871 return FALSE;
1873 h->indx = output_index;
1876 output_index += add;
1877 outsym += add * osymesz;
1880 esym += add * isymesz;
1881 isymp += add;
1882 ++secpp;
1883 ++indexp;
1884 for (--add; add > 0; --add)
1886 *secpp++ = NULL;
1887 *indexp++ = -1;
1891 /* Fix up the aux entries. This must be done in a separate pass,
1892 because we don't know the correct symbol indices until we have
1893 already decided which symbols we are going to keep. */
1894 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1895 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1896 isymp = finfo->internal_syms;
1897 indexp = finfo->sym_indices;
1898 sym_hash = obj_coff_sym_hashes (input_bfd);
1899 outsym = finfo->outsyms;
1901 while (esym < esym_end)
1903 int add;
1905 add = 1 + isymp->n_numaux;
1907 if ((*indexp < 0
1908 || (bfd_size_type) *indexp < syment_base)
1909 && (*sym_hash == NULL
1910 || (*sym_hash)->auxbfd != input_bfd))
1911 esym += add * isymesz;
1912 else
1914 struct coff_link_hash_entry *h;
1915 int i;
1917 h = NULL;
1918 if (*indexp < 0)
1920 h = *sym_hash;
1922 /* The m68k-motorola-sysv assembler will sometimes
1923 generate two symbols with the same name, but only one
1924 will have aux entries. */
1925 BFD_ASSERT (isymp->n_numaux == 0
1926 || h->numaux == isymp->n_numaux);
1929 esym += isymesz;
1931 if (h == NULL)
1932 outsym += osymesz;
1934 /* Handle the aux entries. This handling is based on
1935 coff_pointerize_aux. I don't know if it always correct. */
1936 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1938 union internal_auxent aux;
1939 union internal_auxent *auxp;
1941 if (h != NULL)
1942 auxp = h->aux + i;
1943 else
1945 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type,
1946 isymp->n_sclass, i, isymp->n_numaux, &aux);
1947 auxp = &aux;
1950 if (isymp->n_sclass == C_FILE)
1952 /* If this is a long filename, we must put it in the
1953 string table. */
1954 if (auxp->x_file.x_n.x_zeroes == 0
1955 && auxp->x_file.x_n.x_offset != 0)
1957 const char *filename;
1958 bfd_size_type indx;
1960 BFD_ASSERT (auxp->x_file.x_n.x_offset
1961 >= STRING_SIZE_SIZE);
1962 if (strings == NULL)
1964 strings = _bfd_coff_read_string_table (input_bfd);
1965 if (strings == NULL)
1966 return FALSE;
1968 filename = strings + auxp->x_file.x_n.x_offset;
1969 indx = _bfd_stringtab_add (finfo->strtab, filename,
1970 hash, copy);
1971 if (indx == (bfd_size_type) -1)
1972 return FALSE;
1973 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1976 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1977 && isymp->n_sclass != C_NT_WEAK)
1979 unsigned long indx;
1981 if (ISFCN (isymp->n_type)
1982 || ISTAG (isymp->n_sclass)
1983 || isymp->n_sclass == C_BLOCK
1984 || isymp->n_sclass == C_FCN)
1986 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1987 if (indx > 0
1988 && indx < obj_raw_syment_count (input_bfd))
1990 /* We look forward through the symbol for
1991 the index of the next symbol we are going
1992 to include. I don't know if this is
1993 entirely right. */
1994 while ((finfo->sym_indices[indx] < 0
1995 || ((bfd_size_type) finfo->sym_indices[indx]
1996 < syment_base))
1997 && indx < obj_raw_syment_count (input_bfd))
1998 ++indx;
1999 if (indx >= obj_raw_syment_count (input_bfd))
2000 indx = output_index;
2001 else
2002 indx = finfo->sym_indices[indx];
2003 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2007 indx = auxp->x_sym.x_tagndx.l;
2008 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2010 long symindx;
2012 symindx = finfo->sym_indices[indx];
2013 if (symindx < 0)
2014 auxp->x_sym.x_tagndx.l = 0;
2015 else
2016 auxp->x_sym.x_tagndx.l = symindx;
2019 /* The .bf symbols are supposed to be linked through
2020 the endndx field. We need to carry this list
2021 across object files. */
2022 if (i == 0
2023 && h == NULL
2024 && isymp->n_sclass == C_FCN
2025 && (isymp->_n._n_n._n_zeroes != 0
2026 || isymp->_n._n_n._n_offset == 0)
2027 && isymp->_n._n_name[0] == '.'
2028 && isymp->_n._n_name[1] == 'b'
2029 && isymp->_n._n_name[2] == 'f'
2030 && isymp->_n._n_name[3] == '\0')
2032 if (finfo->last_bf_index != -1)
2034 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2035 *indexp;
2037 if ((bfd_size_type) finfo->last_bf_index
2038 >= syment_base)
2040 void *auxout;
2042 /* The last .bf symbol is in this input
2043 file. This will only happen if the
2044 assembler did not set up the .bf
2045 endndx symbols correctly. */
2046 auxout = (finfo->outsyms
2047 + ((finfo->last_bf_index
2048 - syment_base)
2049 * osymesz));
2051 bfd_coff_swap_aux_out (output_bfd,
2052 &finfo->last_bf,
2053 isymp->n_type,
2054 isymp->n_sclass,
2055 0, isymp->n_numaux,
2056 auxout);
2058 else
2060 file_ptr pos;
2062 /* We have already written out the last
2063 .bf aux entry. We need to write it
2064 out again. We borrow *outsym
2065 temporarily. FIXME: This case should
2066 be made faster. */
2067 bfd_coff_swap_aux_out (output_bfd,
2068 &finfo->last_bf,
2069 isymp->n_type,
2070 isymp->n_sclass,
2071 0, isymp->n_numaux,
2072 outsym);
2073 pos = obj_sym_filepos (output_bfd);
2074 pos += finfo->last_bf_index * osymesz;
2075 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2076 || (bfd_bwrite (outsym, osymesz, output_bfd)
2077 != osymesz))
2078 return FALSE;
2082 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2083 finfo->last_bf_index = -1;
2084 else
2086 /* The endndx field of this aux entry must
2087 be updated with the symbol number of the
2088 next .bf symbol. */
2089 finfo->last_bf = *auxp;
2090 finfo->last_bf_index = (((outsym - finfo->outsyms)
2091 / osymesz)
2092 + syment_base);
2097 if (h == NULL)
2099 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type,
2100 isymp->n_sclass, i, isymp->n_numaux,
2101 outsym);
2102 outsym += osymesz;
2105 esym += isymesz;
2109 indexp += add;
2110 isymp += add;
2111 sym_hash += add;
2114 /* Relocate the line numbers, unless we are stripping them. */
2115 if (finfo->info->strip == strip_none
2116 || finfo->info->strip == strip_some)
2118 for (o = input_bfd->sections; o != NULL; o = o->next)
2120 bfd_vma offset;
2121 bfd_byte *eline;
2122 bfd_byte *elineend;
2123 bfd_byte *oeline;
2124 bfd_boolean skipping;
2125 file_ptr pos;
2126 bfd_size_type amt;
2128 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2129 build_link_order in ldwrite.c will not have created a
2130 link order, which means that we will not have seen this
2131 input section in _bfd_coff_final_link, which means that
2132 we will not have allocated space for the line numbers of
2133 this section. I don't think line numbers can be
2134 meaningful for a section which does not have
2135 SEC_HAS_CONTENTS set, but, if they do, this must be
2136 changed. */
2137 if (o->lineno_count == 0
2138 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2139 continue;
2141 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2142 || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2143 input_bfd) != linesz * o->lineno_count)
2144 return FALSE;
2146 offset = o->output_section->vma + o->output_offset - o->vma;
2147 eline = finfo->linenos;
2148 oeline = finfo->linenos;
2149 elineend = eline + linesz * o->lineno_count;
2150 skipping = FALSE;
2151 for (; eline < elineend; eline += linesz)
2153 struct internal_lineno iline;
2155 bfd_coff_swap_lineno_in (input_bfd, eline, &iline);
2157 if (iline.l_lnno != 0)
2158 iline.l_addr.l_paddr += offset;
2159 else if (iline.l_addr.l_symndx >= 0
2160 && ((unsigned long) iline.l_addr.l_symndx
2161 < obj_raw_syment_count (input_bfd)))
2163 long indx;
2165 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2167 if (indx < 0)
2169 /* These line numbers are attached to a symbol
2170 which we are stripping. We must discard the
2171 line numbers because reading them back with
2172 no associated symbol (or associating them all
2173 with symbol #0) will fail. We can't regain
2174 the space in the output file, but at least
2175 they're dense. */
2176 skipping = TRUE;
2178 else
2180 struct internal_syment is;
2181 union internal_auxent ia;
2183 /* Fix up the lnnoptr field in the aux entry of
2184 the symbol. It turns out that we can't do
2185 this when we modify the symbol aux entries,
2186 because gas sometimes screws up the lnnoptr
2187 field and makes it an offset from the start
2188 of the line numbers rather than an absolute
2189 file index. */
2190 bfd_coff_swap_sym_in (output_bfd,
2191 (finfo->outsyms
2192 + ((indx - syment_base)
2193 * osymesz)), &is);
2194 if ((ISFCN (is.n_type)
2195 || is.n_sclass == C_BLOCK)
2196 && is.n_numaux >= 1)
2198 void *auxptr;
2200 auxptr = (finfo->outsyms
2201 + ((indx - syment_base + 1)
2202 * osymesz));
2203 bfd_coff_swap_aux_in (output_bfd, auxptr,
2204 is.n_type, is.n_sclass,
2205 0, is.n_numaux, &ia);
2206 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2207 (o->output_section->line_filepos
2208 + o->output_section->lineno_count * linesz
2209 + eline - finfo->linenos);
2210 bfd_coff_swap_aux_out (output_bfd, &ia,
2211 is.n_type, is.n_sclass, 0,
2212 is.n_numaux, auxptr);
2215 skipping = FALSE;
2218 iline.l_addr.l_symndx = indx;
2221 if (!skipping)
2223 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline);
2224 oeline += linesz;
2228 pos = o->output_section->line_filepos;
2229 pos += o->output_section->lineno_count * linesz;
2230 amt = oeline - finfo->linenos;
2231 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2232 || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2233 return FALSE;
2235 o->output_section->lineno_count += amt / linesz;
2239 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2240 symbol will be the first symbol in the next input file. In the
2241 normal case, this will save us from writing out the C_FILE symbol
2242 again. */
2243 if (finfo->last_file_index != -1
2244 && (bfd_size_type) finfo->last_file_index >= syment_base)
2246 finfo->last_file.n_value = output_index;
2247 bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
2248 (finfo->outsyms
2249 + ((finfo->last_file_index - syment_base)
2250 * osymesz)));
2253 /* Write the modified symbols to the output file. */
2254 if (outsym > finfo->outsyms)
2256 file_ptr pos;
2257 bfd_size_type amt;
2259 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2260 amt = outsym - finfo->outsyms;
2261 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2262 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2263 return FALSE;
2265 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2266 + (outsym - finfo->outsyms) / osymesz)
2267 == output_index);
2269 obj_raw_syment_count (output_bfd) = output_index;
2272 /* Relocate the contents of each section. */
2273 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2274 for (o = input_bfd->sections; o != NULL; o = o->next)
2276 bfd_byte *contents;
2277 struct coff_section_tdata *secdata;
2279 if (! o->linker_mark)
2280 /* This section was omitted from the link. */
2281 continue;
2283 if ((o->flags & SEC_LINKER_CREATED) != 0)
2284 continue;
2286 if ((o->flags & SEC_HAS_CONTENTS) == 0
2287 || (o->size == 0 && (o->flags & SEC_RELOC) == 0))
2289 if ((o->flags & SEC_RELOC) != 0
2290 && o->reloc_count != 0)
2292 (*_bfd_error_handler)
2293 (_("%B: relocs in section `%A', but it has no contents"),
2294 input_bfd, o);
2295 bfd_set_error (bfd_error_no_contents);
2296 return FALSE;
2299 continue;
2302 secdata = coff_section_data (input_bfd, o);
2303 if (secdata != NULL && secdata->contents != NULL)
2304 contents = secdata->contents;
2305 else
2307 bfd_size_type x = o->rawsize ? o->rawsize : o->size;
2308 if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
2309 return FALSE;
2310 contents = finfo->contents;
2313 if ((o->flags & SEC_RELOC) != 0)
2315 int target_index;
2316 struct internal_reloc *internal_relocs;
2317 struct internal_reloc *irel;
2319 /* Read in the relocs. */
2320 target_index = o->output_section->target_index;
2321 internal_relocs = (_bfd_coff_read_internal_relocs
2322 (input_bfd, o, FALSE, finfo->external_relocs,
2323 finfo->info->relocatable,
2324 (finfo->info->relocatable
2325 ? (finfo->section_info[target_index].relocs
2326 + o->output_section->reloc_count)
2327 : finfo->internal_relocs)));
2328 if (internal_relocs == NULL)
2329 return FALSE;
2331 /* Call processor specific code to relocate the section
2332 contents. */
2333 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2334 input_bfd, o,
2335 contents,
2336 internal_relocs,
2337 finfo->internal_syms,
2338 finfo->sec_ptrs))
2339 return FALSE;
2341 if (finfo->info->relocatable)
2343 bfd_vma offset;
2344 struct internal_reloc *irelend;
2345 struct coff_link_hash_entry **rel_hash;
2347 offset = o->output_section->vma + o->output_offset - o->vma;
2348 irel = internal_relocs;
2349 irelend = irel + o->reloc_count;
2350 rel_hash = (finfo->section_info[target_index].rel_hashes
2351 + o->output_section->reloc_count);
2352 for (; irel < irelend; irel++, rel_hash++)
2354 struct coff_link_hash_entry *h;
2355 bfd_boolean adjusted;
2357 *rel_hash = NULL;
2359 /* Adjust the reloc address and symbol index. */
2360 irel->r_vaddr += offset;
2362 if (irel->r_symndx == -1)
2363 continue;
2365 if (adjust_symndx)
2367 if (! (*adjust_symndx) (output_bfd, finfo->info,
2368 input_bfd, o, irel,
2369 &adjusted))
2370 return FALSE;
2371 if (adjusted)
2372 continue;
2375 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2376 if (h != NULL)
2378 /* This is a global symbol. */
2379 if (h->indx >= 0)
2380 irel->r_symndx = h->indx;
2381 else
2383 /* This symbol is being written at the end
2384 of the file, and we do not yet know the
2385 symbol index. We save the pointer to the
2386 hash table entry in the rel_hash list.
2387 We set the indx field to -2 to indicate
2388 that this symbol must not be stripped. */
2389 *rel_hash = h;
2390 h->indx = -2;
2393 else
2395 long indx;
2397 indx = finfo->sym_indices[irel->r_symndx];
2398 if (indx != -1)
2399 irel->r_symndx = indx;
2400 else
2402 struct internal_syment *is;
2403 const char *name;
2404 char buf[SYMNMLEN + 1];
2406 /* This reloc is against a symbol we are
2407 stripping. This should have been handled
2408 by the 'dont_skip_symbol' code in the while
2409 loop at the top of this function. */
2410 is = finfo->internal_syms + irel->r_symndx;
2412 name = (_bfd_coff_internal_syment_name
2413 (input_bfd, is, buf));
2414 if (name == NULL)
2415 return FALSE;
2417 if (! ((*finfo->info->callbacks->unattached_reloc)
2418 (finfo->info, name, input_bfd, o,
2419 irel->r_vaddr)))
2420 return FALSE;
2425 o->output_section->reloc_count += o->reloc_count;
2429 /* Write out the modified section contents. */
2430 if (secdata == NULL || secdata->stab_info == NULL)
2432 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2433 if (! bfd_set_section_contents (output_bfd, o->output_section,
2434 contents, loc, o->size))
2435 return FALSE;
2437 else
2439 if (! (_bfd_write_section_stabs
2440 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2441 o, &secdata->stab_info, contents)))
2442 return FALSE;
2446 if (! finfo->info->keep_memory
2447 && ! _bfd_coff_free_symbols (input_bfd))
2448 return FALSE;
2450 return TRUE;
2453 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2455 bfd_boolean
2456 _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
2458 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2459 bfd *output_bfd;
2460 struct internal_syment isym;
2461 bfd_size_type symesz;
2462 unsigned int i;
2463 file_ptr pos;
2465 output_bfd = finfo->output_bfd;
2467 if (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_new)
2471 return TRUE;
2474 if (h->indx >= 0)
2475 return TRUE;
2477 if (h->indx != -2
2478 && (finfo->info->strip == strip_all
2479 || (finfo->info->strip == strip_some
2480 && (bfd_hash_lookup (finfo->info->keep_hash,
2481 h->root.root.string, FALSE, FALSE)
2482 == NULL))))
2483 return TRUE;
2485 switch (h->root.type)
2487 default:
2488 case bfd_link_hash_new:
2489 case bfd_link_hash_warning:
2490 abort ();
2491 return FALSE;
2493 case bfd_link_hash_undefined:
2494 case bfd_link_hash_undefweak:
2495 isym.n_scnum = N_UNDEF;
2496 isym.n_value = 0;
2497 break;
2499 case bfd_link_hash_defined:
2500 case bfd_link_hash_defweak:
2502 asection *sec;
2504 sec = h->root.u.def.section->output_section;
2505 if (bfd_is_abs_section (sec))
2506 isym.n_scnum = N_ABS;
2507 else
2508 isym.n_scnum = sec->target_index;
2509 isym.n_value = (h->root.u.def.value
2510 + h->root.u.def.section->output_offset);
2511 if (! obj_pe (finfo->output_bfd))
2512 isym.n_value += sec->vma;
2514 break;
2516 case bfd_link_hash_common:
2517 isym.n_scnum = N_UNDEF;
2518 isym.n_value = h->root.u.c.size;
2519 break;
2521 case bfd_link_hash_indirect:
2522 /* Just ignore these. They can't be handled anyhow. */
2523 return TRUE;
2526 if (strlen (h->root.root.string) <= SYMNMLEN)
2527 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2528 else
2530 bfd_boolean hash;
2531 bfd_size_type indx;
2533 hash = TRUE;
2534 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2535 hash = FALSE;
2536 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2537 FALSE);
2538 if (indx == (bfd_size_type) -1)
2540 finfo->failed = TRUE;
2541 return FALSE;
2543 isym._n._n_n._n_zeroes = 0;
2544 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2547 isym.n_sclass = h->class;
2548 isym.n_type = h->type;
2550 if (isym.n_sclass == C_NULL)
2551 isym.n_sclass = C_EXT;
2553 /* If doing task linking and this is the pass where we convert
2554 defined globals to statics, then do that conversion now. If the
2555 symbol is not being converted, just ignore it and it will be
2556 output during a later pass. */
2557 if (finfo->global_to_static)
2559 if (! IS_EXTERNAL (output_bfd, isym))
2560 return TRUE;
2562 isym.n_sclass = C_STAT;
2565 /* When a weak symbol is not overridden by a strong one,
2566 turn it into an external symbol when not building a
2567 shared or relocatable object. */
2568 if (! finfo->info->shared
2569 && ! finfo->info->relocatable
2570 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2571 isym.n_sclass = C_EXT;
2573 isym.n_numaux = h->numaux;
2575 bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
2577 symesz = bfd_coff_symesz (output_bfd);
2579 pos = obj_sym_filepos (output_bfd);
2580 pos += obj_raw_syment_count (output_bfd) * symesz;
2581 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2582 || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2584 finfo->failed = TRUE;
2585 return FALSE;
2588 h->indx = obj_raw_syment_count (output_bfd);
2590 ++obj_raw_syment_count (output_bfd);
2592 /* Write out any associated aux entries. Most of the aux entries
2593 will have been modified in _bfd_coff_link_input_bfd. We have to
2594 handle section aux entries here, now that we have the final
2595 relocation and line number counts. */
2596 for (i = 0; i < isym.n_numaux; i++)
2598 union internal_auxent *auxp;
2600 auxp = h->aux + i;
2602 /* Look for a section aux entry here using the same tests that
2603 coff_swap_aux_out uses. */
2604 if (i == 0
2605 && (isym.n_sclass == C_STAT
2606 || isym.n_sclass == C_HIDDEN)
2607 && isym.n_type == T_NULL
2608 && (h->root.type == bfd_link_hash_defined
2609 || h->root.type == bfd_link_hash_defweak))
2611 asection *sec;
2613 sec = h->root.u.def.section->output_section;
2614 if (sec != NULL)
2616 auxp->x_scn.x_scnlen = sec->size;
2618 /* For PE, an overflow on the final link reportedly does
2619 not matter. FIXME: Why not? */
2620 if (sec->reloc_count > 0xffff
2621 && (! obj_pe (output_bfd)
2622 || finfo->info->relocatable))
2623 (*_bfd_error_handler)
2624 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2625 bfd_get_filename (output_bfd),
2626 bfd_get_section_name (output_bfd, sec),
2627 sec->reloc_count);
2629 if (sec->lineno_count > 0xffff
2630 && (! obj_pe (output_bfd)
2631 || finfo->info->relocatable))
2632 (*_bfd_error_handler)
2633 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2634 bfd_get_filename (output_bfd),
2635 bfd_get_section_name (output_bfd, sec),
2636 sec->lineno_count);
2638 auxp->x_scn.x_nreloc = sec->reloc_count;
2639 auxp->x_scn.x_nlinno = sec->lineno_count;
2640 auxp->x_scn.x_checksum = 0;
2641 auxp->x_scn.x_associated = 0;
2642 auxp->x_scn.x_comdat = 0;
2646 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
2647 isym.n_sclass, (int) i, isym.n_numaux,
2648 finfo->outsyms);
2649 if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2651 finfo->failed = TRUE;
2652 return FALSE;
2654 ++obj_raw_syment_count (output_bfd);
2657 return TRUE;
2660 /* Write out task global symbols, converting them to statics. Called
2661 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2662 the dirty work, if the symbol we are processing needs conversion. */
2664 bfd_boolean
2665 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
2667 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2668 bfd_boolean rtnval = TRUE;
2669 bfd_boolean save_global_to_static;
2671 if (h->root.type == bfd_link_hash_warning)
2672 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2674 if (h->indx < 0)
2676 switch (h->root.type)
2678 case bfd_link_hash_defined:
2679 case bfd_link_hash_defweak:
2680 save_global_to_static = finfo->global_to_static;
2681 finfo->global_to_static = TRUE;
2682 rtnval = _bfd_coff_write_global_sym (h, data);
2683 finfo->global_to_static = save_global_to_static;
2684 break;
2685 default:
2686 break;
2689 return (rtnval);
2692 /* Handle a link order which is supposed to generate a reloc. */
2694 bfd_boolean
2695 _bfd_coff_reloc_link_order (bfd *output_bfd,
2696 struct coff_final_link_info *finfo,
2697 asection *output_section,
2698 struct bfd_link_order *link_order)
2700 reloc_howto_type *howto;
2701 struct internal_reloc *irel;
2702 struct coff_link_hash_entry **rel_hash_ptr;
2704 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2705 if (howto == NULL)
2707 bfd_set_error (bfd_error_bad_value);
2708 return FALSE;
2711 if (link_order->u.reloc.p->addend != 0)
2713 bfd_size_type size;
2714 bfd_byte *buf;
2715 bfd_reloc_status_type rstat;
2716 bfd_boolean ok;
2717 file_ptr loc;
2719 size = bfd_get_reloc_size (howto);
2720 buf = bfd_zmalloc (size);
2721 if (buf == NULL)
2722 return FALSE;
2724 rstat = _bfd_relocate_contents (howto, output_bfd,
2725 (bfd_vma) link_order->u.reloc.p->addend,\
2726 buf);
2727 switch (rstat)
2729 case bfd_reloc_ok:
2730 break;
2731 default:
2732 case bfd_reloc_outofrange:
2733 abort ();
2734 case bfd_reloc_overflow:
2735 if (! ((*finfo->info->callbacks->reloc_overflow)
2736 (finfo->info, NULL,
2737 (link_order->type == bfd_section_reloc_link_order
2738 ? bfd_section_name (output_bfd,
2739 link_order->u.reloc.p->u.section)
2740 : link_order->u.reloc.p->u.name),
2741 howto->name, link_order->u.reloc.p->addend,
2742 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2744 free (buf);
2745 return FALSE;
2747 break;
2749 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2750 ok = bfd_set_section_contents (output_bfd, output_section, buf,
2751 loc, size);
2752 free (buf);
2753 if (! ok)
2754 return FALSE;
2757 /* Store the reloc information in the right place. It will get
2758 swapped and written out at the end of the final_link routine. */
2759 irel = (finfo->section_info[output_section->target_index].relocs
2760 + output_section->reloc_count);
2761 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2762 + output_section->reloc_count);
2764 memset (irel, 0, sizeof (struct internal_reloc));
2765 *rel_hash_ptr = NULL;
2767 irel->r_vaddr = output_section->vma + link_order->offset;
2769 if (link_order->type == bfd_section_reloc_link_order)
2771 /* We need to somehow locate a symbol in the right section. The
2772 symbol must either have a value of zero, or we must adjust
2773 the addend by the value of the symbol. FIXME: Write this
2774 when we need it. The old linker couldn't handle this anyhow. */
2775 abort ();
2776 *rel_hash_ptr = NULL;
2777 irel->r_symndx = 0;
2779 else
2781 struct coff_link_hash_entry *h;
2783 h = ((struct coff_link_hash_entry *)
2784 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2785 link_order->u.reloc.p->u.name,
2786 FALSE, FALSE, TRUE));
2787 if (h != NULL)
2789 if (h->indx >= 0)
2790 irel->r_symndx = h->indx;
2791 else
2793 /* Set the index to -2 to force this symbol to get
2794 written out. */
2795 h->indx = -2;
2796 *rel_hash_ptr = h;
2797 irel->r_symndx = 0;
2800 else
2802 if (! ((*finfo->info->callbacks->unattached_reloc)
2803 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2804 (asection *) NULL, (bfd_vma) 0)))
2805 return FALSE;
2806 irel->r_symndx = 0;
2810 /* FIXME: Is this always right? */
2811 irel->r_type = howto->type;
2813 /* r_size is only used on the RS/6000, which needs its own linker
2814 routines anyhow. r_extern is only used for ECOFF. */
2816 /* FIXME: What is the right value for r_offset? Is zero OK? */
2817 ++output_section->reloc_count;
2819 return TRUE;
2822 /* A basic reloc handling routine which may be used by processors with
2823 simple relocs. */
2825 bfd_boolean
2826 _bfd_coff_generic_relocate_section (bfd *output_bfd,
2827 struct bfd_link_info *info,
2828 bfd *input_bfd,
2829 asection *input_section,
2830 bfd_byte *contents,
2831 struct internal_reloc *relocs,
2832 struct internal_syment *syms,
2833 asection **sections)
2835 struct internal_reloc *rel;
2836 struct internal_reloc *relend;
2838 rel = relocs;
2839 relend = rel + input_section->reloc_count;
2840 for (; rel < relend; rel++)
2842 long symndx;
2843 struct coff_link_hash_entry *h;
2844 struct internal_syment *sym;
2845 bfd_vma addend;
2846 bfd_vma val;
2847 reloc_howto_type *howto;
2848 bfd_reloc_status_type rstat;
2850 symndx = rel->r_symndx;
2852 if (symndx == -1)
2854 h = NULL;
2855 sym = NULL;
2857 else if (symndx < 0
2858 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2860 (*_bfd_error_handler)
2861 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx);
2862 return FALSE;
2864 else
2866 h = obj_coff_sym_hashes (input_bfd)[symndx];
2867 sym = syms + symndx;
2870 /* COFF treats common symbols in one of two ways. Either the
2871 size of the symbol is included in the section contents, or it
2872 is not. We assume that the size is not included, and force
2873 the rtype_to_howto function to adjust the addend as needed. */
2874 if (sym != NULL && sym->n_scnum != 0)
2875 addend = - sym->n_value;
2876 else
2877 addend = 0;
2879 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2880 sym, &addend);
2881 if (howto == NULL)
2882 return FALSE;
2884 /* If we are doing a relocatable link, then we can just ignore
2885 a PC relative reloc that is pcrel_offset. It will already
2886 have the correct value. If this is not a relocatable link,
2887 then we should ignore the symbol value. */
2888 if (howto->pc_relative && howto->pcrel_offset)
2890 if (info->relocatable)
2891 continue;
2892 if (sym != NULL && sym->n_scnum != 0)
2893 addend += sym->n_value;
2896 val = 0;
2898 if (h == NULL)
2900 asection *sec;
2902 if (symndx == -1)
2904 sec = bfd_abs_section_ptr;
2905 val = 0;
2907 else
2909 sec = sections[symndx];
2910 val = (sec->output_section->vma
2911 + sec->output_offset
2912 + sym->n_value);
2913 if (! obj_pe (input_bfd))
2914 val -= sec->vma;
2917 else
2919 if (h->root.type == bfd_link_hash_defined
2920 || h->root.type == bfd_link_hash_defweak)
2922 /* Defined weak symbols are a GNU extension. */
2923 asection *sec;
2925 sec = h->root.u.def.section;
2926 val = (h->root.u.def.value
2927 + sec->output_section->vma
2928 + sec->output_offset);
2931 else if (h->root.type == bfd_link_hash_undefweak)
2933 if (h->class == C_NT_WEAK && h->numaux == 1)
2935 /* See _Microsoft Portable Executable and Common Object
2936 File Format Specification_, section 5.5.3.
2937 Note that weak symbols without aux records are a GNU
2938 extension.
2939 FIXME: All weak externals are treated as having
2940 characteristics IMAGE_WEAK_EXTERN_SEARCH_LIBRARY (2).
2941 There are no known uses of the other two types of
2942 weak externals. */
2943 asection *sec;
2944 struct coff_link_hash_entry *h2 =
2945 input_bfd->tdata.coff_obj_data->sym_hashes[
2946 h->aux->x_sym.x_tagndx.l];
2948 if (!h2 || h2->root.type == bfd_link_hash_undefined)
2950 sec = bfd_abs_section_ptr;
2951 val = 0;
2953 else
2955 sec = h2->root.u.def.section;
2956 val = h2->root.u.def.value
2957 + sec->output_section->vma + sec->output_offset;
2960 else
2961 /* This is a GNU extension. */
2962 val = 0;
2965 else if (! info->relocatable)
2967 if (! ((*info->callbacks->undefined_symbol)
2968 (info, h->root.root.string, input_bfd, input_section,
2969 rel->r_vaddr - input_section->vma, TRUE)))
2970 return FALSE;
2974 if (info->base_file)
2976 /* Emit a reloc if the backend thinks it needs it. */
2977 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2979 /* Relocation to a symbol in a section which isn't
2980 absolute. We output the address here to a file.
2981 This file is then read by dlltool when generating the
2982 reloc section. Note that the base file is not
2983 portable between systems. We write out a long here,
2984 and dlltool reads in a long. */
2985 long addr = (rel->r_vaddr
2986 - input_section->vma
2987 + input_section->output_offset
2988 + input_section->output_section->vma);
2989 if (coff_data (output_bfd)->pe)
2990 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2991 if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
2992 != sizeof (long))
2994 bfd_set_error (bfd_error_system_call);
2995 return FALSE;
3000 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3001 contents,
3002 rel->r_vaddr - input_section->vma,
3003 val, addend);
3005 switch (rstat)
3007 default:
3008 abort ();
3009 case bfd_reloc_ok:
3010 break;
3011 case bfd_reloc_outofrange:
3012 (*_bfd_error_handler)
3013 (_("%B: bad reloc address 0x%lx in section `%A'"),
3014 input_bfd, input_section, (unsigned long) rel->r_vaddr);
3015 return FALSE;
3016 case bfd_reloc_overflow:
3018 const char *name;
3019 char buf[SYMNMLEN + 1];
3021 if (symndx == -1)
3022 name = "*ABS*";
3023 else if (h != NULL)
3024 name = NULL;
3025 else
3027 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3028 if (name == NULL)
3029 return FALSE;
3032 if (! ((*info->callbacks->reloc_overflow)
3033 (info, (h ? &h->root : NULL), name, howto->name,
3034 (bfd_vma) 0, input_bfd, input_section,
3035 rel->r_vaddr - input_section->vma)))
3036 return FALSE;
3040 return TRUE;