daily update
[binutils.git] / bfd / cofflink.c
blobc1302ee878a28d0dc9dfbe6845ee04c47815a1c1
1 /* COFF specific linker code.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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"
31 static boolean coff_link_add_object_symbols
32 PARAMS ((bfd *, struct bfd_link_info *));
33 static boolean coff_link_check_archive_element
34 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
35 static boolean coff_link_check_ar_symbols
36 PARAMS ((bfd *, struct bfd_link_info *, boolean *));
37 static boolean coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
38 static char *dores_com PARAMS ((char *, bfd *, int));
39 static char *get_name PARAMS ((char *, char **));
40 static int process_embedded_commands
41 PARAMS ((bfd *, struct bfd_link_info *, bfd *));
42 static void mark_relocs PARAMS ((struct coff_final_link_info *, bfd *));
44 /* Return true if SYM is a weak, external symbol. */
45 #define IS_WEAK_EXTERNAL(abfd, sym) \
46 ((sym).n_sclass == C_WEAKEXT \
47 || (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK))
49 /* Return true if SYM is an external symbol. */
50 #define IS_EXTERNAL(abfd, sym) \
51 ((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym))
53 /* Define macros so that the ISFCN, et. al., macros work correctly.
54 These macros are defined in include/coff/internal.h in terms of
55 N_TMASK, etc. These definitions require a user to define local
56 variables with the appropriate names, and with values from the
57 coff_data (abfd) structure. */
59 #define N_TMASK n_tmask
60 #define N_BTSHFT n_btshft
61 #define N_BTMASK n_btmask
63 /* Create an entry in a COFF linker hash table. */
65 struct bfd_hash_entry *
66 _bfd_coff_link_hash_newfunc (entry, table, string)
67 struct bfd_hash_entry *entry;
68 struct bfd_hash_table *table;
69 const char *string;
71 struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry;
73 /* Allocate the structure if it has not already been allocated by a
74 subclass. */
75 if (ret == (struct coff_link_hash_entry *) NULL)
76 ret = ((struct coff_link_hash_entry *)
77 bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry)));
78 if (ret == (struct coff_link_hash_entry *) NULL)
79 return (struct bfd_hash_entry *) ret;
81 /* Call the allocation method of the superclass. */
82 ret = ((struct coff_link_hash_entry *)
83 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
84 table, string));
85 if (ret != (struct coff_link_hash_entry *) NULL)
87 /* Set local fields. */
88 ret->indx = -1;
89 ret->type = T_NULL;
90 ret->class = C_NULL;
91 ret->numaux = 0;
92 ret->auxbfd = NULL;
93 ret->aux = NULL;
96 return (struct bfd_hash_entry *) ret;
99 /* Initialize a COFF linker hash table. */
101 boolean
102 _bfd_coff_link_hash_table_init (table, abfd, newfunc)
103 struct coff_link_hash_table *table;
104 bfd *abfd;
105 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
106 struct bfd_hash_table *,
107 const char *));
109 table->stab_info = NULL;
110 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
113 /* Create a COFF linker hash table. */
115 struct bfd_link_hash_table *
116 _bfd_coff_link_hash_table_create (abfd)
117 bfd *abfd;
119 struct coff_link_hash_table *ret;
120 bfd_size_type amt = sizeof (struct coff_link_hash_table);
122 ret = (struct coff_link_hash_table *) bfd_malloc (amt);
123 if (ret == NULL)
124 return NULL;
125 if (! _bfd_coff_link_hash_table_init (ret, abfd,
126 _bfd_coff_link_hash_newfunc))
128 free (ret);
129 return (struct bfd_link_hash_table *) NULL;
131 return &ret->root;
134 /* Create an entry in a COFF debug merge hash table. */
136 struct bfd_hash_entry *
137 _bfd_coff_debug_merge_hash_newfunc (entry, table, string)
138 struct bfd_hash_entry *entry;
139 struct bfd_hash_table *table;
140 const char *string;
142 struct coff_debug_merge_hash_entry *ret =
143 (struct coff_debug_merge_hash_entry *) entry;
145 /* Allocate the structure if it has not already been allocated by a
146 subclass. */
147 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
148 ret = ((struct coff_debug_merge_hash_entry *)
149 bfd_hash_allocate (table,
150 sizeof (struct coff_debug_merge_hash_entry)));
151 if (ret == (struct coff_debug_merge_hash_entry *) NULL)
152 return (struct bfd_hash_entry *) ret;
154 /* Call the allocation method of the superclass. */
155 ret = ((struct coff_debug_merge_hash_entry *)
156 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
157 if (ret != (struct coff_debug_merge_hash_entry *) NULL)
159 /* Set local fields. */
160 ret->types = NULL;
163 return (struct bfd_hash_entry *) ret;
166 /* Given a COFF BFD, add symbols to the global hash table as
167 appropriate. */
169 boolean
170 _bfd_coff_link_add_symbols (abfd, info)
171 bfd *abfd;
172 struct bfd_link_info *info;
174 switch (bfd_get_format (abfd))
176 case bfd_object:
177 return coff_link_add_object_symbols (abfd, info);
178 case bfd_archive:
179 return (_bfd_generic_link_add_archive_symbols
180 (abfd, info, coff_link_check_archive_element));
181 default:
182 bfd_set_error (bfd_error_wrong_format);
183 return false;
187 /* Add symbols from a COFF object file. */
189 static boolean
190 coff_link_add_object_symbols (abfd, info)
191 bfd *abfd;
192 struct bfd_link_info *info;
194 if (! _bfd_coff_get_external_symbols (abfd))
195 return false;
196 if (! coff_link_add_symbols (abfd, info))
197 return false;
199 if (! info->keep_memory)
201 if (! _bfd_coff_free_symbols (abfd))
202 return false;
204 return true;
207 /* Check a single archive element to see if we need to include it in
208 the link. *PNEEDED is set according to whether this element is
209 needed in the link or not. This is called via
210 _bfd_generic_link_add_archive_symbols. */
212 static boolean
213 coff_link_check_archive_element (abfd, info, pneeded)
214 bfd *abfd;
215 struct bfd_link_info *info;
216 boolean *pneeded;
218 if (! _bfd_coff_get_external_symbols (abfd))
219 return false;
221 if (! coff_link_check_ar_symbols (abfd, info, pneeded))
222 return false;
224 if (*pneeded)
226 if (! coff_link_add_symbols (abfd, info))
227 return false;
230 if (! info->keep_memory || ! *pneeded)
232 if (! _bfd_coff_free_symbols (abfd))
233 return false;
236 return true;
239 /* Look through the symbols to see if this object file should be
240 included in the link. */
242 static boolean
243 coff_link_check_ar_symbols (abfd, info, pneeded)
244 bfd *abfd;
245 struct bfd_link_info *info;
246 boolean *pneeded;
248 bfd_size_type symesz;
249 bfd_byte *esym;
250 bfd_byte *esym_end;
252 *pneeded = false;
254 symesz = bfd_coff_symesz (abfd);
255 esym = (bfd_byte *) obj_coff_external_syms (abfd);
256 esym_end = esym + obj_raw_syment_count (abfd) * symesz;
257 while (esym < esym_end)
259 struct internal_syment sym;
260 enum coff_symbol_classification classification;
262 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
264 classification = bfd_coff_classify_symbol (abfd, &sym);
265 if (classification == COFF_SYMBOL_GLOBAL
266 || classification == COFF_SYMBOL_COMMON)
268 const char *name;
269 char buf[SYMNMLEN + 1];
270 struct bfd_link_hash_entry *h;
272 /* This symbol is externally visible, and is defined by this
273 object file. */
275 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
276 if (name == NULL)
277 return false;
278 h = bfd_link_hash_lookup (info->hash, name, false, false, true);
280 /* auto import */
281 if (!h && info->pei386_auto_import)
283 if (!strncmp (name,"__imp_", 6))
286 bfd_link_hash_lookup (info->hash, name + 6, false, false,
287 true);
290 /* We are only interested in symbols that are currently
291 undefined. If a symbol is currently known to be common,
292 COFF linkers do not bring in an object file which defines
293 it. */
294 if (h != (struct bfd_link_hash_entry *) NULL
295 && h->type == bfd_link_hash_undefined)
297 if (! (*info->callbacks->add_archive_element) (info, abfd, name))
298 return false;
299 *pneeded = true;
300 return true;
304 esym += (sym.n_numaux + 1) * symesz;
307 /* We do not need this object file. */
308 return true;
311 /* Add all the symbols from an object file to the hash table. */
313 static boolean
314 coff_link_add_symbols (abfd, info)
315 bfd *abfd;
316 struct bfd_link_info *info;
318 unsigned int n_tmask = coff_data (abfd)->local_n_tmask;
319 unsigned int n_btshft = coff_data (abfd)->local_n_btshft;
320 unsigned int n_btmask = coff_data (abfd)->local_n_btmask;
321 boolean keep_syms;
322 boolean default_copy;
323 bfd_size_type symcount;
324 struct coff_link_hash_entry **sym_hash;
325 bfd_size_type symesz;
326 bfd_byte *esym;
327 bfd_byte *esym_end;
328 bfd_size_type amt;
330 /* Keep the symbols during this function, in case the linker needs
331 to read the generic symbols in order to report an error message. */
332 keep_syms = obj_coff_keep_syms (abfd);
333 obj_coff_keep_syms (abfd) = true;
335 if (info->keep_memory)
336 default_copy = false;
337 else
338 default_copy = true;
340 symcount = obj_raw_syment_count (abfd);
342 /* We keep a list of the linker hash table entries that correspond
343 to particular symbols. */
344 amt = symcount * sizeof (struct coff_link_hash_entry *);
345 sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
346 if (sym_hash == NULL && symcount != 0)
347 goto error_return;
348 obj_coff_sym_hashes (abfd) = sym_hash;
350 symesz = bfd_coff_symesz (abfd);
351 BFD_ASSERT (symesz == bfd_coff_auxesz (abfd));
352 esym = (bfd_byte *) obj_coff_external_syms (abfd);
353 esym_end = esym + symcount * symesz;
354 while (esym < esym_end)
356 struct internal_syment sym;
357 enum coff_symbol_classification classification;
358 boolean copy;
360 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym);
362 classification = bfd_coff_classify_symbol (abfd, &sym);
363 if (classification != COFF_SYMBOL_LOCAL)
365 const char *name;
366 char buf[SYMNMLEN + 1];
367 flagword flags;
368 asection *section;
369 bfd_vma value;
370 boolean addit;
372 /* This symbol is externally visible. */
374 name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
375 if (name == NULL)
376 goto error_return;
378 /* We must copy the name into memory if we got it from the
379 syment itself, rather than the string table. */
380 copy = default_copy;
381 if (sym._n._n_n._n_zeroes != 0
382 || sym._n._n_n._n_offset == 0)
383 copy = true;
385 value = sym.n_value;
387 switch (classification)
389 default:
390 abort ();
392 case COFF_SYMBOL_GLOBAL:
393 flags = BSF_EXPORT | BSF_GLOBAL;
394 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
395 if (! obj_pe (abfd))
396 value -= section->vma;
397 break;
399 case COFF_SYMBOL_UNDEFINED:
400 flags = 0;
401 section = bfd_und_section_ptr;
402 break;
404 case COFF_SYMBOL_COMMON:
405 flags = BSF_GLOBAL;
406 section = bfd_com_section_ptr;
407 break;
409 case COFF_SYMBOL_PE_SECTION:
410 flags = BSF_SECTION_SYM | BSF_GLOBAL;
411 section = coff_section_from_bfd_index (abfd, sym.n_scnum);
412 break;
415 if (IS_WEAK_EXTERNAL (abfd, sym))
416 flags = BSF_WEAK;
418 addit = true;
420 /* In the PE format, section symbols actually refer to the
421 start of the output section. We handle them specially
422 here. */
423 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
425 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
426 name, false, copy, false);
427 if (*sym_hash != NULL)
429 if (((*sym_hash)->coff_link_hash_flags
430 & COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0
431 && (*sym_hash)->root.type != bfd_link_hash_undefined
432 && (*sym_hash)->root.type != bfd_link_hash_undefweak)
433 (*_bfd_error_handler)
434 ("Warning: symbol `%s' is both section and non-section",
435 name);
437 addit = false;
441 /* The Microsoft Visual C compiler does string pooling by
442 hashing the constants to an internal symbol name, and
443 relying on the linker comdat support to discard
444 duplicate names. However, if one string is a literal and
445 one is a data initializer, one will end up in the .data
446 section and one will end up in the .rdata section. The
447 Microsoft linker will combine them into the .data
448 section, which seems to be wrong since it might cause the
449 literal to change.
451 As long as there are no external references to the
452 symbols, which there shouldn't be, we can treat the .data
453 and .rdata instances as separate symbols. The comdat
454 code in the linker will do the appropriate merging. Here
455 we avoid getting a multiple definition error for one of
456 these special symbols.
458 FIXME: I don't think this will work in the case where
459 there are two object files which use the constants as a
460 literal and two object files which use it as a data
461 initializer. One or the other of the second object files
462 is going to wind up with an inappropriate reference. */
463 if (obj_pe (abfd)
464 && (classification == COFF_SYMBOL_GLOBAL
465 || classification == COFF_SYMBOL_PE_SECTION)
466 && section->comdat != NULL
467 && strncmp (name, "??_", 3) == 0
468 && strcmp (name, section->comdat->name) == 0)
470 if (*sym_hash == NULL)
471 *sym_hash = coff_link_hash_lookup (coff_hash_table (info),
472 name, false, copy, false);
473 if (*sym_hash != NULL
474 && (*sym_hash)->root.type == bfd_link_hash_defined
475 && (*sym_hash)->root.u.def.section->comdat != NULL
476 && strcmp ((*sym_hash)->root.u.def.section->comdat->name,
477 section->comdat->name) == 0)
478 addit = false;
481 if (addit)
483 if (! (bfd_coff_link_add_one_symbol
484 (info, abfd, name, flags, section, value,
485 (const char *) NULL, copy, false,
486 (struct bfd_link_hash_entry **) sym_hash)))
487 goto error_return;
490 if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0)
491 (*sym_hash)->coff_link_hash_flags |=
492 COFF_LINK_HASH_PE_SECTION_SYMBOL;
494 /* Limit the alignment of a common symbol to the possible
495 alignment of a section. There is no point to permitting
496 a higher alignment for a common symbol: we can not
497 guarantee it, and it may cause us to allocate extra space
498 in the common section. */
499 if (section == bfd_com_section_ptr
500 && (*sym_hash)->root.type == bfd_link_hash_common
501 && ((*sym_hash)->root.u.c.p->alignment_power
502 > bfd_coff_default_section_alignment_power (abfd)))
503 (*sym_hash)->root.u.c.p->alignment_power
504 = bfd_coff_default_section_alignment_power (abfd);
506 if (info->hash->creator->flavour == bfd_get_flavour (abfd))
508 /* If we don't have any symbol information currently in
509 the hash table, or if we are looking at a symbol
510 definition, then update the symbol class and type in
511 the hash table. */
512 if (((*sym_hash)->class == C_NULL
513 && (*sym_hash)->type == T_NULL)
514 || sym.n_scnum != 0
515 || (sym.n_value != 0
516 && (*sym_hash)->root.type != bfd_link_hash_defined
517 && (*sym_hash)->root.type != bfd_link_hash_defweak))
519 (*sym_hash)->class = sym.n_sclass;
520 if (sym.n_type != T_NULL)
522 /* We want to warn if the type changed, but not
523 if it changed from an unspecified type.
524 Testing the whole type byte may work, but the
525 change from (e.g.) a function of unspecified
526 type to function of known type also wants to
527 skip the warning. */
528 if ((*sym_hash)->type != T_NULL
529 && (*sym_hash)->type != sym.n_type
530 && !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type)
531 && (BTYPE ((*sym_hash)->type) == T_NULL
532 || BTYPE (sym.n_type) == T_NULL)))
533 (*_bfd_error_handler)
534 (_("Warning: type of symbol `%s' changed from %d to %d in %s"),
535 name, (*sym_hash)->type, sym.n_type,
536 bfd_archive_filename (abfd));
538 /* We don't want to change from a meaningful
539 base type to a null one, but if we know
540 nothing, take what little we might now know. */
541 if (BTYPE (sym.n_type) != T_NULL
542 || (*sym_hash)->type == T_NULL)
543 (*sym_hash)->type = sym.n_type;
545 (*sym_hash)->auxbfd = abfd;
546 if (sym.n_numaux != 0)
548 union internal_auxent *alloc;
549 unsigned int i;
550 bfd_byte *eaux;
551 union internal_auxent *iaux;
553 (*sym_hash)->numaux = sym.n_numaux;
554 alloc = ((union internal_auxent *)
555 bfd_hash_allocate (&info->hash->table,
556 (sym.n_numaux
557 * sizeof (*alloc))));
558 if (alloc == NULL)
559 goto error_return;
560 for (i = 0, eaux = esym + symesz, iaux = alloc;
561 i < sym.n_numaux;
562 i++, eaux += symesz, iaux++)
563 bfd_coff_swap_aux_in (abfd, (PTR) eaux, sym.n_type,
564 sym.n_sclass, (int) i,
565 sym.n_numaux, (PTR) iaux);
566 (*sym_hash)->aux = alloc;
571 if (classification == COFF_SYMBOL_PE_SECTION
572 && (*sym_hash)->numaux != 0)
574 /* Some PE sections (such as .bss) have a zero size in
575 the section header, but a non-zero size in the AUX
576 record. Correct that here.
578 FIXME: This is not at all the right place to do this.
579 For example, it won't help objdump. This needs to be
580 done when we swap in the section header. */
582 BFD_ASSERT ((*sym_hash)->numaux == 1);
583 if (section->_raw_size == 0)
584 section->_raw_size = (*sym_hash)->aux[0].x_scn.x_scnlen;
586 /* FIXME: We could test whether the section sizes
587 matches the size in the aux entry, but apparently
588 that sometimes fails unexpectedly. */
592 esym += (sym.n_numaux + 1) * symesz;
593 sym_hash += sym.n_numaux + 1;
596 /* If this is a non-traditional, non-relocateable link, try to
597 optimize the handling of any .stab/.stabstr sections. */
598 if (! info->relocateable
599 && ! info->traditional_format
600 && info->hash->creator->flavour == bfd_get_flavour (abfd)
601 && (info->strip != strip_all && info->strip != strip_debugger))
603 asection *stab, *stabstr;
605 stab = bfd_get_section_by_name (abfd, ".stab");
606 if (stab != NULL)
608 stabstr = bfd_get_section_by_name (abfd, ".stabstr");
610 if (stabstr != NULL)
612 struct coff_link_hash_table *table;
613 struct coff_section_tdata *secdata;
615 secdata = coff_section_data (abfd, stab);
616 if (secdata == NULL)
618 amt = sizeof (struct coff_section_tdata);
619 stab->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
620 if (stab->used_by_bfd == NULL)
621 goto error_return;
622 secdata = coff_section_data (abfd, stab);
625 table = coff_hash_table (info);
627 if (! _bfd_link_section_stabs (abfd, &table->stab_info,
628 stab, stabstr,
629 &secdata->stab_info))
630 goto error_return;
635 obj_coff_keep_syms (abfd) = keep_syms;
637 return true;
639 error_return:
640 obj_coff_keep_syms (abfd) = keep_syms;
641 return false;
644 /* Do the final link step. */
646 boolean
647 _bfd_coff_final_link (abfd, info)
648 bfd *abfd;
649 struct bfd_link_info *info;
651 bfd_size_type symesz;
652 struct coff_final_link_info finfo;
653 boolean debug_merge_allocated;
654 boolean long_section_names;
655 asection *o;
656 struct bfd_link_order *p;
657 bfd_size_type max_sym_count;
658 bfd_size_type max_lineno_count;
659 bfd_size_type max_reloc_count;
660 bfd_size_type max_output_reloc_count;
661 bfd_size_type max_contents_size;
662 file_ptr rel_filepos;
663 unsigned int relsz;
664 file_ptr line_filepos;
665 unsigned int linesz;
666 bfd *sub;
667 bfd_byte *external_relocs = NULL;
668 char strbuf[STRING_SIZE_SIZE];
669 bfd_size_type amt;
671 symesz = bfd_coff_symesz (abfd);
673 finfo.info = info;
674 finfo.output_bfd = abfd;
675 finfo.strtab = NULL;
676 finfo.section_info = NULL;
677 finfo.last_file_index = -1;
678 finfo.last_bf_index = -1;
679 finfo.internal_syms = NULL;
680 finfo.sec_ptrs = NULL;
681 finfo.sym_indices = NULL;
682 finfo.outsyms = NULL;
683 finfo.linenos = NULL;
684 finfo.contents = NULL;
685 finfo.external_relocs = NULL;
686 finfo.internal_relocs = NULL;
687 finfo.global_to_static = false;
688 debug_merge_allocated = false;
690 coff_data (abfd)->link_info = info;
692 finfo.strtab = _bfd_stringtab_init ();
693 if (finfo.strtab == NULL)
694 goto error_return;
696 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
697 goto error_return;
698 debug_merge_allocated = true;
700 /* Compute the file positions for all the sections. */
701 if (! abfd->output_has_begun)
703 if (! bfd_coff_compute_section_file_positions (abfd))
704 goto error_return;
707 /* Count the line numbers and relocation entries required for the
708 output file. Set the file positions for the relocs. */
709 rel_filepos = obj_relocbase (abfd);
710 relsz = bfd_coff_relsz (abfd);
711 max_contents_size = 0;
712 max_lineno_count = 0;
713 max_reloc_count = 0;
715 long_section_names = false;
716 for (o = abfd->sections; o != NULL; o = o->next)
718 o->reloc_count = 0;
719 o->lineno_count = 0;
720 for (p = o->link_order_head; p != NULL; p = p->next)
722 if (p->type == bfd_indirect_link_order)
724 asection *sec;
726 sec = p->u.indirect.section;
728 /* Mark all sections which are to be included in the
729 link. This will normally be every section. We need
730 to do this so that we can identify any sections which
731 the linker has decided to not include. */
732 sec->linker_mark = true;
734 if (info->strip == strip_none
735 || info->strip == strip_some)
736 o->lineno_count += sec->lineno_count;
738 if (info->relocateable)
739 o->reloc_count += sec->reloc_count;
741 if (sec->_raw_size > max_contents_size)
742 max_contents_size = sec->_raw_size;
743 if (sec->lineno_count > max_lineno_count)
744 max_lineno_count = sec->lineno_count;
745 if (sec->reloc_count > max_reloc_count)
746 max_reloc_count = sec->reloc_count;
748 else if (info->relocateable
749 && (p->type == bfd_section_reloc_link_order
750 || p->type == bfd_symbol_reloc_link_order))
751 ++o->reloc_count;
753 if (o->reloc_count == 0)
754 o->rel_filepos = 0;
755 else
757 o->flags |= SEC_RELOC;
758 o->rel_filepos = rel_filepos;
759 rel_filepos += o->reloc_count * relsz;
760 /* In PE COFF, if there are at least 0xffff relocations an
761 extra relocation will be written out to encode the count. */
762 if (obj_pe (abfd) && o->reloc_count >= 0xffff)
763 rel_filepos += relsz;
766 if (bfd_coff_long_section_names (abfd)
767 && strlen (o->name) > SCNNMLEN)
769 /* This section has a long name which must go in the string
770 table. This must correspond to the code in
771 coff_write_object_contents which puts the string index
772 into the s_name field of the section header. That is why
773 we pass hash as false. */
774 if (_bfd_stringtab_add (finfo.strtab, o->name, false, false)
775 == (bfd_size_type) -1)
776 goto error_return;
777 long_section_names = true;
781 /* If doing a relocateable link, allocate space for the pointers we
782 need to keep. */
783 if (info->relocateable)
785 unsigned int i;
787 /* We use section_count + 1, rather than section_count, because
788 the target_index fields are 1 based. */
789 amt = abfd->section_count + 1;
790 amt *= sizeof (struct coff_link_section_info);
791 finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
792 if (finfo.section_info == NULL)
793 goto error_return;
794 for (i = 0; i <= abfd->section_count; i++)
796 finfo.section_info[i].relocs = NULL;
797 finfo.section_info[i].rel_hashes = NULL;
801 /* We now know the size of the relocs, so we can determine the file
802 positions of the line numbers. */
803 line_filepos = rel_filepos;
804 linesz = bfd_coff_linesz (abfd);
805 max_output_reloc_count = 0;
806 for (o = abfd->sections; o != NULL; o = o->next)
808 if (o->lineno_count == 0)
809 o->line_filepos = 0;
810 else
812 o->line_filepos = line_filepos;
813 line_filepos += o->lineno_count * linesz;
816 if (o->reloc_count != 0)
818 /* We don't know the indices of global symbols until we have
819 written out all the local symbols. For each section in
820 the output file, we keep an array of pointers to hash
821 table entries. Each entry in the array corresponds to a
822 reloc. When we find a reloc against a global symbol, we
823 set the corresponding entry in this array so that we can
824 fix up the symbol index after we have written out all the
825 local symbols.
827 Because of this problem, we also keep the relocs in
828 memory until the end of the link. This wastes memory,
829 but only when doing a relocateable link, which is not the
830 common case. */
831 BFD_ASSERT (info->relocateable);
832 amt = o->reloc_count;
833 amt *= sizeof (struct internal_reloc);
834 finfo.section_info[o->target_index].relocs =
835 (struct internal_reloc *) bfd_malloc (amt);
836 amt = o->reloc_count;
837 amt *= sizeof (struct coff_link_hash_entry *);
838 finfo.section_info[o->target_index].rel_hashes =
839 (struct coff_link_hash_entry **) bfd_malloc (amt);
840 if (finfo.section_info[o->target_index].relocs == NULL
841 || finfo.section_info[o->target_index].rel_hashes == NULL)
842 goto error_return;
844 if (o->reloc_count > max_output_reloc_count)
845 max_output_reloc_count = o->reloc_count;
848 /* Reset the reloc and lineno counts, so that we can use them to
849 count the number of entries we have output so far. */
850 o->reloc_count = 0;
851 o->lineno_count = 0;
854 obj_sym_filepos (abfd) = line_filepos;
856 /* Figure out the largest number of symbols in an input BFD. Take
857 the opportunity to clear the output_has_begun fields of all the
858 input BFD's. */
859 max_sym_count = 0;
860 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
862 size_t sz;
864 sub->output_has_begun = false;
865 sz = obj_raw_syment_count (sub);
866 if (sz > max_sym_count)
867 max_sym_count = sz;
870 /* Allocate some buffers used while linking. */
871 amt = max_sym_count * sizeof (struct internal_syment);
872 finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
873 amt = max_sym_count * sizeof (asection *);
874 finfo.sec_ptrs = (asection **) bfd_malloc (amt);
875 amt = max_sym_count * sizeof (long);
876 finfo.sym_indices = (long *) bfd_malloc (amt);
877 finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
878 amt = max_lineno_count * bfd_coff_linesz (abfd);
879 finfo.linenos = (bfd_byte *) bfd_malloc (amt);
880 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
881 amt = max_reloc_count * relsz;
882 finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
883 if (! info->relocateable)
885 amt = max_reloc_count * sizeof (struct internal_reloc);
886 finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
888 if ((finfo.internal_syms == NULL && max_sym_count > 0)
889 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
890 || (finfo.sym_indices == NULL && max_sym_count > 0)
891 || finfo.outsyms == NULL
892 || (finfo.linenos == NULL && max_lineno_count > 0)
893 || (finfo.contents == NULL && max_contents_size > 0)
894 || (finfo.external_relocs == NULL && max_reloc_count > 0)
895 || (! info->relocateable
896 && finfo.internal_relocs == NULL
897 && max_reloc_count > 0))
898 goto error_return;
900 /* We now know the position of everything in the file, except that
901 we don't know the size of the symbol table and therefore we don't
902 know where the string table starts. We just build the string
903 table in memory as we go along. We process all the relocations
904 for a single input file at once. */
905 obj_raw_syment_count (abfd) = 0;
907 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
909 if (! bfd_coff_start_final_link (abfd, info))
910 goto error_return;
913 for (o = abfd->sections; o != NULL; o = o->next)
915 for (p = o->link_order_head; p != NULL; p = p->next)
917 if (p->type == bfd_indirect_link_order
918 && bfd_family_coff (p->u.indirect.section->owner))
920 sub = p->u.indirect.section->owner;
921 if (! bfd_coff_link_output_has_begun (sub, & finfo))
923 if (! _bfd_coff_link_input_bfd (&finfo, sub))
924 goto error_return;
925 sub->output_has_begun = true;
928 else if (p->type == bfd_section_reloc_link_order
929 || p->type == bfd_symbol_reloc_link_order)
931 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
932 goto error_return;
934 else
936 if (! _bfd_default_link_order (abfd, info, o, p))
937 goto error_return;
942 if (! bfd_coff_final_link_postscript (abfd, & finfo))
943 goto error_return;
945 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
947 coff_debug_merge_hash_table_free (&finfo.debug_merge);
948 debug_merge_allocated = false;
950 if (finfo.internal_syms != NULL)
952 free (finfo.internal_syms);
953 finfo.internal_syms = NULL;
955 if (finfo.sec_ptrs != NULL)
957 free (finfo.sec_ptrs);
958 finfo.sec_ptrs = NULL;
960 if (finfo.sym_indices != NULL)
962 free (finfo.sym_indices);
963 finfo.sym_indices = NULL;
965 if (finfo.linenos != NULL)
967 free (finfo.linenos);
968 finfo.linenos = NULL;
970 if (finfo.contents != NULL)
972 free (finfo.contents);
973 finfo.contents = NULL;
975 if (finfo.external_relocs != NULL)
977 free (finfo.external_relocs);
978 finfo.external_relocs = NULL;
980 if (finfo.internal_relocs != NULL)
982 free (finfo.internal_relocs);
983 finfo.internal_relocs = NULL;
986 /* The value of the last C_FILE symbol is supposed to be the symbol
987 index of the first external symbol. Write it out again if
988 necessary. */
989 if (finfo.last_file_index != -1
990 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
992 file_ptr pos;
994 finfo.last_file.n_value = obj_raw_syment_count (abfd);
995 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
996 (PTR) finfo.outsyms);
998 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
999 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1000 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
1001 return false;
1004 /* If doing task linking (ld --task-link) then make a pass through the
1005 global symbols, writing out any that are defined, and making them
1006 static. */
1007 if (info->task_link)
1009 finfo.failed = false;
1010 coff_link_hash_traverse (coff_hash_table (info),
1011 _bfd_coff_write_task_globals,
1012 (PTR) &finfo);
1013 if (finfo.failed)
1014 goto error_return;
1017 /* Write out the global symbols. */
1018 finfo.failed = false;
1019 coff_link_hash_traverse (coff_hash_table (info),
1020 _bfd_coff_write_global_sym,
1021 (PTR) &finfo);
1022 if (finfo.failed)
1023 goto error_return;
1025 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
1026 if (finfo.outsyms != NULL)
1028 free (finfo.outsyms);
1029 finfo.outsyms = NULL;
1032 if (info->relocateable && max_output_reloc_count > 0)
1034 /* Now that we have written out all the global symbols, we know
1035 the symbol indices to use for relocs against them, and we can
1036 finally write out the relocs. */
1037 amt = max_output_reloc_count * relsz;
1038 external_relocs = (bfd_byte *) bfd_malloc (amt);
1039 if (external_relocs == NULL)
1040 goto error_return;
1042 for (o = abfd->sections; o != NULL; o = o->next)
1044 struct internal_reloc *irel;
1045 struct internal_reloc *irelend;
1046 struct coff_link_hash_entry **rel_hash;
1047 bfd_byte *erel;
1049 if (o->reloc_count == 0)
1050 continue;
1052 irel = finfo.section_info[o->target_index].relocs;
1053 irelend = irel + o->reloc_count;
1054 rel_hash = finfo.section_info[o->target_index].rel_hashes;
1055 erel = external_relocs;
1056 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
1058 if (*rel_hash != NULL)
1060 BFD_ASSERT ((*rel_hash)->indx >= 0);
1061 irel->r_symndx = (*rel_hash)->indx;
1063 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
1066 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
1067 || (bfd_bwrite ((PTR) external_relocs,
1068 (bfd_size_type) relsz * o->reloc_count, abfd)
1069 != (bfd_size_type) relsz * o->reloc_count))
1070 goto error_return;
1073 free (external_relocs);
1074 external_relocs = NULL;
1077 /* Free up the section information. */
1078 if (finfo.section_info != NULL)
1080 unsigned int i;
1082 for (i = 0; i < abfd->section_count; i++)
1084 if (finfo.section_info[i].relocs != NULL)
1085 free (finfo.section_info[i].relocs);
1086 if (finfo.section_info[i].rel_hashes != NULL)
1087 free (finfo.section_info[i].rel_hashes);
1089 free (finfo.section_info);
1090 finfo.section_info = NULL;
1093 /* If we have optimized stabs strings, output them. */
1094 if (coff_hash_table (info)->stab_info != NULL)
1096 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
1097 return false;
1100 /* Write out the string table. */
1101 if (obj_raw_syment_count (abfd) != 0 || long_section_names)
1103 file_ptr pos;
1105 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
1106 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1107 return false;
1109 #if STRING_SIZE_SIZE == 4
1110 H_PUT_32 (abfd,
1111 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
1112 strbuf);
1113 #else
1114 #error Change H_PUT_32 above
1115 #endif
1117 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1118 != STRING_SIZE_SIZE)
1119 return false;
1121 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
1122 return false;
1124 obj_coff_strings_written (abfd) = true;
1127 _bfd_stringtab_free (finfo.strtab);
1129 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
1130 not try to write out the symbols. */
1131 bfd_get_symcount (abfd) = 0;
1133 return true;
1135 error_return:
1136 if (debug_merge_allocated)
1137 coff_debug_merge_hash_table_free (&finfo.debug_merge);
1138 if (finfo.strtab != NULL)
1139 _bfd_stringtab_free (finfo.strtab);
1140 if (finfo.section_info != NULL)
1142 unsigned int i;
1144 for (i = 0; i < abfd->section_count; i++)
1146 if (finfo.section_info[i].relocs != NULL)
1147 free (finfo.section_info[i].relocs);
1148 if (finfo.section_info[i].rel_hashes != NULL)
1149 free (finfo.section_info[i].rel_hashes);
1151 free (finfo.section_info);
1153 if (finfo.internal_syms != NULL)
1154 free (finfo.internal_syms);
1155 if (finfo.sec_ptrs != NULL)
1156 free (finfo.sec_ptrs);
1157 if (finfo.sym_indices != NULL)
1158 free (finfo.sym_indices);
1159 if (finfo.outsyms != NULL)
1160 free (finfo.outsyms);
1161 if (finfo.linenos != NULL)
1162 free (finfo.linenos);
1163 if (finfo.contents != NULL)
1164 free (finfo.contents);
1165 if (finfo.external_relocs != NULL)
1166 free (finfo.external_relocs);
1167 if (finfo.internal_relocs != NULL)
1168 free (finfo.internal_relocs);
1169 if (external_relocs != NULL)
1170 free (external_relocs);
1171 return false;
1174 /* parse out a -heap <reserved>,<commit> line */
1176 static char *
1177 dores_com (ptr, output_bfd, heap)
1178 char *ptr;
1179 bfd *output_bfd;
1180 int heap;
1182 if (coff_data(output_bfd)->pe)
1184 int val = strtoul (ptr, &ptr, 0);
1185 if (heap)
1186 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val;
1187 else
1188 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val;
1190 if (ptr[0] == ',')
1192 val = strtoul (ptr+1, &ptr, 0);
1193 if (heap)
1194 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val;
1195 else
1196 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val;
1199 return ptr;
1202 static char *get_name(ptr, dst)
1203 char *ptr;
1204 char **dst;
1206 while (*ptr == ' ')
1207 ptr++;
1208 *dst = ptr;
1209 while (*ptr && *ptr != ' ')
1210 ptr++;
1211 *ptr = 0;
1212 return ptr+1;
1215 /* Process any magic embedded commands in a section called .drectve */
1217 static int
1218 process_embedded_commands (output_bfd, info, abfd)
1219 bfd *output_bfd;
1220 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1221 bfd *abfd;
1223 asection *sec = bfd_get_section_by_name (abfd, ".drectve");
1224 char *s;
1225 char *e;
1226 char *copy;
1227 if (!sec)
1228 return 1;
1230 copy = bfd_malloc (sec->_raw_size);
1231 if (!copy)
1232 return 0;
1233 if (! bfd_get_section_contents(abfd, sec, copy, (bfd_vma) 0, sec->_raw_size))
1235 free (copy);
1236 return 0;
1238 e = copy + sec->_raw_size;
1239 for (s = copy; s < e ; )
1241 if (s[0]!= '-') {
1242 s++;
1243 continue;
1245 if (strncmp (s,"-attr", 5) == 0)
1247 char *name;
1248 char *attribs;
1249 asection *asec;
1251 int loop = 1;
1252 int had_write = 0;
1253 int had_read = 0;
1254 int had_exec= 0;
1255 int had_shared= 0;
1256 s += 5;
1257 s = get_name(s, &name);
1258 s = get_name(s, &attribs);
1259 while (loop) {
1260 switch (*attribs++)
1262 case 'W':
1263 had_write = 1;
1264 break;
1265 case 'R':
1266 had_read = 1;
1267 break;
1268 case 'S':
1269 had_shared = 1;
1270 break;
1271 case 'X':
1272 had_exec = 1;
1273 break;
1274 default:
1275 loop = 0;
1278 asec = bfd_get_section_by_name (abfd, name);
1279 if (asec) {
1280 if (had_exec)
1281 asec->flags |= SEC_CODE;
1282 if (!had_write)
1283 asec->flags |= SEC_READONLY;
1286 else if (strncmp (s,"-heap", 5) == 0)
1288 s = dores_com (s+5, output_bfd, 1);
1290 else if (strncmp (s,"-stack", 6) == 0)
1292 s = dores_com (s+6, output_bfd, 0);
1294 else
1295 s++;
1297 free (copy);
1298 return 1;
1301 /* Place a marker against all symbols which are used by relocations.
1302 This marker can be picked up by the 'do we skip this symbol ?'
1303 loop in _bfd_coff_link_input_bfd() and used to prevent skipping
1304 that symbol.
1307 static void
1308 mark_relocs (finfo, input_bfd)
1309 struct coff_final_link_info * finfo;
1310 bfd * input_bfd;
1312 asection * a;
1314 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0)
1315 return;
1317 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next)
1319 struct internal_reloc * internal_relocs;
1320 struct internal_reloc * irel;
1321 struct internal_reloc * irelend;
1323 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1324 continue;
1325 /* Don't mark relocs in excluded sections. */
1326 if (a->output_section == bfd_abs_section_ptr)
1327 continue;
1329 /* Read in the relocs. */
1330 internal_relocs = _bfd_coff_read_internal_relocs
1331 (input_bfd, a, false,
1332 finfo->external_relocs,
1333 finfo->info->relocateable,
1334 (finfo->info->relocateable
1335 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1336 : finfo->internal_relocs)
1339 if (internal_relocs == NULL)
1340 continue;
1342 irel = internal_relocs;
1343 irelend = irel + a->reloc_count;
1345 /* Place a mark in the sym_indices array (whose entries have
1346 been initialised to 0) for all of the symbols that are used
1347 in the relocation table. This will then be picked up in the
1348 skip/don't pass */
1350 for (; irel < irelend; irel++)
1352 finfo->sym_indices[ irel->r_symndx ] = -1;
1357 /* Link an input file into the linker output file. This function
1358 handles all the sections and relocations of the input file at once. */
1360 boolean
1361 _bfd_coff_link_input_bfd (finfo, input_bfd)
1362 struct coff_final_link_info *finfo;
1363 bfd *input_bfd;
1365 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1366 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1367 #if 0
1368 unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask;
1369 #endif
1370 boolean (*adjust_symndx) PARAMS ((bfd *, struct bfd_link_info *, bfd *,
1371 asection *, struct internal_reloc *,
1372 boolean *));
1373 bfd *output_bfd;
1374 const char *strings;
1375 bfd_size_type syment_base;
1376 boolean copy, hash;
1377 bfd_size_type isymesz;
1378 bfd_size_type osymesz;
1379 bfd_size_type linesz;
1380 bfd_byte *esym;
1381 bfd_byte *esym_end;
1382 struct internal_syment *isymp;
1383 asection **secpp;
1384 long *indexp;
1385 unsigned long output_index;
1386 bfd_byte *outsym;
1387 struct coff_link_hash_entry **sym_hash;
1388 asection *o;
1390 /* Move all the symbols to the output file. */
1392 output_bfd = finfo->output_bfd;
1393 strings = NULL;
1394 syment_base = obj_raw_syment_count (output_bfd);
1395 isymesz = bfd_coff_symesz (input_bfd);
1396 osymesz = bfd_coff_symesz (output_bfd);
1397 linesz = bfd_coff_linesz (input_bfd);
1398 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1400 copy = false;
1401 if (! finfo->info->keep_memory)
1402 copy = true;
1403 hash = true;
1404 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1405 hash = false;
1407 if (! _bfd_coff_get_external_symbols (input_bfd))
1408 return false;
1410 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1411 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1412 isymp = finfo->internal_syms;
1413 secpp = finfo->sec_ptrs;
1414 indexp = finfo->sym_indices;
1415 output_index = syment_base;
1416 outsym = finfo->outsyms;
1418 if (coff_data (output_bfd)->pe)
1420 if (! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1421 return false;
1424 /* If we are going to perform relocations and also strip/discard some symbols
1425 then we must make sure that we do not strip/discard those symbols that are
1426 going to be involved in the relocations */
1427 if (( finfo->info->strip != strip_none
1428 || finfo->info->discard != discard_none)
1429 && finfo->info->relocateable)
1431 /* mark the symbol array as 'not-used' */
1432 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1434 mark_relocs (finfo, input_bfd);
1437 while (esym < esym_end)
1439 struct internal_syment isym;
1440 enum coff_symbol_classification classification;
1441 boolean skip;
1442 boolean global;
1443 boolean dont_skip_symbol;
1444 int add;
1446 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1448 /* Make a copy of *isymp so that the relocate_section function
1449 always sees the original values. This is more reliable than
1450 always recomputing the symbol value even if we are stripping
1451 the symbol. */
1452 isym = *isymp;
1454 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1455 switch (classification)
1457 default:
1458 abort ();
1459 case COFF_SYMBOL_GLOBAL:
1460 case COFF_SYMBOL_PE_SECTION:
1461 case COFF_SYMBOL_LOCAL:
1462 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1463 break;
1464 case COFF_SYMBOL_COMMON:
1465 *secpp = bfd_com_section_ptr;
1466 break;
1467 case COFF_SYMBOL_UNDEFINED:
1468 *secpp = bfd_und_section_ptr;
1469 break;
1472 /* Extract the flag indicating if this symbol is used by a
1473 relocation. */
1474 if ((finfo->info->strip != strip_none
1475 || finfo->info->discard != discard_none)
1476 && finfo->info->relocateable)
1477 dont_skip_symbol = *indexp;
1478 else
1479 dont_skip_symbol = false;
1481 *indexp = -1;
1483 skip = false;
1484 global = false;
1485 add = 1 + isym.n_numaux;
1487 /* If we are stripping all symbols, we want to skip this one. */
1488 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1489 skip = true;
1491 if (! skip)
1493 switch (classification)
1495 default:
1496 abort ();
1497 case COFF_SYMBOL_GLOBAL:
1498 case COFF_SYMBOL_COMMON:
1499 case COFF_SYMBOL_PE_SECTION:
1500 /* This is a global symbol. Global symbols come at the
1501 end of the symbol table, so skip them for now.
1502 Locally defined function symbols, however, are an
1503 exception, and are not moved to the end. */
1504 global = true;
1505 if (! ISFCN (isym.n_type))
1506 skip = true;
1507 break;
1509 case COFF_SYMBOL_UNDEFINED:
1510 /* Undefined symbols are left for the end. */
1511 global = true;
1512 skip = true;
1513 break;
1515 case COFF_SYMBOL_LOCAL:
1516 /* This is a local symbol. Skip it if we are discarding
1517 local symbols. */
1518 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1519 skip = true;
1520 break;
1524 #ifndef COFF_WITH_PE
1525 /* Skip section symbols for sections which are not going to be
1526 emitted. */
1527 if (!skip
1528 && isym.n_sclass == C_STAT
1529 && isym.n_type == T_NULL
1530 && isym.n_numaux > 0)
1532 if ((*secpp)->output_section == bfd_abs_section_ptr)
1533 skip = true;
1535 #endif
1537 /* If we stripping debugging symbols, and this is a debugging
1538 symbol, then skip it. FIXME: gas sets the section to N_ABS
1539 for some types of debugging symbols; I don't know if this is
1540 a bug or not. In any case, we handle it here. */
1541 if (! skip
1542 && finfo->info->strip == strip_debugger
1543 && ! dont_skip_symbol
1544 && (isym.n_scnum == N_DEBUG
1545 || (isym.n_scnum == N_ABS
1546 && (isym.n_sclass == C_AUTO
1547 || isym.n_sclass == C_REG
1548 || isym.n_sclass == C_MOS
1549 || isym.n_sclass == C_MOE
1550 || isym.n_sclass == C_MOU
1551 || isym.n_sclass == C_ARG
1552 || isym.n_sclass == C_REGPARM
1553 || isym.n_sclass == C_FIELD
1554 || isym.n_sclass == C_EOS))))
1555 skip = true;
1557 /* If some symbols are stripped based on the name, work out the
1558 name and decide whether to skip this symbol. */
1559 if (! skip
1560 && (finfo->info->strip == strip_some
1561 || finfo->info->discard == discard_l))
1563 const char *name;
1564 char buf[SYMNMLEN + 1];
1566 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1567 if (name == NULL)
1568 return false;
1570 if (! dont_skip_symbol
1571 && ((finfo->info->strip == strip_some
1572 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
1573 false) == NULL))
1574 || (! global
1575 && finfo->info->discard == discard_l
1576 && bfd_is_local_label_name (input_bfd, name))))
1577 skip = true;
1580 /* If this is an enum, struct, or union tag, see if we have
1581 already output an identical type. */
1582 if (! skip
1583 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1584 && (isym.n_sclass == C_ENTAG
1585 || isym.n_sclass == C_STRTAG
1586 || isym.n_sclass == C_UNTAG)
1587 && isym.n_numaux == 1)
1589 const char *name;
1590 char buf[SYMNMLEN + 1];
1591 struct coff_debug_merge_hash_entry *mh;
1592 struct coff_debug_merge_type *mt;
1593 union internal_auxent aux;
1594 struct coff_debug_merge_element **epp;
1595 bfd_byte *esl, *eslend;
1596 struct internal_syment *islp;
1597 bfd_size_type amt;
1599 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1600 if (name == NULL)
1601 return false;
1603 /* Ignore fake names invented by compiler; treat them all as
1604 the same name. */
1605 if (*name == '~' || *name == '.' || *name == '$'
1606 || (*name == bfd_get_symbol_leading_char (input_bfd)
1607 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1608 name = "";
1610 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1611 true, true);
1612 if (mh == NULL)
1613 return false;
1615 /* Allocate memory to hold type information. If this turns
1616 out to be a duplicate, we pass this address to
1617 bfd_release. */
1618 amt = sizeof (struct coff_debug_merge_type);
1619 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);
1620 if (mt == NULL)
1621 return false;
1622 mt->class = isym.n_sclass;
1624 /* Pick up the aux entry, which points to the end of the tag
1625 entries. */
1626 bfd_coff_swap_aux_in (input_bfd, (PTR) (esym + isymesz),
1627 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1628 (PTR) &aux);
1630 /* Gather the elements. */
1631 epp = &mt->elements;
1632 mt->elements = NULL;
1633 islp = isymp + 2;
1634 esl = esym + 2 * isymesz;
1635 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1636 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1637 while (esl < eslend)
1639 const char *elename;
1640 char elebuf[SYMNMLEN + 1];
1641 char *name_copy;
1643 bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp);
1645 amt = sizeof (struct coff_debug_merge_element);
1646 *epp = ((struct coff_debug_merge_element *)
1647 bfd_alloc (input_bfd, amt));
1648 if (*epp == NULL)
1649 return false;
1651 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1652 elebuf);
1653 if (elename == NULL)
1654 return false;
1656 amt = strlen (elename) + 1;
1657 name_copy = (char *) bfd_alloc (input_bfd, amt);
1658 if (name_copy == NULL)
1659 return false;
1660 strcpy (name_copy, elename);
1662 (*epp)->name = name_copy;
1663 (*epp)->type = islp->n_type;
1664 (*epp)->tagndx = 0;
1665 if (islp->n_numaux >= 1
1666 && islp->n_type != T_NULL
1667 && islp->n_sclass != C_EOS)
1669 union internal_auxent eleaux;
1670 long indx;
1672 bfd_coff_swap_aux_in (input_bfd, (PTR) (esl + isymesz),
1673 islp->n_type, islp->n_sclass, 0,
1674 islp->n_numaux, (PTR) &eleaux);
1675 indx = eleaux.x_sym.x_tagndx.l;
1677 /* FIXME: If this tagndx entry refers to a symbol
1678 defined later in this file, we just ignore it.
1679 Handling this correctly would be tedious, and may
1680 not be required. */
1682 if (indx > 0
1683 && (indx
1684 < ((esym -
1685 (bfd_byte *) obj_coff_external_syms (input_bfd))
1686 / (long) isymesz)))
1688 (*epp)->tagndx = finfo->sym_indices[indx];
1689 if ((*epp)->tagndx < 0)
1690 (*epp)->tagndx = 0;
1693 epp = &(*epp)->next;
1694 *epp = NULL;
1696 esl += (islp->n_numaux + 1) * isymesz;
1697 islp += islp->n_numaux + 1;
1700 /* See if we already have a definition which matches this
1701 type. We always output the type if it has no elements,
1702 for simplicity. */
1703 if (mt->elements == NULL)
1704 bfd_release (input_bfd, (PTR) mt);
1705 else
1707 struct coff_debug_merge_type *mtl;
1709 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1711 struct coff_debug_merge_element *me, *mel;
1713 if (mtl->class != mt->class)
1714 continue;
1716 for (me = mt->elements, mel = mtl->elements;
1717 me != NULL && mel != NULL;
1718 me = me->next, mel = mel->next)
1720 if (strcmp (me->name, mel->name) != 0
1721 || me->type != mel->type
1722 || me->tagndx != mel->tagndx)
1723 break;
1726 if (me == NULL && mel == NULL)
1727 break;
1730 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1732 /* This is the first definition of this type. */
1733 mt->indx = output_index;
1734 mt->next = mh->types;
1735 mh->types = mt;
1737 else
1739 /* This is a redefinition which can be merged. */
1740 bfd_release (input_bfd, (PTR) mt);
1741 *indexp = mtl->indx;
1742 add = (eslend - esym) / isymesz;
1743 skip = true;
1748 /* We now know whether we are to skip this symbol or not. */
1749 if (! skip)
1751 /* Adjust the symbol in order to output it. */
1753 if (isym._n._n_n._n_zeroes == 0
1754 && isym._n._n_n._n_offset != 0)
1756 const char *name;
1757 bfd_size_type indx;
1759 /* This symbol has a long name. Enter it in the string
1760 table we are building. Note that we do not check
1761 bfd_coff_symname_in_debug. That is only true for
1762 XCOFF, and XCOFF requires different linking code
1763 anyhow. */
1764 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
1765 (char *) NULL);
1766 if (name == NULL)
1767 return false;
1768 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1769 if (indx == (bfd_size_type) -1)
1770 return false;
1771 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1774 switch (isym.n_sclass)
1776 case C_AUTO:
1777 case C_MOS:
1778 case C_EOS:
1779 case C_MOE:
1780 case C_MOU:
1781 case C_UNTAG:
1782 case C_STRTAG:
1783 case C_ENTAG:
1784 case C_TPDEF:
1785 case C_ARG:
1786 case C_USTATIC:
1787 case C_REG:
1788 case C_REGPARM:
1789 case C_FIELD:
1790 /* The symbol value should not be modified. */
1791 break;
1793 case C_FCN:
1794 if (obj_pe (input_bfd)
1795 && strcmp (isym.n_name, ".bf") != 0
1796 && isym.n_scnum > 0)
1798 /* For PE, .lf and .ef get their value left alone,
1799 while .bf gets relocated. However, they all have
1800 "real" section numbers, and need to be moved into
1801 the new section. */
1802 isym.n_scnum = (*secpp)->output_section->target_index;
1803 break;
1805 /* Fall through. */
1806 default:
1807 case C_LABEL: /* Not completely sure about these 2 */
1808 case C_EXTDEF:
1809 case C_BLOCK:
1810 case C_EFCN:
1811 case C_NULL:
1812 case C_EXT:
1813 case C_STAT:
1814 case C_SECTION:
1815 case C_NT_WEAK:
1816 /* Compute new symbol location. */
1817 if (isym.n_scnum > 0)
1819 isym.n_scnum = (*secpp)->output_section->target_index;
1820 isym.n_value += (*secpp)->output_offset;
1821 if (! obj_pe (input_bfd))
1822 isym.n_value -= (*secpp)->vma;
1823 if (! obj_pe (finfo->output_bfd))
1824 isym.n_value += (*secpp)->output_section->vma;
1826 break;
1828 case C_FILE:
1829 /* The value of a C_FILE symbol is the symbol index of
1830 the next C_FILE symbol. The value of the last C_FILE
1831 symbol is the symbol index to the first external
1832 symbol (actually, coff_renumber_symbols does not get
1833 this right--it just sets the value of the last C_FILE
1834 symbol to zero--and nobody has ever complained about
1835 it). We try to get this right, below, just before we
1836 write the symbols out, but in the general case we may
1837 have to write the symbol out twice. */
1839 if (finfo->last_file_index != -1
1840 && finfo->last_file.n_value != (bfd_vma) output_index)
1842 /* We must correct the value of the last C_FILE
1843 entry. */
1844 finfo->last_file.n_value = output_index;
1845 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1847 /* The last C_FILE symbol is in this input file. */
1848 bfd_coff_swap_sym_out (output_bfd,
1849 (PTR) &finfo->last_file,
1850 (PTR) (finfo->outsyms
1851 + ((finfo->last_file_index
1852 - syment_base)
1853 * osymesz)));
1855 else
1857 file_ptr pos;
1859 /* We have already written out the last C_FILE
1860 symbol. We need to write it out again. We
1861 borrow *outsym temporarily. */
1862 bfd_coff_swap_sym_out (output_bfd,
1863 (PTR) &finfo->last_file,
1864 (PTR) outsym);
1865 pos = obj_sym_filepos (output_bfd);
1866 pos += finfo->last_file_index * osymesz;
1867 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
1868 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
1869 return false;
1873 finfo->last_file_index = output_index;
1874 finfo->last_file = isym;
1875 break;
1878 /* If doing task linking, convert normal global function symbols to
1879 static functions. */
1880 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
1881 isym.n_sclass = C_STAT;
1883 /* Output the symbol. */
1885 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
1887 *indexp = output_index;
1889 if (global)
1891 long indx;
1892 struct coff_link_hash_entry *h;
1894 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1895 / isymesz);
1896 h = obj_coff_sym_hashes (input_bfd)[indx];
1897 if (h == NULL)
1899 /* This can happen if there were errors earlier in
1900 the link. */
1901 bfd_set_error (bfd_error_bad_value);
1902 return false;
1904 h->indx = output_index;
1907 output_index += add;
1908 outsym += add * osymesz;
1911 esym += add * isymesz;
1912 isymp += add;
1913 ++secpp;
1914 ++indexp;
1915 for (--add; add > 0; --add)
1917 *secpp++ = NULL;
1918 *indexp++ = -1;
1922 /* Fix up the aux entries. This must be done in a separate pass,
1923 because we don't know the correct symbol indices until we have
1924 already decided which symbols we are going to keep. */
1926 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1927 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1928 isymp = finfo->internal_syms;
1929 indexp = finfo->sym_indices;
1930 sym_hash = obj_coff_sym_hashes (input_bfd);
1931 outsym = finfo->outsyms;
1932 while (esym < esym_end)
1934 int add;
1936 add = 1 + isymp->n_numaux;
1938 if ((*indexp < 0
1939 || (bfd_size_type) *indexp < syment_base)
1940 && (*sym_hash == NULL
1941 || (*sym_hash)->auxbfd != input_bfd))
1942 esym += add * isymesz;
1943 else
1945 struct coff_link_hash_entry *h;
1946 int i;
1948 h = NULL;
1949 if (*indexp < 0)
1951 h = *sym_hash;
1953 /* The m68k-motorola-sysv assembler will sometimes
1954 generate two symbols with the same name, but only one
1955 will have aux entries. */
1956 BFD_ASSERT (isymp->n_numaux == 0
1957 || h->numaux == isymp->n_numaux);
1960 esym += isymesz;
1962 if (h == NULL)
1963 outsym += osymesz;
1965 /* Handle the aux entries. This handling is based on
1966 coff_pointerize_aux. I don't know if it always correct. */
1967 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1969 union internal_auxent aux;
1970 union internal_auxent *auxp;
1972 if (h != NULL)
1973 auxp = h->aux + i;
1974 else
1976 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
1977 isymp->n_sclass, i, isymp->n_numaux,
1978 (PTR) &aux);
1979 auxp = &aux;
1982 if (isymp->n_sclass == C_FILE)
1984 /* If this is a long filename, we must put it in the
1985 string table. */
1986 if (auxp->x_file.x_n.x_zeroes == 0
1987 && auxp->x_file.x_n.x_offset != 0)
1989 const char *filename;
1990 bfd_size_type indx;
1992 BFD_ASSERT (auxp->x_file.x_n.x_offset
1993 >= STRING_SIZE_SIZE);
1994 if (strings == NULL)
1996 strings = _bfd_coff_read_string_table (input_bfd);
1997 if (strings == NULL)
1998 return false;
2000 filename = strings + auxp->x_file.x_n.x_offset;
2001 indx = _bfd_stringtab_add (finfo->strtab, filename,
2002 hash, copy);
2003 if (indx == (bfd_size_type) -1)
2004 return false;
2005 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
2008 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
2010 unsigned long indx;
2012 if (ISFCN (isymp->n_type)
2013 || ISTAG (isymp->n_sclass)
2014 || isymp->n_sclass == C_BLOCK
2015 || isymp->n_sclass == C_FCN)
2017 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
2018 if (indx > 0
2019 && indx < obj_raw_syment_count (input_bfd))
2021 /* We look forward through the symbol for
2022 the index of the next symbol we are going
2023 to include. I don't know if this is
2024 entirely right. */
2025 while ((finfo->sym_indices[indx] < 0
2026 || ((bfd_size_type) finfo->sym_indices[indx]
2027 < syment_base))
2028 && indx < obj_raw_syment_count (input_bfd))
2029 ++indx;
2030 if (indx >= obj_raw_syment_count (input_bfd))
2031 indx = output_index;
2032 else
2033 indx = finfo->sym_indices[indx];
2034 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2038 indx = auxp->x_sym.x_tagndx.l;
2039 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2041 long symindx;
2043 symindx = finfo->sym_indices[indx];
2044 if (symindx < 0)
2045 auxp->x_sym.x_tagndx.l = 0;
2046 else
2047 auxp->x_sym.x_tagndx.l = symindx;
2050 /* The .bf symbols are supposed to be linked through
2051 the endndx field. We need to carry this list
2052 across object files. */
2053 if (i == 0
2054 && h == NULL
2055 && isymp->n_sclass == C_FCN
2056 && (isymp->_n._n_n._n_zeroes != 0
2057 || isymp->_n._n_n._n_offset == 0)
2058 && isymp->_n._n_name[0] == '.'
2059 && isymp->_n._n_name[1] == 'b'
2060 && isymp->_n._n_name[2] == 'f'
2061 && isymp->_n._n_name[3] == '\0')
2063 if (finfo->last_bf_index != -1)
2065 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2066 *indexp;
2068 if ((bfd_size_type) finfo->last_bf_index
2069 >= syment_base)
2071 PTR auxout;
2073 /* The last .bf symbol is in this input
2074 file. This will only happen if the
2075 assembler did not set up the .bf
2076 endndx symbols correctly. */
2077 auxout = (PTR) (finfo->outsyms
2078 + ((finfo->last_bf_index
2079 - syment_base)
2080 * osymesz));
2081 bfd_coff_swap_aux_out (output_bfd,
2082 (PTR) &finfo->last_bf,
2083 isymp->n_type,
2084 isymp->n_sclass,
2085 0, isymp->n_numaux,
2086 auxout);
2088 else
2090 file_ptr pos;
2092 /* We have already written out the last
2093 .bf aux entry. We need to write it
2094 out again. We borrow *outsym
2095 temporarily. FIXME: This case should
2096 be made faster. */
2097 bfd_coff_swap_aux_out (output_bfd,
2098 (PTR) &finfo->last_bf,
2099 isymp->n_type,
2100 isymp->n_sclass,
2101 0, isymp->n_numaux,
2102 (PTR) outsym);
2103 pos = obj_sym_filepos (output_bfd);
2104 pos += finfo->last_bf_index * osymesz;
2105 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2106 || (bfd_bwrite (outsym, osymesz, output_bfd)
2107 != osymesz))
2108 return false;
2112 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2113 finfo->last_bf_index = -1;
2114 else
2116 /* The endndx field of this aux entry must
2117 be updated with the symbol number of the
2118 next .bf symbol. */
2119 finfo->last_bf = *auxp;
2120 finfo->last_bf_index = (((outsym - finfo->outsyms)
2121 / osymesz)
2122 + syment_base);
2127 if (h == NULL)
2129 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isymp->n_type,
2130 isymp->n_sclass, i, isymp->n_numaux,
2131 (PTR) outsym);
2132 outsym += osymesz;
2135 esym += isymesz;
2139 indexp += add;
2140 isymp += add;
2141 sym_hash += add;
2144 /* Relocate the line numbers, unless we are stripping them. */
2145 if (finfo->info->strip == strip_none
2146 || finfo->info->strip == strip_some)
2148 for (o = input_bfd->sections; o != NULL; o = o->next)
2150 bfd_vma offset;
2151 bfd_byte *eline;
2152 bfd_byte *elineend;
2153 bfd_byte *oeline;
2154 boolean skipping;
2155 file_ptr pos;
2156 bfd_size_type amt;
2158 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2159 build_link_order in ldwrite.c will not have created a
2160 link order, which means that we will not have seen this
2161 input section in _bfd_coff_final_link, which means that
2162 we will not have allocated space for the line numbers of
2163 this section. I don't think line numbers can be
2164 meaningful for a section which does not have
2165 SEC_HAS_CONTENTS set, but, if they do, this must be
2166 changed. */
2167 if (o->lineno_count == 0
2168 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2169 continue;
2171 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2172 || bfd_bread (finfo->linenos, linesz * o->lineno_count,
2173 input_bfd) != linesz * o->lineno_count)
2174 return false;
2176 offset = o->output_section->vma + o->output_offset - o->vma;
2177 eline = finfo->linenos;
2178 oeline = finfo->linenos;
2179 elineend = eline + linesz * o->lineno_count;
2180 skipping = false;
2181 for (; eline < elineend; eline += linesz)
2183 struct internal_lineno iline;
2185 bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline);
2187 if (iline.l_lnno != 0)
2188 iline.l_addr.l_paddr += offset;
2189 else if (iline.l_addr.l_symndx >= 0
2190 && ((unsigned long) iline.l_addr.l_symndx
2191 < obj_raw_syment_count (input_bfd)))
2193 long indx;
2195 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2197 if (indx < 0)
2199 /* These line numbers are attached to a symbol
2200 which we are stripping. We must discard the
2201 line numbers because reading them back with
2202 no associated symbol (or associating them all
2203 with symbol #0) will fail. We can't regain
2204 the space in the output file, but at least
2205 they're dense. */
2206 skipping = true;
2208 else
2210 struct internal_syment is;
2211 union internal_auxent ia;
2213 /* Fix up the lnnoptr field in the aux entry of
2214 the symbol. It turns out that we can't do
2215 this when we modify the symbol aux entries,
2216 because gas sometimes screws up the lnnoptr
2217 field and makes it an offset from the start
2218 of the line numbers rather than an absolute
2219 file index. */
2220 bfd_coff_swap_sym_in (output_bfd,
2221 (PTR) (finfo->outsyms
2222 + ((indx - syment_base)
2223 * osymesz)),
2224 (PTR) &is);
2225 if ((ISFCN (is.n_type)
2226 || is.n_sclass == C_BLOCK)
2227 && is.n_numaux >= 1)
2229 PTR auxptr;
2231 auxptr = (PTR) (finfo->outsyms
2232 + ((indx - syment_base + 1)
2233 * osymesz));
2234 bfd_coff_swap_aux_in (output_bfd, auxptr,
2235 is.n_type, is.n_sclass,
2236 0, is.n_numaux, (PTR) &ia);
2237 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2238 (o->output_section->line_filepos
2239 + o->output_section->lineno_count * linesz
2240 + eline - finfo->linenos);
2241 bfd_coff_swap_aux_out (output_bfd, (PTR) &ia,
2242 is.n_type, is.n_sclass, 0,
2243 is.n_numaux, auxptr);
2246 skipping = false;
2249 iline.l_addr.l_symndx = indx;
2252 if (!skipping)
2254 bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline,
2255 (PTR) oeline);
2256 oeline += linesz;
2260 pos = o->output_section->line_filepos;
2261 pos += o->output_section->lineno_count * linesz;
2262 amt = oeline - finfo->linenos;
2263 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2264 || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
2265 return false;
2267 o->output_section->lineno_count += amt / linesz;
2271 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2272 symbol will be the first symbol in the next input file. In the
2273 normal case, this will save us from writing out the C_FILE symbol
2274 again. */
2275 if (finfo->last_file_index != -1
2276 && (bfd_size_type) finfo->last_file_index >= syment_base)
2278 finfo->last_file.n_value = output_index;
2279 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
2280 (PTR) (finfo->outsyms
2281 + ((finfo->last_file_index - syment_base)
2282 * osymesz)));
2285 /* Write the modified symbols to the output file. */
2286 if (outsym > finfo->outsyms)
2288 file_ptr pos;
2289 bfd_size_type amt;
2291 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
2292 amt = outsym - finfo->outsyms;
2293 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2294 || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
2295 return false;
2297 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2298 + (outsym - finfo->outsyms) / osymesz)
2299 == output_index);
2301 obj_raw_syment_count (output_bfd) = output_index;
2304 /* Relocate the contents of each section. */
2305 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2306 for (o = input_bfd->sections; o != NULL; o = o->next)
2308 bfd_byte *contents;
2309 struct coff_section_tdata *secdata;
2311 if (! o->linker_mark)
2313 /* This section was omitted from the link. */
2314 continue;
2317 if ((o->flags & SEC_HAS_CONTENTS) == 0
2318 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2320 if ((o->flags & SEC_RELOC) != 0
2321 && o->reloc_count != 0)
2323 ((*_bfd_error_handler)
2324 (_("%s: relocs in section `%s', but it has no contents"),
2325 bfd_archive_filename (input_bfd),
2326 bfd_get_section_name (input_bfd, o)));
2327 bfd_set_error (bfd_error_no_contents);
2328 return false;
2331 continue;
2334 secdata = coff_section_data (input_bfd, o);
2335 if (secdata != NULL && secdata->contents != NULL)
2336 contents = secdata->contents;
2337 else
2339 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2340 (file_ptr) 0, o->_raw_size))
2341 return false;
2342 contents = finfo->contents;
2345 if ((o->flags & SEC_RELOC) != 0)
2347 int target_index;
2348 struct internal_reloc *internal_relocs;
2349 struct internal_reloc *irel;
2351 /* Read in the relocs. */
2352 target_index = o->output_section->target_index;
2353 internal_relocs = (_bfd_coff_read_internal_relocs
2354 (input_bfd, o, false, finfo->external_relocs,
2355 finfo->info->relocateable,
2356 (finfo->info->relocateable
2357 ? (finfo->section_info[target_index].relocs
2358 + o->output_section->reloc_count)
2359 : finfo->internal_relocs)));
2360 if (internal_relocs == NULL)
2361 return false;
2363 /* Call processor specific code to relocate the section
2364 contents. */
2365 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2366 input_bfd, o,
2367 contents,
2368 internal_relocs,
2369 finfo->internal_syms,
2370 finfo->sec_ptrs))
2371 return false;
2373 if (finfo->info->relocateable)
2375 bfd_vma offset;
2376 struct internal_reloc *irelend;
2377 struct coff_link_hash_entry **rel_hash;
2379 offset = o->output_section->vma + o->output_offset - o->vma;
2380 irel = internal_relocs;
2381 irelend = irel + o->reloc_count;
2382 rel_hash = (finfo->section_info[target_index].rel_hashes
2383 + o->output_section->reloc_count);
2384 for (; irel < irelend; irel++, rel_hash++)
2386 struct coff_link_hash_entry *h;
2387 boolean adjusted;
2389 *rel_hash = NULL;
2391 /* Adjust the reloc address and symbol index. */
2393 irel->r_vaddr += offset;
2395 if (irel->r_symndx == -1)
2396 continue;
2398 if (adjust_symndx)
2400 if (! (*adjust_symndx) (output_bfd, finfo->info,
2401 input_bfd, o, irel,
2402 &adjusted))
2403 return false;
2404 if (adjusted)
2405 continue;
2408 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2409 if (h != NULL)
2411 /* This is a global symbol. */
2412 if (h->indx >= 0)
2413 irel->r_symndx = h->indx;
2414 else
2416 /* This symbol is being written at the end
2417 of the file, and we do not yet know the
2418 symbol index. We save the pointer to the
2419 hash table entry in the rel_hash list.
2420 We set the indx field to -2 to indicate
2421 that this symbol must not be stripped. */
2422 *rel_hash = h;
2423 h->indx = -2;
2426 else
2428 long indx;
2430 indx = finfo->sym_indices[irel->r_symndx];
2431 if (indx != -1)
2432 irel->r_symndx = indx;
2433 else
2435 struct internal_syment *is;
2436 const char *name;
2437 char buf[SYMNMLEN + 1];
2439 /* This reloc is against a symbol we are
2440 stripping. This should have been handled
2441 by the 'dont_skip_symbol' code in the while
2442 loop at the top of this function. */
2444 is = finfo->internal_syms + irel->r_symndx;
2446 name = (_bfd_coff_internal_syment_name
2447 (input_bfd, is, buf));
2448 if (name == NULL)
2449 return false;
2451 if (! ((*finfo->info->callbacks->unattached_reloc)
2452 (finfo->info, name, input_bfd, o,
2453 irel->r_vaddr)))
2454 return false;
2459 o->output_section->reloc_count += o->reloc_count;
2463 /* Write out the modified section contents. */
2464 if (secdata == NULL || secdata->stab_info == NULL)
2466 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd);
2467 bfd_size_type amt = (o->_cooked_size != 0
2468 ? o->_cooked_size : o->_raw_size);
2469 if (! bfd_set_section_contents (output_bfd, o->output_section,
2470 contents, loc, amt))
2471 return false;
2473 else
2475 if (! (_bfd_write_section_stabs
2476 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2477 o, &secdata->stab_info, contents)))
2478 return false;
2482 if (! finfo->info->keep_memory)
2484 if (! _bfd_coff_free_symbols (input_bfd))
2485 return false;
2488 return true;
2491 /* Write out a global symbol. Called via coff_link_hash_traverse. */
2493 boolean
2494 _bfd_coff_write_global_sym (h, data)
2495 struct coff_link_hash_entry *h;
2496 PTR data;
2498 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2499 bfd *output_bfd;
2500 struct internal_syment isym;
2501 bfd_size_type symesz;
2502 unsigned int i;
2503 file_ptr pos;
2505 output_bfd = finfo->output_bfd;
2507 if (h->root.type == bfd_link_hash_warning)
2509 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2510 if (h->root.type == bfd_link_hash_new)
2511 return true;
2514 if (h->indx >= 0)
2515 return true;
2517 if (h->indx != -2
2518 && (finfo->info->strip == strip_all
2519 || (finfo->info->strip == strip_some
2520 && (bfd_hash_lookup (finfo->info->keep_hash,
2521 h->root.root.string, false, false)
2522 == NULL))))
2523 return true;
2525 switch (h->root.type)
2527 default:
2528 case bfd_link_hash_new:
2529 case bfd_link_hash_warning:
2530 abort ();
2531 return false;
2533 case bfd_link_hash_undefined:
2534 case bfd_link_hash_undefweak:
2535 isym.n_scnum = N_UNDEF;
2536 isym.n_value = 0;
2537 break;
2539 case bfd_link_hash_defined:
2540 case bfd_link_hash_defweak:
2542 asection *sec;
2544 sec = h->root.u.def.section->output_section;
2545 if (bfd_is_abs_section (sec))
2546 isym.n_scnum = N_ABS;
2547 else
2548 isym.n_scnum = sec->target_index;
2549 isym.n_value = (h->root.u.def.value
2550 + h->root.u.def.section->output_offset);
2551 if (! obj_pe (finfo->output_bfd))
2552 isym.n_value += sec->vma;
2554 break;
2556 case bfd_link_hash_common:
2557 isym.n_scnum = N_UNDEF;
2558 isym.n_value = h->root.u.c.size;
2559 break;
2561 case bfd_link_hash_indirect:
2562 /* Just ignore these. They can't be handled anyhow. */
2563 return true;
2566 if (strlen (h->root.root.string) <= SYMNMLEN)
2567 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2568 else
2570 boolean hash;
2571 bfd_size_type indx;
2573 hash = true;
2574 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2575 hash = false;
2576 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2577 false);
2578 if (indx == (bfd_size_type) -1)
2580 finfo->failed = true;
2581 return false;
2583 isym._n._n_n._n_zeroes = 0;
2584 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2587 isym.n_sclass = h->class;
2588 isym.n_type = h->type;
2590 if (isym.n_sclass == C_NULL)
2591 isym.n_sclass = C_EXT;
2593 /* If doing task linking and this is the pass where we convert
2594 defined globals to statics, then do that conversion now. If the
2595 symbol is not being converted, just ignore it and it will be
2596 output during a later pass. */
2597 if (finfo->global_to_static)
2599 if (! IS_EXTERNAL (output_bfd, isym))
2600 return true;
2602 isym.n_sclass = C_STAT;
2605 /* When a weak symbol is not overriden by a strong one,
2606 turn it into an external symbol when not building a
2607 shared or relocateable object. */
2608 if (! finfo->info->shared
2609 && ! finfo->info->relocateable
2610 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2611 isym.n_sclass = C_EXT;
2613 isym.n_numaux = h->numaux;
2615 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) finfo->outsyms);
2617 symesz = bfd_coff_symesz (output_bfd);
2619 pos = obj_sym_filepos (output_bfd);
2620 pos += obj_raw_syment_count (output_bfd) * symesz;
2621 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
2622 || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2624 finfo->failed = true;
2625 return false;
2628 h->indx = obj_raw_syment_count (output_bfd);
2630 ++obj_raw_syment_count (output_bfd);
2632 /* Write out any associated aux entries. Most of the aux entries
2633 will have been modified in _bfd_coff_link_input_bfd. We have to
2634 handle section aux entries here, now that we have the final
2635 relocation and line number counts. */
2636 for (i = 0; i < isym.n_numaux; i++)
2638 union internal_auxent *auxp;
2640 auxp = h->aux + i;
2642 /* Look for a section aux entry here using the same tests that
2643 coff_swap_aux_out uses. */
2644 if (i == 0
2645 && (isym.n_sclass == C_STAT
2646 || isym.n_sclass == C_HIDDEN)
2647 && isym.n_type == T_NULL
2648 && (h->root.type == bfd_link_hash_defined
2649 || h->root.type == bfd_link_hash_defweak))
2651 asection *sec;
2653 sec = h->root.u.def.section->output_section;
2654 if (sec != NULL)
2656 auxp->x_scn.x_scnlen = (sec->_cooked_size != 0
2657 ? sec->_cooked_size
2658 : sec->_raw_size);
2660 /* For PE, an overflow on the final link reportedly does
2661 not matter. FIXME: Why not? */
2663 if (sec->reloc_count > 0xffff
2664 && (! obj_pe (output_bfd)
2665 || finfo->info->relocateable))
2666 (*_bfd_error_handler)
2667 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2668 bfd_get_filename (output_bfd),
2669 bfd_get_section_name (output_bfd, sec),
2670 sec->reloc_count);
2672 if (sec->lineno_count > 0xffff
2673 && (! obj_pe (output_bfd)
2674 || finfo->info->relocateable))
2675 (*_bfd_error_handler)
2676 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2677 bfd_get_filename (output_bfd),
2678 bfd_get_section_name (output_bfd, sec),
2679 sec->lineno_count);
2681 auxp->x_scn.x_nreloc = sec->reloc_count;
2682 auxp->x_scn.x_nlinno = sec->lineno_count;
2683 auxp->x_scn.x_checksum = 0;
2684 auxp->x_scn.x_associated = 0;
2685 auxp->x_scn.x_comdat = 0;
2689 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isym.n_type,
2690 isym.n_sclass, (int) i, isym.n_numaux,
2691 (PTR) finfo->outsyms);
2692 if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
2694 finfo->failed = true;
2695 return false;
2697 ++obj_raw_syment_count (output_bfd);
2700 return true;
2703 /* Write out task global symbols, converting them to statics. Called
2704 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2705 the dirty work, if the symbol we are processing needs conversion. */
2707 boolean
2708 _bfd_coff_write_task_globals (h, data)
2709 struct coff_link_hash_entry *h;
2710 PTR data;
2712 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2713 boolean rtnval = true;
2714 boolean save_global_to_static;
2716 if (h->root.type == bfd_link_hash_warning)
2717 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2719 if (h->indx < 0)
2721 switch (h->root.type)
2723 case bfd_link_hash_defined:
2724 case bfd_link_hash_defweak:
2725 save_global_to_static = finfo->global_to_static;
2726 finfo->global_to_static = true;
2727 rtnval = _bfd_coff_write_global_sym (h, data);
2728 finfo->global_to_static = save_global_to_static;
2729 break;
2730 default:
2731 break;
2734 return (rtnval);
2737 /* Handle a link order which is supposed to generate a reloc. */
2739 boolean
2740 _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
2741 bfd *output_bfd;
2742 struct coff_final_link_info *finfo;
2743 asection *output_section;
2744 struct bfd_link_order *link_order;
2746 reloc_howto_type *howto;
2747 struct internal_reloc *irel;
2748 struct coff_link_hash_entry **rel_hash_ptr;
2750 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2751 if (howto == NULL)
2753 bfd_set_error (bfd_error_bad_value);
2754 return false;
2757 if (link_order->u.reloc.p->addend != 0)
2759 bfd_size_type size;
2760 bfd_byte *buf;
2761 bfd_reloc_status_type rstat;
2762 boolean ok;
2763 file_ptr loc;
2765 size = bfd_get_reloc_size (howto);
2766 buf = (bfd_byte *) bfd_zmalloc (size);
2767 if (buf == NULL)
2768 return false;
2770 rstat = _bfd_relocate_contents (howto, output_bfd,
2771 (bfd_vma) link_order->u.reloc.p->addend,\
2772 buf);
2773 switch (rstat)
2775 case bfd_reloc_ok:
2776 break;
2777 default:
2778 case bfd_reloc_outofrange:
2779 abort ();
2780 case bfd_reloc_overflow:
2781 if (! ((*finfo->info->callbacks->reloc_overflow)
2782 (finfo->info,
2783 (link_order->type == bfd_section_reloc_link_order
2784 ? bfd_section_name (output_bfd,
2785 link_order->u.reloc.p->u.section)
2786 : link_order->u.reloc.p->u.name),
2787 howto->name, link_order->u.reloc.p->addend,
2788 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2790 free (buf);
2791 return false;
2793 break;
2795 loc = link_order->offset * bfd_octets_per_byte (output_bfd);
2796 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
2797 loc, size);
2798 free (buf);
2799 if (! ok)
2800 return false;
2803 /* Store the reloc information in the right place. It will get
2804 swapped and written out at the end of the final_link routine. */
2806 irel = (finfo->section_info[output_section->target_index].relocs
2807 + output_section->reloc_count);
2808 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2809 + output_section->reloc_count);
2811 memset (irel, 0, sizeof (struct internal_reloc));
2812 *rel_hash_ptr = NULL;
2814 irel->r_vaddr = output_section->vma + link_order->offset;
2816 if (link_order->type == bfd_section_reloc_link_order)
2818 /* We need to somehow locate a symbol in the right section. The
2819 symbol must either have a value of zero, or we must adjust
2820 the addend by the value of the symbol. FIXME: Write this
2821 when we need it. The old linker couldn't handle this anyhow. */
2822 abort ();
2823 *rel_hash_ptr = NULL;
2824 irel->r_symndx = 0;
2826 else
2828 struct coff_link_hash_entry *h;
2830 h = ((struct coff_link_hash_entry *)
2831 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2832 link_order->u.reloc.p->u.name,
2833 false, false, true));
2834 if (h != NULL)
2836 if (h->indx >= 0)
2837 irel->r_symndx = h->indx;
2838 else
2840 /* Set the index to -2 to force this symbol to get
2841 written out. */
2842 h->indx = -2;
2843 *rel_hash_ptr = h;
2844 irel->r_symndx = 0;
2847 else
2849 if (! ((*finfo->info->callbacks->unattached_reloc)
2850 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2851 (asection *) NULL, (bfd_vma) 0)))
2852 return false;
2853 irel->r_symndx = 0;
2857 /* FIXME: Is this always right? */
2858 irel->r_type = howto->type;
2860 /* r_size is only used on the RS/6000, which needs its own linker
2861 routines anyhow. r_extern is only used for ECOFF. */
2863 /* FIXME: What is the right value for r_offset? Is zero OK? */
2865 ++output_section->reloc_count;
2867 return true;
2870 /* A basic reloc handling routine which may be used by processors with
2871 simple relocs. */
2873 boolean
2874 _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
2875 input_section, contents, relocs, syms,
2876 sections)
2877 bfd *output_bfd;
2878 struct bfd_link_info *info;
2879 bfd *input_bfd;
2880 asection *input_section;
2881 bfd_byte *contents;
2882 struct internal_reloc *relocs;
2883 struct internal_syment *syms;
2884 asection **sections;
2886 struct internal_reloc *rel;
2887 struct internal_reloc *relend;
2889 rel = relocs;
2890 relend = rel + input_section->reloc_count;
2891 for (; rel < relend; rel++)
2893 long symndx;
2894 struct coff_link_hash_entry *h;
2895 struct internal_syment *sym;
2896 bfd_vma addend;
2897 bfd_vma val;
2898 reloc_howto_type *howto;
2899 bfd_reloc_status_type rstat;
2901 symndx = rel->r_symndx;
2903 if (symndx == -1)
2905 h = NULL;
2906 sym = NULL;
2908 else if (symndx < 0
2909 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2911 (*_bfd_error_handler)
2912 ("%s: illegal symbol index %ld in relocs",
2913 bfd_archive_filename (input_bfd), symndx);
2914 return false;
2916 else
2918 h = obj_coff_sym_hashes (input_bfd)[symndx];
2919 sym = syms + symndx;
2922 /* COFF treats common symbols in one of two ways. Either the
2923 size of the symbol is included in the section contents, or it
2924 is not. We assume that the size is not included, and force
2925 the rtype_to_howto function to adjust the addend as needed. */
2927 if (sym != NULL && sym->n_scnum != 0)
2928 addend = - sym->n_value;
2929 else
2930 addend = 0;
2932 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2933 sym, &addend);
2934 if (howto == NULL)
2935 return false;
2937 /* If we are doing a relocateable link, then we can just ignore
2938 a PC relative reloc that is pcrel_offset. It will already
2939 have the correct value. If this is not a relocateable link,
2940 then we should ignore the symbol value. */
2941 if (howto->pc_relative && howto->pcrel_offset)
2943 if (info->relocateable)
2944 continue;
2945 if (sym != NULL && sym->n_scnum != 0)
2946 addend += sym->n_value;
2949 val = 0;
2951 if (h == NULL)
2953 asection *sec;
2955 if (symndx == -1)
2957 sec = bfd_abs_section_ptr;
2958 val = 0;
2960 else
2962 sec = sections[symndx];
2963 val = (sec->output_section->vma
2964 + sec->output_offset
2965 + sym->n_value);
2966 if (! obj_pe (input_bfd))
2967 val -= sec->vma;
2970 else
2972 if (h->root.type == bfd_link_hash_defined
2973 || h->root.type == bfd_link_hash_defweak)
2975 asection *sec;
2977 sec = h->root.u.def.section;
2978 val = (h->root.u.def.value
2979 + sec->output_section->vma
2980 + sec->output_offset);
2983 else if (h->root.type == bfd_link_hash_undefweak)
2984 val = 0;
2986 else if (! info->relocateable)
2988 if (! ((*info->callbacks->undefined_symbol)
2989 (info, h->root.root.string, input_bfd, input_section,
2990 rel->r_vaddr - input_section->vma, true)))
2991 return false;
2995 if (info->base_file)
2997 /* Emit a reloc if the backend thinks it needs it. */
2998 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
3000 /* Relocation to a symbol in a section which isn't
3001 absolute. We output the address here to a file.
3002 This file is then read by dlltool when generating the
3003 reloc section. Note that the base file is not
3004 portable between systems. We write out a long here,
3005 and dlltool reads in a long. */
3006 long addr = (rel->r_vaddr
3007 - input_section->vma
3008 + input_section->output_offset
3009 + input_section->output_section->vma);
3010 if (coff_data (output_bfd)->pe)
3011 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
3012 if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
3013 != sizeof (long))
3015 bfd_set_error (bfd_error_system_call);
3016 return false;
3021 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
3022 contents,
3023 rel->r_vaddr - input_section->vma,
3024 val, addend);
3026 switch (rstat)
3028 default:
3029 abort ();
3030 case bfd_reloc_ok:
3031 break;
3032 case bfd_reloc_outofrange:
3033 (*_bfd_error_handler)
3034 (_("%s: bad reloc address 0x%lx in section `%s'"),
3035 bfd_archive_filename (input_bfd),
3036 (unsigned long) rel->r_vaddr,
3037 bfd_get_section_name (input_bfd, input_section));
3038 return false;
3039 case bfd_reloc_overflow:
3041 const char *name;
3042 char buf[SYMNMLEN + 1];
3044 if (symndx == -1)
3045 name = "*ABS*";
3046 else if (h != NULL)
3047 name = h->root.root.string;
3048 else
3050 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3051 if (name == NULL)
3052 return false;
3055 if (! ((*info->callbacks->reloc_overflow)
3056 (info, name, howto->name, (bfd_vma) 0, input_bfd,
3057 input_section, rel->r_vaddr - input_section->vma)))
3058 return false;
3062 return true;