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