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