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