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