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