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