1 /* COFF specific linker code. 2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 3 2004, 2005, 2006, 2007, 2008, 2009, 2011 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 flaginfo; 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 flaginfo.info = info; 676 flaginfo.output_bfd = abfd; 677 flaginfo.strtab = NULL; 678 flaginfo.section_info = NULL; 679 flaginfo.last_file_index = -1; 680 flaginfo.last_bf_index = -1; 681 flaginfo.internal_syms = NULL; 682 flaginfo.sec_ptrs = NULL; 683 flaginfo.sym_indices = NULL; 684 flaginfo.outsyms = NULL; 685 flaginfo.linenos = NULL; 686 flaginfo.contents = NULL; 687 flaginfo.external_relocs = NULL; 688 flaginfo.internal_relocs = NULL; 689 flaginfo.global_to_static = FALSE; 690 debug_merge_allocated = FALSE; 691 692 coff_data (abfd)->link_info = info; 693 694 flaginfo.strtab = _bfd_stringtab_init (); 695 if (flaginfo.strtab == NULL) 696 goto error_return; 697 698 if (! coff_debug_merge_hash_table_init (&flaginfo.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 (flaginfo.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 flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt); 796 if (flaginfo.section_info == NULL) 797 goto error_return; 798 for (i = 0; i <= abfd->section_count; i++) 799 { 800 flaginfo.section_info[i].relocs = NULL; 801 flaginfo.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 flaginfo.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 flaginfo.section_info[o->target_index].rel_hashes = 843 (struct coff_link_hash_entry **) bfd_malloc (amt); 844 if (flaginfo.section_info[o->target_index].relocs == NULL 845 || flaginfo.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 = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2; 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 flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt); 877 amt = max_sym_count * sizeof (asection *); 878 flaginfo.sec_ptrs = (asection **) bfd_malloc (amt); 879 amt = max_sym_count * sizeof (long); 880 flaginfo.sym_indices = (long int *) bfd_malloc (amt); 881 flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz); 882 amt = max_lineno_count * bfd_coff_linesz (abfd); 883 flaginfo.linenos = (bfd_byte *) bfd_malloc (amt); 884 flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); 885 amt = max_reloc_count * relsz; 886 flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt); 887 if (! info->relocatable) 888 { 889 amt = max_reloc_count * sizeof (struct internal_reloc); 890 flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); 891 } 892 if ((flaginfo.internal_syms == NULL && max_sym_count > 0) 893 || (flaginfo.sec_ptrs == NULL && max_sym_count > 0) 894 || (flaginfo.sym_indices == NULL && max_sym_count > 0) 895 || flaginfo.outsyms == NULL 896 || (flaginfo.linenos == NULL && max_lineno_count > 0) 897 || (flaginfo.contents == NULL && max_contents_size > 0) 898 || (flaginfo.external_relocs == NULL && max_reloc_count > 0) 899 || (! info->relocatable 900 && flaginfo.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, & flaginfo)) 926 { 927 if (! _bfd_coff_link_input_bfd (&flaginfo, 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, &flaginfo, 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 (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all) 947 { 948 /* Add local symbols from foreign inputs. */ 949 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) 950 { 951 unsigned int i; 952 953 if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub)) 954 continue; 955 for (i = 0; i < bfd_get_symcount (sub); ++i) 956 { 957 asymbol *sym = bfd_get_outsymbols (sub) [i]; 958 file_ptr pos; 959 struct internal_syment isym; 960 bfd_size_type string_size = 0; 961 bfd_vma written = 0; 962 bfd_boolean rewrite = FALSE; 963 964 if (! (sym->flags & BSF_LOCAL) 965 || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC 966 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC 967 | BSF_SYNTHETIC)) 968 || ((sym->flags & BSF_DEBUGGING) 969 && ! (sym->flags & BSF_FILE))) 970 continue; 971 972 /* See if we are discarding symbols with this name. */ 973 if ((flaginfo.info->strip == strip_some 974 && (bfd_hash_lookup (flaginfo.info->keep_hash, 975 bfd_asymbol_name(sym), FALSE, FALSE) 976 == NULL)) 977 || (((flaginfo.info->discard == discard_sec_merge 978 && (bfd_get_section (sym)->flags & SEC_MERGE) 979 && ! flaginfo.info->relocatable) 980 || flaginfo.info->discard == discard_l) 981 && bfd_is_local_label_name (sub, bfd_asymbol_name(sym)))) 982 continue; 983 984 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) 985 * symesz; 986 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 987 goto error_return; 988 if (! coff_write_alien_symbol(abfd, sym, &isym, &written, 989 &string_size, NULL, NULL)) 990 goto error_return; 991 992 if (string_size) 993 { 994 bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT); 995 bfd_size_type indx; 996 997 indx = _bfd_stringtab_add (flaginfo.strtab, 998 bfd_asymbol_name (sym), hash, 999 FALSE); 1000 if (indx == (bfd_size_type) -1) 1001 goto error_return; 1002 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; 1003 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms); 1004 rewrite = TRUE; 1005 } 1006 1007 if (isym.n_sclass == C_FILE) 1008 { 1009 if (flaginfo.last_file_index != -1) 1010 { 1011 flaginfo.last_file.n_value = obj_raw_syment_count (abfd); 1012 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, 1013 flaginfo.outsyms); 1014 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index 1015 * symesz; 1016 rewrite = TRUE; 1017 } 1018 flaginfo.last_file_index = obj_raw_syment_count (abfd); 1019 flaginfo.last_file = isym; 1020 } 1021 1022 if (rewrite 1023 && (bfd_seek (abfd, pos, SEEK_SET) != 0 1024 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)) 1025 goto error_return; 1026 1027 obj_raw_syment_count (abfd) += written; 1028 } 1029 } 1030 } 1031 1032 if (! bfd_coff_final_link_postscript (abfd, & flaginfo)) 1033 goto error_return; 1034 1035 /* Free up the buffers used by _bfd_coff_link_input_bfd. */ 1036 1037 coff_debug_merge_hash_table_free (&flaginfo.debug_merge); 1038 debug_merge_allocated = FALSE; 1039 1040 if (flaginfo.internal_syms != NULL) 1041 { 1042 free (flaginfo.internal_syms); 1043 flaginfo.internal_syms = NULL; 1044 } 1045 if (flaginfo.sec_ptrs != NULL) 1046 { 1047 free (flaginfo.sec_ptrs); 1048 flaginfo.sec_ptrs = NULL; 1049 } 1050 if (flaginfo.sym_indices != NULL) 1051 { 1052 free (flaginfo.sym_indices); 1053 flaginfo.sym_indices = NULL; 1054 } 1055 if (flaginfo.linenos != NULL) 1056 { 1057 free (flaginfo.linenos); 1058 flaginfo.linenos = NULL; 1059 } 1060 if (flaginfo.contents != NULL) 1061 { 1062 free (flaginfo.contents); 1063 flaginfo.contents = NULL; 1064 } 1065 if (flaginfo.external_relocs != NULL) 1066 { 1067 free (flaginfo.external_relocs); 1068 flaginfo.external_relocs = NULL; 1069 } 1070 if (flaginfo.internal_relocs != NULL) 1071 { 1072 free (flaginfo.internal_relocs); 1073 flaginfo.internal_relocs = NULL; 1074 } 1075 1076 /* The value of the last C_FILE symbol is supposed to be the symbol 1077 index of the first external symbol. Write it out again if 1078 necessary. */ 1079 if (flaginfo.last_file_index != -1 1080 && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd)) 1081 { 1082 file_ptr pos; 1083 1084 flaginfo.last_file.n_value = obj_raw_syment_count (abfd); 1085 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, 1086 flaginfo.outsyms); 1087 1088 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz; 1089 if (bfd_seek (abfd, pos, SEEK_SET) != 0 1090 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz) 1091 return FALSE; 1092 } 1093 1094 /* If doing task linking (ld --task-link) then make a pass through the 1095 global symbols, writing out any that are defined, and making them 1096 static. */ 1097 if (info->task_link) 1098 { 1099 flaginfo.failed = FALSE; 1100 coff_link_hash_traverse (coff_hash_table (info), 1101 _bfd_coff_write_task_globals, &flaginfo); 1102 if (flaginfo.failed) 1103 goto error_return; 1104 } 1105 1106 /* Write out the global symbols. */ 1107 flaginfo.failed = FALSE; 1108 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo); 1109 if (flaginfo.failed) 1110 goto error_return; 1111 1112 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */ 1113 if (flaginfo.outsyms != NULL) 1114 { 1115 free (flaginfo.outsyms); 1116 flaginfo.outsyms = NULL; 1117 } 1118 1119 if (info->relocatable && max_output_reloc_count > 0) 1120 { 1121 /* Now that we have written out all the global symbols, we know 1122 the symbol indices to use for relocs against them, and we can 1123 finally write out the relocs. */ 1124 amt = max_output_reloc_count * relsz; 1125 external_relocs = (bfd_byte *) bfd_malloc (amt); 1126 if (external_relocs == NULL) 1127 goto error_return; 1128 1129 for (o = abfd->sections; o != NULL; o = o->next) 1130 { 1131 struct internal_reloc *irel; 1132 struct internal_reloc *irelend; 1133 struct coff_link_hash_entry **rel_hash; 1134 bfd_byte *erel; 1135 1136 if (o->reloc_count == 0) 1137 continue; 1138 1139 irel = flaginfo.section_info[o->target_index].relocs; 1140 irelend = irel + o->reloc_count; 1141 rel_hash = flaginfo.section_info[o->target_index].rel_hashes; 1142 erel = external_relocs; 1143 for (; irel < irelend; irel++, rel_hash++, erel += relsz) 1144 { 1145 if (*rel_hash != NULL) 1146 { 1147 BFD_ASSERT ((*rel_hash)->indx >= 0); 1148 irel->r_symndx = (*rel_hash)->indx; 1149 } 1150 bfd_coff_swap_reloc_out (abfd, irel, erel); 1151 } 1152 1153 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0) 1154 goto error_return; 1155 if (obj_pe (abfd) && o->reloc_count >= 0xffff) 1156 { 1157 /* In PE COFF, write the count of relocs as the first 1158 reloc. The header overflow bit will be set 1159 elsewhere. */ 1160 struct internal_reloc incount; 1161 bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz); 1162 1163 memset (&incount, 0, sizeof (incount)); 1164 incount.r_vaddr = o->reloc_count + 1; 1165 bfd_coff_swap_reloc_out (abfd, &incount, excount); 1166 if (bfd_bwrite (excount, relsz, abfd) != relsz) 1167 /* We'll leak, but it's an error anyway. */ 1168 goto error_return; 1169 free (excount); 1170 } 1171 if (bfd_bwrite (external_relocs, 1172 (bfd_size_type) relsz * o->reloc_count, abfd) 1173 != (bfd_size_type) relsz * o->reloc_count) 1174 goto error_return; 1175 } 1176 1177 free (external_relocs); 1178 external_relocs = NULL; 1179 } 1180 1181 /* Free up the section information. */ 1182 if (flaginfo.section_info != NULL) 1183 { 1184 unsigned int i; 1185 1186 for (i = 0; i < abfd->section_count; i++) 1187 { 1188 if (flaginfo.section_info[i].relocs != NULL) 1189 free (flaginfo.section_info[i].relocs); 1190 if (flaginfo.section_info[i].rel_hashes != NULL) 1191 free (flaginfo.section_info[i].rel_hashes); 1192 } 1193 free (flaginfo.section_info); 1194 flaginfo.section_info = NULL; 1195 } 1196 1197 /* If we have optimized stabs strings, output them. */ 1198 if (coff_hash_table (info)->stab_info.stabstr != NULL) 1199 { 1200 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info)) 1201 return FALSE; 1202 } 1203 1204 /* Write out the string table. */ 1205 if (obj_raw_syment_count (abfd) != 0 || long_section_names) 1206 { 1207 file_ptr pos; 1208 1209 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz; 1210 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 1211 return FALSE; 1212 1213 #if STRING_SIZE_SIZE == 4 1214 H_PUT_32 (abfd, 1215 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE, 1216 strbuf); 1217 #else 1218 #error Change H_PUT_32 above 1219 #endif 1220 1221 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd) 1222 != STRING_SIZE_SIZE) 1223 return FALSE; 1224 1225 if (! _bfd_stringtab_emit (abfd, flaginfo.strtab)) 1226 return FALSE; 1227 1228 obj_coff_strings_written (abfd) = TRUE; 1229 } 1230 1231 _bfd_stringtab_free (flaginfo.strtab); 1232 1233 /* Setting bfd_get_symcount to 0 will cause write_object_contents to 1234 not try to write out the symbols. */ 1235 bfd_get_symcount (abfd) = 0; 1236 1237 return TRUE; 1238 1239 error_return: 1240 if (debug_merge_allocated) 1241 coff_debug_merge_hash_table_free (&flaginfo.debug_merge); 1242 if (flaginfo.strtab != NULL) 1243 _bfd_stringtab_free (flaginfo.strtab); 1244 if (flaginfo.section_info != NULL) 1245 { 1246 unsigned int i; 1247 1248 for (i = 0; i < abfd->section_count; i++) 1249 { 1250 if (flaginfo.section_info[i].relocs != NULL) 1251 free (flaginfo.section_info[i].relocs); 1252 if (flaginfo.section_info[i].rel_hashes != NULL) 1253 free (flaginfo.section_info[i].rel_hashes); 1254 } 1255 free (flaginfo.section_info); 1256 } 1257 if (flaginfo.internal_syms != NULL) 1258 free (flaginfo.internal_syms); 1259 if (flaginfo.sec_ptrs != NULL) 1260 free (flaginfo.sec_ptrs); 1261 if (flaginfo.sym_indices != NULL) 1262 free (flaginfo.sym_indices); 1263 if (flaginfo.outsyms != NULL) 1264 free (flaginfo.outsyms); 1265 if (flaginfo.linenos != NULL) 1266 free (flaginfo.linenos); 1267 if (flaginfo.contents != NULL) 1268 free (flaginfo.contents); 1269 if (flaginfo.external_relocs != NULL) 1270 free (flaginfo.external_relocs); 1271 if (flaginfo.internal_relocs != NULL) 1272 free (flaginfo.internal_relocs); 1273 if (external_relocs != NULL) 1274 free (external_relocs); 1275 return FALSE; 1276 } 1277 1278 /* Parse out a -heap <reserved>,<commit> line. */ 1279 1280 static char * 1281 dores_com (char *ptr, bfd *output_bfd, int heap) 1282 { 1283 if (coff_data(output_bfd)->pe) 1284 { 1285 int val = strtoul (ptr, &ptr, 0); 1286 1287 if (heap) 1288 pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val; 1289 else 1290 pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val; 1291 1292 if (ptr[0] == ',') 1293 { 1294 val = strtoul (ptr+1, &ptr, 0); 1295 if (heap) 1296 pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val; 1297 else 1298 pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val; 1299 } 1300 } 1301 return ptr; 1302 } 1303 1304 static char * 1305 get_name (char *ptr, char **dst) 1306 { 1307 while (*ptr == ' ') 1308 ptr++; 1309 *dst = ptr; 1310 while (*ptr && *ptr != ' ') 1311 ptr++; 1312 *ptr = 0; 1313 return ptr+1; 1314 } 1315 1316 /* Process any magic embedded commands in a section called .drectve. */ 1317 1318 static int 1319 process_embedded_commands (bfd *output_bfd, 1320 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1321 bfd *abfd) 1322 { 1323 asection *sec = bfd_get_section_by_name (abfd, ".drectve"); 1324 char *s; 1325 char *e; 1326 bfd_byte *copy; 1327 1328 if (!sec) 1329 return 1; 1330 1331 if (!bfd_malloc_and_get_section (abfd, sec, ©)) 1332 { 1333 if (copy != NULL) 1334 free (copy); 1335 return 0; 1336 } 1337 e = (char *) copy + sec->size; 1338 1339 for (s = (char *) copy; s < e ; ) 1340 { 1341 if (s[0] != '-') 1342 { 1343 s++; 1344 continue; 1345 } 1346 if (CONST_STRNEQ (s, "-attr")) 1347 { 1348 char *name; 1349 char *attribs; 1350 asection *asec; 1351 int loop = 1; 1352 int had_write = 0; 1353 int had_exec= 0; 1354 1355 s += 5; 1356 s = get_name (s, &name); 1357 s = get_name (s, &attribs); 1358 1359 while (loop) 1360 { 1361 switch (*attribs++) 1362 { 1363 case 'W': 1364 had_write = 1; 1365 break; 1366 case 'R': 1367 break; 1368 case 'S': 1369 break; 1370 case 'X': 1371 had_exec = 1; 1372 break; 1373 default: 1374 loop = 0; 1375 } 1376 } 1377 asec = bfd_get_section_by_name (abfd, name); 1378 if (asec) 1379 { 1380 if (had_exec) 1381 asec->flags |= SEC_CODE; 1382 if (!had_write) 1383 asec->flags |= SEC_READONLY; 1384 } 1385 } 1386 else if (CONST_STRNEQ (s, "-heap")) 1387 s = dores_com (s + 5, output_bfd, 1); 1388 1389 else if (CONST_STRNEQ (s, "-stack")) 1390 s = dores_com (s + 6, output_bfd, 0); 1391 1392 /* GNU extension for aligned commons. */ 1393 else if (CONST_STRNEQ (s, "-aligncomm:")) 1394 { 1395 /* Common symbols must be aligned on reading, as it 1396 is too late to do anything here, after they have 1397 already been allocated, so just skip the directive. */ 1398 s += 11; 1399 } 1400 1401 else 1402 s++; 1403 } 1404 free (copy); 1405 return 1; 1406 } 1407 1408 /* Place a marker against all symbols which are used by relocations. 1409 This marker can be picked up by the 'do we skip this symbol ?' 1410 loop in _bfd_coff_link_input_bfd() and used to prevent skipping 1411 that symbol. */ 1412 1413 static void 1414 mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd) 1415 { 1416 asection * a; 1417 1418 if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0) 1419 return; 1420 1421 for (a = input_bfd->sections; a != (asection *) NULL; a = a->next) 1422 { 1423 struct internal_reloc * internal_relocs; 1424 struct internal_reloc * irel; 1425 struct internal_reloc * irelend; 1426 1427 if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1 1428 || a->linker_mark == 0) 1429 continue; 1430 /* Don't mark relocs in excluded sections. */ 1431 if (a->output_section == bfd_abs_section_ptr) 1432 continue; 1433 1434 /* Read in the relocs. */ 1435 internal_relocs = _bfd_coff_read_internal_relocs 1436 (input_bfd, a, FALSE, 1437 flaginfo->external_relocs, 1438 flaginfo->info->relocatable, 1439 (flaginfo->info->relocatable 1440 ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count) 1441 : flaginfo->internal_relocs) 1442 ); 1443 1444 if (internal_relocs == NULL) 1445 continue; 1446 1447 irel = internal_relocs; 1448 irelend = irel + a->reloc_count; 1449 1450 /* Place a mark in the sym_indices array (whose entries have 1451 been initialised to 0) for all of the symbols that are used 1452 in the relocation table. This will then be picked up in the 1453 skip/don't-skip pass. */ 1454 for (; irel < irelend; irel++) 1455 flaginfo->sym_indices[ irel->r_symndx ] = -1; 1456 } 1457 } 1458 1459 /* Link an input file into the linker output file. This function 1460 handles all the sections and relocations of the input file at once. */ 1461 1462 bfd_boolean 1463 _bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd) 1464 { 1465 unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask; 1466 unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft; 1467 bfd_boolean (*adjust_symndx) 1468 (bfd *, struct bfd_link_info *, bfd *, asection *, 1469 struct internal_reloc *, bfd_boolean *); 1470 bfd *output_bfd; 1471 const char *strings; 1472 bfd_size_type syment_base; 1473 bfd_boolean copy, hash; 1474 bfd_size_type isymesz; 1475 bfd_size_type osymesz; 1476 bfd_size_type linesz; 1477 bfd_byte *esym; 1478 bfd_byte *esym_end; 1479 struct internal_syment *isymp; 1480 asection **secpp; 1481 long *indexp; 1482 unsigned long output_index; 1483 bfd_byte *outsym; 1484 struct coff_link_hash_entry **sym_hash; 1485 asection *o; 1486 1487 /* Move all the symbols to the output file. */ 1488 1489 output_bfd = flaginfo->output_bfd; 1490 strings = NULL; 1491 syment_base = obj_raw_syment_count (output_bfd); 1492 isymesz = bfd_coff_symesz (input_bfd); 1493 osymesz = bfd_coff_symesz (output_bfd); 1494 linesz = bfd_coff_linesz (input_bfd); 1495 BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd)); 1496 1497 copy = FALSE; 1498 if (! flaginfo->info->keep_memory) 1499 copy = TRUE; 1500 hash = TRUE; 1501 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0) 1502 hash = FALSE; 1503 1504 if (! _bfd_coff_get_external_symbols (input_bfd)) 1505 return FALSE; 1506 1507 esym = (bfd_byte *) obj_coff_external_syms (input_bfd); 1508 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; 1509 isymp = flaginfo->internal_syms; 1510 secpp = flaginfo->sec_ptrs; 1511 indexp = flaginfo->sym_indices; 1512 output_index = syment_base; 1513 outsym = flaginfo->outsyms; 1514 1515 if (coff_data (output_bfd)->pe 1516 && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd)) 1517 return FALSE; 1518 1519 /* If we are going to perform relocations and also strip/discard some 1520 symbols then we must make sure that we do not strip/discard those 1521 symbols that are going to be involved in the relocations. */ 1522 if (( flaginfo->info->strip != strip_none 1523 || flaginfo->info->discard != discard_none) 1524 && flaginfo->info->relocatable) 1525 { 1526 /* Mark the symbol array as 'not-used'. */ 1527 memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp); 1528 1529 mark_relocs (flaginfo, input_bfd); 1530 } 1531 1532 while (esym < esym_end) 1533 { 1534 struct internal_syment isym; 1535 enum coff_symbol_classification classification; 1536 bfd_boolean skip; 1537 bfd_boolean global; 1538 bfd_boolean dont_skip_symbol; 1539 int add; 1540 1541 bfd_coff_swap_sym_in (input_bfd, esym, isymp); 1542 1543 /* Make a copy of *isymp so that the relocate_section function 1544 always sees the original values. This is more reliable than 1545 always recomputing the symbol value even if we are stripping 1546 the symbol. */ 1547 isym = *isymp; 1548 1549 classification = bfd_coff_classify_symbol (input_bfd, &isym); 1550 switch (classification) 1551 { 1552 default: 1553 abort (); 1554 case COFF_SYMBOL_GLOBAL: 1555 case COFF_SYMBOL_PE_SECTION: 1556 case COFF_SYMBOL_LOCAL: 1557 *secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum); 1558 break; 1559 case COFF_SYMBOL_COMMON: 1560 *secpp = bfd_com_section_ptr; 1561 break; 1562 case COFF_SYMBOL_UNDEFINED: 1563 *secpp = bfd_und_section_ptr; 1564 break; 1565 } 1566 1567 /* Extract the flag indicating if this symbol is used by a 1568 relocation. */ 1569 if ((flaginfo->info->strip != strip_none 1570 || flaginfo->info->discard != discard_none) 1571 && flaginfo->info->relocatable) 1572 dont_skip_symbol = *indexp; 1573 else 1574 dont_skip_symbol = FALSE; 1575 1576 *indexp = -1; 1577 1578 skip = FALSE; 1579 global = FALSE; 1580 add = 1 + isym.n_numaux; 1581 1582 /* If we are stripping all symbols, we want to skip this one. */ 1583 if (flaginfo->info->strip == strip_all && ! dont_skip_symbol) 1584 skip = TRUE; 1585 1586 if (! skip) 1587 { 1588 switch (classification) 1589 { 1590 default: 1591 abort (); 1592 case COFF_SYMBOL_GLOBAL: 1593 case COFF_SYMBOL_COMMON: 1594 case COFF_SYMBOL_PE_SECTION: 1595 /* This is a global symbol. Global symbols come at the 1596 end of the symbol table, so skip them for now. 1597 Locally defined function symbols, however, are an 1598 exception, and are not moved to the end. */ 1599 global = TRUE; 1600 if (! ISFCN (isym.n_type)) 1601 skip = TRUE; 1602 break; 1603 1604 case COFF_SYMBOL_UNDEFINED: 1605 /* Undefined symbols are left for the end. */ 1606 global = TRUE; 1607 skip = TRUE; 1608 break; 1609 1610 case COFF_SYMBOL_LOCAL: 1611 /* This is a local symbol. Skip it if we are discarding 1612 local symbols. */ 1613 if (flaginfo->info->discard == discard_all && ! dont_skip_symbol) 1614 skip = TRUE; 1615 break; 1616 } 1617 } 1618 1619 #ifndef COFF_WITH_PE 1620 /* Skip section symbols for sections which are not going to be 1621 emitted. */ 1622 if (!skip 1623 && !dont_skip_symbol 1624 && isym.n_sclass == C_STAT 1625 && isym.n_type == T_NULL 1626 && isym.n_numaux > 0 1627 && ((*secpp)->output_section == bfd_abs_section_ptr 1628 || bfd_section_removed_from_list (output_bfd, 1629 (*secpp)->output_section))) 1630 skip = TRUE; 1631 #endif 1632 1633 /* If we stripping debugging symbols, and this is a debugging 1634 symbol, then skip it. FIXME: gas sets the section to N_ABS 1635 for some types of debugging symbols; I don't know if this is 1636 a bug or not. In any case, we handle it here. */ 1637 if (! skip 1638 && flaginfo->info->strip == strip_debugger 1639 && ! dont_skip_symbol 1640 && (isym.n_scnum == N_DEBUG 1641 || (isym.n_scnum == N_ABS 1642 && (isym.n_sclass == C_AUTO 1643 || isym.n_sclass == C_REG 1644 || isym.n_sclass == C_MOS 1645 || isym.n_sclass == C_MOE 1646 || isym.n_sclass == C_MOU 1647 || isym.n_sclass == C_ARG 1648 || isym.n_sclass == C_REGPARM 1649 || isym.n_sclass == C_FIELD 1650 || isym.n_sclass == C_EOS)))) 1651 skip = TRUE; 1652 1653 /* If some symbols are stripped based on the name, work out the 1654 name and decide whether to skip this symbol. */ 1655 if (! skip 1656 && (flaginfo->info->strip == strip_some 1657 || flaginfo->info->discard == discard_l)) 1658 { 1659 const char *name; 1660 char buf[SYMNMLEN + 1]; 1661 1662 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf); 1663 if (name == NULL) 1664 return FALSE; 1665 1666 if (! dont_skip_symbol 1667 && ((flaginfo->info->strip == strip_some 1668 && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, 1669 FALSE) == NULL)) 1670 || (! global 1671 && flaginfo->info->discard == discard_l 1672 && bfd_is_local_label_name (input_bfd, name)))) 1673 skip = TRUE; 1674 } 1675 1676 /* If this is an enum, struct, or union tag, see if we have 1677 already output an identical type. */ 1678 if (! skip 1679 && (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0 1680 && (isym.n_sclass == C_ENTAG 1681 || isym.n_sclass == C_STRTAG 1682 || isym.n_sclass == C_UNTAG) 1683 && isym.n_numaux == 1) 1684 { 1685 const char *name; 1686 char buf[SYMNMLEN + 1]; 1687 struct coff_debug_merge_hash_entry *mh; 1688 struct coff_debug_merge_type *mt; 1689 union internal_auxent aux; 1690 struct coff_debug_merge_element **epp; 1691 bfd_byte *esl, *eslend; 1692 struct internal_syment *islp; 1693 bfd_size_type amt; 1694 1695 name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf); 1696 if (name == NULL) 1697 return FALSE; 1698 1699 /* Ignore fake names invented by compiler; treat them all as 1700 the same name. */ 1701 if (*name == '~' || *name == '.' || *name == '$' 1702 || (*name == bfd_get_symbol_leading_char (input_bfd) 1703 && (name[1] == '~' || name[1] == '.' || name[1] == '$'))) 1704 name = ""; 1705 1706 mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name, 1707 TRUE, TRUE); 1708 if (mh == NULL) 1709 return FALSE; 1710 1711 /* Allocate memory to hold type information. If this turns 1712 out to be a duplicate, we pass this address to 1713 bfd_release. */ 1714 amt = sizeof (struct coff_debug_merge_type); 1715 mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt); 1716 if (mt == NULL) 1717 return FALSE; 1718 mt->type_class = isym.n_sclass; 1719 1720 /* Pick up the aux entry, which points to the end of the tag 1721 entries. */ 1722 bfd_coff_swap_aux_in (input_bfd, (esym + isymesz), 1723 isym.n_type, isym.n_sclass, 0, isym.n_numaux, 1724 &aux); 1725 1726 /* Gather the elements. */ 1727 epp = &mt->elements; 1728 mt->elements = NULL; 1729 islp = isymp + 2; 1730 esl = esym + 2 * isymesz; 1731 eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd) 1732 + aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz); 1733 while (esl < eslend) 1734 { 1735 const char *elename; 1736 char elebuf[SYMNMLEN + 1]; 1737 char *name_copy; 1738 1739 bfd_coff_swap_sym_in (input_bfd, esl, islp); 1740 1741 amt = sizeof (struct coff_debug_merge_element); 1742 *epp = (struct coff_debug_merge_element *) 1743 bfd_alloc (input_bfd, amt); 1744 if (*epp == NULL) 1745 return FALSE; 1746 1747 elename = _bfd_coff_internal_syment_name (input_bfd, islp, 1748 elebuf); 1749 if (elename == NULL) 1750 return FALSE; 1751 1752 amt = strlen (elename) + 1; 1753 name_copy = (char *) bfd_alloc (input_bfd, amt); 1754 if (name_copy == NULL) 1755 return FALSE; 1756 strcpy (name_copy, elename); 1757 1758 (*epp)->name = name_copy; 1759 (*epp)->type = islp->n_type; 1760 (*epp)->tagndx = 0; 1761 if (islp->n_numaux >= 1 1762 && islp->n_type != T_NULL 1763 && islp->n_sclass != C_EOS) 1764 { 1765 union internal_auxent eleaux; 1766 long indx; 1767 1768 bfd_coff_swap_aux_in (input_bfd, (esl + isymesz), 1769 islp->n_type, islp->n_sclass, 0, 1770 islp->n_numaux, &eleaux); 1771 indx = eleaux.x_sym.x_tagndx.l; 1772 1773 /* FIXME: If this tagndx entry refers to a symbol 1774 defined later in this file, we just ignore it. 1775 Handling this correctly would be tedious, and may 1776 not be required. */ 1777 if (indx > 0 1778 && (indx 1779 < ((esym - 1780 (bfd_byte *) obj_coff_external_syms (input_bfd)) 1781 / (long) isymesz))) 1782 { 1783 (*epp)->tagndx = flaginfo->sym_indices[indx]; 1784 if ((*epp)->tagndx < 0) 1785 (*epp)->tagndx = 0; 1786 } 1787 } 1788 epp = &(*epp)->next; 1789 *epp = NULL; 1790 1791 esl += (islp->n_numaux + 1) * isymesz; 1792 islp += islp->n_numaux + 1; 1793 } 1794 1795 /* See if we already have a definition which matches this 1796 type. We always output the type if it has no elements, 1797 for simplicity. */ 1798 if (mt->elements == NULL) 1799 bfd_release (input_bfd, mt); 1800 else 1801 { 1802 struct coff_debug_merge_type *mtl; 1803 1804 for (mtl = mh->types; mtl != NULL; mtl = mtl->next) 1805 { 1806 struct coff_debug_merge_element *me, *mel; 1807 1808 if (mtl->type_class != mt->type_class) 1809 continue; 1810 1811 for (me = mt->elements, mel = mtl->elements; 1812 me != NULL && mel != NULL; 1813 me = me->next, mel = mel->next) 1814 { 1815 if (strcmp (me->name, mel->name) != 0 1816 || me->type != mel->type 1817 || me->tagndx != mel->tagndx) 1818 break; 1819 } 1820 1821 if (me == NULL && mel == NULL) 1822 break; 1823 } 1824 1825 if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base) 1826 { 1827 /* This is the first definition of this type. */ 1828 mt->indx = output_index; 1829 mt->next = mh->types; 1830 mh->types = mt; 1831 } 1832 else 1833 { 1834 /* This is a redefinition which can be merged. */ 1835 bfd_release (input_bfd, mt); 1836 *indexp = mtl->indx; 1837 add = (eslend - esym) / isymesz; 1838 skip = TRUE; 1839 } 1840 } 1841 } 1842 1843 /* We now know whether we are to skip this symbol or not. */ 1844 if (! skip) 1845 { 1846 /* Adjust the symbol in order to output it. */ 1847 1848 if (isym._n._n_n._n_zeroes == 0 1849 && isym._n._n_n._n_offset != 0) 1850 { 1851 const char *name; 1852 bfd_size_type indx; 1853 1854 /* This symbol has a long name. Enter it in the string 1855 table we are building. Note that we do not check 1856 bfd_coff_symname_in_debug. That is only true for 1857 XCOFF, and XCOFF requires different linking code 1858 anyhow. */ 1859 name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL); 1860 if (name == NULL) 1861 return FALSE; 1862 indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy); 1863 if (indx == (bfd_size_type) -1) 1864 return FALSE; 1865 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; 1866 } 1867 1868 switch (isym.n_sclass) 1869 { 1870 case C_AUTO: 1871 case C_MOS: 1872 case C_EOS: 1873 case C_MOE: 1874 case C_MOU: 1875 case C_UNTAG: 1876 case C_STRTAG: 1877 case C_ENTAG: 1878 case C_TPDEF: 1879 case C_ARG: 1880 case C_USTATIC: 1881 case C_REG: 1882 case C_REGPARM: 1883 case C_FIELD: 1884 /* The symbol value should not be modified. */ 1885 break; 1886 1887 case C_FCN: 1888 if (obj_pe (input_bfd) 1889 && strcmp (isym.n_name, ".bf") != 0 1890 && isym.n_scnum > 0) 1891 { 1892 /* For PE, .lf and .ef get their value left alone, 1893 while .bf gets relocated. However, they all have 1894 "real" section numbers, and need to be moved into 1895 the new section. */ 1896 isym.n_scnum = (*secpp)->output_section->target_index; 1897 break; 1898 } 1899 /* Fall through. */ 1900 default: 1901 case C_LABEL: /* Not completely sure about these 2 */ 1902 case C_EXTDEF: 1903 case C_BLOCK: 1904 case C_EFCN: 1905 case C_NULL: 1906 case C_EXT: 1907 case C_STAT: 1908 case C_SECTION: 1909 case C_NT_WEAK: 1910 /* Compute new symbol location. */ 1911 if (isym.n_scnum > 0) 1912 { 1913 isym.n_scnum = (*secpp)->output_section->target_index; 1914 isym.n_value += (*secpp)->output_offset; 1915 if (! obj_pe (input_bfd)) 1916 isym.n_value -= (*secpp)->vma; 1917 if (! obj_pe (flaginfo->output_bfd)) 1918 isym.n_value += (*secpp)->output_section->vma; 1919 } 1920 break; 1921 1922 case C_FILE: 1923 /* The value of a C_FILE symbol is the symbol index of 1924 the next C_FILE symbol. The value of the last C_FILE 1925 symbol is the symbol index to the first external 1926 symbol (actually, coff_renumber_symbols does not get 1927 this right--it just sets the value of the last C_FILE 1928 symbol to zero--and nobody has ever complained about 1929 it). We try to get this right, below, just before we 1930 write the symbols out, but in the general case we may 1931 have to write the symbol out twice. */ 1932 if (flaginfo->last_file_index != -1 1933 && flaginfo->last_file.n_value != (bfd_vma) output_index) 1934 { 1935 /* We must correct the value of the last C_FILE 1936 entry. */ 1937 flaginfo->last_file.n_value = output_index; 1938 if ((bfd_size_type) flaginfo->last_file_index >= syment_base) 1939 { 1940 /* The last C_FILE symbol is in this input file. */ 1941 bfd_coff_swap_sym_out (output_bfd, 1942 &flaginfo->last_file, 1943 (flaginfo->outsyms 1944 + ((flaginfo->last_file_index 1945 - syment_base) 1946 * osymesz))); 1947 } 1948 else 1949 { 1950 file_ptr pos; 1951 1952 /* We have already written out the last C_FILE 1953 symbol. We need to write it out again. We 1954 borrow *outsym temporarily. */ 1955 bfd_coff_swap_sym_out (output_bfd, 1956 &flaginfo->last_file, outsym); 1957 pos = obj_sym_filepos (output_bfd); 1958 pos += flaginfo->last_file_index * osymesz; 1959 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 1960 || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz) 1961 return FALSE; 1962 } 1963 } 1964 1965 flaginfo->last_file_index = output_index; 1966 flaginfo->last_file = isym; 1967 break; 1968 } 1969 1970 /* If doing task linking, convert normal global function symbols to 1971 static functions. */ 1972 if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym)) 1973 isym.n_sclass = C_STAT; 1974 1975 /* Output the symbol. */ 1976 bfd_coff_swap_sym_out (output_bfd, &isym, outsym); 1977 1978 *indexp = output_index; 1979 1980 if (global) 1981 { 1982 long indx; 1983 struct coff_link_hash_entry *h; 1984 1985 indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd)) 1986 / isymesz); 1987 h = obj_coff_sym_hashes (input_bfd)[indx]; 1988 if (h == NULL) 1989 { 1990 /* This can happen if there were errors earlier in 1991 the link. */ 1992 bfd_set_error (bfd_error_bad_value); 1993 return FALSE; 1994 } 1995 h->indx = output_index; 1996 } 1997 1998 output_index += add; 1999 outsym += add * osymesz; 2000 } 2001 2002 esym += add * isymesz; 2003 isymp += add; 2004 ++secpp; 2005 ++indexp; 2006 for (--add; add > 0; --add) 2007 { 2008 *secpp++ = NULL; 2009 *indexp++ = -1; 2010 } 2011 } 2012 2013 /* Fix up the aux entries. This must be done in a separate pass, 2014 because we don't know the correct symbol indices until we have 2015 already decided which symbols we are going to keep. */ 2016 esym = (bfd_byte *) obj_coff_external_syms (input_bfd); 2017 esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; 2018 isymp = flaginfo->internal_syms; 2019 indexp = flaginfo->sym_indices; 2020 sym_hash = obj_coff_sym_hashes (input_bfd); 2021 outsym = flaginfo->outsyms; 2022 2023 while (esym < esym_end) 2024 { 2025 int add; 2026 2027 add = 1 + isymp->n_numaux; 2028 2029 if ((*indexp < 0 2030 || (bfd_size_type) *indexp < syment_base) 2031 && (*sym_hash == NULL 2032 || (*sym_hash)->auxbfd != input_bfd)) 2033 esym += add * isymesz; 2034 else 2035 { 2036 struct coff_link_hash_entry *h; 2037 int i; 2038 2039 h = NULL; 2040 if (*indexp < 0) 2041 { 2042 h = *sym_hash; 2043 2044 /* The m68k-motorola-sysv assembler will sometimes 2045 generate two symbols with the same name, but only one 2046 will have aux entries. */ 2047 BFD_ASSERT (isymp->n_numaux == 0 2048 || h->numaux == 0 2049 || h->numaux == isymp->n_numaux); 2050 } 2051 2052 esym += isymesz; 2053 2054 if (h == NULL) 2055 outsym += osymesz; 2056 2057 /* Handle the aux entries. This handling is based on 2058 coff_pointerize_aux. I don't know if it always correct. */ 2059 for (i = 0; i < isymp->n_numaux && esym < esym_end; i++) 2060 { 2061 union internal_auxent aux; 2062 union internal_auxent *auxp; 2063 2064 if (h != NULL && h->aux != NULL && (h->numaux > i)) 2065 auxp = h->aux + i; 2066 else 2067 { 2068 bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type, 2069 isymp->n_sclass, i, isymp->n_numaux, &aux); 2070 auxp = &aux; 2071 } 2072 2073 if (isymp->n_sclass == C_FILE) 2074 { 2075 /* If this is a long filename, we must put it in the 2076 string table. */ 2077 if (auxp->x_file.x_n.x_zeroes == 0 2078 && auxp->x_file.x_n.x_offset != 0) 2079 { 2080 const char *filename; 2081 bfd_size_type indx; 2082 2083 BFD_ASSERT (auxp->x_file.x_n.x_offset 2084 >= STRING_SIZE_SIZE); 2085 if (strings == NULL) 2086 { 2087 strings = _bfd_coff_read_string_table (input_bfd); 2088 if (strings == NULL) 2089 return FALSE; 2090 } 2091 filename = strings + auxp->x_file.x_n.x_offset; 2092 indx = _bfd_stringtab_add (flaginfo->strtab, filename, 2093 hash, copy); 2094 if (indx == (bfd_size_type) -1) 2095 return FALSE; 2096 auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx; 2097 } 2098 } 2099 else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL) 2100 && isymp->n_sclass != C_NT_WEAK) 2101 { 2102 unsigned long indx; 2103 2104 if (ISFCN (isymp->n_type) 2105 || ISTAG (isymp->n_sclass) 2106 || isymp->n_sclass == C_BLOCK 2107 || isymp->n_sclass == C_FCN) 2108 { 2109 indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l; 2110 if (indx > 0 2111 && indx < obj_raw_syment_count (input_bfd)) 2112 { 2113 /* We look forward through the symbol for 2114 the index of the next symbol we are going 2115 to include. I don't know if this is 2116 entirely right. */ 2117 while ((flaginfo->sym_indices[indx] < 0 2118 || ((bfd_size_type) flaginfo->sym_indices[indx] 2119 < syment_base)) 2120 && indx < obj_raw_syment_count (input_bfd)) 2121 ++indx; 2122 if (indx >= obj_raw_syment_count (input_bfd)) 2123 indx = output_index; 2124 else 2125 indx = flaginfo->sym_indices[indx]; 2126 auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx; 2127 } 2128 } 2129 2130 indx = auxp->x_sym.x_tagndx.l; 2131 if (indx > 0 && indx < obj_raw_syment_count (input_bfd)) 2132 { 2133 long symindx; 2134 2135 symindx = flaginfo->sym_indices[indx]; 2136 if (symindx < 0) 2137 auxp->x_sym.x_tagndx.l = 0; 2138 else 2139 auxp->x_sym.x_tagndx.l = symindx; 2140 } 2141 2142 /* The .bf symbols are supposed to be linked through 2143 the endndx field. We need to carry this list 2144 across object files. */ 2145 if (i == 0 2146 && h == NULL 2147 && isymp->n_sclass == C_FCN 2148 && (isymp->_n._n_n._n_zeroes != 0 2149 || isymp->_n._n_n._n_offset == 0) 2150 && isymp->_n._n_name[0] == '.' 2151 && isymp->_n._n_name[1] == 'b' 2152 && isymp->_n._n_name[2] == 'f' 2153 && isymp->_n._n_name[3] == '\0') 2154 { 2155 if (flaginfo->last_bf_index != -1) 2156 { 2157 flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l = 2158 *indexp; 2159 2160 if ((bfd_size_type) flaginfo->last_bf_index 2161 >= syment_base) 2162 { 2163 void *auxout; 2164 2165 /* The last .bf symbol is in this input 2166 file. This will only happen if the 2167 assembler did not set up the .bf 2168 endndx symbols correctly. */ 2169 auxout = (flaginfo->outsyms 2170 + ((flaginfo->last_bf_index 2171 - syment_base) 2172 * osymesz)); 2173 2174 bfd_coff_swap_aux_out (output_bfd, 2175 &flaginfo->last_bf, 2176 isymp->n_type, 2177 isymp->n_sclass, 2178 0, isymp->n_numaux, 2179 auxout); 2180 } 2181 else 2182 { 2183 file_ptr pos; 2184 2185 /* We have already written out the last 2186 .bf aux entry. We need to write it 2187 out again. We borrow *outsym 2188 temporarily. FIXME: This case should 2189 be made faster. */ 2190 bfd_coff_swap_aux_out (output_bfd, 2191 &flaginfo->last_bf, 2192 isymp->n_type, 2193 isymp->n_sclass, 2194 0, isymp->n_numaux, 2195 outsym); 2196 pos = obj_sym_filepos (output_bfd); 2197 pos += flaginfo->last_bf_index * osymesz; 2198 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 2199 || (bfd_bwrite (outsym, osymesz, output_bfd) 2200 != osymesz)) 2201 return FALSE; 2202 } 2203 } 2204 2205 if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0) 2206 flaginfo->last_bf_index = -1; 2207 else 2208 { 2209 /* The endndx field of this aux entry must 2210 be updated with the symbol number of the 2211 next .bf symbol. */ 2212 flaginfo->last_bf = *auxp; 2213 flaginfo->last_bf_index = (((outsym - flaginfo->outsyms) 2214 / osymesz) 2215 + syment_base); 2216 } 2217 } 2218 } 2219 2220 if (h == NULL) 2221 { 2222 bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type, 2223 isymp->n_sclass, i, isymp->n_numaux, 2224 outsym); 2225 outsym += osymesz; 2226 } 2227 2228 esym += isymesz; 2229 } 2230 } 2231 2232 indexp += add; 2233 isymp += add; 2234 sym_hash += add; 2235 } 2236 2237 /* Relocate the line numbers, unless we are stripping them. */ 2238 if (flaginfo->info->strip == strip_none 2239 || flaginfo->info->strip == strip_some) 2240 { 2241 for (o = input_bfd->sections; o != NULL; o = o->next) 2242 { 2243 bfd_vma offset; 2244 bfd_byte *eline; 2245 bfd_byte *elineend; 2246 bfd_byte *oeline; 2247 bfd_boolean skipping; 2248 file_ptr pos; 2249 bfd_size_type amt; 2250 2251 /* FIXME: If SEC_HAS_CONTENTS is not for the section, then 2252 build_link_order in ldwrite.c will not have created a 2253 link order, which means that we will not have seen this 2254 input section in _bfd_coff_final_link, which means that 2255 we will not have allocated space for the line numbers of 2256 this section. I don't think line numbers can be 2257 meaningful for a section which does not have 2258 SEC_HAS_CONTENTS set, but, if they do, this must be 2259 changed. */ 2260 if (o->lineno_count == 0 2261 || (o->output_section->flags & SEC_HAS_CONTENTS) == 0) 2262 continue; 2263 2264 if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0 2265 || bfd_bread (flaginfo->linenos, linesz * o->lineno_count, 2266 input_bfd) != linesz * o->lineno_count) 2267 return FALSE; 2268 2269 offset = o->output_section->vma + o->output_offset - o->vma; 2270 eline = flaginfo->linenos; 2271 oeline = flaginfo->linenos; 2272 elineend = eline + linesz * o->lineno_count; 2273 skipping = FALSE; 2274 for (; eline < elineend; eline += linesz) 2275 { 2276 struct internal_lineno iline; 2277 2278 bfd_coff_swap_lineno_in (input_bfd, eline, &iline); 2279 2280 if (iline.l_lnno != 0) 2281 iline.l_addr.l_paddr += offset; 2282 else if (iline.l_addr.l_symndx >= 0 2283 && ((unsigned long) iline.l_addr.l_symndx 2284 < obj_raw_syment_count (input_bfd))) 2285 { 2286 long indx; 2287 2288 indx = flaginfo->sym_indices[iline.l_addr.l_symndx]; 2289 2290 if (indx < 0) 2291 { 2292 /* These line numbers are attached to a symbol 2293 which we are stripping. We must discard the 2294 line numbers because reading them back with 2295 no associated symbol (or associating them all 2296 with symbol #0) will fail. We can't regain 2297 the space in the output file, but at least 2298 they're dense. */ 2299 skipping = TRUE; 2300 } 2301 else 2302 { 2303 struct internal_syment is; 2304 union internal_auxent ia; 2305 2306 /* Fix up the lnnoptr field in the aux entry of 2307 the symbol. It turns out that we can't do 2308 this when we modify the symbol aux entries, 2309 because gas sometimes screws up the lnnoptr 2310 field and makes it an offset from the start 2311 of the line numbers rather than an absolute 2312 file index. */ 2313 bfd_coff_swap_sym_in (output_bfd, 2314 (flaginfo->outsyms 2315 + ((indx - syment_base) 2316 * osymesz)), &is); 2317 if ((ISFCN (is.n_type) 2318 || is.n_sclass == C_BLOCK) 2319 && is.n_numaux >= 1) 2320 { 2321 void *auxptr; 2322 2323 auxptr = (flaginfo->outsyms 2324 + ((indx - syment_base + 1) 2325 * osymesz)); 2326 bfd_coff_swap_aux_in (output_bfd, auxptr, 2327 is.n_type, is.n_sclass, 2328 0, is.n_numaux, &ia); 2329 ia.x_sym.x_fcnary.x_fcn.x_lnnoptr = 2330 (o->output_section->line_filepos 2331 + o->output_section->lineno_count * linesz 2332 + eline - flaginfo->linenos); 2333 bfd_coff_swap_aux_out (output_bfd, &ia, 2334 is.n_type, is.n_sclass, 0, 2335 is.n_numaux, auxptr); 2336 } 2337 2338 skipping = FALSE; 2339 } 2340 2341 iline.l_addr.l_symndx = indx; 2342 } 2343 2344 if (!skipping) 2345 { 2346 bfd_coff_swap_lineno_out (output_bfd, &iline, oeline); 2347 oeline += linesz; 2348 } 2349 } 2350 2351 pos = o->output_section->line_filepos; 2352 pos += o->output_section->lineno_count * linesz; 2353 amt = oeline - flaginfo->linenos; 2354 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 2355 || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt) 2356 return FALSE; 2357 2358 o->output_section->lineno_count += amt / linesz; 2359 } 2360 } 2361 2362 /* If we swapped out a C_FILE symbol, guess that the next C_FILE 2363 symbol will be the first symbol in the next input file. In the 2364 normal case, this will save us from writing out the C_FILE symbol 2365 again. */ 2366 if (flaginfo->last_file_index != -1 2367 && (bfd_size_type) flaginfo->last_file_index >= syment_base) 2368 { 2369 flaginfo->last_file.n_value = output_index; 2370 bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file, 2371 (flaginfo->outsyms 2372 + ((flaginfo->last_file_index - syment_base) 2373 * osymesz))); 2374 } 2375 2376 /* Write the modified symbols to the output file. */ 2377 if (outsym > flaginfo->outsyms) 2378 { 2379 file_ptr pos; 2380 bfd_size_type amt; 2381 2382 pos = obj_sym_filepos (output_bfd) + syment_base * osymesz; 2383 amt = outsym - flaginfo->outsyms; 2384 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 2385 || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt) 2386 return FALSE; 2387 2388 BFD_ASSERT ((obj_raw_syment_count (output_bfd) 2389 + (outsym - flaginfo->outsyms) / osymesz) 2390 == output_index); 2391 2392 obj_raw_syment_count (output_bfd) = output_index; 2393 } 2394 2395 /* Relocate the contents of each section. */ 2396 adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx; 2397 for (o = input_bfd->sections; o != NULL; o = o->next) 2398 { 2399 bfd_byte *contents; 2400 struct coff_section_tdata *secdata; 2401 2402 if (! o->linker_mark) 2403 /* This section was omitted from the link. */ 2404 continue; 2405 2406 if ((o->flags & SEC_LINKER_CREATED) != 0) 2407 continue; 2408 2409 if ((o->flags & SEC_HAS_CONTENTS) == 0 2410 || (o->size == 0 && (o->flags & SEC_RELOC) == 0)) 2411 { 2412 if ((o->flags & SEC_RELOC) != 0 2413 && o->reloc_count != 0) 2414 { 2415 (*_bfd_error_handler) 2416 (_("%B: relocs in section `%A', but it has no contents"), 2417 input_bfd, o); 2418 bfd_set_error (bfd_error_no_contents); 2419 return FALSE; 2420 } 2421 2422 continue; 2423 } 2424 2425 secdata = coff_section_data (input_bfd, o); 2426 if (secdata != NULL && secdata->contents != NULL) 2427 contents = secdata->contents; 2428 else 2429 { 2430 contents = flaginfo->contents; 2431 if (! bfd_get_full_section_contents (input_bfd, o, &contents)) 2432 return FALSE; 2433 } 2434 2435 if ((o->flags & SEC_RELOC) != 0) 2436 { 2437 int target_index; 2438 struct internal_reloc *internal_relocs; 2439 struct internal_reloc *irel; 2440 2441 /* Read in the relocs. */ 2442 target_index = o->output_section->target_index; 2443 internal_relocs = (_bfd_coff_read_internal_relocs 2444 (input_bfd, o, FALSE, flaginfo->external_relocs, 2445 flaginfo->info->relocatable, 2446 (flaginfo->info->relocatable 2447 ? (flaginfo->section_info[target_index].relocs 2448 + o->output_section->reloc_count) 2449 : flaginfo->internal_relocs))); 2450 if (internal_relocs == NULL 2451 && o->reloc_count > 0) 2452 return FALSE; 2453 2454 /* Run through the relocs looking for relocs against symbols 2455 coming from discarded sections and complain about them. */ 2456 irel = internal_relocs; 2457 for (; irel < &internal_relocs[o->reloc_count]; irel++) 2458 { 2459 struct coff_link_hash_entry *h; 2460 asection *ps = NULL; 2461 long symndx = irel->r_symndx; 2462 if (symndx < 0) 2463 continue; 2464 h = obj_coff_sym_hashes (input_bfd)[symndx]; 2465 if (h == NULL) 2466 continue; 2467 while (h->root.type == bfd_link_hash_indirect 2468 || h->root.type == bfd_link_hash_warning) 2469 h = (struct coff_link_hash_entry *) h->root.u.i.link; 2470 if (h->root.type == bfd_link_hash_defined 2471 || h->root.type == bfd_link_hash_defweak) 2472 ps = h->root.u.def.section; 2473 if (ps == NULL) 2474 continue; 2475 /* Complain if definition comes from an excluded section. */ 2476 if (ps->flags & SEC_EXCLUDE) 2477 (*flaginfo->info->callbacks->einfo) 2478 (_("%X`%s' referenced in section `%A' of %B: " 2479 "defined in discarded section `%A' of %B\n"), 2480 h->root.root.string, o, input_bfd, ps, ps->owner); 2481 } 2482 2483 /* Call processor specific code to relocate the section 2484 contents. */ 2485 if (! bfd_coff_relocate_section (output_bfd, flaginfo->info, 2486 input_bfd, o, 2487 contents, 2488 internal_relocs, 2489 flaginfo->internal_syms, 2490 flaginfo->sec_ptrs)) 2491 return FALSE; 2492 2493 if (flaginfo->info->relocatable) 2494 { 2495 bfd_vma offset; 2496 struct internal_reloc *irelend; 2497 struct coff_link_hash_entry **rel_hash; 2498 2499 offset = o->output_section->vma + o->output_offset - o->vma; 2500 irel = internal_relocs; 2501 irelend = irel + o->reloc_count; 2502 rel_hash = (flaginfo->section_info[target_index].rel_hashes 2503 + o->output_section->reloc_count); 2504 for (; irel < irelend; irel++, rel_hash++) 2505 { 2506 struct coff_link_hash_entry *h; 2507 bfd_boolean adjusted; 2508 2509 *rel_hash = NULL; 2510 2511 /* Adjust the reloc address and symbol index. */ 2512 irel->r_vaddr += offset; 2513 2514 if (irel->r_symndx == -1) 2515 continue; 2516 2517 if (adjust_symndx) 2518 { 2519 if (! (*adjust_symndx) (output_bfd, flaginfo->info, 2520 input_bfd, o, irel, 2521 &adjusted)) 2522 return FALSE; 2523 if (adjusted) 2524 continue; 2525 } 2526 2527 h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx]; 2528 if (h != NULL) 2529 { 2530 /* This is a global symbol. */ 2531 if (h->indx >= 0) 2532 irel->r_symndx = h->indx; 2533 else 2534 { 2535 /* This symbol is being written at the end 2536 of the file, and we do not yet know the 2537 symbol index. We save the pointer to the 2538 hash table entry in the rel_hash list. 2539 We set the indx field to -2 to indicate 2540 that this symbol must not be stripped. */ 2541 *rel_hash = h; 2542 h->indx = -2; 2543 } 2544 } 2545 else 2546 { 2547 long indx; 2548 2549 indx = flaginfo->sym_indices[irel->r_symndx]; 2550 if (indx != -1) 2551 irel->r_symndx = indx; 2552 else 2553 { 2554 struct internal_syment *is; 2555 const char *name; 2556 char buf[SYMNMLEN + 1]; 2557 2558 /* This reloc is against a symbol we are 2559 stripping. This should have been handled 2560 by the 'dont_skip_symbol' code in the while 2561 loop at the top of this function. */ 2562 is = flaginfo->internal_syms + irel->r_symndx; 2563 2564 name = (_bfd_coff_internal_syment_name 2565 (input_bfd, is, buf)); 2566 if (name == NULL) 2567 return FALSE; 2568 2569 if (! ((*flaginfo->info->callbacks->unattached_reloc) 2570 (flaginfo->info, name, input_bfd, o, 2571 irel->r_vaddr))) 2572 return FALSE; 2573 } 2574 } 2575 } 2576 2577 o->output_section->reloc_count += o->reloc_count; 2578 } 2579 } 2580 2581 /* Write out the modified section contents. */ 2582 if (secdata == NULL || secdata->stab_info == NULL) 2583 { 2584 file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd); 2585 if (! bfd_set_section_contents (output_bfd, o->output_section, 2586 contents, loc, o->size)) 2587 return FALSE; 2588 } 2589 else 2590 { 2591 if (! (_bfd_write_section_stabs 2592 (output_bfd, &coff_hash_table (flaginfo->info)->stab_info, 2593 o, &secdata->stab_info, contents))) 2594 return FALSE; 2595 } 2596 } 2597 2598 if (! flaginfo->info->keep_memory 2599 && ! _bfd_coff_free_symbols (input_bfd)) 2600 return FALSE; 2601 2602 return TRUE; 2603 } 2604 2605 /* Write out a global symbol. Called via bfd_hash_traverse. */ 2606 2607 bfd_boolean 2608 _bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data) 2609 { 2610 struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh; 2611 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data; 2612 bfd *output_bfd; 2613 struct internal_syment isym; 2614 bfd_size_type symesz; 2615 unsigned int i; 2616 file_ptr pos; 2617 2618 output_bfd = flaginfo->output_bfd; 2619 2620 if (h->root.type == bfd_link_hash_warning) 2621 { 2622 h = (struct coff_link_hash_entry *) h->root.u.i.link; 2623 if (h->root.type == bfd_link_hash_new) 2624 return TRUE; 2625 } 2626 2627 if (h->indx >= 0) 2628 return TRUE; 2629 2630 if (h->indx != -2 2631 && (flaginfo->info->strip == strip_all 2632 || (flaginfo->info->strip == strip_some 2633 && (bfd_hash_lookup (flaginfo->info->keep_hash, 2634 h->root.root.string, FALSE, FALSE) 2635 == NULL)))) 2636 return TRUE; 2637 2638 switch (h->root.type) 2639 { 2640 default: 2641 case bfd_link_hash_new: 2642 case bfd_link_hash_warning: 2643 abort (); 2644 return FALSE; 2645 2646 case bfd_link_hash_undefined: 2647 case bfd_link_hash_undefweak: 2648 isym.n_scnum = N_UNDEF; 2649 isym.n_value = 0; 2650 break; 2651 2652 case bfd_link_hash_defined: 2653 case bfd_link_hash_defweak: 2654 { 2655 asection *sec; 2656 2657 sec = h->root.u.def.section->output_section; 2658 if (bfd_is_abs_section (sec)) 2659 isym.n_scnum = N_ABS; 2660 else 2661 isym.n_scnum = sec->target_index; 2662 isym.n_value = (h->root.u.def.value 2663 + h->root.u.def.section->output_offset); 2664 if (! obj_pe (flaginfo->output_bfd)) 2665 isym.n_value += sec->vma; 2666 } 2667 break; 2668 2669 case bfd_link_hash_common: 2670 isym.n_scnum = N_UNDEF; 2671 isym.n_value = h->root.u.c.size; 2672 break; 2673 2674 case bfd_link_hash_indirect: 2675 /* Just ignore these. They can't be handled anyhow. */ 2676 return TRUE; 2677 } 2678 2679 if (strlen (h->root.root.string) <= SYMNMLEN) 2680 strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN); 2681 else 2682 { 2683 bfd_boolean hash; 2684 bfd_size_type indx; 2685 2686 hash = TRUE; 2687 if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0) 2688 hash = FALSE; 2689 indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash, 2690 FALSE); 2691 if (indx == (bfd_size_type) -1) 2692 { 2693 flaginfo->failed = TRUE; 2694 return FALSE; 2695 } 2696 isym._n._n_n._n_zeroes = 0; 2697 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; 2698 } 2699 2700 isym.n_sclass = h->symbol_class; 2701 isym.n_type = h->type; 2702 2703 if (isym.n_sclass == C_NULL) 2704 isym.n_sclass = C_EXT; 2705 2706 /* If doing task linking and this is the pass where we convert 2707 defined globals to statics, then do that conversion now. If the 2708 symbol is not being converted, just ignore it and it will be 2709 output during a later pass. */ 2710 if (flaginfo->global_to_static) 2711 { 2712 if (! IS_EXTERNAL (output_bfd, isym)) 2713 return TRUE; 2714 2715 isym.n_sclass = C_STAT; 2716 } 2717 2718 /* When a weak symbol is not overridden by a strong one, 2719 turn it into an external symbol when not building a 2720 shared or relocatable object. */ 2721 if (! flaginfo->info->shared 2722 && ! flaginfo->info->relocatable 2723 && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym)) 2724 isym.n_sclass = C_EXT; 2725 2726 isym.n_numaux = h->numaux; 2727 2728 bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms); 2729 2730 symesz = bfd_coff_symesz (output_bfd); 2731 2732 pos = obj_sym_filepos (output_bfd); 2733 pos += obj_raw_syment_count (output_bfd) * symesz; 2734 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 2735 || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz) 2736 { 2737 flaginfo->failed = TRUE; 2738 return FALSE; 2739 } 2740 2741 h->indx = obj_raw_syment_count (output_bfd); 2742 2743 ++obj_raw_syment_count (output_bfd); 2744 2745 /* Write out any associated aux entries. Most of the aux entries 2746 will have been modified in _bfd_coff_link_input_bfd. We have to 2747 handle section aux entries here, now that we have the final 2748 relocation and line number counts. */ 2749 for (i = 0; i < isym.n_numaux; i++) 2750 { 2751 union internal_auxent *auxp; 2752 2753 auxp = h->aux + i; 2754 2755 /* Look for a section aux entry here using the same tests that 2756 coff_swap_aux_out uses. */ 2757 if (i == 0 2758 && (isym.n_sclass == C_STAT 2759 || isym.n_sclass == C_HIDDEN) 2760 && isym.n_type == T_NULL 2761 && (h->root.type == bfd_link_hash_defined 2762 || h->root.type == bfd_link_hash_defweak)) 2763 { 2764 asection *sec; 2765 2766 sec = h->root.u.def.section->output_section; 2767 if (sec != NULL) 2768 { 2769 auxp->x_scn.x_scnlen = sec->size; 2770 2771 /* For PE, an overflow on the final link reportedly does 2772 not matter. FIXME: Why not? */ 2773 if (sec->reloc_count > 0xffff 2774 && (! obj_pe (output_bfd) 2775 || flaginfo->info->relocatable)) 2776 (*_bfd_error_handler) 2777 (_("%s: %s: reloc overflow: 0x%lx > 0xffff"), 2778 bfd_get_filename (output_bfd), 2779 bfd_get_section_name (output_bfd, sec), 2780 sec->reloc_count); 2781 2782 if (sec->lineno_count > 0xffff 2783 && (! obj_pe (output_bfd) 2784 || flaginfo->info->relocatable)) 2785 (*_bfd_error_handler) 2786 (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"), 2787 bfd_get_filename (output_bfd), 2788 bfd_get_section_name (output_bfd, sec), 2789 sec->lineno_count); 2790 2791 auxp->x_scn.x_nreloc = sec->reloc_count; 2792 auxp->x_scn.x_nlinno = sec->lineno_count; 2793 auxp->x_scn.x_checksum = 0; 2794 auxp->x_scn.x_associated = 0; 2795 auxp->x_scn.x_comdat = 0; 2796 } 2797 } 2798 2799 bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type, 2800 isym.n_sclass, (int) i, isym.n_numaux, 2801 flaginfo->outsyms); 2802 if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz) 2803 { 2804 flaginfo->failed = TRUE; 2805 return FALSE; 2806 } 2807 ++obj_raw_syment_count (output_bfd); 2808 } 2809 2810 return TRUE; 2811 } 2812 2813 /* Write out task global symbols, converting them to statics. Called 2814 via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do 2815 the dirty work, if the symbol we are processing needs conversion. */ 2816 2817 bfd_boolean 2818 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data) 2819 { 2820 struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data; 2821 bfd_boolean rtnval = TRUE; 2822 bfd_boolean save_global_to_static; 2823 2824 if (h->root.type == bfd_link_hash_warning) 2825 h = (struct coff_link_hash_entry *) h->root.u.i.link; 2826 2827 if (h->indx < 0) 2828 { 2829 switch (h->root.type) 2830 { 2831 case bfd_link_hash_defined: 2832 case bfd_link_hash_defweak: 2833 save_global_to_static = flaginfo->global_to_static; 2834 flaginfo->global_to_static = TRUE; 2835 rtnval = _bfd_coff_write_global_sym (&h->root.root, data); 2836 flaginfo->global_to_static = save_global_to_static; 2837 break; 2838 default: 2839 break; 2840 } 2841 } 2842 return (rtnval); 2843 } 2844 2845 /* Handle a link order which is supposed to generate a reloc. */ 2846 2847 bfd_boolean 2848 _bfd_coff_reloc_link_order (bfd *output_bfd, 2849 struct coff_final_link_info *flaginfo, 2850 asection *output_section, 2851 struct bfd_link_order *link_order) 2852 { 2853 reloc_howto_type *howto; 2854 struct internal_reloc *irel; 2855 struct coff_link_hash_entry **rel_hash_ptr; 2856 2857 howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 2858 if (howto == NULL) 2859 { 2860 bfd_set_error (bfd_error_bad_value); 2861 return FALSE; 2862 } 2863 2864 if (link_order->u.reloc.p->addend != 0) 2865 { 2866 bfd_size_type size; 2867 bfd_byte *buf; 2868 bfd_reloc_status_type rstat; 2869 bfd_boolean ok; 2870 file_ptr loc; 2871 2872 size = bfd_get_reloc_size (howto); 2873 buf = (bfd_byte *) bfd_zmalloc (size); 2874 if (buf == NULL) 2875 return FALSE; 2876 2877 rstat = _bfd_relocate_contents (howto, output_bfd, 2878 (bfd_vma) link_order->u.reloc.p->addend,\ 2879 buf); 2880 switch (rstat) 2881 { 2882 case bfd_reloc_ok: 2883 break; 2884 default: 2885 case bfd_reloc_outofrange: 2886 abort (); 2887 case bfd_reloc_overflow: 2888 if (! ((*flaginfo->info->callbacks->reloc_overflow) 2889 (flaginfo->info, NULL, 2890 (link_order->type == bfd_section_reloc_link_order 2891 ? bfd_section_name (output_bfd, 2892 link_order->u.reloc.p->u.section) 2893 : link_order->u.reloc.p->u.name), 2894 howto->name, link_order->u.reloc.p->addend, 2895 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0))) 2896 { 2897 free (buf); 2898 return FALSE; 2899 } 2900 break; 2901 } 2902 loc = link_order->offset * bfd_octets_per_byte (output_bfd); 2903 ok = bfd_set_section_contents (output_bfd, output_section, buf, 2904 loc, size); 2905 free (buf); 2906 if (! ok) 2907 return FALSE; 2908 } 2909 2910 /* Store the reloc information in the right place. It will get 2911 swapped and written out at the end of the final_link routine. */ 2912 irel = (flaginfo->section_info[output_section->target_index].relocs 2913 + output_section->reloc_count); 2914 rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes 2915 + output_section->reloc_count); 2916 2917 memset (irel, 0, sizeof (struct internal_reloc)); 2918 *rel_hash_ptr = NULL; 2919 2920 irel->r_vaddr = output_section->vma + link_order->offset; 2921 2922 if (link_order->type == bfd_section_reloc_link_order) 2923 { 2924 /* We need to somehow locate a symbol in the right section. The 2925 symbol must either have a value of zero, or we must adjust 2926 the addend by the value of the symbol. FIXME: Write this 2927 when we need it. The old linker couldn't handle this anyhow. */ 2928 abort (); 2929 *rel_hash_ptr = NULL; 2930 irel->r_symndx = 0; 2931 } 2932 else 2933 { 2934 struct coff_link_hash_entry *h; 2935 2936 h = ((struct coff_link_hash_entry *) 2937 bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info, 2938 link_order->u.reloc.p->u.name, 2939 FALSE, FALSE, TRUE)); 2940 if (h != NULL) 2941 { 2942 if (h->indx >= 0) 2943 irel->r_symndx = h->indx; 2944 else 2945 { 2946 /* Set the index to -2 to force this symbol to get 2947 written out. */ 2948 h->indx = -2; 2949 *rel_hash_ptr = h; 2950 irel->r_symndx = 0; 2951 } 2952 } 2953 else 2954 { 2955 if (! ((*flaginfo->info->callbacks->unattached_reloc) 2956 (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL, 2957 (asection *) NULL, (bfd_vma) 0))) 2958 return FALSE; 2959 irel->r_symndx = 0; 2960 } 2961 } 2962 2963 /* FIXME: Is this always right? */ 2964 irel->r_type = howto->type; 2965 2966 /* r_size is only used on the RS/6000, which needs its own linker 2967 routines anyhow. r_extern is only used for ECOFF. */ 2968 2969 /* FIXME: What is the right value for r_offset? Is zero OK? */ 2970 ++output_section->reloc_count; 2971 2972 return TRUE; 2973 } 2974 2975 /* A basic reloc handling routine which may be used by processors with 2976 simple relocs. */ 2977 2978 bfd_boolean 2979 _bfd_coff_generic_relocate_section (bfd *output_bfd, 2980 struct bfd_link_info *info, 2981 bfd *input_bfd, 2982 asection *input_section, 2983 bfd_byte *contents, 2984 struct internal_reloc *relocs, 2985 struct internal_syment *syms, 2986 asection **sections) 2987 { 2988 struct internal_reloc *rel; 2989 struct internal_reloc *relend; 2990 2991 rel = relocs; 2992 relend = rel + input_section->reloc_count; 2993 for (; rel < relend; rel++) 2994 { 2995 long symndx; 2996 struct coff_link_hash_entry *h; 2997 struct internal_syment *sym; 2998 bfd_vma addend; 2999 bfd_vma val; 3000 reloc_howto_type *howto; 3001 bfd_reloc_status_type rstat; 3002 3003 symndx = rel->r_symndx; 3004 3005 if (symndx == -1) 3006 { 3007 h = NULL; 3008 sym = NULL; 3009 } 3010 else if (symndx < 0 3011 || (unsigned long) symndx >= obj_raw_syment_count (input_bfd)) 3012 { 3013 (*_bfd_error_handler) 3014 ("%B: illegal symbol index %ld in relocs", input_bfd, symndx); 3015 return FALSE; 3016 } 3017 else 3018 { 3019 h = obj_coff_sym_hashes (input_bfd)[symndx]; 3020 sym = syms + symndx; 3021 } 3022 3023 /* COFF treats common symbols in one of two ways. Either the 3024 size of the symbol is included in the section contents, or it 3025 is not. We assume that the size is not included, and force 3026 the rtype_to_howto function to adjust the addend as needed. */ 3027 if (sym != NULL && sym->n_scnum != 0) 3028 addend = - sym->n_value; 3029 else 3030 addend = 0; 3031 3032 howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h, 3033 sym, &addend); 3034 if (howto == NULL) 3035 return FALSE; 3036 3037 /* If we are doing a relocatable link, then we can just ignore 3038 a PC relative reloc that is pcrel_offset. It will already 3039 have the correct value. If this is not a relocatable link, 3040 then we should ignore the symbol value. */ 3041 if (howto->pc_relative && howto->pcrel_offset) 3042 { 3043 if (info->relocatable) 3044 continue; 3045 if (sym != NULL && sym->n_scnum != 0) 3046 addend += sym->n_value; 3047 } 3048 3049 val = 0; 3050 3051 if (h == NULL) 3052 { 3053 asection *sec; 3054 3055 if (symndx == -1) 3056 { 3057 sec = bfd_abs_section_ptr; 3058 val = 0; 3059 } 3060 else 3061 { 3062 sec = sections[symndx]; 3063 val = (sec->output_section->vma 3064 + sec->output_offset 3065 + sym->n_value); 3066 if (! obj_pe (input_bfd)) 3067 val -= sec->vma; 3068 } 3069 } 3070 else 3071 { 3072 if (h->root.type == bfd_link_hash_defined 3073 || h->root.type == bfd_link_hash_defweak) 3074 { 3075 /* Defined weak symbols are a GNU extension. */ 3076 asection *sec; 3077 3078 sec = h->root.u.def.section; 3079 val = (h->root.u.def.value 3080 + sec->output_section->vma 3081 + sec->output_offset); 3082 } 3083 3084 else if (h->root.type == bfd_link_hash_undefweak) 3085 { 3086 if (h->symbol_class == C_NT_WEAK && h->numaux == 1) 3087 { 3088 /* See _Microsoft Portable Executable and Common Object 3089 File Format Specification_, section 5.5.3. 3090 Note that weak symbols without aux records are a GNU 3091 extension. 3092 FIXME: All weak externals are treated as having 3093 characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1). 3094 These behave as per SVR4 ABI: A library member 3095 will resolve a weak external only if a normal 3096 external causes the library member to be linked. 3097 See also linker.c: generic_link_check_archive_element. */ 3098 asection *sec; 3099 struct coff_link_hash_entry *h2 = 3100 h->auxbfd->tdata.coff_obj_data->sym_hashes[ 3101 h->aux->x_sym.x_tagndx.l]; 3102 3103 if (!h2 || h2->root.type == bfd_link_hash_undefined) 3104 { 3105 sec = bfd_abs_section_ptr; 3106 val = 0; 3107 } 3108 else 3109 { 3110 sec = h2->root.u.def.section; 3111 val = h2->root.u.def.value 3112 + sec->output_section->vma + sec->output_offset; 3113 } 3114 } 3115 else 3116 /* This is a GNU extension. */ 3117 val = 0; 3118 } 3119 3120 else if (! info->relocatable) 3121 { 3122 if (! ((*info->callbacks->undefined_symbol) 3123 (info, h->root.root.string, input_bfd, input_section, 3124 rel->r_vaddr - input_section->vma, TRUE))) 3125 return FALSE; 3126 } 3127 } 3128 3129 if (info->base_file) 3130 { 3131 /* Emit a reloc if the backend thinks it needs it. */ 3132 if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto)) 3133 { 3134 /* Relocation to a symbol in a section which isn't 3135 absolute. We output the address here to a file. 3136 This file is then read by dlltool when generating the 3137 reloc section. Note that the base file is not 3138 portable between systems. We write out a bfd_vma here, 3139 and dlltool reads in a bfd_vma. */ 3140 bfd_vma addr = (rel->r_vaddr 3141 - input_section->vma 3142 + input_section->output_offset 3143 + input_section->output_section->vma); 3144 if (coff_data (output_bfd)->pe) 3145 addr -= pe_data(output_bfd)->pe_opthdr.ImageBase; 3146 if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file) 3147 != sizeof (bfd_vma)) 3148 { 3149 bfd_set_error (bfd_error_system_call); 3150 return FALSE; 3151 } 3152 } 3153 } 3154 3155 rstat = _bfd_final_link_relocate (howto, input_bfd, input_section, 3156 contents, 3157 rel->r_vaddr - input_section->vma, 3158 val, addend); 3159 3160 switch (rstat) 3161 { 3162 default: 3163 abort (); 3164 case bfd_reloc_ok: 3165 break; 3166 case bfd_reloc_outofrange: 3167 (*_bfd_error_handler) 3168 (_("%B: bad reloc address 0x%lx in section `%A'"), 3169 input_bfd, input_section, (unsigned long) rel->r_vaddr); 3170 return FALSE; 3171 case bfd_reloc_overflow: 3172 { 3173 const char *name; 3174 char buf[SYMNMLEN + 1]; 3175 3176 if (symndx == -1) 3177 name = "*ABS*"; 3178 else if (h != NULL) 3179 name = NULL; 3180 else 3181 { 3182 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf); 3183 if (name == NULL) 3184 return FALSE; 3185 } 3186 3187 if (! ((*info->callbacks->reloc_overflow) 3188 (info, (h ? &h->root : NULL), name, howto->name, 3189 (bfd_vma) 0, input_bfd, input_section, 3190 rel->r_vaddr - input_section->vma))) 3191 return FALSE; 3192 } 3193 } 3194 } 3195 return TRUE; 3196 } 3197