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