projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-11-27 Kazu Hirata <kazu@hxi.com>
[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;
931
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
992 static. */
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{
1164 if (coff_data(output_bfd)->pe)
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
1172 if (ptr[0] == ',')
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 */
1198
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;
1209 if (!sec)
1210 return 1;
1211
1212 copy = bfd_malloc ((size_t) sec->_raw_size);
1213 if (!copy)
1214 return 0;
1215 if (! bfd_get_section_contents(abfd, sec, copy, 0, sec->_raw_size))
1216 {
1217 free (copy);
1218 return 0;
1219 }
1220 e = copy + sec->_raw_size;
1221 for (s = copy; s < e ; )
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) {
1242 switch (*attribs++)
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 }
1276 else
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
1286 that symbol.
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;
1298
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
1305
1306 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1)
1307 continue;
1308
1309 /* Read in the relocs. */
1310 internal_relocs = _bfd_coff_read_internal_relocs
1311 (input_bfd, a, false,
1312 finfo->external_relocs,
1313 finfo->info->relocateable,
1314 (finfo->info->relocateable
1315 ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
1316 : finfo->internal_relocs)
1317 );
1318
1319 if (internal_relocs == NULL)
1320 continue;
1321
1322 irel = internal_relocs;
1323 irelend = irel + a->reloc_count;
1324
1325 /* Place a mark in the sym_indices array (whose entries have
1326 been initialised to 0) for all of the symbols that are used
1327 in the relocation table. This will then be picked up in the
1328 skip/don't pass */
1329
1330 for (; irel < irelend; irel++)
1331 {
1332 finfo->sym_indices[ irel->r_symndx ] = -1;
1333 }
1334 }
1335}
1336
1337/* Link an input file into the linker output file. This function
1338 handles all the sections and relocations of the input file at once. */
1339
1340boolean
1341_bfd_coff_link_input_bfd (finfo, input_bfd)
1342 struct coff_final_link_info *finfo;
1343 bfd *input_bfd;
1344{
b2d638c7
ILT		 1345 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
1346 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
1347#if 0
1348 unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask;
1349#endif
252b5132
RH		 1350 boolean (*adjust_symndx) PARAMS ((bfd *, struct bfd_link_info *, bfd *,
1351 asection *, struct internal_reloc *,
1352 boolean *));
1353 bfd *output_bfd;
1354 const char *strings;
1355 bfd_size_type syment_base;
252b5132
RH		 1356 boolean copy, hash;
1357 bfd_size_type isymesz;
1358 bfd_size_type osymesz;
1359 bfd_size_type linesz;
1360 bfd_byte *esym;
1361 bfd_byte *esym_end;
1362 struct internal_syment *isymp;
1363 asection **secpp;
1364 long *indexp;
1365 unsigned long output_index;
1366 bfd_byte *outsym;
1367 struct coff_link_hash_entry **sym_hash;
1368 asection *o;
1369
1370 /* Move all the symbols to the output file. */
1371
1372 output_bfd = finfo->output_bfd;
252b5132
RH		 1373 strings = NULL;
1374 syment_base = obj_raw_syment_count (output_bfd);
1375 isymesz = bfd_coff_symesz (input_bfd);
1376 osymesz = bfd_coff_symesz (output_bfd);
1377 linesz = bfd_coff_linesz (input_bfd);
1378 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
1379
252b5132
RH		 1380 copy = false;
1381 if (! finfo->info->keep_memory)
1382 copy = true;
1383 hash = true;
1384 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1385 hash = false;
1386
1387 if (! _bfd_coff_get_external_symbols (input_bfd))
1388 return false;
1389
1390 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1391 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1392 isymp = finfo->internal_syms;
1393 secpp = finfo->sec_ptrs;
1394 indexp = finfo->sym_indices;
1395 output_index = syment_base;
1396 outsym = finfo->outsyms;
1397
1398 if (coff_data (output_bfd)->pe)
1399 {
1400 if (! process_embedded_commands (output_bfd, finfo->info, input_bfd))
1401 return false;
1402 }
1403
1404 /* If we are going to perform relocations and also strip/discard some symbols
1405 then we must make sure that we do not strip/discard those symbols that are
1406 going to be involved in the relocations */
1407 if (( finfo->info->strip != strip_none
1408 || finfo->info->discard != discard_none)
1409 && finfo->info->relocateable)
1410 {
1411 /* mark the symbol array as 'not-used' */
1412 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
1413
1414 mark_relocs (finfo, input_bfd);
1415 }
1416
1417 while (esym < esym_end)
1418 {
1419 struct internal_syment isym;
5d54c628 1420 enum coff_symbol_classification classification;
252b5132
RH		 1421 boolean skip;
1422 boolean global;
1423 boolean dont_skip_symbol;
1424 int add;
1425
1426 bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp);
1427
1428 /* Make a copy of *isymp so that the relocate_section function
1429 always sees the original values. This is more reliable than
1430 always recomputing the symbol value even if we are stripping
1431 the symbol. */
1432 isym = *isymp;
1433
5d54c628
ILT		 1434 classification = bfd_coff_classify_symbol (input_bfd, &isym);
1435 switch (classification)
252b5132 1436 {
5d54c628
ILT		 1437 default:
1438 abort ();
1439 case COFF_SYMBOL_GLOBAL:
1440 case COFF_SYMBOL_PE_SECTION:
1441 case COFF_SYMBOL_LOCAL:
1442 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum);
1443 break;
1444 case COFF_SYMBOL_COMMON:
1445 *secpp = bfd_com_section_ptr;
1446 break;
1447 case COFF_SYMBOL_UNDEFINED:
1448 *secpp = bfd_und_section_ptr;
1449 break;
252b5132
RH		 1450 }
1451
1452 /* Extract the flag indicating if this symbol is used by a
1453 relocation. */
1454 if ((finfo->info->strip != strip_none
1455 || finfo->info->discard != discard_none)
1456 && finfo->info->relocateable)
1457 dont_skip_symbol = *indexp;
1458 else
1459 dont_skip_symbol = false;
1460
1461 *indexp = -1;
1462
1463 skip = false;
1464 global = false;
1465 add = 1 + isym.n_numaux;
1466
1467 /* If we are stripping all symbols, we want to skip this one. */
1468 if (finfo->info->strip == strip_all && ! dont_skip_symbol)
1469 skip = true;
1470
1471 if (! skip)
1472 {
5d54c628 1473 switch (classification)
252b5132 1474 {
5d54c628
ILT		 1475 default:
1476 abort ();
1477 case COFF_SYMBOL_GLOBAL:
1478 case COFF_SYMBOL_COMMON:
1479 case COFF_SYMBOL_PE_SECTION:
252b5132
RH		 1480 /* This is a global symbol. Global symbols come at the
1481 end of the symbol table, so skip them for now.
1482 Locally defined function symbols, however, are an
1483 exception, and are not moved to the end. */
1484 global = true;
5d54c628 1485 if (! ISFCN (isym.n_type))
252b5132 1486 skip = true;
5d54c628
ILT		 1487 break;
1488
1489 case COFF_SYMBOL_UNDEFINED:
1490 /* Undefined symbols are left for the end. */
1491 global = true;
1492 skip = true;
1493 break;
1494
1495 case COFF_SYMBOL_LOCAL:
252b5132
RH		 1496 /* This is a local symbol. Skip it if we are discarding
1497 local symbols. */
1498 if (finfo->info->discard == discard_all && ! dont_skip_symbol)
1499 skip = true;
5d54c628 1500 break;
252b5132
RH		 1501 }
1502 }
1503
1504 /* If we stripping debugging symbols, and this is a debugging
1505 symbol, then skip it. FIXME: gas sets the section to N_ABS
1506 for some types of debugging symbols; I don't know if this is
1507 a bug or not. In any case, we handle it here. */
1508 if (! skip
1509 && finfo->info->strip == strip_debugger
1510 && ! dont_skip_symbol
1511 && (isym.n_scnum == N_DEBUG
1512 || (isym.n_scnum == N_ABS
1513 && (isym.n_sclass == C_AUTO
1514 || isym.n_sclass == C_REG
1515 || isym.n_sclass == C_MOS
1516 || isym.n_sclass == C_MOE
1517 || isym.n_sclass == C_MOU
1518 || isym.n_sclass == C_ARG
1519 || isym.n_sclass == C_REGPARM
1520 || isym.n_sclass == C_FIELD
1521 || isym.n_sclass == C_EOS))))
1522 skip = true;
1523
1524 /* If some symbols are stripped based on the name, work out the
1525 name and decide whether to skip this symbol. */
1526 if (! skip
1527 && (finfo->info->strip == strip_some
1528 || finfo->info->discard == discard_l))
1529 {
1530 const char *name;
1531 char buf[SYMNMLEN + 1];
1532
1533 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1534 if (name == NULL)
1535 return false;
1536
1537 if (! dont_skip_symbol
1538 && ((finfo->info->strip == strip_some
1539 && (bfd_hash_lookup (finfo->info->keep_hash, name, false,
1540 false) == NULL))
1541 || (! global
1542 && finfo->info->discard == discard_l
1543 && bfd_is_local_label_name (input_bfd, name))))
1544 skip = true;
1545 }
1546
1547 /* If this is an enum, struct, or union tag, see if we have
1548 already output an identical type. */
1549 if (! skip
1550 && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
1551 && (isym.n_sclass == C_ENTAG
1552 || isym.n_sclass == C_STRTAG
1553 || isym.n_sclass == C_UNTAG)
1554 && isym.n_numaux == 1)
1555 {
1556 const char *name;
1557 char buf[SYMNMLEN + 1];
1558 struct coff_debug_merge_hash_entry *mh;
1559 struct coff_debug_merge_type *mt;
1560 union internal_auxent aux;
1561 struct coff_debug_merge_element **epp;
1562 bfd_byte *esl, *eslend;
1563 struct internal_syment *islp;
1564
1565 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf);
1566 if (name == NULL)
1567 return false;
1568
1569 /* Ignore fake names invented by compiler; treat them all as
1570 the same name. */
1571 if (*name == '~' || *name == '.' || *name == '$'
1572 || (*name == bfd_get_symbol_leading_char (input_bfd)
1573 && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
1574 name = "";
1575
1576 mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
1577 true, true);
1578 if (mh == NULL)
1579 return false;
1580
1581 /* Allocate memory to hold type information. If this turns
1582 out to be a duplicate, we pass this address to
1583 bfd_release. */
1584 mt = ((struct coff_debug_merge_type *)
1585 bfd_alloc (input_bfd,
1586 sizeof (struct coff_debug_merge_type)));
1587 if (mt == NULL)
1588 return false;
1589 mt->class = isym.n_sclass;
1590
1591 /* Pick up the aux entry, which points to the end of the tag
1592 entries. */
1593 bfd_coff_swap_aux_in (input_bfd, (PTR) (esym + isymesz),
1594 isym.n_type, isym.n_sclass, 0, isym.n_numaux,
1595 (PTR) &aux);
1596
1597 /* Gather the elements. */
1598 epp = &mt->elements;
1599 mt->elements = NULL;
1600 islp = isymp + 2;
1601 esl = esym + 2 * isymesz;
1602 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd)
1603 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz);
1604 while (esl < eslend)
1605 {
1606 const char *elename;
1607 char elebuf[SYMNMLEN + 1];
00692651 1608 char *name_copy;
252b5132
RH		 1609
1610 bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp);
1611
1612 *epp = ((struct coff_debug_merge_element *)
1613 bfd_alloc (input_bfd,
1614 sizeof (struct coff_debug_merge_element)));
1615 if (*epp == NULL)
1616 return false;
1617
1618 elename = _bfd_coff_internal_syment_name (input_bfd, islp,
1619 elebuf);
1620 if (elename == NULL)
1621 return false;
1622
00692651
ILT		 1623 name_copy = (char *) bfd_alloc (input_bfd,
1624 strlen (elename) + 1);
1625 if (name_copy == NULL)
252b5132 1626 return false;
00692651 1627 strcpy (name_copy, elename);
252b5132 1628
00692651 1629 (*epp)->name = name_copy;
252b5132
RH		 1630 (*epp)->type = islp->n_type;
1631 (*epp)->tagndx = 0;
1632 if (islp->n_numaux >= 1
1633 && islp->n_type != T_NULL
1634 && islp->n_sclass != C_EOS)
1635 {
1636 union internal_auxent eleaux;
1637 long indx;
1638
1639 bfd_coff_swap_aux_in (input_bfd, (PTR) (esl + isymesz),
1640 islp->n_type, islp->n_sclass, 0,
1641 islp->n_numaux, (PTR) &eleaux);
1642 indx = eleaux.x_sym.x_tagndx.l;
1643
1644 /* FIXME: If this tagndx entry refers to a symbol
1645 defined later in this file, we just ignore it.
1646 Handling this correctly would be tedious, and may
1647 not be required. */
1648
1649 if (indx > 0
1650 && (indx
1651 < ((esym -
1652 (bfd_byte *) obj_coff_external_syms (input_bfd))
1653 / (long) isymesz)))
1654 {
1655 (*epp)->tagndx = finfo->sym_indices[indx];
1656 if ((*epp)->tagndx < 0)
1657 (*epp)->tagndx = 0;
1658 }
1659 }
1660 epp = &(*epp)->next;
1661 *epp = NULL;
1662
1663 esl += (islp->n_numaux + 1) * isymesz;
1664 islp += islp->n_numaux + 1;
1665 }
1666
1667 /* See if we already have a definition which matches this
1668 type. We always output the type if it has no elements,
1669 for simplicity. */
1670 if (mt->elements == NULL)
1671 bfd_release (input_bfd, (PTR) mt);
1672 else
1673 {
1674 struct coff_debug_merge_type *mtl;
1675
1676 for (mtl = mh->types; mtl != NULL; mtl = mtl->next)
1677 {
1678 struct coff_debug_merge_element *me, *mel;
1679
1680 if (mtl->class != mt->class)
1681 continue;
1682
1683 for (me = mt->elements, mel = mtl->elements;
1684 me != NULL && mel != NULL;
1685 me = me->next, mel = mel->next)
1686 {
1687 if (strcmp (me->name, mel->name) != 0
1688 || me->type != mel->type
1689 || me->tagndx != mel->tagndx)
1690 break;
1691 }
1692
1693 if (me == NULL && mel == NULL)
1694 break;
1695 }
1696
1697 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base)
1698 {
1699 /* This is the first definition of this type. */
1700 mt->indx = output_index;
1701 mt->next = mh->types;
1702 mh->types = mt;
1703 }
1704 else
1705 {
1706 /* This is a redefinition which can be merged. */
1707 bfd_release (input_bfd, (PTR) mt);
1708 *indexp = mtl->indx;
1709 add = (eslend - esym) / isymesz;
1710 skip = true;
1711 }
1712 }
1713 }
1714
1715 /* We now know whether we are to skip this symbol or not. */
1716 if (! skip)
1717 {
1718 /* Adjust the symbol in order to output it. */
1719
1720 if (isym._n._n_n._n_zeroes == 0
1721 && isym._n._n_n._n_offset != 0)
1722 {
1723 const char *name;
1724 bfd_size_type indx;
1725
1726 /* This symbol has a long name. Enter it in the string
1727 table we are building. Note that we do not check
1728 bfd_coff_symname_in_debug. That is only true for
1729 XCOFF, and XCOFF requires different linking code
1730 anyhow. */
1731 name = _bfd_coff_internal_syment_name (input_bfd, &isym,
1732 (char *) NULL);
1733 if (name == NULL)
1734 return false;
1735 indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
1736 if (indx == (bfd_size_type) -1)
1737 return false;
1738 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1739 }
1740
8add8e30 1741 switch (isym.n_sclass)
252b5132 1742 {
8add8e30
ILT		 1743 case C_AUTO:
1744 case C_MOS:
1745 case C_EOS:
1746 case C_MOE:
1747 case C_MOU:
1748 case C_UNTAG:
1749 case C_STRTAG:
1750 case C_ENTAG:
1751 case C_TPDEF:
1752 case C_ARG:
1753 case C_USTATIC:
1754 case C_REG:
1755 case C_REGPARM:
1756 case C_FIELD:
1757 /* The symbol value should not be modified. */
1758 break;
1759
1760 case C_FCN:
1761 if (obj_pe (input_bfd)
1762 && strcmp (isym.n_name, ".bf") != 0
1763 && isym.n_scnum > 0)
1764 {
1765 /* For PE, .lf and .ef get their value left alone,
1766 while .bf gets relocated. However, they all have
1767 "real" section numbers, and need to be moved into
1768 the new section. */
1769 isym.n_scnum = (*secpp)->output_section->target_index;
1770 break;
1771 }
1772 /* Fall through. */
1773 default:
1774 case C_LABEL: /* Not completely sure about these 2 */
1775 case C_EXTDEF:
1776 case C_BLOCK:
1777 case C_EFCN:
1778 case C_NULL:
1779 case C_EXT:
1780 case C_STAT:
1781 case C_SECTION:
1782 case C_NT_WEAK:
1783 /* Compute new symbol location. */
1784 if (isym.n_scnum > 0)
1785 {
1786 isym.n_scnum = (*secpp)->output_section->target_index;
1787 isym.n_value += (*secpp)->output_offset;
1788 if (! obj_pe (input_bfd))
1789 isym.n_value -= (*secpp)->vma;
1790 if (! obj_pe (finfo->output_bfd))
1791 isym.n_value += (*secpp)->output_section->vma;
1792 }
1793 break;
1794
1795 case C_FILE:
1796 /* The value of a C_FILE symbol is the symbol index of
1797 the next C_FILE symbol. The value of the last C_FILE
1798 symbol is the symbol index to the first external
1799 symbol (actually, coff_renumber_symbols does not get
1800 this right--it just sets the value of the last C_FILE
1801 symbol to zero--and nobody has ever complained about
1802 it). We try to get this right, below, just before we
1803 write the symbols out, but in the general case we may
1804 have to write the symbol out twice. */
252b5132 1805
252b5132
RH		 1806 if (finfo->last_file_index != -1
1807 && finfo->last_file.n_value != (long) output_index)
1808 {
8add8e30
ILT		 1809 /* We must correct the value of the last C_FILE
1810 entry. */
252b5132
RH		 1811 finfo->last_file.n_value = output_index;
1812 if ((bfd_size_type) finfo->last_file_index >= syment_base)
1813 {
1814 /* The last C_FILE symbol is in this input file. */
1815 bfd_coff_swap_sym_out (output_bfd,
1816 (PTR) &finfo->last_file,
1817 (PTR) (finfo->outsyms
1818 + ((finfo->last_file_index
1819 - syment_base)
1820 * osymesz)));
1821 }
1822 else
1823 {
1824 /* We have already written out the last C_FILE
1825 symbol. We need to write it out again. We
1826 borrow *outsym temporarily. */
1827 bfd_coff_swap_sym_out (output_bfd,
1828 (PTR) &finfo->last_file,
1829 (PTR) outsym);
1830 if (bfd_seek (output_bfd,
1831 (obj_sym_filepos (output_bfd)
1832 + finfo->last_file_index * osymesz),
1833 SEEK_SET) != 0
1834 || (bfd_write (outsym, osymesz, 1, output_bfd)
1835 != osymesz))
1836 return false;
1837 }
1838 }
1839
1840 finfo->last_file_index = output_index;
1841 finfo->last_file = isym;
8add8e30 1842 break;
252b5132
RH		 1843 }
1844
1845 /* If doing task linking, convert normal global function symbols to
e4202681
NC		 1846 static functions. */
1847 if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
252b5132
RH		 1848 isym.n_sclass = C_STAT;
1849
1850 /* Output the symbol. */
1851
1852 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym);
1853
1854 *indexp = output_index;
1855
1856 if (global)
1857 {
1858 long indx;
1859 struct coff_link_hash_entry *h;
1860
1861 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd))
1862 / isymesz);
1863 h = obj_coff_sym_hashes (input_bfd)[indx];
1864 if (h == NULL)
1865 {
1866 /* This can happen if there were errors earlier in
1867 the link. */
1868 bfd_set_error (bfd_error_bad_value);
1869 return false;
1870 }
1871 h->indx = output_index;
1872 }
1873
1874 output_index += add;
1875 outsym += add * osymesz;
1876 }
1877
1878 esym += add * isymesz;
1879 isymp += add;
1880 ++secpp;
1881 ++indexp;
1882 for (--add; add > 0; --add)
1883 {
1884 *secpp++ = NULL;
1885 *indexp++ = -1;
1886 }
1887 }
1888
1889 /* Fix up the aux entries. This must be done in a separate pass,
1890 because we don't know the correct symbol indices until we have
1891 already decided which symbols we are going to keep. */
1892
1893 esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
1894 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
1895 isymp = finfo->internal_syms;
1896 indexp = finfo->sym_indices;
1897 sym_hash = obj_coff_sym_hashes (input_bfd);
1898 outsym = finfo->outsyms;
1899 while (esym < esym_end)
1900 {
1901 int add;
1902
1903 add = 1 + isymp->n_numaux;
1904
1905 if ((*indexp < 0
1906 || (bfd_size_type) *indexp < syment_base)
1907 && (*sym_hash == NULL
1908 || (*sym_hash)->auxbfd != input_bfd))
1909 esym += add * isymesz;
1910 else
1911 {
1912 struct coff_link_hash_entry *h;
1913 int i;
1914
1915 h = NULL;
1916 if (*indexp < 0)
1917 {
1918 h = *sym_hash;
1919
1920 /* The m68k-motorola-sysv assembler will sometimes
1921 generate two symbols with the same name, but only one
1922 will have aux entries. */
1923 BFD_ASSERT (isymp->n_numaux == 0
1924 || h->numaux == isymp->n_numaux);
1925 }
1926
1927 esym += isymesz;
1928
1929 if (h == NULL)
1930 outsym += osymesz;
1931
1932 /* Handle the aux entries. This handling is based on
1933 coff_pointerize_aux. I don't know if it always correct. */
1934 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++)
1935 {
1936 union internal_auxent aux;
1937 union internal_auxent *auxp;
1938
1939 if (h != NULL)
1940 auxp = h->aux + i;
1941 else
1942 {
1943 bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type,
1944 isymp->n_sclass, i, isymp->n_numaux,
1945 (PTR) &aux);
1946 auxp = &aux;
1947 }
1948
1949 if (isymp->n_sclass == C_FILE)
1950 {
1951 /* If this is a long filename, we must put it in the
1952 string table. */
1953 if (auxp->x_file.x_n.x_zeroes == 0
1954 && auxp->x_file.x_n.x_offset != 0)
1955 {
1956 const char *filename;
1957 bfd_size_type indx;
1958
1959 BFD_ASSERT (auxp->x_file.x_n.x_offset
1960 >= STRING_SIZE_SIZE);
1961 if (strings == NULL)
1962 {
1963 strings = _bfd_coff_read_string_table (input_bfd);
1964 if (strings == NULL)
1965 return false;
1966 }
1967 filename = strings + auxp->x_file.x_n.x_offset;
1968 indx = _bfd_stringtab_add (finfo->strtab, filename,
1969 hash, copy);
1970 if (indx == (bfd_size_type) -1)
1971 return false;
1972 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx;
1973 }
1974 }
1975 else if (isymp->n_sclass != C_STAT || isymp->n_type != T_NULL)
1976 {
1977 unsigned long indx;
1978
1979 if (ISFCN (isymp->n_type)
1980 || ISTAG (isymp->n_sclass)
1981 || isymp->n_sclass == C_BLOCK
1982 || isymp->n_sclass == C_FCN)
1983 {
1984 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l;
1985 if (indx > 0
1986 && indx < obj_raw_syment_count (input_bfd))
1987 {
1988 /* We look forward through the symbol for
1989 the index of the next symbol we are going
1990 to include. I don't know if this is
1991 entirely right. */
1992 while ((finfo->sym_indices[indx] < 0
1993 || ((bfd_size_type) finfo->sym_indices[indx]
1994 < syment_base))
1995 && indx < obj_raw_syment_count (input_bfd))
1996 ++indx;
1997 if (indx >= obj_raw_syment_count (input_bfd))
1998 indx = output_index;
1999 else
2000 indx = finfo->sym_indices[indx];
2001 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
2002 }
2003 }
2004
2005 indx = auxp->x_sym.x_tagndx.l;
2006 if (indx > 0 && indx < obj_raw_syment_count (input_bfd))
2007 {
2008 long symindx;
2009
2010 symindx = finfo->sym_indices[indx];
2011 if (symindx < 0)
2012 auxp->x_sym.x_tagndx.l = 0;
2013 else
2014 auxp->x_sym.x_tagndx.l = symindx;
2015 }
2016
2017 /* The .bf symbols are supposed to be linked through
2018 the endndx field. We need to carry this list
2019 across object files. */
2020 if (i == 0
2021 && h == NULL
2022 && isymp->n_sclass == C_FCN
2023 && (isymp->_n._n_n._n_zeroes != 0
2024 || isymp->_n._n_n._n_offset == 0)
2025 && isymp->_n._n_name[0] == '.'
2026 && isymp->_n._n_name[1] == 'b'
2027 && isymp->_n._n_name[2] == 'f'
2028 && isymp->_n._n_name[3] == '\0')
2029 {
2030 if (finfo->last_bf_index != -1)
2031 {
2032 finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
2033 *indexp;
2034
2035 if ((bfd_size_type) finfo->last_bf_index
2036 >= syment_base)
2037 {
2038 PTR auxout;
2039
2040 /* The last .bf symbol is in this input
2041 file. This will only happen if the
2042 assembler did not set up the .bf
2043 endndx symbols correctly. */
2044 auxout = (PTR) (finfo->outsyms
2045 + ((finfo->last_bf_index
2046 - syment_base)
2047 * osymesz));
2048 bfd_coff_swap_aux_out (output_bfd,
2049 (PTR) &finfo->last_bf,
2050 isymp->n_type,
2051 isymp->n_sclass,
2052 0, isymp->n_numaux,
2053 auxout);
2054 }
2055 else
2056 {
2057 /* We have already written out the last
2058 .bf aux entry. We need to write it
2059 out again. We borrow *outsym
2060 temporarily. FIXME: This case should
2061 be made faster. */
2062 bfd_coff_swap_aux_out (output_bfd,
2063 (PTR) &finfo->last_bf,
2064 isymp->n_type,
2065 isymp->n_sclass,
2066 0, isymp->n_numaux,
2067 (PTR) outsym);
2068 if (bfd_seek (output_bfd,
2069 (obj_sym_filepos (output_bfd)
2070 + finfo->last_bf_index * osymesz),
2071 SEEK_SET) != 0
2072 || bfd_write (outsym, osymesz, 1,
2073 output_bfd) != osymesz)
2074 return false;
2075 }
2076 }
2077
2078 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
2079 finfo->last_bf_index = -1;
2080 else
2081 {
2082 /* The endndx field of this aux entry must
2083 be updated with the symbol number of the
2084 next .bf symbol. */
2085 finfo->last_bf = *auxp;
2086 finfo->last_bf_index = (((outsym - finfo->outsyms)
2087 / osymesz)
2088 + syment_base);
2089 }
2090 }
2091 }
2092
2093 if (h == NULL)
2094 {
2095 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isymp->n_type,
2096 isymp->n_sclass, i, isymp->n_numaux,
2097 (PTR) outsym);
2098 outsym += osymesz;
2099 }
2100
2101 esym += isymesz;
2102 }
2103 }
2104
2105 indexp += add;
2106 isymp += add;
2107 sym_hash += add;
2108 }
2109
2110 /* Relocate the line numbers, unless we are stripping them. */
2111 if (finfo->info->strip == strip_none
2112 || finfo->info->strip == strip_some)
2113 {
2114 for (o = input_bfd->sections; o != NULL; o = o->next)
2115 {
2116 bfd_vma offset;
2117 bfd_byte *eline;
2118 bfd_byte *elineend;
b545f675
ILT		 2119 bfd_byte *oeline;
2120 boolean skipping;
252b5132
RH		 2121
2122 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then
2123 build_link_order in ldwrite.c will not have created a
2124 link order, which means that we will not have seen this
2125 input section in _bfd_coff_final_link, which means that
2126 we will not have allocated space for the line numbers of
2127 this section. I don't think line numbers can be
2128 meaningful for a section which does not have
2129 SEC_HAS_CONTENTS set, but, if they do, this must be
2130 changed. */
2131 if (o->lineno_count == 0
2132 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0)
2133 continue;
2134
2135 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
2136 || bfd_read (finfo->linenos, linesz, o->lineno_count,
2137 input_bfd) != linesz * o->lineno_count)
2138 return false;
2139
2140 offset = o->output_section->vma + o->output_offset - o->vma;
2141 eline = finfo->linenos;
b545f675 2142 oeline = finfo->linenos;
252b5132 2143 elineend = eline + linesz * o->lineno_count;
b545f675 2144 skipping = false;
252b5132
RH		 2145 for (; eline < elineend; eline += linesz)
2146 {
2147 struct internal_lineno iline;
2148
2149 bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline);
2150
2151 if (iline.l_lnno != 0)
2152 iline.l_addr.l_paddr += offset;
2153 else if (iline.l_addr.l_symndx >= 0
2154 && ((unsigned long) iline.l_addr.l_symndx
2155 < obj_raw_syment_count (input_bfd)))
2156 {
2157 long indx;
2158
2159 indx = finfo->sym_indices[iline.l_addr.l_symndx];
2160
2161 if (indx < 0)
2162 {
2163 /* These line numbers are attached to a symbol
b545f675
ILT		 2164 which we are stripping. We must discard the
2165 line numbers because reading them back with
2166 no associated symbol (or associating them all
2167 with symbol #0) will fail. We can't regain
2168 the space in the output file, but at least
2169 they're dense. */
2170 skipping = true;
252b5132
RH		 2171 }
2172 else
2173 {
2174 struct internal_syment is;
2175 union internal_auxent ia;
2176
2177 /* Fix up the lnnoptr field in the aux entry of
2178 the symbol. It turns out that we can't do
2179 this when we modify the symbol aux entries,
2180 because gas sometimes screws up the lnnoptr
2181 field and makes it an offset from the start
2182 of the line numbers rather than an absolute
2183 file index. */
2184 bfd_coff_swap_sym_in (output_bfd,
2185 (PTR) (finfo->outsyms
2186 + ((indx - syment_base)
2187 * osymesz)),
2188 (PTR) &is);
2189 if ((ISFCN (is.n_type)
2190 || is.n_sclass == C_BLOCK)
2191 && is.n_numaux >= 1)
2192 {
2193 PTR auxptr;
2194
2195 auxptr = (PTR) (finfo->outsyms
2196 + ((indx - syment_base + 1)
2197 * osymesz));
2198 bfd_coff_swap_aux_in (output_bfd, auxptr,
2199 is.n_type, is.n_sclass,
2200 0, is.n_numaux, (PTR) &ia);
2201 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
2202 (o->output_section->line_filepos
2203 + o->output_section->lineno_count * linesz
2204 + eline - finfo->linenos);
2205 bfd_coff_swap_aux_out (output_bfd, (PTR) &ia,
2206 is.n_type, is.n_sclass, 0,
2207 is.n_numaux, auxptr);
2208 }
b545f675 2209
60bcf0fa 2210 skipping = false;
252b5132
RH		 2211 }
2212
2213 iline.l_addr.l_symndx = indx;
2214 }
2215
b545f675
ILT		 2216 if (!skipping)
2217 {
2218 bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline,
2219 (PTR) oeline);
2220 oeline += linesz;
2221 }
252b5132
RH		 2222 }
2223
2224 if (bfd_seek (output_bfd,
2225 (o->output_section->line_filepos
2226 + o->output_section->lineno_count * linesz),
2227 SEEK_SET) != 0
b545f675
ILT		 2228 || (bfd_write (finfo->linenos, 1, oeline - finfo->linenos,
2229 output_bfd)
2230 != (bfd_size_type) (oeline - finfo->linenos)))
252b5132
RH		 2231 return false;
2232
b545f675
ILT		 2233 o->output_section->lineno_count +=
2234 (oeline - finfo->linenos) / linesz;
252b5132
RH		 2235 }
2236 }
2237
2238 /* If we swapped out a C_FILE symbol, guess that the next C_FILE
2239 symbol will be the first symbol in the next input file. In the
2240 normal case, this will save us from writing out the C_FILE symbol
2241 again. */
2242 if (finfo->last_file_index != -1
2243 && (bfd_size_type) finfo->last_file_index >= syment_base)
2244 {
2245 finfo->last_file.n_value = output_index;
2246 bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file,
2247 (PTR) (finfo->outsyms
2248 + ((finfo->last_file_index - syment_base)
2249 * osymesz)));
2250 }
2251
2252 /* Write the modified symbols to the output file. */
2253 if (outsym > finfo->outsyms)
2254 {
2255 if (bfd_seek (output_bfd,
2256 obj_sym_filepos (output_bfd) + syment_base * osymesz,
2257 SEEK_SET) != 0
2258 || (bfd_write (finfo->outsyms, outsym - finfo->outsyms, 1,
2259 output_bfd)
2260 != (bfd_size_type) (outsym - finfo->outsyms)))
2261 return false;
2262
2263 BFD_ASSERT ((obj_raw_syment_count (output_bfd)
2264 + (outsym - finfo->outsyms) / osymesz)
2265 == output_index);
2266
2267 obj_raw_syment_count (output_bfd) = output_index;
2268 }
2269
2270 /* Relocate the contents of each section. */
2271 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx;
2272 for (o = input_bfd->sections; o != NULL; o = o->next)
2273 {
2274 bfd_byte *contents;
2275 struct coff_section_tdata *secdata;
2276
2277 if (! o->linker_mark)
2278 {
2279 /* This section was omitted from the link. */
2280 continue;
2281 }
2282
2283 if ((o->flags & SEC_HAS_CONTENTS) == 0
2284 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0))
2285 {
2286 if ((o->flags & SEC_RELOC) != 0
2287 && o->reloc_count != 0)
2288 {
2289 ((*_bfd_error_handler)
2290 (_("%s: relocs in section `%s', but it has no contents"),
2291 bfd_get_filename (input_bfd),
2292 bfd_get_section_name (input_bfd, o)));
2293 bfd_set_error (bfd_error_no_contents);
2294 return false;
2295 }
2296
2297 continue;
2298 }
2299
2300 secdata = coff_section_data (input_bfd, o);
2301 if (secdata != NULL && secdata->contents != NULL)
2302 contents = secdata->contents;
2303 else
2304 {
2305 if (! bfd_get_section_contents (input_bfd, o, finfo->contents,
2306 (file_ptr) 0, o->_raw_size))
2307 return false;
2308 contents = finfo->contents;
2309 }
2310
2311 if ((o->flags & SEC_RELOC) != 0)
2312 {
2313 int target_index;
2314 struct internal_reloc *internal_relocs;
2315 struct internal_reloc *irel;
2316
2317 /* Read in the relocs. */
2318 target_index = o->output_section->target_index;
2319 internal_relocs = (_bfd_coff_read_internal_relocs
2320 (input_bfd, o, false, finfo->external_relocs,
2321 finfo->info->relocateable,
2322 (finfo->info->relocateable
2323 ? (finfo->section_info[target_index].relocs
2324 + o->output_section->reloc_count)
2325 : finfo->internal_relocs)));
2326 if (internal_relocs == NULL)
2327 return false;
2328
2329 /* Call processor specific code to relocate the section
2330 contents. */
2331 if (! bfd_coff_relocate_section (output_bfd, finfo->info,
2332 input_bfd, o,
2333 contents,
2334 internal_relocs,
2335 finfo->internal_syms,
2336 finfo->sec_ptrs))
2337 return false;
2338
2339 if (finfo->info->relocateable)
2340 {
2341 bfd_vma offset;
2342 struct internal_reloc *irelend;
2343 struct coff_link_hash_entry **rel_hash;
2344
2345 offset = o->output_section->vma + o->output_offset - o->vma;
2346 irel = internal_relocs;
2347 irelend = irel + o->reloc_count;
2348 rel_hash = (finfo->section_info[target_index].rel_hashes
2349 + o->output_section->reloc_count);
2350 for (; irel < irelend; irel++, rel_hash++)
2351 {
2352 struct coff_link_hash_entry *h;
2353 boolean adjusted;
2354
2355 *rel_hash = NULL;
2356
2357 /* Adjust the reloc address and symbol index. */
2358
2359 irel->r_vaddr += offset;
2360
2361 if (irel->r_symndx == -1)
2362 continue;
2363
2364 if (adjust_symndx)
2365 {
2366 if (! (*adjust_symndx) (output_bfd, finfo->info,
2367 input_bfd, o, irel,
2368 &adjusted))
2369 return false;
2370 if (adjusted)
2371 continue;
2372 }
2373
2374 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx];
2375 if (h != NULL)
2376 {
2377 /* This is a global symbol. */
2378 if (h->indx >= 0)
2379 irel->r_symndx = h->indx;
2380 else
2381 {
2382 /* This symbol is being written at the end
2383 of the file, and we do not yet know the
2384 symbol index. We save the pointer to the
2385 hash table entry in the rel_hash list.
2386 We set the indx field to -2 to indicate
2387 that this symbol must not be stripped. */
2388 *rel_hash = h;
2389 h->indx = -2;
2390 }
2391 }
2392 else
2393 {
2394 long indx;
2395
2396 indx = finfo->sym_indices[irel->r_symndx];
2397 if (indx != -1)
2398 irel->r_symndx = indx;
2399 else
2400 {
2401 struct internal_syment *is;
2402 const char *name;
2403 char buf[SYMNMLEN + 1];
2404
2405 /* This reloc is against a symbol we are
2406 stripping. This should have been handled
2407 by the 'dont_skip_symbol' code in the while
2408 loop at the top of this function. */
2409
2410 is = finfo->internal_syms + irel->r_symndx;
2411
2412 name = (_bfd_coff_internal_syment_name
2413 (input_bfd, is, buf));
2414 if (name == NULL)
2415 return false;
2416
2417 if (! ((*finfo->info->callbacks->unattached_reloc)
2418 (finfo->info, name, input_bfd, o,
2419 irel->r_vaddr)))
2420 return false;
2421 }
2422 }
2423 }
2424
2425 o->output_section->reloc_count += o->reloc_count;
2426 }
2427 }
2428
2429 /* Write out the modified section contents. */
2430 if (secdata == NULL || secdata->stab_info == NULL)
2431 {
2432 if (! bfd_set_section_contents (output_bfd, o->output_section,
9a968f43
NC		 2433 contents,
2434 (file_ptr)
2435 (o->output_offset *
2436 bfd_octets_per_byte (output_bfd)),
252b5132
RH		 2437 (o->_cooked_size != 0
2438 ? o->_cooked_size
2439 : o->_raw_size)))
2440 return false;
2441 }
2442 else
2443 {
2444 if (! (_bfd_write_section_stabs
2445 (output_bfd, &coff_hash_table (finfo->info)->stab_info,
2446 o, &secdata->stab_info, contents)))
2447 return false;
2448 }
2449 }
2450
2451 if (! finfo->info->keep_memory)
2452 {
2453 if (! _bfd_coff_free_symbols (input_bfd))
2454 return false;
2455 }
2456
2457 return true;
2458}
2459
2460/* Write out a global symbol. Called via coff_link_hash_traverse. */
2461
2462boolean
2463_bfd_coff_write_global_sym (h, data)
2464 struct coff_link_hash_entry *h;
2465 PTR data;
2466{
2467 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2468 bfd *output_bfd;
2469 struct internal_syment isym;
2470 bfd_size_type symesz;
2471 unsigned int i;
2472
2473 output_bfd = finfo->output_bfd;
2474
2475 if (h->indx >= 0)
2476 return true;
2477
2478 if (h->indx != -2
2479 && (finfo->info->strip == strip_all
2480 || (finfo->info->strip == strip_some
2481 && (bfd_hash_lookup (finfo->info->keep_hash,
2482 h->root.root.string, false, false)
2483 == NULL))))
2484 return true;
2485
2486 switch (h->root.type)
2487 {
2488 default:
2489 case bfd_link_hash_new:
2490 abort ();
2491 return false;
2492
2493 case bfd_link_hash_undefined:
2494 case bfd_link_hash_undefweak:
2495 isym.n_scnum = N_UNDEF;
2496 isym.n_value = 0;
2497 break;
2498
2499 case bfd_link_hash_defined:
2500 case bfd_link_hash_defweak:
2501 {
2502 asection *sec;
2503
2504 sec = h->root.u.def.section->output_section;
2505 if (bfd_is_abs_section (sec))
2506 isym.n_scnum = N_ABS;
2507 else
2508 isym.n_scnum = sec->target_index;
2509 isym.n_value = (h->root.u.def.value
2510 + h->root.u.def.section->output_offset);
2511 if (! obj_pe (finfo->output_bfd))
2512 isym.n_value += sec->vma;
2513 }
2514 break;
2515
2516 case bfd_link_hash_common:
2517 isym.n_scnum = N_UNDEF;
2518 isym.n_value = h->root.u.c.size;
2519 break;
2520
2521 case bfd_link_hash_indirect:
2522 case bfd_link_hash_warning:
2523 /* Just ignore these. They can't be handled anyhow. */
2524 return true;
2525 }
2526
2527 if (strlen (h->root.root.string) <= SYMNMLEN)
2528 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN);
2529 else
2530 {
2531 boolean hash;
2532 bfd_size_type indx;
2533
2534 hash = true;
2535 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2536 hash = false;
2537 indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
2538 false);
2539 if (indx == (bfd_size_type) -1)
2540 {
2541 finfo->failed = true;
2542 return false;
2543 }
2544 isym._n._n_n._n_zeroes = 0;
2545 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2546 }
2547
2548 isym.n_sclass = h->class;
2549 isym.n_type = h->type;
2550
2551 if (isym.n_sclass == C_NULL)
2552 isym.n_sclass = C_EXT;
2553
2554 /* If doing task linking and this is the pass where we convert
2555 defined globals to statics, then do that conversion now. If the
2556 symbol is not being converted, just ignore it and it will be
e4202681 2557 output during a later pass. */
252b5132
RH		 2558 if (finfo->global_to_static)
2559 {
e4202681
NC		 2560 if (! IS_EXTERNAL (output_bfd, isym))
2561 return true;
2562
252b5132
RH		 2563 isym.n_sclass = C_STAT;
2564 }
2565
e4202681
NC		 2566 /* When a weak symbol is not overriden by a strong one,
2567 turn it into an external symbol when not building a
2568 shared or relocateable object. */
2569 if (! finfo->info->shared
2570 && ! finfo->info->relocateable
2571 && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
2572 isym.n_sclass = C_EXT;
2573
252b5132
RH		 2574 isym.n_numaux = h->numaux;
2575
2576 bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) finfo->outsyms);
2577
2578 symesz = bfd_coff_symesz (output_bfd);
2579
2580 if (bfd_seek (output_bfd,
2581 (obj_sym_filepos (output_bfd)
2582 + obj_raw_syment_count (output_bfd) * symesz),
2583 SEEK_SET) != 0
2584 || bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
2585 {
2586 finfo->failed = true;
2587 return false;
2588 }
2589
2590 h->indx = obj_raw_syment_count (output_bfd);
2591
2592 ++obj_raw_syment_count (output_bfd);
2593
2c546cd8
ILT		 2594 /* Write out any associated aux entries. Most of the aux entries
2595 will have been modified in _bfd_coff_link_input_bfd. We have to
2596 handle section aux entries here, now that we have the final
2597 relocation and line number counts. */
252b5132
RH		 2598 for (i = 0; i < isym.n_numaux; i++)
2599 {
2c546cd8
ILT		 2600 union internal_auxent *auxp;
2601
2602 auxp = h->aux + i;
2603
2604 /* Look for a section aux entry here using the same tests that
2605 coff_swap_aux_out uses. */
2606 if (i == 0
2607 && (isym.n_sclass == C_STAT
2608 || isym.n_sclass == C_HIDDEN)
2609 && isym.n_type == T_NULL
2610 && (h->root.type == bfd_link_hash_defined
2611 || h->root.type == bfd_link_hash_defweak))
2612 {
2613 asection *sec;
2614
2615 sec = h->root.u.def.section->output_section;
2616 if (sec != NULL)
2617 {
2618 auxp->x_scn.x_scnlen = (sec->_cooked_size != 0
2619 ? sec->_cooked_size
2620 : sec->_raw_size);
2621
2622 /* For PE, an overflow on the final link reportedly does
2623 not matter. FIXME: Why not? */
2624
2625 if (sec->reloc_count > 0xffff
2626 && (! obj_pe (output_bfd)
2627 || finfo->info->relocateable))
2628 (*_bfd_error_handler)
2629 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
2630 bfd_get_filename (output_bfd),
2631 bfd_get_section_name (output_bfd, sec),
2632 sec->reloc_count);
2633
2634 if (sec->lineno_count > 0xffff
2635 && (! obj_pe (output_bfd)
2636 || finfo->info->relocateable))
2637 (*_bfd_error_handler)
2638 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
2639 bfd_get_filename (output_bfd),
2640 bfd_get_section_name (output_bfd, sec),
2641 sec->lineno_count);
2642
2643 auxp->x_scn.x_nreloc = sec->reloc_count;
2644 auxp->x_scn.x_nlinno = sec->lineno_count;
2645 auxp->x_scn.x_checksum = 0;
2646 auxp->x_scn.x_associated = 0;
2647 auxp->x_scn.x_comdat = 0;
2648 }
2649 }
2650
2651 bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isym.n_type,
252b5132
RH		 2652 isym.n_sclass, i, isym.n_numaux,
2653 (PTR) finfo->outsyms);
2654 if (bfd_write (finfo->outsyms, symesz, 1, output_bfd) != symesz)
2655 {
2656 finfo->failed = true;
2657 return false;
2658 }
2659 ++obj_raw_syment_count (output_bfd);
2660 }
2661
2662 return true;
2663}
2664
2665/* Write out task global symbols, converting them to statics. Called
2666 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do
2667 the dirty work, if the symbol we are processing needs conversion. */
2668
2669boolean
2670_bfd_coff_write_task_globals (h, data)
2671 struct coff_link_hash_entry *h;
2672 PTR data;
2673{
2674 struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
2675 boolean rtnval = true;
2676 boolean save_global_to_static;
2677
2678 if (h->indx < 0)
2679 {
2680 switch (h->root.type)
2681 {
2682 case bfd_link_hash_defined:
2683 case bfd_link_hash_defweak:
2684 save_global_to_static = finfo->global_to_static;
2685 finfo->global_to_static = true;
2686 rtnval = _bfd_coff_write_global_sym (h, data);
2687 finfo->global_to_static = save_global_to_static;
2688 break;
2689 default:
2690 break;
2691 }
2692 }
2693 return (rtnval);
2694}
2695
2696/* Handle a link order which is supposed to generate a reloc. */
2697
2698boolean
2699_bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order)
2700 bfd *output_bfd;
2701 struct coff_final_link_info *finfo;
2702 asection *output_section;
2703 struct bfd_link_order *link_order;
2704{
2705 reloc_howto_type *howto;
2706 struct internal_reloc *irel;
2707 struct coff_link_hash_entry **rel_hash_ptr;
2708
2709 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
2710 if (howto == NULL)
2711 {
2712 bfd_set_error (bfd_error_bad_value);
2713 return false;
2714 }
2715
2716 if (link_order->u.reloc.p->addend != 0)
2717 {
2718 bfd_size_type size;
2719 bfd_byte *buf;
2720 bfd_reloc_status_type rstat;
2721 boolean ok;
2722
2723 size = bfd_get_reloc_size (howto);
2724 buf = (bfd_byte *) bfd_zmalloc (size);
2725 if (buf == NULL)
2726 return false;
2727
2728 rstat = _bfd_relocate_contents (howto, output_bfd,
2729 link_order->u.reloc.p->addend, buf);
2730 switch (rstat)
2731 {
2732 case bfd_reloc_ok:
2733 break;
2734 default:
2735 case bfd_reloc_outofrange:
2736 abort ();
2737 case bfd_reloc_overflow:
2738 if (! ((*finfo->info->callbacks->reloc_overflow)
2739 (finfo->info,
2740 (link_order->type == bfd_section_reloc_link_order
2741 ? bfd_section_name (output_bfd,
2742 link_order->u.reloc.p->u.section)
2743 : link_order->u.reloc.p->u.name),
2744 howto->name, link_order->u.reloc.p->addend,
2745 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
2746 {
2747 free (buf);
2748 return false;
2749 }
2750 break;
2751 }
2752 ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
9a968f43
NC		 2753 (file_ptr)
2754 (link_order->offset *
2755 bfd_octets_per_byte (output_bfd)), size);
252b5132
RH		 2756 free (buf);
2757 if (! ok)
2758 return false;
2759 }
2760
2761 /* Store the reloc information in the right place. It will get
2762 swapped and written out at the end of the final_link routine. */
2763
2764 irel = (finfo->section_info[output_section->target_index].relocs
2765 + output_section->reloc_count);
2766 rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
2767 + output_section->reloc_count);
2768
2769 memset (irel, 0, sizeof (struct internal_reloc));
2770 *rel_hash_ptr = NULL;
2771
2772 irel->r_vaddr = output_section->vma + link_order->offset;
2773
2774 if (link_order->type == bfd_section_reloc_link_order)
2775 {
2776 /* We need to somehow locate a symbol in the right section. The
2777 symbol must either have a value of zero, or we must adjust
2778 the addend by the value of the symbol. FIXME: Write this
2779 when we need it. The old linker couldn't handle this anyhow. */
2780 abort ();
2781 *rel_hash_ptr = NULL;
2782 irel->r_symndx = 0;
2783 }
2784 else
2785 {
2786 struct coff_link_hash_entry *h;
2787
2788 h = ((struct coff_link_hash_entry *)
2789 bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
2790 link_order->u.reloc.p->u.name,
2791 false, false, true));
2792 if (h != NULL)
2793 {
2794 if (h->indx >= 0)
2795 irel->r_symndx = h->indx;
2796 else
2797 {
2798 /* Set the index to -2 to force this symbol to get
2799 written out. */
2800 h->indx = -2;
2801 *rel_hash_ptr = h;
2802 irel->r_symndx = 0;
2803 }
2804 }
2805 else
2806 {
2807 if (! ((*finfo->info->callbacks->unattached_reloc)
2808 (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
2809 (asection *) NULL, (bfd_vma) 0)))
2810 return false;
2811 irel->r_symndx = 0;
2812 }
2813 }
2814
2815 /* FIXME: Is this always right? */
2816 irel->r_type = howto->type;
2817
2818 /* r_size is only used on the RS/6000, which needs its own linker
2819 routines anyhow. r_extern is only used for ECOFF. */
2820
2821 /* FIXME: What is the right value for r_offset? Is zero OK? */
2822
2823 ++output_section->reloc_count;
2824
2825 return true;
2826}
2827
2828/* A basic reloc handling routine which may be used by processors with
2829 simple relocs. */
2830
2831boolean
2832_bfd_coff_generic_relocate_section (output_bfd, info, input_bfd,
2833 input_section, contents, relocs, syms,
2834 sections)
2835 bfd *output_bfd;
2836 struct bfd_link_info *info;
2837 bfd *input_bfd;
2838 asection *input_section;
2839 bfd_byte *contents;
2840 struct internal_reloc *relocs;
2841 struct internal_syment *syms;
2842 asection **sections;
2843{
2844 struct internal_reloc *rel;
2845 struct internal_reloc *relend;
2846
2847 rel = relocs;
2848 relend = rel + input_section->reloc_count;
2849 for (; rel < relend; rel++)
2850 {
2851 long symndx;
2852 struct coff_link_hash_entry *h;
2853 struct internal_syment *sym;
2854 bfd_vma addend;
2855 bfd_vma val;
2856 reloc_howto_type *howto;
2857 bfd_reloc_status_type rstat;
2858
2859 symndx = rel->r_symndx;
2860
2861 if (symndx == -1)
2862 {
2863 h = NULL;
2864 sym = NULL;
2865 }
75987f83
ILT		 2866 else if (symndx < 0
2867 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd))
2868 {
2869 (*_bfd_error_handler)
2870 ("%s: illegal symbol index %ld in relocs",
2871 bfd_get_filename (input_bfd), symndx);
2872 return false;
2873 }
252b5132
RH		 2874 else
2875 {
2876 h = obj_coff_sym_hashes (input_bfd)[symndx];
2877 sym = syms + symndx;
2878 }
2879
2880 /* COFF treats common symbols in one of two ways. Either the
2881 size of the symbol is included in the section contents, or it
2882 is not. We assume that the size is not included, and force
2883 the rtype_to_howto function to adjust the addend as needed. */
2884
2885 if (sym != NULL && sym->n_scnum != 0)
2886 addend = - sym->n_value;
2887 else
2888 addend = 0;
2889
2890
2891 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h,
2892 sym, &addend);
2893 if (howto == NULL)
2894 return false;
2895
2896 /* If we are doing a relocateable link, then we can just ignore
2897 a PC relative reloc that is pcrel_offset. It will already
2898 have the correct value. If this is not a relocateable link,
2899 then we should ignore the symbol value. */
2900 if (howto->pc_relative && howto->pcrel_offset)
2901 {
2902 if (info->relocateable)
2903 continue;
2904 if (sym != NULL && sym->n_scnum != 0)
2905 addend += sym->n_value;
2906 }
2907
2908 val = 0;
2909
2910 if (h == NULL)
2911 {
2912 asection *sec;
2913
2914 if (symndx == -1)
2915 {
2916 sec = bfd_abs_section_ptr;
2917 val = 0;
2918 }
2919 else
2920 {
2921 sec = sections[symndx];
2922 val = (sec->output_section->vma
2923 + sec->output_offset
2924 + sym->n_value);
2925 if (! obj_pe (input_bfd))
2926 val -= sec->vma;
2927 }
2928 }
2929 else
2930 {
2931 if (h->root.type == bfd_link_hash_defined
2932 || h->root.type == bfd_link_hash_defweak)
2933 {
2934 asection *sec;
2935
2936 sec = h->root.u.def.section;
2937 val = (h->root.u.def.value
2938 + sec->output_section->vma
2939 + sec->output_offset);
2940 }
2941
bc7a577d
PB		 2942 else if (h->root.type == bfd_link_hash_undefweak)
2943 val = 0;
2944
252b5132
RH		 2945 else if (! info->relocateable)
2946 {
2947 if (! ((*info->callbacks->undefined_symbol)
2948 (info, h->root.root.string, input_bfd, input_section,
5cc7c785 2949 rel->r_vaddr - input_section->vma, true)))
252b5132
RH		 2950 return false;
2951 }
2952 }
2953
2954 if (info->base_file)
2955 {
2956 /* Emit a reloc if the backend thinks it needs it. */
2957 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto))
2958 {
2959 /* Relocation to a symbol in a section which isn't
2960 absolute. We output the address here to a file.
2961 This file is then read by dlltool when generating the
2962 reloc section. Note that the base file is not
2963 portable between systems. We write out a long here,
2964 and dlltool reads in a long. */
2965 long addr = (rel->r_vaddr
2966 - input_section->vma
2967 + input_section->output_offset
2968 + input_section->output_section->vma);
2969 if (coff_data (output_bfd)->pe)
2970 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
2971 if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
2972 != sizeof (long))
2973 {
2974 bfd_set_error (bfd_error_system_call);
2975 return false;
2976 }
2977 }
2978 }
2979
2980 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
2981 contents,
2982 rel->r_vaddr - input_section->vma,
2983 val, addend);
2984
2985 switch (rstat)
2986 {
2987 default:
2988 abort ();
2989 case bfd_reloc_ok:
2990 break;
2991 case bfd_reloc_outofrange:
2992 (*_bfd_error_handler)
2993 (_("%s: bad reloc address 0x%lx in section `%s'"),
2994 bfd_get_filename (input_bfd),
2995 (unsigned long) rel->r_vaddr,
2996 bfd_get_section_name (input_bfd, input_section));
2997 return false;
2998 case bfd_reloc_overflow:
2999 {
3000 const char *name;
3001 char buf[SYMNMLEN + 1];
3002
3003 if (symndx == -1)
3004 name = "*ABS*";
3005 else if (h != NULL)
3006 name = h->root.root.string;
3007 else
3008 {
3009 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3010 if (name == NULL)
3011 return false;
3012 }
3013
3014 if (! ((*info->callbacks->reloc_overflow)
3015 (info, name, howto->name, (bfd_vma) 0, input_bfd,
3016 input_section, rel->r_vaddr - input_section->vma)))
3017 return false;
3018 }
3019 }
3020 }
3021 return true;
3022}
3023
GDB Binutils - Deliverables
This page took 0.263333 seconds and 4 git commands to generate.