1 /* linker.c -- BFD linker routines 2 Copyright (C) 1993-2015 Free Software Foundation, Inc. 3 Written by Steve Chamberlain and 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 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "bfdlink.h" 26 #include "genlink.h" 27 28 /* 29 SECTION 30 Linker Functions 31 32 @cindex Linker 33 The linker uses three special entry points in the BFD target 34 vector. It is not necessary to write special routines for 35 these entry points when creating a new BFD back end, since 36 generic versions are provided. However, writing them can 37 speed up linking and make it use significantly less runtime 38 memory. 39 40 The first routine creates a hash table used by the other 41 routines. The second routine adds the symbols from an object 42 file to the hash table. The third routine takes all the 43 object files and links them together to create the output 44 file. These routines are designed so that the linker proper 45 does not need to know anything about the symbols in the object 46 files that it is linking. The linker merely arranges the 47 sections as directed by the linker script and lets BFD handle 48 the details of symbols and relocs. 49 50 The second routine and third routines are passed a pointer to 51 a <<struct bfd_link_info>> structure (defined in 52 <<bfdlink.h>>) which holds information relevant to the link, 53 including the linker hash table (which was created by the 54 first routine) and a set of callback functions to the linker 55 proper. 56 57 The generic linker routines are in <<linker.c>>, and use the 58 header file <<genlink.h>>. As of this writing, the only back 59 ends which have implemented versions of these routines are 60 a.out (in <<aoutx.h>>) and ECOFF (in <<ecoff.c>>). The a.out 61 routines are used as examples throughout this section. 62 63 @menu 64 @* Creating a Linker Hash Table:: 65 @* Adding Symbols to the Hash Table:: 66 @* Performing the Final Link:: 67 @end menu 68 69 INODE 70 Creating a Linker Hash Table, Adding Symbols to the Hash Table, Linker Functions, Linker Functions 71 SUBSECTION 72 Creating a linker hash table 73 74 @cindex _bfd_link_hash_table_create in target vector 75 @cindex target vector (_bfd_link_hash_table_create) 76 The linker routines must create a hash table, which must be 77 derived from <<struct bfd_link_hash_table>> described in 78 <<bfdlink.c>>. @xref{Hash Tables}, for information on how to 79 create a derived hash table. This entry point is called using 80 the target vector of the linker output file. 81 82 The <<_bfd_link_hash_table_create>> entry point must allocate 83 and initialize an instance of the desired hash table. If the 84 back end does not require any additional information to be 85 stored with the entries in the hash table, the entry point may 86 simply create a <<struct bfd_link_hash_table>>. Most likely, 87 however, some additional information will be needed. 88 89 For example, with each entry in the hash table the a.out 90 linker keeps the index the symbol has in the final output file 91 (this index number is used so that when doing a relocatable 92 link the symbol index used in the output file can be quickly 93 filled in when copying over a reloc). The a.out linker code 94 defines the required structures and functions for a hash table 95 derived from <<struct bfd_link_hash_table>>. The a.out linker 96 hash table is created by the function 97 <<NAME(aout,link_hash_table_create)>>; it simply allocates 98 space for the hash table, initializes it, and returns a 99 pointer to it. 100 101 When writing the linker routines for a new back end, you will 102 generally not know exactly which fields will be required until 103 you have finished. You should simply create a new hash table 104 which defines no additional fields, and then simply add fields 105 as they become necessary. 106 107 INODE 108 Adding Symbols to the Hash Table, Performing the Final Link, Creating a Linker Hash Table, Linker Functions 109 SUBSECTION 110 Adding symbols to the hash table 111 112 @cindex _bfd_link_add_symbols in target vector 113 @cindex target vector (_bfd_link_add_symbols) 114 The linker proper will call the <<_bfd_link_add_symbols>> 115 entry point for each object file or archive which is to be 116 linked (typically these are the files named on the command 117 line, but some may also come from the linker script). The 118 entry point is responsible for examining the file. For an 119 object file, BFD must add any relevant symbol information to 120 the hash table. For an archive, BFD must determine which 121 elements of the archive should be used and adding them to the 122 link. 123 124 The a.out version of this entry point is 125 <<NAME(aout,link_add_symbols)>>. 126 127 @menu 128 @* Differing file formats:: 129 @* Adding symbols from an object file:: 130 @* Adding symbols from an archive:: 131 @end menu 132 133 INODE 134 Differing file formats, Adding symbols from an object file, Adding Symbols to the Hash Table, Adding Symbols to the Hash Table 135 SUBSUBSECTION 136 Differing file formats 137 138 Normally all the files involved in a link will be of the same 139 format, but it is also possible to link together different 140 format object files, and the back end must support that. The 141 <<_bfd_link_add_symbols>> entry point is called via the target 142 vector of the file to be added. This has an important 143 consequence: the function may not assume that the hash table 144 is the type created by the corresponding 145 <<_bfd_link_hash_table_create>> vector. All the 146 <<_bfd_link_add_symbols>> function can assume about the hash 147 table is that it is derived from <<struct 148 bfd_link_hash_table>>. 149 150 Sometimes the <<_bfd_link_add_symbols>> function must store 151 some information in the hash table entry to be used by the 152 <<_bfd_final_link>> function. In such a case the output bfd 153 xvec must be checked to make sure that the hash table was 154 created by an object file of the same format. 155 156 The <<_bfd_final_link>> routine must be prepared to handle a 157 hash entry without any extra information added by the 158 <<_bfd_link_add_symbols>> function. A hash entry without 159 extra information will also occur when the linker script 160 directs the linker to create a symbol. Note that, regardless 161 of how a hash table entry is added, all the fields will be 162 initialized to some sort of null value by the hash table entry 163 initialization function. 164 165 See <<ecoff_link_add_externals>> for an example of how to 166 check the output bfd before saving information (in this 167 case, the ECOFF external symbol debugging information) in a 168 hash table entry. 169 170 INODE 171 Adding symbols from an object file, Adding symbols from an archive, Differing file formats, Adding Symbols to the Hash Table 172 SUBSUBSECTION 173 Adding symbols from an object file 174 175 When the <<_bfd_link_add_symbols>> routine is passed an object 176 file, it must add all externally visible symbols in that 177 object file to the hash table. The actual work of adding the 178 symbol to the hash table is normally handled by the function 179 <<_bfd_generic_link_add_one_symbol>>. The 180 <<_bfd_link_add_symbols>> routine is responsible for reading 181 all the symbols from the object file and passing the correct 182 information to <<_bfd_generic_link_add_one_symbol>>. 183 184 The <<_bfd_link_add_symbols>> routine should not use 185 <<bfd_canonicalize_symtab>> to read the symbols. The point of 186 providing this routine is to avoid the overhead of converting 187 the symbols into generic <<asymbol>> structures. 188 189 @findex _bfd_generic_link_add_one_symbol 190 <<_bfd_generic_link_add_one_symbol>> handles the details of 191 combining common symbols, warning about multiple definitions, 192 and so forth. It takes arguments which describe the symbol to 193 add, notably symbol flags, a section, and an offset. The 194 symbol flags include such things as <<BSF_WEAK>> or 195 <<BSF_INDIRECT>>. The section is a section in the object 196 file, or something like <<bfd_und_section_ptr>> for an undefined 197 symbol or <<bfd_com_section_ptr>> for a common symbol. 198 199 If the <<_bfd_final_link>> routine is also going to need to 200 read the symbol information, the <<_bfd_link_add_symbols>> 201 routine should save it somewhere attached to the object file 202 BFD. However, the information should only be saved if the 203 <<keep_memory>> field of the <<info>> argument is TRUE, so 204 that the <<-no-keep-memory>> linker switch is effective. 205 206 The a.out function which adds symbols from an object file is 207 <<aout_link_add_object_symbols>>, and most of the interesting 208 work is in <<aout_link_add_symbols>>. The latter saves 209 pointers to the hash tables entries created by 210 <<_bfd_generic_link_add_one_symbol>> indexed by symbol number, 211 so that the <<_bfd_final_link>> routine does not have to call 212 the hash table lookup routine to locate the entry. 213 214 INODE 215 Adding symbols from an archive, , Adding symbols from an object file, Adding Symbols to the Hash Table 216 SUBSUBSECTION 217 Adding symbols from an archive 218 219 When the <<_bfd_link_add_symbols>> routine is passed an 220 archive, it must look through the symbols defined by the 221 archive and decide which elements of the archive should be 222 included in the link. For each such element it must call the 223 <<add_archive_element>> linker callback, and it must add the 224 symbols from the object file to the linker hash table. (The 225 callback may in fact indicate that a replacement BFD should be 226 used, in which case the symbols from that BFD should be added 227 to the linker hash table instead.) 228 229 @findex _bfd_generic_link_add_archive_symbols 230 In most cases the work of looking through the symbols in the 231 archive should be done by the 232 <<_bfd_generic_link_add_archive_symbols>> function. 233 <<_bfd_generic_link_add_archive_symbols>> is passed a function 234 to call to make the final decision about adding an archive 235 element to the link and to do the actual work of adding the 236 symbols to the linker hash table. If the element is to 237 be included, the <<add_archive_element>> linker callback 238 routine must be called with the element as an argument, and 239 the element's symbols must be added to the linker hash table 240 just as though the element had itself been passed to the 241 <<_bfd_link_add_symbols>> function. 242 243 When the a.out <<_bfd_link_add_symbols>> function receives an 244 archive, it calls <<_bfd_generic_link_add_archive_symbols>> 245 passing <<aout_link_check_archive_element>> as the function 246 argument. <<aout_link_check_archive_element>> calls 247 <<aout_link_check_ar_symbols>>. If the latter decides to add 248 the element (an element is only added if it provides a real, 249 non-common, definition for a previously undefined or common 250 symbol) it calls the <<add_archive_element>> callback and then 251 <<aout_link_check_archive_element>> calls 252 <<aout_link_add_symbols>> to actually add the symbols to the 253 linker hash table - possibly those of a substitute BFD, if the 254 <<add_archive_element>> callback avails itself of that option. 255 256 The ECOFF back end is unusual in that it does not normally 257 call <<_bfd_generic_link_add_archive_symbols>>, because ECOFF 258 archives already contain a hash table of symbols. The ECOFF 259 back end searches the archive itself to avoid the overhead of 260 creating a new hash table. 261 262 INODE 263 Performing the Final Link, , Adding Symbols to the Hash Table, Linker Functions 264 SUBSECTION 265 Performing the final link 266 267 @cindex _bfd_link_final_link in target vector 268 @cindex target vector (_bfd_final_link) 269 When all the input files have been processed, the linker calls 270 the <<_bfd_final_link>> entry point of the output BFD. This 271 routine is responsible for producing the final output file, 272 which has several aspects. It must relocate the contents of 273 the input sections and copy the data into the output sections. 274 It must build an output symbol table including any local 275 symbols from the input files and the global symbols from the 276 hash table. When producing relocatable output, it must 277 modify the input relocs and write them into the output file. 278 There may also be object format dependent work to be done. 279 280 The linker will also call the <<write_object_contents>> entry 281 point when the BFD is closed. The two entry points must work 282 together in order to produce the correct output file. 283 284 The details of how this works are inevitably dependent upon 285 the specific object file format. The a.out 286 <<_bfd_final_link>> routine is <<NAME(aout,final_link)>>. 287 288 @menu 289 @* Information provided by the linker:: 290 @* Relocating the section contents:: 291 @* Writing the symbol table:: 292 @end menu 293 294 INODE 295 Information provided by the linker, Relocating the section contents, Performing the Final Link, Performing the Final Link 296 SUBSUBSECTION 297 Information provided by the linker 298 299 Before the linker calls the <<_bfd_final_link>> entry point, 300 it sets up some data structures for the function to use. 301 302 The <<input_bfds>> field of the <<bfd_link_info>> structure 303 will point to a list of all the input files included in the 304 link. These files are linked through the <<link.next>> field 305 of the <<bfd>> structure. 306 307 Each section in the output file will have a list of 308 <<link_order>> structures attached to the <<map_head.link_order>> 309 field (the <<link_order>> structure is defined in 310 <<bfdlink.h>>). These structures describe how to create the 311 contents of the output section in terms of the contents of 312 various input sections, fill constants, and, eventually, other 313 types of information. They also describe relocs that must be 314 created by the BFD backend, but do not correspond to any input 315 file; this is used to support -Ur, which builds constructors 316 while generating a relocatable object file. 317 318 INODE 319 Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link 320 SUBSUBSECTION 321 Relocating the section contents 322 323 The <<_bfd_final_link>> function should look through the 324 <<link_order>> structures attached to each section of the 325 output file. Each <<link_order>> structure should either be 326 handled specially, or it should be passed to the function 327 <<_bfd_default_link_order>> which will do the right thing 328 (<<_bfd_default_link_order>> is defined in <<linker.c>>). 329 330 For efficiency, a <<link_order>> of type 331 <<bfd_indirect_link_order>> whose associated section belongs 332 to a BFD of the same format as the output BFD must be handled 333 specially. This type of <<link_order>> describes part of an 334 output section in terms of a section belonging to one of the 335 input files. The <<_bfd_final_link>> function should read the 336 contents of the section and any associated relocs, apply the 337 relocs to the section contents, and write out the modified 338 section contents. If performing a relocatable link, the 339 relocs themselves must also be modified and written out. 340 341 @findex _bfd_relocate_contents 342 @findex _bfd_final_link_relocate 343 The functions <<_bfd_relocate_contents>> and 344 <<_bfd_final_link_relocate>> provide some general support for 345 performing the actual relocations, notably overflow checking. 346 Their arguments include information about the symbol the 347 relocation is against and a <<reloc_howto_type>> argument 348 which describes the relocation to perform. These functions 349 are defined in <<reloc.c>>. 350 351 The a.out function which handles reading, relocating, and 352 writing section contents is <<aout_link_input_section>>. The 353 actual relocation is done in <<aout_link_input_section_std>> 354 and <<aout_link_input_section_ext>>. 355 356 INODE 357 Writing the symbol table, , Relocating the section contents, Performing the Final Link 358 SUBSUBSECTION 359 Writing the symbol table 360 361 The <<_bfd_final_link>> function must gather all the symbols 362 in the input files and write them out. It must also write out 363 all the symbols in the global hash table. This must be 364 controlled by the <<strip>> and <<discard>> fields of the 365 <<bfd_link_info>> structure. 366 367 The local symbols of the input files will not have been 368 entered into the linker hash table. The <<_bfd_final_link>> 369 routine must consider each input file and include the symbols 370 in the output file. It may be convenient to do this when 371 looking through the <<link_order>> structures, or it may be 372 done by stepping through the <<input_bfds>> list. 373 374 The <<_bfd_final_link>> routine must also traverse the global 375 hash table to gather all the externally visible symbols. It 376 is possible that most of the externally visible symbols may be 377 written out when considering the symbols of each input file, 378 but it is still necessary to traverse the hash table since the 379 linker script may have defined some symbols that are not in 380 any of the input files. 381 382 The <<strip>> field of the <<bfd_link_info>> structure 383 controls which symbols are written out. The possible values 384 are listed in <<bfdlink.h>>. If the value is <<strip_some>>, 385 then the <<keep_hash>> field of the <<bfd_link_info>> 386 structure is a hash table of symbols to keep; each symbol 387 should be looked up in this hash table, and only symbols which 388 are present should be included in the output file. 389 390 If the <<strip>> field of the <<bfd_link_info>> structure 391 permits local symbols to be written out, the <<discard>> field 392 is used to further controls which local symbols are included 393 in the output file. If the value is <<discard_l>>, then all 394 local symbols which begin with a certain prefix are discarded; 395 this is controlled by the <<bfd_is_local_label_name>> entry point. 396 397 The a.out backend handles symbols by calling 398 <<aout_link_write_symbols>> on each input BFD and then 399 traversing the global hash table with the function 400 <<aout_link_write_other_symbol>>. It builds a string table 401 while writing out the symbols, which is written to the output 402 file at the end of <<NAME(aout,final_link)>>. 403 */ 404 405 static bfd_boolean generic_link_add_object_symbols 406 (bfd *, struct bfd_link_info *, bfd_boolean collect); 407 static bfd_boolean generic_link_add_symbols 408 (bfd *, struct bfd_link_info *, bfd_boolean); 409 static bfd_boolean generic_link_check_archive_element_no_collect 410 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, 411 bfd_boolean *); 412 static bfd_boolean generic_link_check_archive_element_collect 413 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, 414 bfd_boolean *); 415 static bfd_boolean generic_link_check_archive_element 416 (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, 417 bfd_boolean *, bfd_boolean); 418 static bfd_boolean generic_link_add_symbol_list 419 (bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **, 420 bfd_boolean); 421 static bfd_boolean generic_add_output_symbol 422 (bfd *, size_t *psymalloc, asymbol *); 423 static bfd_boolean default_data_link_order 424 (bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *); 425 static bfd_boolean default_indirect_link_order 426 (bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *, 427 bfd_boolean); 428 429 /* The link hash table structure is defined in bfdlink.h. It provides 430 a base hash table which the backend specific hash tables are built 431 upon. */ 432 433 /* Routine to create an entry in the link hash table. */ 434 435 struct bfd_hash_entry * 436 _bfd_link_hash_newfunc (struct bfd_hash_entry *entry, 437 struct bfd_hash_table *table, 438 const char *string) 439 { 440 /* Allocate the structure if it has not already been allocated by a 441 subclass. */ 442 if (entry == NULL) 443 { 444 entry = (struct bfd_hash_entry *) 445 bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry)); 446 if (entry == NULL) 447 return entry; 448 } 449 450 /* Call the allocation method of the superclass. */ 451 entry = bfd_hash_newfunc (entry, table, string); 452 if (entry) 453 { 454 struct bfd_link_hash_entry *h = (struct bfd_link_hash_entry *) entry; 455 456 /* Initialize the local fields. */ 457 memset ((char *) &h->root + sizeof (h->root), 0, 458 sizeof (*h) - sizeof (h->root)); 459 } 460 461 return entry; 462 } 463 464 /* Initialize a link hash table. The BFD argument is the one 465 responsible for creating this table. */ 466 467 bfd_boolean 468 _bfd_link_hash_table_init 469 (struct bfd_link_hash_table *table, 470 bfd *abfd ATTRIBUTE_UNUSED, 471 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, 472 struct bfd_hash_table *, 473 const char *), 474 unsigned int entsize) 475 { 476 bfd_boolean ret; 477 478 BFD_ASSERT (!abfd->is_linker_output && !abfd->link.hash); 479 table->undefs = NULL; 480 table->undefs_tail = NULL; 481 table->type = bfd_link_generic_hash_table; 482 483 ret = bfd_hash_table_init (&table->table, newfunc, entsize); 484 if (ret) 485 { 486 /* Arrange for destruction of this hash table on closing ABFD. */ 487 table->hash_table_free = _bfd_generic_link_hash_table_free; 488 abfd->link.hash = table; 489 abfd->is_linker_output = TRUE; 490 } 491 return ret; 492 } 493 494 /* Look up a symbol in a link hash table. If follow is TRUE, we 495 follow bfd_link_hash_indirect and bfd_link_hash_warning links to 496 the real symbol. */ 497 498 struct bfd_link_hash_entry * 499 bfd_link_hash_lookup (struct bfd_link_hash_table *table, 500 const char *string, 501 bfd_boolean create, 502 bfd_boolean copy, 503 bfd_boolean follow) 504 { 505 struct bfd_link_hash_entry *ret; 506 507 ret = ((struct bfd_link_hash_entry *) 508 bfd_hash_lookup (&table->table, string, create, copy)); 509 510 if (follow && ret != NULL) 511 { 512 while (ret->type == bfd_link_hash_indirect 513 || ret->type == bfd_link_hash_warning) 514 ret = ret->u.i.link; 515 } 516 517 return ret; 518 } 519 520 /* Look up a symbol in the main linker hash table if the symbol might 521 be wrapped. This should only be used for references to an 522 undefined symbol, not for definitions of a symbol. */ 523 524 struct bfd_link_hash_entry * 525 bfd_wrapped_link_hash_lookup (bfd *abfd, 526 struct bfd_link_info *info, 527 const char *string, 528 bfd_boolean create, 529 bfd_boolean copy, 530 bfd_boolean follow) 531 { 532 bfd_size_type amt; 533 534 if (info->wrap_hash != NULL) 535 { 536 const char *l; 537 char prefix = '\0'; 538 539 l = string; 540 if (*l == bfd_get_symbol_leading_char (abfd) || *l == info->wrap_char) 541 { 542 prefix = *l; 543 ++l; 544 } 545 546 #undef WRAP 547 #define WRAP "__wrap_" 548 549 if (bfd_hash_lookup (info->wrap_hash, l, FALSE, FALSE) != NULL) 550 { 551 char *n; 552 struct bfd_link_hash_entry *h; 553 554 /* This symbol is being wrapped. We want to replace all 555 references to SYM with references to __wrap_SYM. */ 556 557 amt = strlen (l) + sizeof WRAP + 1; 558 n = (char *) bfd_malloc (amt); 559 if (n == NULL) 560 return NULL; 561 562 n[0] = prefix; 563 n[1] = '\0'; 564 strcat (n, WRAP); 565 strcat (n, l); 566 h = bfd_link_hash_lookup (info->hash, n, create, TRUE, follow); 567 free (n); 568 return h; 569 } 570 571 #undef REAL 572 #define REAL "__real_" 573 574 if (*l == '_' 575 && CONST_STRNEQ (l, REAL) 576 && bfd_hash_lookup (info->wrap_hash, l + sizeof REAL - 1, 577 FALSE, FALSE) != NULL) 578 { 579 char *n; 580 struct bfd_link_hash_entry *h; 581 582 /* This is a reference to __real_SYM, where SYM is being 583 wrapped. We want to replace all references to __real_SYM 584 with references to SYM. */ 585 586 amt = strlen (l + sizeof REAL - 1) + 2; 587 n = (char *) bfd_malloc (amt); 588 if (n == NULL) 589 return NULL; 590 591 n[0] = prefix; 592 n[1] = '\0'; 593 strcat (n, l + sizeof REAL - 1); 594 h = bfd_link_hash_lookup (info->hash, n, create, TRUE, follow); 595 free (n); 596 return h; 597 } 598 599 #undef REAL 600 } 601 602 return bfd_link_hash_lookup (info->hash, string, create, copy, follow); 603 } 604 605 /* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_" 606 and the remainder is found in wrap_hash, return the real symbol. */ 607 608 struct bfd_link_hash_entry * 609 unwrap_hash_lookup (struct bfd_link_info *info, 610 bfd *input_bfd, 611 struct bfd_link_hash_entry *h) 612 { 613 const char *l = h->root.string; 614 615 if (*l == bfd_get_symbol_leading_char (input_bfd) 616 || *l == info->wrap_char) 617 ++l; 618 619 if (CONST_STRNEQ (l, WRAP)) 620 { 621 l += sizeof WRAP - 1; 622 623 if (bfd_hash_lookup (info->wrap_hash, l, FALSE, FALSE) != NULL) 624 { 625 char save = 0; 626 if (l - (sizeof WRAP - 1) != h->root.string) 627 { 628 --l; 629 save = *l; 630 *(char *) l = *h->root.string; 631 } 632 h = bfd_link_hash_lookup (info->hash, l, FALSE, FALSE, FALSE); 633 if (save) 634 *(char *) l = save; 635 } 636 } 637 return h; 638 } 639 #undef WRAP 640 641 /* Traverse a generic link hash table. Differs from bfd_hash_traverse 642 in the treatment of warning symbols. When warning symbols are 643 created they replace the real symbol, so you don't get to see the 644 real symbol in a bfd_hash_travere. This traversal calls func with 645 the real symbol. */ 646 647 void 648 bfd_link_hash_traverse 649 (struct bfd_link_hash_table *htab, 650 bfd_boolean (*func) (struct bfd_link_hash_entry *, void *), 651 void *info) 652 { 653 unsigned int i; 654 655 htab->table.frozen = 1; 656 for (i = 0; i < htab->table.size; i++) 657 { 658 struct bfd_link_hash_entry *p; 659 660 p = (struct bfd_link_hash_entry *) htab->table.table[i]; 661 for (; p != NULL; p = (struct bfd_link_hash_entry *) p->root.next) 662 if (!(*func) (p->type == bfd_link_hash_warning ? p->u.i.link : p, info)) 663 goto out; 664 } 665 out: 666 htab->table.frozen = 0; 667 } 668 669 /* Add a symbol to the linker hash table undefs list. */ 670 671 void 672 bfd_link_add_undef (struct bfd_link_hash_table *table, 673 struct bfd_link_hash_entry *h) 674 { 675 BFD_ASSERT (h->u.undef.next == NULL); 676 if (table->undefs_tail != NULL) 677 table->undefs_tail->u.undef.next = h; 678 if (table->undefs == NULL) 679 table->undefs = h; 680 table->undefs_tail = h; 681 } 682 683 /* The undefs list was designed so that in normal use we don't need to 684 remove entries. However, if symbols on the list are changed from 685 bfd_link_hash_undefined to either bfd_link_hash_undefweak or 686 bfd_link_hash_new for some reason, then they must be removed from the 687 list. Failure to do so might result in the linker attempting to add 688 the symbol to the list again at a later stage. */ 689 690 void 691 bfd_link_repair_undef_list (struct bfd_link_hash_table *table) 692 { 693 struct bfd_link_hash_entry **pun; 694 695 pun = &table->undefs; 696 while (*pun != NULL) 697 { 698 struct bfd_link_hash_entry *h = *pun; 699 700 if (h->type == bfd_link_hash_new 701 || h->type == bfd_link_hash_undefweak) 702 { 703 *pun = h->u.undef.next; 704 h->u.undef.next = NULL; 705 if (h == table->undefs_tail) 706 { 707 if (pun == &table->undefs) 708 table->undefs_tail = NULL; 709 else 710 /* pun points at an u.undef.next field. Go back to 711 the start of the link_hash_entry. */ 712 table->undefs_tail = (struct bfd_link_hash_entry *) 713 ((char *) pun - ((char *) &h->u.undef.next - (char *) h)); 714 break; 715 } 716 } 717 else 718 pun = &h->u.undef.next; 719 } 720 } 721 722 /* Routine to create an entry in a generic link hash table. */ 723 724 struct bfd_hash_entry * 725 _bfd_generic_link_hash_newfunc (struct bfd_hash_entry *entry, 726 struct bfd_hash_table *table, 727 const char *string) 728 { 729 /* Allocate the structure if it has not already been allocated by a 730 subclass. */ 731 if (entry == NULL) 732 { 733 entry = (struct bfd_hash_entry *) 734 bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry)); 735 if (entry == NULL) 736 return entry; 737 } 738 739 /* Call the allocation method of the superclass. */ 740 entry = _bfd_link_hash_newfunc (entry, table, string); 741 if (entry) 742 { 743 struct generic_link_hash_entry *ret; 744 745 /* Set local fields. */ 746 ret = (struct generic_link_hash_entry *) entry; 747 ret->written = FALSE; 748 ret->sym = NULL; 749 } 750 751 return entry; 752 } 753 754 /* Create a generic link hash table. */ 755 756 struct bfd_link_hash_table * 757 _bfd_generic_link_hash_table_create (bfd *abfd) 758 { 759 struct generic_link_hash_table *ret; 760 bfd_size_type amt = sizeof (struct generic_link_hash_table); 761 762 ret = (struct generic_link_hash_table *) bfd_malloc (amt); 763 if (ret == NULL) 764 return NULL; 765 if (! _bfd_link_hash_table_init (&ret->root, abfd, 766 _bfd_generic_link_hash_newfunc, 767 sizeof (struct generic_link_hash_entry))) 768 { 769 free (ret); 770 return NULL; 771 } 772 return &ret->root; 773 } 774 775 void 776 _bfd_generic_link_hash_table_free (bfd *obfd) 777 { 778 struct generic_link_hash_table *ret; 779 780 BFD_ASSERT (obfd->is_linker_output && obfd->link.hash); 781 ret = (struct generic_link_hash_table *) obfd->link.hash; 782 bfd_hash_table_free (&ret->root.table); 783 free (ret); 784 obfd->link.hash = NULL; 785 obfd->is_linker_output = FALSE; 786 } 787 788 /* Grab the symbols for an object file when doing a generic link. We 789 store the symbols in the outsymbols field. We need to keep them 790 around for the entire link to ensure that we only read them once. 791 If we read them multiple times, we might wind up with relocs and 792 the hash table pointing to different instances of the symbol 793 structure. */ 794 795 bfd_boolean 796 bfd_generic_link_read_symbols (bfd *abfd) 797 { 798 if (bfd_get_outsymbols (abfd) == NULL) 799 { 800 long symsize; 801 long symcount; 802 803 symsize = bfd_get_symtab_upper_bound (abfd); 804 if (symsize < 0) 805 return FALSE; 806 bfd_get_outsymbols (abfd) = (struct bfd_symbol **) bfd_alloc (abfd, 807 symsize); 808 if (bfd_get_outsymbols (abfd) == NULL && symsize != 0) 809 return FALSE; 810 symcount = bfd_canonicalize_symtab (abfd, bfd_get_outsymbols (abfd)); 811 if (symcount < 0) 812 return FALSE; 813 bfd_get_symcount (abfd) = symcount; 814 } 815 816 return TRUE; 817 } 818 819 /* Generic function to add symbols to from an object file to the 820 global hash table. This version does not automatically collect 821 constructors by name. */ 822 823 bfd_boolean 824 _bfd_generic_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 825 { 826 return generic_link_add_symbols (abfd, info, FALSE); 827 } 828 829 /* Generic function to add symbols from an object file to the global 830 hash table. This version automatically collects constructors by 831 name, as the collect2 program does. It should be used for any 832 target which does not provide some other mechanism for setting up 833 constructors and destructors; these are approximately those targets 834 for which gcc uses collect2 and do not support stabs. */ 835 836 bfd_boolean 837 _bfd_generic_link_add_symbols_collect (bfd *abfd, struct bfd_link_info *info) 838 { 839 return generic_link_add_symbols (abfd, info, TRUE); 840 } 841 842 /* Indicate that we are only retrieving symbol values from this 843 section. We want the symbols to act as though the values in the 844 file are absolute. */ 845 846 void 847 _bfd_generic_link_just_syms (asection *sec, 848 struct bfd_link_info *info ATTRIBUTE_UNUSED) 849 { 850 sec->sec_info_type = SEC_INFO_TYPE_JUST_SYMS; 851 sec->output_section = bfd_abs_section_ptr; 852 sec->output_offset = sec->vma; 853 } 854 855 /* Copy the symbol type and other attributes for a linker script 856 assignment from HSRC to HDEST. 857 The default implementation does nothing. */ 858 void 859 _bfd_generic_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED, 860 struct bfd_link_hash_entry *hdest ATTRIBUTE_UNUSED, 861 struct bfd_link_hash_entry *hsrc ATTRIBUTE_UNUSED) 862 { 863 } 864 865 /* Add symbols from an object file to the global hash table. */ 866 867 static bfd_boolean 868 generic_link_add_symbols (bfd *abfd, 869 struct bfd_link_info *info, 870 bfd_boolean collect) 871 { 872 bfd_boolean ret; 873 874 switch (bfd_get_format (abfd)) 875 { 876 case bfd_object: 877 ret = generic_link_add_object_symbols (abfd, info, collect); 878 break; 879 case bfd_archive: 880 ret = (_bfd_generic_link_add_archive_symbols 881 (abfd, info, 882 (collect 883 ? generic_link_check_archive_element_collect 884 : generic_link_check_archive_element_no_collect))); 885 break; 886 default: 887 bfd_set_error (bfd_error_wrong_format); 888 ret = FALSE; 889 } 890 891 return ret; 892 } 893 894 /* Add symbols from an object file to the global hash table. */ 895 896 static bfd_boolean 897 generic_link_add_object_symbols (bfd *abfd, 898 struct bfd_link_info *info, 899 bfd_boolean collect) 900 { 901 bfd_size_type symcount; 902 struct bfd_symbol **outsyms; 903 904 if (!bfd_generic_link_read_symbols (abfd)) 905 return FALSE; 906 symcount = _bfd_generic_link_get_symcount (abfd); 907 outsyms = _bfd_generic_link_get_symbols (abfd); 908 return generic_link_add_symbol_list (abfd, info, symcount, outsyms, collect); 909 } 910 911 /* Generic function to add symbols from an archive file to the global 912 hash file. This function presumes that the archive symbol table 913 has already been read in (this is normally done by the 914 bfd_check_format entry point). It looks through the archive symbol 915 table for symbols that are undefined or common in the linker global 916 symbol hash table. When one is found, the CHECKFN argument is used 917 to see if an object file should be included. This allows targets 918 to customize common symbol behaviour. CHECKFN should set *PNEEDED 919 to TRUE if the object file should be included, and must also call 920 the bfd_link_info add_archive_element callback function and handle 921 adding the symbols to the global hash table. CHECKFN must notice 922 if the callback indicates a substitute BFD, and arrange to add 923 those symbols instead if it does so. CHECKFN should only return 924 FALSE if some sort of error occurs. */ 925 926 bfd_boolean 927 _bfd_generic_link_add_archive_symbols 928 (bfd *abfd, 929 struct bfd_link_info *info, 930 bfd_boolean (*checkfn) (bfd *, struct bfd_link_info *, 931 struct bfd_link_hash_entry *, const char *, 932 bfd_boolean *)) 933 { 934 bfd_boolean loop; 935 bfd_size_type amt; 936 unsigned char *included; 937 938 if (! bfd_has_map (abfd)) 939 { 940 /* An empty archive is a special case. */ 941 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 942 return TRUE; 943 bfd_set_error (bfd_error_no_armap); 944 return FALSE; 945 } 946 947 amt = bfd_ardata (abfd)->symdef_count; 948 if (amt == 0) 949 return TRUE; 950 amt *= sizeof (*included); 951 included = (unsigned char *) bfd_zmalloc (amt); 952 if (included == NULL) 953 return FALSE; 954 955 do 956 { 957 carsym *arsyms; 958 carsym *arsym_end; 959 carsym *arsym; 960 unsigned int indx; 961 file_ptr last_ar_offset = -1; 962 bfd_boolean needed = FALSE; 963 bfd *element = NULL; 964 965 loop = FALSE; 966 arsyms = bfd_ardata (abfd)->symdefs; 967 arsym_end = arsyms + bfd_ardata (abfd)->symdef_count; 968 for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++) 969 { 970 struct bfd_link_hash_entry *h; 971 struct bfd_link_hash_entry *undefs_tail; 972 973 if (included[indx]) 974 continue; 975 if (needed && arsym->file_offset == last_ar_offset) 976 { 977 included[indx] = 1; 978 continue; 979 } 980 981 h = bfd_link_hash_lookup (info->hash, arsym->name, 982 FALSE, FALSE, TRUE); 983 984 if (h == NULL 985 && info->pei386_auto_import 986 && CONST_STRNEQ (arsym->name, "__imp_")) 987 h = bfd_link_hash_lookup (info->hash, arsym->name + 6, 988 FALSE, FALSE, TRUE); 989 if (h == NULL) 990 continue; 991 992 if (h->type != bfd_link_hash_undefined 993 && h->type != bfd_link_hash_common) 994 { 995 if (h->type != bfd_link_hash_undefweak) 996 /* Symbol must be defined. Don't check it again. */ 997 included[indx] = 1; 998 continue; 999 } 1000 1001 if (last_ar_offset != arsym->file_offset) 1002 { 1003 last_ar_offset = arsym->file_offset; 1004 element = _bfd_get_elt_at_filepos (abfd, last_ar_offset); 1005 if (element == NULL 1006 || !bfd_check_format (element, bfd_object)) 1007 goto error_return; 1008 } 1009 1010 undefs_tail = info->hash->undefs_tail; 1011 1012 /* CHECKFN will see if this element should be included, and 1013 go ahead and include it if appropriate. */ 1014 if (! (*checkfn) (element, info, h, arsym->name, &needed)) 1015 goto error_return; 1016 1017 if (needed) 1018 { 1019 unsigned int mark; 1020 1021 /* Look backward to mark all symbols from this object file 1022 which we have already seen in this pass. */ 1023 mark = indx; 1024 do 1025 { 1026 included[mark] = 1; 1027 if (mark == 0) 1028 break; 1029 --mark; 1030 } 1031 while (arsyms[mark].file_offset == last_ar_offset); 1032 1033 if (undefs_tail != info->hash->undefs_tail) 1034 loop = TRUE; 1035 } 1036 } 1037 } while (loop); 1038 1039 free (included); 1040 return TRUE; 1041 1042 error_return: 1043 free (included); 1044 return FALSE; 1045 } 1046 1047 /* See if we should include an archive element. This version is used 1048 when we do not want to automatically collect constructors based on 1049 the symbol name, presumably because we have some other mechanism 1050 for finding them. */ 1051 1052 static bfd_boolean 1053 generic_link_check_archive_element_no_collect (bfd *abfd, 1054 struct bfd_link_info *info, 1055 struct bfd_link_hash_entry *h, 1056 const char *name, 1057 bfd_boolean *pneeded) 1058 { 1059 return generic_link_check_archive_element (abfd, info, h, name, pneeded, 1060 FALSE); 1061 } 1062 1063 /* See if we should include an archive element. This version is used 1064 when we want to automatically collect constructors based on the 1065 symbol name, as collect2 does. */ 1066 1067 static bfd_boolean 1068 generic_link_check_archive_element_collect (bfd *abfd, 1069 struct bfd_link_info *info, 1070 struct bfd_link_hash_entry *h, 1071 const char *name, 1072 bfd_boolean *pneeded) 1073 { 1074 return generic_link_check_archive_element (abfd, info, h, name, pneeded, 1075 TRUE); 1076 } 1077 1078 /* See if we should include an archive element. Optionally collect 1079 constructors. */ 1080 1081 static bfd_boolean 1082 generic_link_check_archive_element (bfd *abfd, 1083 struct bfd_link_info *info, 1084 struct bfd_link_hash_entry *h, 1085 const char *name ATTRIBUTE_UNUSED, 1086 bfd_boolean *pneeded, 1087 bfd_boolean collect) 1088 { 1089 asymbol **pp, **ppend; 1090 1091 *pneeded = FALSE; 1092 1093 if (!bfd_generic_link_read_symbols (abfd)) 1094 return FALSE; 1095 1096 pp = _bfd_generic_link_get_symbols (abfd); 1097 ppend = pp + _bfd_generic_link_get_symcount (abfd); 1098 for (; pp < ppend; pp++) 1099 { 1100 asymbol *p; 1101 1102 p = *pp; 1103 1104 /* We are only interested in globally visible symbols. */ 1105 if (! bfd_is_com_section (p->section) 1106 && (p->flags & (BSF_GLOBAL | BSF_INDIRECT | BSF_WEAK)) == 0) 1107 continue; 1108 1109 /* We are only interested if we know something about this 1110 symbol, and it is undefined or common. An undefined weak 1111 symbol (type bfd_link_hash_undefweak) is not considered to be 1112 a reference when pulling files out of an archive. See the 1113 SVR4 ABI, p. 4-27. */ 1114 h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), FALSE, 1115 FALSE, TRUE); 1116 if (h == NULL 1117 || (h->type != bfd_link_hash_undefined 1118 && h->type != bfd_link_hash_common)) 1119 continue; 1120 1121 /* P is a symbol we are looking for. */ 1122 1123 if (! bfd_is_com_section (p->section) 1124 || (h->type == bfd_link_hash_undefined 1125 && h->u.undef.abfd == NULL)) 1126 { 1127 /* P is not a common symbol, or an undefined reference was 1128 created from outside BFD such as from a linker -u option. 1129 This object file defines the symbol, so pull it in. */ 1130 *pneeded = TRUE; 1131 if (!(*info->callbacks 1132 ->add_archive_element) (info, abfd, bfd_asymbol_name (p), 1133 &abfd)) 1134 return FALSE; 1135 /* Potentially, the add_archive_element hook may have set a 1136 substitute BFD for us. */ 1137 return generic_link_add_object_symbols (abfd, info, collect); 1138 } 1139 1140 /* P is a common symbol. */ 1141 1142 if (h->type == bfd_link_hash_undefined) 1143 { 1144 bfd *symbfd; 1145 bfd_vma size; 1146 unsigned int power; 1147 1148 /* Turn the symbol into a common symbol but do not link in 1149 the object file. This is how a.out works. Object 1150 formats that require different semantics must implement 1151 this function differently. This symbol is already on the 1152 undefs list. We add the section to a common section 1153 attached to symbfd to ensure that it is in a BFD which 1154 will be linked in. */ 1155 symbfd = h->u.undef.abfd; 1156 h->type = bfd_link_hash_common; 1157 h->u.c.p = (struct bfd_link_hash_common_entry *) 1158 bfd_hash_allocate (&info->hash->table, 1159 sizeof (struct bfd_link_hash_common_entry)); 1160 if (h->u.c.p == NULL) 1161 return FALSE; 1162 1163 size = bfd_asymbol_value (p); 1164 h->u.c.size = size; 1165 1166 power = bfd_log2 (size); 1167 if (power > 4) 1168 power = 4; 1169 h->u.c.p->alignment_power = power; 1170 1171 if (p->section == bfd_com_section_ptr) 1172 h->u.c.p->section = bfd_make_section_old_way (symbfd, "COMMON"); 1173 else 1174 h->u.c.p->section = bfd_make_section_old_way (symbfd, 1175 p->section->name); 1176 h->u.c.p->section->flags |= SEC_ALLOC; 1177 } 1178 else 1179 { 1180 /* Adjust the size of the common symbol if necessary. This 1181 is how a.out works. Object formats that require 1182 different semantics must implement this function 1183 differently. */ 1184 if (bfd_asymbol_value (p) > h->u.c.size) 1185 h->u.c.size = bfd_asymbol_value (p); 1186 } 1187 } 1188 1189 /* This archive element is not needed. */ 1190 return TRUE; 1191 } 1192 1193 /* Add the symbols from an object file to the global hash table. ABFD 1194 is the object file. INFO is the linker information. SYMBOL_COUNT 1195 is the number of symbols. SYMBOLS is the list of symbols. COLLECT 1196 is TRUE if constructors should be automatically collected by name 1197 as is done by collect2. */ 1198 1199 static bfd_boolean 1200 generic_link_add_symbol_list (bfd *abfd, 1201 struct bfd_link_info *info, 1202 bfd_size_type symbol_count, 1203 asymbol **symbols, 1204 bfd_boolean collect) 1205 { 1206 asymbol **pp, **ppend; 1207 1208 pp = symbols; 1209 ppend = symbols + symbol_count; 1210 for (; pp < ppend; pp++) 1211 { 1212 asymbol *p; 1213 1214 p = *pp; 1215 1216 if ((p->flags & (BSF_INDIRECT 1217 | BSF_WARNING 1218 | BSF_GLOBAL 1219 | BSF_CONSTRUCTOR 1220 | BSF_WEAK)) != 0 1221 || bfd_is_und_section (bfd_get_section (p)) 1222 || bfd_is_com_section (bfd_get_section (p)) 1223 || bfd_is_ind_section (bfd_get_section (p))) 1224 { 1225 const char *name; 1226 const char *string; 1227 struct generic_link_hash_entry *h; 1228 struct bfd_link_hash_entry *bh; 1229 1230 string = name = bfd_asymbol_name (p); 1231 if (((p->flags & BSF_INDIRECT) != 0 1232 || bfd_is_ind_section (p->section)) 1233 && pp + 1 < ppend) 1234 { 1235 pp++; 1236 string = bfd_asymbol_name (*pp); 1237 } 1238 else if ((p->flags & BSF_WARNING) != 0 1239 && pp + 1 < ppend) 1240 { 1241 /* The name of P is actually the warning string, and the 1242 next symbol is the one to warn about. */ 1243 pp++; 1244 name = bfd_asymbol_name (*pp); 1245 } 1246 1247 bh = NULL; 1248 if (! (_bfd_generic_link_add_one_symbol 1249 (info, abfd, name, p->flags, bfd_get_section (p), 1250 p->value, string, FALSE, collect, &bh))) 1251 return FALSE; 1252 h = (struct generic_link_hash_entry *) bh; 1253 1254 /* If this is a constructor symbol, and the linker didn't do 1255 anything with it, then we want to just pass the symbol 1256 through to the output file. This will happen when 1257 linking with -r. */ 1258 if ((p->flags & BSF_CONSTRUCTOR) != 0 1259 && (h == NULL || h->root.type == bfd_link_hash_new)) 1260 { 1261 p->udata.p = NULL; 1262 continue; 1263 } 1264 1265 /* Save the BFD symbol so that we don't lose any backend 1266 specific information that may be attached to it. We only 1267 want this one if it gives more information than the 1268 existing one; we don't want to replace a defined symbol 1269 with an undefined one. This routine may be called with a 1270 hash table other than the generic hash table, so we only 1271 do this if we are certain that the hash table is a 1272 generic one. */ 1273 if (info->output_bfd->xvec == abfd->xvec) 1274 { 1275 if (h->sym == NULL 1276 || (! bfd_is_und_section (bfd_get_section (p)) 1277 && (! bfd_is_com_section (bfd_get_section (p)) 1278 || bfd_is_und_section (bfd_get_section (h->sym))))) 1279 { 1280 h->sym = p; 1281 /* BSF_OLD_COMMON is a hack to support COFF reloc 1282 reading, and it should go away when the COFF 1283 linker is switched to the new version. */ 1284 if (bfd_is_com_section (bfd_get_section (p))) 1285 p->flags |= BSF_OLD_COMMON; 1286 } 1287 } 1288 1289 /* Store a back pointer from the symbol to the hash 1290 table entry for the benefit of relaxation code until 1291 it gets rewritten to not use asymbol structures. 1292 Setting this is also used to check whether these 1293 symbols were set up by the generic linker. */ 1294 p->udata.p = h; 1295 } 1296 } 1297 1298 return TRUE; 1299 } 1300 1301 /* We use a state table to deal with adding symbols from an object 1302 file. The first index into the state table describes the symbol 1303 from the object file. The second index into the state table is the 1304 type of the symbol in the hash table. */ 1305 1306 /* The symbol from the object file is turned into one of these row 1307 values. */ 1308 1309 enum link_row 1310 { 1311 UNDEF_ROW, /* Undefined. */ 1312 UNDEFW_ROW, /* Weak undefined. */ 1313 DEF_ROW, /* Defined. */ 1314 DEFW_ROW, /* Weak defined. */ 1315 COMMON_ROW, /* Common. */ 1316 INDR_ROW, /* Indirect. */ 1317 WARN_ROW, /* Warning. */ 1318 SET_ROW /* Member of set. */ 1319 }; 1320 1321 /* apparently needed for Hitachi 3050R(HI-UX/WE2)? */ 1322 #undef FAIL 1323 1324 /* The actions to take in the state table. */ 1325 1326 enum link_action 1327 { 1328 FAIL, /* Abort. */ 1329 UND, /* Mark symbol undefined. */ 1330 WEAK, /* Mark symbol weak undefined. */ 1331 DEF, /* Mark symbol defined. */ 1332 DEFW, /* Mark symbol weak defined. */ 1333 COM, /* Mark symbol common. */ 1334 REF, /* Mark defined symbol referenced. */ 1335 CREF, /* Possibly warn about common reference to defined symbol. */ 1336 CDEF, /* Define existing common symbol. */ 1337 NOACT, /* No action. */ 1338 BIG, /* Mark symbol common using largest size. */ 1339 MDEF, /* Multiple definition error. */ 1340 MIND, /* Multiple indirect symbols. */ 1341 IND, /* Make indirect symbol. */ 1342 CIND, /* Make indirect symbol from existing common symbol. */ 1343 SET, /* Add value to set. */ 1344 MWARN, /* Make warning symbol. */ 1345 WARN, /* Warn if referenced, else MWARN. */ 1346 CYCLE, /* Repeat with symbol pointed to. */ 1347 REFC, /* Mark indirect symbol referenced and then CYCLE. */ 1348 WARNC /* Issue warning and then CYCLE. */ 1349 }; 1350 1351 /* The state table itself. The first index is a link_row and the 1352 second index is a bfd_link_hash_type. */ 1353 1354 static const enum link_action link_action[8][8] = 1355 { 1356 /* current\prev new undef undefw def defw com indr warn */ 1357 /* UNDEF_ROW */ {UND, NOACT, UND, REF, REF, NOACT, REFC, WARNC }, 1358 /* UNDEFW_ROW */ {WEAK, NOACT, NOACT, REF, REF, NOACT, REFC, WARNC }, 1359 /* DEF_ROW */ {DEF, DEF, DEF, MDEF, DEF, CDEF, MDEF, CYCLE }, 1360 /* DEFW_ROW */ {DEFW, DEFW, DEFW, NOACT, NOACT, NOACT, NOACT, CYCLE }, 1361 /* COMMON_ROW */ {COM, COM, COM, CREF, COM, BIG, REFC, WARNC }, 1362 /* INDR_ROW */ {IND, IND, IND, MDEF, IND, CIND, MIND, CYCLE }, 1363 /* WARN_ROW */ {MWARN, WARN, WARN, WARN, WARN, WARN, WARN, NOACT }, 1364 /* SET_ROW */ {SET, SET, SET, SET, SET, SET, CYCLE, CYCLE } 1365 }; 1366 1367 /* Most of the entries in the LINK_ACTION table are straightforward, 1368 but a few are somewhat subtle. 1369 1370 A reference to an indirect symbol (UNDEF_ROW/indr or 1371 UNDEFW_ROW/indr) is counted as a reference both to the indirect 1372 symbol and to the symbol the indirect symbol points to. 1373 1374 A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn) 1375 causes the warning to be issued. 1376 1377 A common definition of an indirect symbol (COMMON_ROW/indr) is 1378 treated as a multiple definition error. Likewise for an indirect 1379 definition of a common symbol (INDR_ROW/com). 1380 1381 An indirect definition of a warning (INDR_ROW/warn) does not cause 1382 the warning to be issued. 1383 1384 If a warning is created for an indirect symbol (WARN_ROW/indr) no 1385 warning is created for the symbol the indirect symbol points to. 1386 1387 Adding an entry to a set does not count as a reference to a set, 1388 and no warning is issued (SET_ROW/warn). */ 1389 1390 /* Return the BFD in which a hash entry has been defined, if known. */ 1391 1392 static bfd * 1393 hash_entry_bfd (struct bfd_link_hash_entry *h) 1394 { 1395 while (h->type == bfd_link_hash_warning) 1396 h = h->u.i.link; 1397 switch (h->type) 1398 { 1399 default: 1400 return NULL; 1401 case bfd_link_hash_undefined: 1402 case bfd_link_hash_undefweak: 1403 return h->u.undef.abfd; 1404 case bfd_link_hash_defined: 1405 case bfd_link_hash_defweak: 1406 return h->u.def.section->owner; 1407 case bfd_link_hash_common: 1408 return h->u.c.p->section->owner; 1409 } 1410 /*NOTREACHED*/ 1411 } 1412 1413 /* Add a symbol to the global hash table. 1414 ABFD is the BFD the symbol comes from. 1415 NAME is the name of the symbol. 1416 FLAGS is the BSF_* bits associated with the symbol. 1417 SECTION is the section in which the symbol is defined; this may be 1418 bfd_und_section_ptr or bfd_com_section_ptr. 1419 VALUE is the value of the symbol, relative to the section. 1420 STRING is used for either an indirect symbol, in which case it is 1421 the name of the symbol to indirect to, or a warning symbol, in 1422 which case it is the warning string. 1423 COPY is TRUE if NAME or STRING must be copied into locally 1424 allocated memory if they need to be saved. 1425 COLLECT is TRUE if we should automatically collect gcc constructor 1426 or destructor names as collect2 does. 1427 HASHP, if not NULL, is a place to store the created hash table 1428 entry; if *HASHP is not NULL, the caller has already looked up 1429 the hash table entry, and stored it in *HASHP. */ 1430 1431 bfd_boolean 1432 _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, 1433 bfd *abfd, 1434 const char *name, 1435 flagword flags, 1436 asection *section, 1437 bfd_vma value, 1438 const char *string, 1439 bfd_boolean copy, 1440 bfd_boolean collect, 1441 struct bfd_link_hash_entry **hashp) 1442 { 1443 enum link_row row; 1444 struct bfd_link_hash_entry *h; 1445 struct bfd_link_hash_entry *inh = NULL; 1446 bfd_boolean cycle; 1447 1448 BFD_ASSERT (section != NULL); 1449 1450 if (bfd_is_ind_section (section) 1451 || (flags & BSF_INDIRECT) != 0) 1452 { 1453 row = INDR_ROW; 1454 /* Create the indirect symbol here. This is for the benefit of 1455 the plugin "notice" function. 1456 STRING is the name of the symbol we want to indirect to. */ 1457 inh = bfd_wrapped_link_hash_lookup (abfd, info, string, TRUE, 1458 copy, FALSE); 1459 if (inh == NULL) 1460 return FALSE; 1461 } 1462 else if ((flags & BSF_WARNING) != 0) 1463 row = WARN_ROW; 1464 else if ((flags & BSF_CONSTRUCTOR) != 0) 1465 row = SET_ROW; 1466 else if (bfd_is_und_section (section)) 1467 { 1468 if ((flags & BSF_WEAK) != 0) 1469 row = UNDEFW_ROW; 1470 else 1471 row = UNDEF_ROW; 1472 } 1473 else if ((flags & BSF_WEAK) != 0) 1474 row = DEFW_ROW; 1475 else if (bfd_is_com_section (section)) 1476 { 1477 row = COMMON_ROW; 1478 if (strcmp (name, "__gnu_lto_slim") == 0) 1479 (*_bfd_error_handler) 1480 (_("%s: plugin needed to handle lto object"), 1481 bfd_get_filename (abfd)); 1482 } 1483 else 1484 row = DEF_ROW; 1485 1486 if (hashp != NULL && *hashp != NULL) 1487 h = *hashp; 1488 else 1489 { 1490 if (row == UNDEF_ROW || row == UNDEFW_ROW) 1491 h = bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE); 1492 else 1493 h = bfd_link_hash_lookup (info->hash, name, TRUE, copy, FALSE); 1494 if (h == NULL) 1495 { 1496 if (hashp != NULL) 1497 *hashp = NULL; 1498 return FALSE; 1499 } 1500 } 1501 1502 if (info->notice_all 1503 || (info->notice_hash != NULL 1504 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)) 1505 { 1506 if (! (*info->callbacks->notice) (info, h, inh, 1507 abfd, section, value, flags)) 1508 return FALSE; 1509 } 1510 1511 if (hashp != NULL) 1512 *hashp = h; 1513 1514 do 1515 { 1516 enum link_action action; 1517 1518 cycle = FALSE; 1519 action = link_action[(int) row][(int) h->type]; 1520 switch (action) 1521 { 1522 case FAIL: 1523 abort (); 1524 1525 case NOACT: 1526 /* Do nothing. */ 1527 break; 1528 1529 case UND: 1530 /* Make a new undefined symbol. */ 1531 h->type = bfd_link_hash_undefined; 1532 h->u.undef.abfd = abfd; 1533 bfd_link_add_undef (info->hash, h); 1534 break; 1535 1536 case WEAK: 1537 /* Make a new weak undefined symbol. */ 1538 h->type = bfd_link_hash_undefweak; 1539 h->u.undef.abfd = abfd; 1540 break; 1541 1542 case CDEF: 1543 /* We have found a definition for a symbol which was 1544 previously common. */ 1545 BFD_ASSERT (h->type == bfd_link_hash_common); 1546 if (! ((*info->callbacks->multiple_common) 1547 (info, h, abfd, bfd_link_hash_defined, 0))) 1548 return FALSE; 1549 /* Fall through. */ 1550 case DEF: 1551 case DEFW: 1552 { 1553 enum bfd_link_hash_type oldtype; 1554 1555 /* Define a symbol. */ 1556 oldtype = h->type; 1557 if (action == DEFW) 1558 h->type = bfd_link_hash_defweak; 1559 else 1560 h->type = bfd_link_hash_defined; 1561 h->u.def.section = section; 1562 h->u.def.value = value; 1563 h->linker_def = 0; 1564 1565 /* If we have been asked to, we act like collect2 and 1566 identify all functions that might be global 1567 constructors and destructors and pass them up in a 1568 callback. We only do this for certain object file 1569 types, since many object file types can handle this 1570 automatically. */ 1571 if (collect && name[0] == '_') 1572 { 1573 const char *s; 1574 1575 /* A constructor or destructor name starts like this: 1576 _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and 1577 the second are the same character (we accept any 1578 character there, in case a new object file format 1579 comes along with even worse naming restrictions). */ 1580 1581 #define CONS_PREFIX "GLOBAL_" 1582 #define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1) 1583 1584 s = name + 1; 1585 while (*s == '_') 1586 ++s; 1587 if (s[0] == 'G' && CONST_STRNEQ (s, CONS_PREFIX)) 1588 { 1589 char c; 1590 1591 c = s[CONS_PREFIX_LEN + 1]; 1592 if ((c == 'I' || c == 'D') 1593 && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2]) 1594 { 1595 /* If this is a definition of a symbol which 1596 was previously weakly defined, we are in 1597 trouble. We have already added a 1598 constructor entry for the weak defined 1599 symbol, and now we are trying to add one 1600 for the new symbol. Fortunately, this case 1601 should never arise in practice. */ 1602 if (oldtype == bfd_link_hash_defweak) 1603 abort (); 1604 1605 if (! ((*info->callbacks->constructor) 1606 (info, c == 'I', 1607 h->root.string, abfd, section, value))) 1608 return FALSE; 1609 } 1610 } 1611 } 1612 } 1613 1614 break; 1615 1616 case COM: 1617 /* We have found a common definition for a symbol. */ 1618 if (h->type == bfd_link_hash_new) 1619 bfd_link_add_undef (info->hash, h); 1620 h->type = bfd_link_hash_common; 1621 h->u.c.p = (struct bfd_link_hash_common_entry *) 1622 bfd_hash_allocate (&info->hash->table, 1623 sizeof (struct bfd_link_hash_common_entry)); 1624 if (h->u.c.p == NULL) 1625 return FALSE; 1626 1627 h->u.c.size = value; 1628 1629 /* Select a default alignment based on the size. This may 1630 be overridden by the caller. */ 1631 { 1632 unsigned int power; 1633 1634 power = bfd_log2 (value); 1635 if (power > 4) 1636 power = 4; 1637 h->u.c.p->alignment_power = power; 1638 } 1639 1640 /* The section of a common symbol is only used if the common 1641 symbol is actually allocated. It basically provides a 1642 hook for the linker script to decide which output section 1643 the common symbols should be put in. In most cases, the 1644 section of a common symbol will be bfd_com_section_ptr, 1645 the code here will choose a common symbol section named 1646 "COMMON", and the linker script will contain *(COMMON) in 1647 the appropriate place. A few targets use separate common 1648 sections for small symbols, and they require special 1649 handling. */ 1650 if (section == bfd_com_section_ptr) 1651 { 1652 h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON"); 1653 h->u.c.p->section->flags |= SEC_ALLOC; 1654 } 1655 else if (section->owner != abfd) 1656 { 1657 h->u.c.p->section = bfd_make_section_old_way (abfd, 1658 section->name); 1659 h->u.c.p->section->flags |= SEC_ALLOC; 1660 } 1661 else 1662 h->u.c.p->section = section; 1663 h->linker_def = 0; 1664 break; 1665 1666 case REF: 1667 /* A reference to a defined symbol. */ 1668 if (h->u.undef.next == NULL && info->hash->undefs_tail != h) 1669 h->u.undef.next = h; 1670 break; 1671 1672 case BIG: 1673 /* We have found a common definition for a symbol which 1674 already had a common definition. Use the maximum of the 1675 two sizes, and use the section required by the larger symbol. */ 1676 BFD_ASSERT (h->type == bfd_link_hash_common); 1677 if (! ((*info->callbacks->multiple_common) 1678 (info, h, abfd, bfd_link_hash_common, value))) 1679 return FALSE; 1680 if (value > h->u.c.size) 1681 { 1682 unsigned int power; 1683 1684 h->u.c.size = value; 1685 1686 /* Select a default alignment based on the size. This may 1687 be overridden by the caller. */ 1688 power = bfd_log2 (value); 1689 if (power > 4) 1690 power = 4; 1691 h->u.c.p->alignment_power = power; 1692 1693 /* Some systems have special treatment for small commons, 1694 hence we want to select the section used by the larger 1695 symbol. This makes sure the symbol does not go in a 1696 small common section if it is now too large. */ 1697 if (section == bfd_com_section_ptr) 1698 { 1699 h->u.c.p->section 1700 = bfd_make_section_old_way (abfd, "COMMON"); 1701 h->u.c.p->section->flags |= SEC_ALLOC; 1702 } 1703 else if (section->owner != abfd) 1704 { 1705 h->u.c.p->section 1706 = bfd_make_section_old_way (abfd, section->name); 1707 h->u.c.p->section->flags |= SEC_ALLOC; 1708 } 1709 else 1710 h->u.c.p->section = section; 1711 } 1712 break; 1713 1714 case CREF: 1715 /* We have found a common definition for a symbol which 1716 was already defined. */ 1717 if (! ((*info->callbacks->multiple_common) 1718 (info, h, abfd, bfd_link_hash_common, value))) 1719 return FALSE; 1720 break; 1721 1722 case MIND: 1723 /* Multiple indirect symbols. This is OK if they both point 1724 to the same symbol. */ 1725 if (strcmp (h->u.i.link->root.string, string) == 0) 1726 break; 1727 /* Fall through. */ 1728 case MDEF: 1729 /* Handle a multiple definition. */ 1730 if (! ((*info->callbacks->multiple_definition) 1731 (info, h, abfd, section, value))) 1732 return FALSE; 1733 break; 1734 1735 case CIND: 1736 /* Create an indirect symbol from an existing common symbol. */ 1737 BFD_ASSERT (h->type == bfd_link_hash_common); 1738 if (! ((*info->callbacks->multiple_common) 1739 (info, h, abfd, bfd_link_hash_indirect, 0))) 1740 return FALSE; 1741 /* Fall through. */ 1742 case IND: 1743 if (inh->type == bfd_link_hash_indirect 1744 && inh->u.i.link == h) 1745 { 1746 (*_bfd_error_handler) 1747 (_("%B: indirect symbol `%s' to `%s' is a loop"), 1748 abfd, name, string); 1749 bfd_set_error (bfd_error_invalid_operation); 1750 return FALSE; 1751 } 1752 if (inh->type == bfd_link_hash_new) 1753 { 1754 inh->type = bfd_link_hash_undefined; 1755 inh->u.undef.abfd = abfd; 1756 bfd_link_add_undef (info->hash, inh); 1757 } 1758 1759 /* If the indirect symbol has been referenced, we need to 1760 push the reference down to the symbol we are referencing. */ 1761 if (h->type != bfd_link_hash_new) 1762 { 1763 /* ??? If inh->type == bfd_link_hash_undefweak this 1764 converts inh to bfd_link_hash_undefined. */ 1765 row = UNDEF_ROW; 1766 cycle = TRUE; 1767 } 1768 1769 h->type = bfd_link_hash_indirect; 1770 h->u.i.link = inh; 1771 /* Not setting h = h->u.i.link here means that when cycle is 1772 set above we'll always go to REFC, and then cycle again 1773 to the indirected symbol. This means that any successful 1774 change of an existing symbol to indirect counts as a 1775 reference. ??? That may not be correct when the existing 1776 symbol was defweak. */ 1777 break; 1778 1779 case SET: 1780 /* Add an entry to a set. */ 1781 if (! (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR, 1782 abfd, section, value)) 1783 return FALSE; 1784 break; 1785 1786 case WARNC: 1787 /* Issue a warning and cycle, except when the reference is 1788 in LTO IR. */ 1789 if (h->u.i.warning != NULL 1790 && (abfd->flags & BFD_PLUGIN) == 0) 1791 { 1792 if (! (*info->callbacks->warning) (info, h->u.i.warning, 1793 h->root.string, abfd, 1794 NULL, 0)) 1795 return FALSE; 1796 /* Only issue a warning once. */ 1797 h->u.i.warning = NULL; 1798 } 1799 /* Fall through. */ 1800 case CYCLE: 1801 /* Try again with the referenced symbol. */ 1802 h = h->u.i.link; 1803 cycle = TRUE; 1804 break; 1805 1806 case REFC: 1807 /* A reference to an indirect symbol. */ 1808 if (h->u.undef.next == NULL && info->hash->undefs_tail != h) 1809 h->u.undef.next = h; 1810 h = h->u.i.link; 1811 cycle = TRUE; 1812 break; 1813 1814 case WARN: 1815 /* Warn if this symbol has been referenced already from non-IR, 1816 otherwise add a warning. */ 1817 if ((!info->lto_plugin_active 1818 && (h->u.undef.next != NULL || info->hash->undefs_tail == h)) 1819 || h->non_ir_ref) 1820 { 1821 if (! (*info->callbacks->warning) (info, string, h->root.string, 1822 hash_entry_bfd (h), NULL, 0)) 1823 return FALSE; 1824 break; 1825 } 1826 /* Fall through. */ 1827 case MWARN: 1828 /* Make a warning symbol. */ 1829 { 1830 struct bfd_link_hash_entry *sub; 1831 1832 /* STRING is the warning to give. */ 1833 sub = ((struct bfd_link_hash_entry *) 1834 ((*info->hash->table.newfunc) 1835 (NULL, &info->hash->table, h->root.string))); 1836 if (sub == NULL) 1837 return FALSE; 1838 *sub = *h; 1839 sub->type = bfd_link_hash_warning; 1840 sub->u.i.link = h; 1841 if (! copy) 1842 sub->u.i.warning = string; 1843 else 1844 { 1845 char *w; 1846 size_t len = strlen (string) + 1; 1847 1848 w = (char *) bfd_hash_allocate (&info->hash->table, len); 1849 if (w == NULL) 1850 return FALSE; 1851 memcpy (w, string, len); 1852 sub->u.i.warning = w; 1853 } 1854 1855 bfd_hash_replace (&info->hash->table, 1856 (struct bfd_hash_entry *) h, 1857 (struct bfd_hash_entry *) sub); 1858 if (hashp != NULL) 1859 *hashp = sub; 1860 } 1861 break; 1862 } 1863 } 1864 while (cycle); 1865 1866 return TRUE; 1867 } 1868 1869 /* Generic final link routine. */ 1870 1871 bfd_boolean 1872 _bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info) 1873 { 1874 bfd *sub; 1875 asection *o; 1876 struct bfd_link_order *p; 1877 size_t outsymalloc; 1878 struct generic_write_global_symbol_info wginfo; 1879 1880 bfd_get_outsymbols (abfd) = NULL; 1881 bfd_get_symcount (abfd) = 0; 1882 outsymalloc = 0; 1883 1884 /* Mark all sections which will be included in the output file. */ 1885 for (o = abfd->sections; o != NULL; o = o->next) 1886 for (p = o->map_head.link_order; p != NULL; p = p->next) 1887 if (p->type == bfd_indirect_link_order) 1888 p->u.indirect.section->linker_mark = TRUE; 1889 1890 /* Build the output symbol table. */ 1891 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 1892 if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc)) 1893 return FALSE; 1894 1895 /* Accumulate the global symbols. */ 1896 wginfo.info = info; 1897 wginfo.output_bfd = abfd; 1898 wginfo.psymalloc = &outsymalloc; 1899 _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info), 1900 _bfd_generic_link_write_global_symbol, 1901 &wginfo); 1902 1903 /* Make sure we have a trailing NULL pointer on OUTSYMBOLS. We 1904 shouldn't really need one, since we have SYMCOUNT, but some old 1905 code still expects one. */ 1906 if (! generic_add_output_symbol (abfd, &outsymalloc, NULL)) 1907 return FALSE; 1908 1909 if (info->relocatable) 1910 { 1911 /* Allocate space for the output relocs for each section. */ 1912 for (o = abfd->sections; o != NULL; o = o->next) 1913 { 1914 o->reloc_count = 0; 1915 for (p = o->map_head.link_order; p != NULL; p = p->next) 1916 { 1917 if (p->type == bfd_section_reloc_link_order 1918 || p->type == bfd_symbol_reloc_link_order) 1919 ++o->reloc_count; 1920 else if (p->type == bfd_indirect_link_order) 1921 { 1922 asection *input_section; 1923 bfd *input_bfd; 1924 long relsize; 1925 arelent **relocs; 1926 asymbol **symbols; 1927 long reloc_count; 1928 1929 input_section = p->u.indirect.section; 1930 input_bfd = input_section->owner; 1931 relsize = bfd_get_reloc_upper_bound (input_bfd, 1932 input_section); 1933 if (relsize < 0) 1934 return FALSE; 1935 relocs = (arelent **) bfd_malloc (relsize); 1936 if (!relocs && relsize != 0) 1937 return FALSE; 1938 symbols = _bfd_generic_link_get_symbols (input_bfd); 1939 reloc_count = bfd_canonicalize_reloc (input_bfd, 1940 input_section, 1941 relocs, 1942 symbols); 1943 free (relocs); 1944 if (reloc_count < 0) 1945 return FALSE; 1946 BFD_ASSERT ((unsigned long) reloc_count 1947 == input_section->reloc_count); 1948 o->reloc_count += reloc_count; 1949 } 1950 } 1951 if (o->reloc_count > 0) 1952 { 1953 bfd_size_type amt; 1954 1955 amt = o->reloc_count; 1956 amt *= sizeof (arelent *); 1957 o->orelocation = (struct reloc_cache_entry **) bfd_alloc (abfd, amt); 1958 if (!o->orelocation) 1959 return FALSE; 1960 o->flags |= SEC_RELOC; 1961 /* Reset the count so that it can be used as an index 1962 when putting in the output relocs. */ 1963 o->reloc_count = 0; 1964 } 1965 } 1966 } 1967 1968 /* Handle all the link order information for the sections. */ 1969 for (o = abfd->sections; o != NULL; o = o->next) 1970 { 1971 for (p = o->map_head.link_order; p != NULL; p = p->next) 1972 { 1973 switch (p->type) 1974 { 1975 case bfd_section_reloc_link_order: 1976 case bfd_symbol_reloc_link_order: 1977 if (! _bfd_generic_reloc_link_order (abfd, info, o, p)) 1978 return FALSE; 1979 break; 1980 case bfd_indirect_link_order: 1981 if (! default_indirect_link_order (abfd, info, o, p, TRUE)) 1982 return FALSE; 1983 break; 1984 default: 1985 if (! _bfd_default_link_order (abfd, info, o, p)) 1986 return FALSE; 1987 break; 1988 } 1989 } 1990 } 1991 1992 return TRUE; 1993 } 1994 1995 /* Add an output symbol to the output BFD. */ 1996 1997 static bfd_boolean 1998 generic_add_output_symbol (bfd *output_bfd, size_t *psymalloc, asymbol *sym) 1999 { 2000 if (bfd_get_symcount (output_bfd) >= *psymalloc) 2001 { 2002 asymbol **newsyms; 2003 bfd_size_type amt; 2004 2005 if (*psymalloc == 0) 2006 *psymalloc = 124; 2007 else 2008 *psymalloc *= 2; 2009 amt = *psymalloc; 2010 amt *= sizeof (asymbol *); 2011 newsyms = (asymbol **) bfd_realloc (bfd_get_outsymbols (output_bfd), amt); 2012 if (newsyms == NULL) 2013 return FALSE; 2014 bfd_get_outsymbols (output_bfd) = newsyms; 2015 } 2016 2017 bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym; 2018 if (sym != NULL) 2019 ++ bfd_get_symcount (output_bfd); 2020 2021 return TRUE; 2022 } 2023 2024 /* Handle the symbols for an input BFD. */ 2025 2026 bfd_boolean 2027 _bfd_generic_link_output_symbols (bfd *output_bfd, 2028 bfd *input_bfd, 2029 struct bfd_link_info *info, 2030 size_t *psymalloc) 2031 { 2032 asymbol **sym_ptr; 2033 asymbol **sym_end; 2034 2035 if (!bfd_generic_link_read_symbols (input_bfd)) 2036 return FALSE; 2037 2038 /* Create a filename symbol if we are supposed to. */ 2039 if (info->create_object_symbols_section != NULL) 2040 { 2041 asection *sec; 2042 2043 for (sec = input_bfd->sections; sec != NULL; sec = sec->next) 2044 { 2045 if (sec->output_section == info->create_object_symbols_section) 2046 { 2047 asymbol *newsym; 2048 2049 newsym = bfd_make_empty_symbol (input_bfd); 2050 if (!newsym) 2051 return FALSE; 2052 newsym->name = input_bfd->filename; 2053 newsym->value = 0; 2054 newsym->flags = BSF_LOCAL | BSF_FILE; 2055 newsym->section = sec; 2056 2057 if (! generic_add_output_symbol (output_bfd, psymalloc, 2058 newsym)) 2059 return FALSE; 2060 2061 break; 2062 } 2063 } 2064 } 2065 2066 /* Adjust the values of the globally visible symbols, and write out 2067 local symbols. */ 2068 sym_ptr = _bfd_generic_link_get_symbols (input_bfd); 2069 sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd); 2070 for (; sym_ptr < sym_end; sym_ptr++) 2071 { 2072 asymbol *sym; 2073 struct generic_link_hash_entry *h; 2074 bfd_boolean output; 2075 2076 h = NULL; 2077 sym = *sym_ptr; 2078 if ((sym->flags & (BSF_INDIRECT 2079 | BSF_WARNING 2080 | BSF_GLOBAL 2081 | BSF_CONSTRUCTOR 2082 | BSF_WEAK)) != 0 2083 || bfd_is_und_section (bfd_get_section (sym)) 2084 || bfd_is_com_section (bfd_get_section (sym)) 2085 || bfd_is_ind_section (bfd_get_section (sym))) 2086 { 2087 if (sym->udata.p != NULL) 2088 h = (struct generic_link_hash_entry *) sym->udata.p; 2089 else if ((sym->flags & BSF_CONSTRUCTOR) != 0) 2090 { 2091 /* This case normally means that the main linker code 2092 deliberately ignored this constructor symbol. We 2093 should just pass it through. This will screw up if 2094 the constructor symbol is from a different, 2095 non-generic, object file format, but the case will 2096 only arise when linking with -r, which will probably 2097 fail anyhow, since there will be no way to represent 2098 the relocs in the output format being used. */ 2099 h = NULL; 2100 } 2101 else if (bfd_is_und_section (bfd_get_section (sym))) 2102 h = ((struct generic_link_hash_entry *) 2103 bfd_wrapped_link_hash_lookup (output_bfd, info, 2104 bfd_asymbol_name (sym), 2105 FALSE, FALSE, TRUE)); 2106 else 2107 h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info), 2108 bfd_asymbol_name (sym), 2109 FALSE, FALSE, TRUE); 2110 2111 if (h != NULL) 2112 { 2113 /* Force all references to this symbol to point to 2114 the same area in memory. It is possible that 2115 this routine will be called with a hash table 2116 other than a generic hash table, so we double 2117 check that. */ 2118 if (info->output_bfd->xvec == input_bfd->xvec) 2119 { 2120 if (h->sym != NULL) 2121 *sym_ptr = sym = h->sym; 2122 } 2123 2124 switch (h->root.type) 2125 { 2126 default: 2127 case bfd_link_hash_new: 2128 abort (); 2129 case bfd_link_hash_undefined: 2130 break; 2131 case bfd_link_hash_undefweak: 2132 sym->flags |= BSF_WEAK; 2133 break; 2134 case bfd_link_hash_indirect: 2135 h = (struct generic_link_hash_entry *) h->root.u.i.link; 2136 /* fall through */ 2137 case bfd_link_hash_defined: 2138 sym->flags |= BSF_GLOBAL; 2139 sym->flags &=~ (BSF_WEAK | BSF_CONSTRUCTOR); 2140 sym->value = h->root.u.def.value; 2141 sym->section = h->root.u.def.section; 2142 break; 2143 case bfd_link_hash_defweak: 2144 sym->flags |= BSF_WEAK; 2145 sym->flags &=~ BSF_CONSTRUCTOR; 2146 sym->value = h->root.u.def.value; 2147 sym->section = h->root.u.def.section; 2148 break; 2149 case bfd_link_hash_common: 2150 sym->value = h->root.u.c.size; 2151 sym->flags |= BSF_GLOBAL; 2152 if (! bfd_is_com_section (sym->section)) 2153 { 2154 BFD_ASSERT (bfd_is_und_section (sym->section)); 2155 sym->section = bfd_com_section_ptr; 2156 } 2157 /* We do not set the section of the symbol to 2158 h->root.u.c.p->section. That value was saved so 2159 that we would know where to allocate the symbol 2160 if it was defined. In this case the type is 2161 still bfd_link_hash_common, so we did not define 2162 it, so we do not want to use that section. */ 2163 break; 2164 } 2165 } 2166 } 2167 2168 /* This switch is straight from the old code in 2169 write_file_locals in ldsym.c. */ 2170 if (info->strip == strip_all 2171 || (info->strip == strip_some 2172 && bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym), 2173 FALSE, FALSE) == NULL)) 2174 output = FALSE; 2175 else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0) 2176 { 2177 /* If this symbol is marked as occurring now, rather 2178 than at the end, output it now. This is used for 2179 COFF C_EXT FCN symbols. FIXME: There must be a 2180 better way. */ 2181 if (bfd_asymbol_bfd (sym) == input_bfd 2182 && (sym->flags & BSF_NOT_AT_END) != 0) 2183 output = TRUE; 2184 else 2185 output = FALSE; 2186 } 2187 else if (bfd_is_ind_section (sym->section)) 2188 output = FALSE; 2189 else if ((sym->flags & BSF_DEBUGGING) != 0) 2190 { 2191 if (info->strip == strip_none) 2192 output = TRUE; 2193 else 2194 output = FALSE; 2195 } 2196 else if (bfd_is_und_section (sym->section) 2197 || bfd_is_com_section (sym->section)) 2198 output = FALSE; 2199 else if ((sym->flags & BSF_LOCAL) != 0) 2200 { 2201 if ((sym->flags & BSF_WARNING) != 0) 2202 output = FALSE; 2203 else 2204 { 2205 switch (info->discard) 2206 { 2207 default: 2208 case discard_all: 2209 output = FALSE; 2210 break; 2211 case discard_sec_merge: 2212 output = TRUE; 2213 if (info->relocatable 2214 || ! (sym->section->flags & SEC_MERGE)) 2215 break; 2216 /* FALLTHROUGH */ 2217 case discard_l: 2218 if (bfd_is_local_label (input_bfd, sym)) 2219 output = FALSE; 2220 else 2221 output = TRUE; 2222 break; 2223 case discard_none: 2224 output = TRUE; 2225 break; 2226 } 2227 } 2228 } 2229 else if ((sym->flags & BSF_CONSTRUCTOR)) 2230 { 2231 if (info->strip != strip_all) 2232 output = TRUE; 2233 else 2234 output = FALSE; 2235 } 2236 else if (sym->flags == 0 2237 && (sym->section->owner->flags & BFD_PLUGIN) != 0) 2238 /* LTO doesn't set symbol information. We get here with the 2239 generic linker for a symbol that was "common" but no longer 2240 needs to be global. */ 2241 output = FALSE; 2242 else 2243 abort (); 2244 2245 /* If this symbol is in a section which is not being included 2246 in the output file, then we don't want to output the 2247 symbol. */ 2248 if (!bfd_is_abs_section (sym->section) 2249 && bfd_section_removed_from_list (output_bfd, 2250 sym->section->output_section)) 2251 output = FALSE; 2252 2253 if (output) 2254 { 2255 if (! generic_add_output_symbol (output_bfd, psymalloc, sym)) 2256 return FALSE; 2257 if (h != NULL) 2258 h->written = TRUE; 2259 } 2260 } 2261 2262 return TRUE; 2263 } 2264 2265 /* Set the section and value of a generic BFD symbol based on a linker 2266 hash table entry. */ 2267 2268 static void 2269 set_symbol_from_hash (asymbol *sym, struct bfd_link_hash_entry *h) 2270 { 2271 switch (h->type) 2272 { 2273 default: 2274 abort (); 2275 break; 2276 case bfd_link_hash_new: 2277 /* This can happen when a constructor symbol is seen but we are 2278 not building constructors. */ 2279 if (sym->section != NULL) 2280 { 2281 BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0); 2282 } 2283 else 2284 { 2285 sym->flags |= BSF_CONSTRUCTOR; 2286 sym->section = bfd_abs_section_ptr; 2287 sym->value = 0; 2288 } 2289 break; 2290 case bfd_link_hash_undefined: 2291 sym->section = bfd_und_section_ptr; 2292 sym->value = 0; 2293 break; 2294 case bfd_link_hash_undefweak: 2295 sym->section = bfd_und_section_ptr; 2296 sym->value = 0; 2297 sym->flags |= BSF_WEAK; 2298 break; 2299 case bfd_link_hash_defined: 2300 sym->section = h->u.def.section; 2301 sym->value = h->u.def.value; 2302 break; 2303 case bfd_link_hash_defweak: 2304 sym->flags |= BSF_WEAK; 2305 sym->section = h->u.def.section; 2306 sym->value = h->u.def.value; 2307 break; 2308 case bfd_link_hash_common: 2309 sym->value = h->u.c.size; 2310 if (sym->section == NULL) 2311 sym->section = bfd_com_section_ptr; 2312 else if (! bfd_is_com_section (sym->section)) 2313 { 2314 BFD_ASSERT (bfd_is_und_section (sym->section)); 2315 sym->section = bfd_com_section_ptr; 2316 } 2317 /* Do not set the section; see _bfd_generic_link_output_symbols. */ 2318 break; 2319 case bfd_link_hash_indirect: 2320 case bfd_link_hash_warning: 2321 /* FIXME: What should we do here? */ 2322 break; 2323 } 2324 } 2325 2326 /* Write out a global symbol, if it hasn't already been written out. 2327 This is called for each symbol in the hash table. */ 2328 2329 bfd_boolean 2330 _bfd_generic_link_write_global_symbol (struct generic_link_hash_entry *h, 2331 void *data) 2332 { 2333 struct generic_write_global_symbol_info *wginfo = 2334 (struct generic_write_global_symbol_info *) data; 2335 asymbol *sym; 2336 2337 if (h->written) 2338 return TRUE; 2339 2340 h->written = TRUE; 2341 2342 if (wginfo->info->strip == strip_all 2343 || (wginfo->info->strip == strip_some 2344 && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string, 2345 FALSE, FALSE) == NULL)) 2346 return TRUE; 2347 2348 if (h->sym != NULL) 2349 sym = h->sym; 2350 else 2351 { 2352 sym = bfd_make_empty_symbol (wginfo->output_bfd); 2353 if (!sym) 2354 return FALSE; 2355 sym->name = h->root.root.string; 2356 sym->flags = 0; 2357 } 2358 2359 set_symbol_from_hash (sym, &h->root); 2360 2361 sym->flags |= BSF_GLOBAL; 2362 2363 if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc, 2364 sym)) 2365 { 2366 /* FIXME: No way to return failure. */ 2367 abort (); 2368 } 2369 2370 return TRUE; 2371 } 2372 2373 /* Create a relocation. */ 2374 2375 bfd_boolean 2376 _bfd_generic_reloc_link_order (bfd *abfd, 2377 struct bfd_link_info *info, 2378 asection *sec, 2379 struct bfd_link_order *link_order) 2380 { 2381 arelent *r; 2382 2383 if (! info->relocatable) 2384 abort (); 2385 if (sec->orelocation == NULL) 2386 abort (); 2387 2388 r = (arelent *) bfd_alloc (abfd, sizeof (arelent)); 2389 if (r == NULL) 2390 return FALSE; 2391 2392 r->address = link_order->offset; 2393 r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc); 2394 if (r->howto == 0) 2395 { 2396 bfd_set_error (bfd_error_bad_value); 2397 return FALSE; 2398 } 2399 2400 /* Get the symbol to use for the relocation. */ 2401 if (link_order->type == bfd_section_reloc_link_order) 2402 r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr; 2403 else 2404 { 2405 struct generic_link_hash_entry *h; 2406 2407 h = ((struct generic_link_hash_entry *) 2408 bfd_wrapped_link_hash_lookup (abfd, info, 2409 link_order->u.reloc.p->u.name, 2410 FALSE, FALSE, TRUE)); 2411 if (h == NULL 2412 || ! h->written) 2413 { 2414 if (! ((*info->callbacks->unattached_reloc) 2415 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0))) 2416 return FALSE; 2417 bfd_set_error (bfd_error_bad_value); 2418 return FALSE; 2419 } 2420 r->sym_ptr_ptr = &h->sym; 2421 } 2422 2423 /* If this is an inplace reloc, write the addend to the object file. 2424 Otherwise, store it in the reloc addend. */ 2425 if (! r->howto->partial_inplace) 2426 r->addend = link_order->u.reloc.p->addend; 2427 else 2428 { 2429 bfd_size_type size; 2430 bfd_reloc_status_type rstat; 2431 bfd_byte *buf; 2432 bfd_boolean ok; 2433 file_ptr loc; 2434 2435 size = bfd_get_reloc_size (r->howto); 2436 buf = (bfd_byte *) bfd_zmalloc (size); 2437 if (buf == NULL && size != 0) 2438 return FALSE; 2439 rstat = _bfd_relocate_contents (r->howto, abfd, 2440 (bfd_vma) link_order->u.reloc.p->addend, 2441 buf); 2442 switch (rstat) 2443 { 2444 case bfd_reloc_ok: 2445 break; 2446 default: 2447 case bfd_reloc_outofrange: 2448 abort (); 2449 case bfd_reloc_overflow: 2450 if (! ((*info->callbacks->reloc_overflow) 2451 (info, NULL, 2452 (link_order->type == bfd_section_reloc_link_order 2453 ? bfd_section_name (abfd, link_order->u.reloc.p->u.section) 2454 : link_order->u.reloc.p->u.name), 2455 r->howto->name, link_order->u.reloc.p->addend, 2456 NULL, NULL, 0))) 2457 { 2458 free (buf); 2459 return FALSE; 2460 } 2461 break; 2462 } 2463 loc = link_order->offset * bfd_octets_per_byte (abfd); 2464 ok = bfd_set_section_contents (abfd, sec, buf, loc, size); 2465 free (buf); 2466 if (! ok) 2467 return FALSE; 2468 2469 r->addend = 0; 2470 } 2471 2472 sec->orelocation[sec->reloc_count] = r; 2473 ++sec->reloc_count; 2474 2475 return TRUE; 2476 } 2477 2478 /* Allocate a new link_order for a section. */ 2479 2480 struct bfd_link_order * 2481 bfd_new_link_order (bfd *abfd, asection *section) 2482 { 2483 bfd_size_type amt = sizeof (struct bfd_link_order); 2484 struct bfd_link_order *new_lo; 2485 2486 new_lo = (struct bfd_link_order *) bfd_zalloc (abfd, amt); 2487 if (!new_lo) 2488 return NULL; 2489 2490 new_lo->type = bfd_undefined_link_order; 2491 2492 if (section->map_tail.link_order != NULL) 2493 section->map_tail.link_order->next = new_lo; 2494 else 2495 section->map_head.link_order = new_lo; 2496 section->map_tail.link_order = new_lo; 2497 2498 return new_lo; 2499 } 2500 2501 /* Default link order processing routine. Note that we can not handle 2502 the reloc_link_order types here, since they depend upon the details 2503 of how the particular backends generates relocs. */ 2504 2505 bfd_boolean 2506 _bfd_default_link_order (bfd *abfd, 2507 struct bfd_link_info *info, 2508 asection *sec, 2509 struct bfd_link_order *link_order) 2510 { 2511 switch (link_order->type) 2512 { 2513 case bfd_undefined_link_order: 2514 case bfd_section_reloc_link_order: 2515 case bfd_symbol_reloc_link_order: 2516 default: 2517 abort (); 2518 case bfd_indirect_link_order: 2519 return default_indirect_link_order (abfd, info, sec, link_order, 2520 FALSE); 2521 case bfd_data_link_order: 2522 return default_data_link_order (abfd, info, sec, link_order); 2523 } 2524 } 2525 2526 /* Default routine to handle a bfd_data_link_order. */ 2527 2528 static bfd_boolean 2529 default_data_link_order (bfd *abfd, 2530 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2531 asection *sec, 2532 struct bfd_link_order *link_order) 2533 { 2534 bfd_size_type size; 2535 size_t fill_size; 2536 bfd_byte *fill; 2537 file_ptr loc; 2538 bfd_boolean result; 2539 2540 BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0); 2541 2542 size = link_order->size; 2543 if (size == 0) 2544 return TRUE; 2545 2546 fill = link_order->u.data.contents; 2547 fill_size = link_order->u.data.size; 2548 if (fill_size == 0) 2549 { 2550 fill = abfd->arch_info->fill (size, bfd_big_endian (abfd), 2551 (sec->flags & SEC_CODE) != 0); 2552 if (fill == NULL) 2553 return FALSE; 2554 } 2555 else if (fill_size < size) 2556 { 2557 bfd_byte *p; 2558 fill = (bfd_byte *) bfd_malloc (size); 2559 if (fill == NULL) 2560 return FALSE; 2561 p = fill; 2562 if (fill_size == 1) 2563 memset (p, (int) link_order->u.data.contents[0], (size_t) size); 2564 else 2565 { 2566 do 2567 { 2568 memcpy (p, link_order->u.data.contents, fill_size); 2569 p += fill_size; 2570 size -= fill_size; 2571 } 2572 while (size >= fill_size); 2573 if (size != 0) 2574 memcpy (p, link_order->u.data.contents, (size_t) size); 2575 size = link_order->size; 2576 } 2577 } 2578 2579 loc = link_order->offset * bfd_octets_per_byte (abfd); 2580 result = bfd_set_section_contents (abfd, sec, fill, loc, size); 2581 2582 if (fill != link_order->u.data.contents) 2583 free (fill); 2584 return result; 2585 } 2586 2587 /* Default routine to handle a bfd_indirect_link_order. */ 2588 2589 static bfd_boolean 2590 default_indirect_link_order (bfd *output_bfd, 2591 struct bfd_link_info *info, 2592 asection *output_section, 2593 struct bfd_link_order *link_order, 2594 bfd_boolean generic_linker) 2595 { 2596 asection *input_section; 2597 bfd *input_bfd; 2598 bfd_byte *contents = NULL; 2599 bfd_byte *new_contents; 2600 bfd_size_type sec_size; 2601 file_ptr loc; 2602 2603 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); 2604 2605 input_section = link_order->u.indirect.section; 2606 input_bfd = input_section->owner; 2607 if (input_section->size == 0) 2608 return TRUE; 2609 2610 BFD_ASSERT (input_section->output_section == output_section); 2611 BFD_ASSERT (input_section->output_offset == link_order->offset); 2612 BFD_ASSERT (input_section->size == link_order->size); 2613 2614 if (info->relocatable 2615 && input_section->reloc_count > 0 2616 && output_section->orelocation == NULL) 2617 { 2618 /* Space has not been allocated for the output relocations. 2619 This can happen when we are called by a specific backend 2620 because somebody is attempting to link together different 2621 types of object files. Handling this case correctly is 2622 difficult, and sometimes impossible. */ 2623 (*_bfd_error_handler) 2624 (_("Attempt to do relocatable link with %s input and %s output"), 2625 bfd_get_target (input_bfd), bfd_get_target (output_bfd)); 2626 bfd_set_error (bfd_error_wrong_format); 2627 return FALSE; 2628 } 2629 2630 if (! generic_linker) 2631 { 2632 asymbol **sympp; 2633 asymbol **symppend; 2634 2635 /* Get the canonical symbols. The generic linker will always 2636 have retrieved them by this point, but we are being called by 2637 a specific linker, presumably because we are linking 2638 different types of object files together. */ 2639 if (!bfd_generic_link_read_symbols (input_bfd)) 2640 return FALSE; 2641 2642 /* Since we have been called by a specific linker, rather than 2643 the generic linker, the values of the symbols will not be 2644 right. They will be the values as seen in the input file, 2645 not the values of the final link. We need to fix them up 2646 before we can relocate the section. */ 2647 sympp = _bfd_generic_link_get_symbols (input_bfd); 2648 symppend = sympp + _bfd_generic_link_get_symcount (input_bfd); 2649 for (; sympp < symppend; sympp++) 2650 { 2651 asymbol *sym; 2652 struct bfd_link_hash_entry *h; 2653 2654 sym = *sympp; 2655 2656 if ((sym->flags & (BSF_INDIRECT 2657 | BSF_WARNING 2658 | BSF_GLOBAL 2659 | BSF_CONSTRUCTOR 2660 | BSF_WEAK)) != 0 2661 || bfd_is_und_section (bfd_get_section (sym)) 2662 || bfd_is_com_section (bfd_get_section (sym)) 2663 || bfd_is_ind_section (bfd_get_section (sym))) 2664 { 2665 /* sym->udata may have been set by 2666 generic_link_add_symbol_list. */ 2667 if (sym->udata.p != NULL) 2668 h = (struct bfd_link_hash_entry *) sym->udata.p; 2669 else if (bfd_is_und_section (bfd_get_section (sym))) 2670 h = bfd_wrapped_link_hash_lookup (output_bfd, info, 2671 bfd_asymbol_name (sym), 2672 FALSE, FALSE, TRUE); 2673 else 2674 h = bfd_link_hash_lookup (info->hash, 2675 bfd_asymbol_name (sym), 2676 FALSE, FALSE, TRUE); 2677 if (h != NULL) 2678 set_symbol_from_hash (sym, h); 2679 } 2680 } 2681 } 2682 2683 if ((output_section->flags & (SEC_GROUP | SEC_LINKER_CREATED)) == SEC_GROUP 2684 && input_section->size != 0) 2685 { 2686 /* Group section contents are set by bfd_elf_set_group_contents. */ 2687 if (!output_bfd->output_has_begun) 2688 { 2689 /* FIXME: This hack ensures bfd_elf_set_group_contents is called. */ 2690 if (!bfd_set_section_contents (output_bfd, output_section, "", 0, 1)) 2691 goto error_return; 2692 } 2693 new_contents = output_section->contents; 2694 BFD_ASSERT (new_contents != NULL); 2695 BFD_ASSERT (input_section->output_offset == 0); 2696 } 2697 else 2698 { 2699 /* Get and relocate the section contents. */ 2700 sec_size = (input_section->rawsize > input_section->size 2701 ? input_section->rawsize 2702 : input_section->size); 2703 contents = (bfd_byte *) bfd_malloc (sec_size); 2704 if (contents == NULL && sec_size != 0) 2705 goto error_return; 2706 new_contents = (bfd_get_relocated_section_contents 2707 (output_bfd, info, link_order, contents, 2708 info->relocatable, 2709 _bfd_generic_link_get_symbols (input_bfd))); 2710 if (!new_contents) 2711 goto error_return; 2712 } 2713 2714 /* Output the section contents. */ 2715 loc = input_section->output_offset * bfd_octets_per_byte (output_bfd); 2716 if (! bfd_set_section_contents (output_bfd, output_section, 2717 new_contents, loc, input_section->size)) 2718 goto error_return; 2719 2720 if (contents != NULL) 2721 free (contents); 2722 return TRUE; 2723 2724 error_return: 2725 if (contents != NULL) 2726 free (contents); 2727 return FALSE; 2728 } 2729 2730 /* A little routine to count the number of relocs in a link_order 2731 list. */ 2732 2733 unsigned int 2734 _bfd_count_link_order_relocs (struct bfd_link_order *link_order) 2735 { 2736 register unsigned int c; 2737 register struct bfd_link_order *l; 2738 2739 c = 0; 2740 for (l = link_order; l != NULL; l = l->next) 2741 { 2742 if (l->type == bfd_section_reloc_link_order 2743 || l->type == bfd_symbol_reloc_link_order) 2744 ++c; 2745 } 2746 2747 return c; 2748 } 2749 2750 /* 2751 FUNCTION 2752 bfd_link_split_section 2753 2754 SYNOPSIS 2755 bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec); 2756 2757 DESCRIPTION 2758 Return nonzero if @var{sec} should be split during a 2759 reloceatable or final link. 2760 2761 .#define bfd_link_split_section(abfd, sec) \ 2762 . BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) 2763 . 2764 2765 */ 2766 2767 bfd_boolean 2768 _bfd_generic_link_split_section (bfd *abfd ATTRIBUTE_UNUSED, 2769 asection *sec ATTRIBUTE_UNUSED) 2770 { 2771 return FALSE; 2772 } 2773 2774 /* 2775 FUNCTION 2776 bfd_section_already_linked 2777 2778 SYNOPSIS 2779 bfd_boolean bfd_section_already_linked (bfd *abfd, 2780 asection *sec, 2781 struct bfd_link_info *info); 2782 2783 DESCRIPTION 2784 Check if @var{data} has been already linked during a reloceatable 2785 or final link. Return TRUE if it has. 2786 2787 .#define bfd_section_already_linked(abfd, sec, info) \ 2788 . BFD_SEND (abfd, _section_already_linked, (abfd, sec, info)) 2789 . 2790 2791 */ 2792 2793 /* Sections marked with the SEC_LINK_ONCE flag should only be linked 2794 once into the output. This routine checks each section, and 2795 arrange to discard it if a section of the same name has already 2796 been linked. This code assumes that all relevant sections have the 2797 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the 2798 section name. bfd_section_already_linked is called via 2799 bfd_map_over_sections. */ 2800 2801 /* The hash table. */ 2802 2803 static struct bfd_hash_table _bfd_section_already_linked_table; 2804 2805 /* Support routines for the hash table used by section_already_linked, 2806 initialize the table, traverse, lookup, fill in an entry and remove 2807 the table. */ 2808 2809 void 2810 bfd_section_already_linked_table_traverse 2811 (bfd_boolean (*func) (struct bfd_section_already_linked_hash_entry *, 2812 void *), void *info) 2813 { 2814 bfd_hash_traverse (&_bfd_section_already_linked_table, 2815 (bfd_boolean (*) (struct bfd_hash_entry *, 2816 void *)) func, 2817 info); 2818 } 2819 2820 struct bfd_section_already_linked_hash_entry * 2821 bfd_section_already_linked_table_lookup (const char *name) 2822 { 2823 return ((struct bfd_section_already_linked_hash_entry *) 2824 bfd_hash_lookup (&_bfd_section_already_linked_table, name, 2825 TRUE, FALSE)); 2826 } 2827 2828 bfd_boolean 2829 bfd_section_already_linked_table_insert 2830 (struct bfd_section_already_linked_hash_entry *already_linked_list, 2831 asection *sec) 2832 { 2833 struct bfd_section_already_linked *l; 2834 2835 /* Allocate the memory from the same obstack as the hash table is 2836 kept in. */ 2837 l = (struct bfd_section_already_linked *) 2838 bfd_hash_allocate (&_bfd_section_already_linked_table, sizeof *l); 2839 if (l == NULL) 2840 return FALSE; 2841 l->sec = sec; 2842 l->next = already_linked_list->entry; 2843 already_linked_list->entry = l; 2844 return TRUE; 2845 } 2846 2847 static struct bfd_hash_entry * 2848 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED, 2849 struct bfd_hash_table *table, 2850 const char *string ATTRIBUTE_UNUSED) 2851 { 2852 struct bfd_section_already_linked_hash_entry *ret = 2853 (struct bfd_section_already_linked_hash_entry *) 2854 bfd_hash_allocate (table, sizeof *ret); 2855 2856 if (ret == NULL) 2857 return NULL; 2858 2859 ret->entry = NULL; 2860 2861 return &ret->root; 2862 } 2863 2864 bfd_boolean 2865 bfd_section_already_linked_table_init (void) 2866 { 2867 return bfd_hash_table_init_n (&_bfd_section_already_linked_table, 2868 already_linked_newfunc, 2869 sizeof (struct bfd_section_already_linked_hash_entry), 2870 42); 2871 } 2872 2873 void 2874 bfd_section_already_linked_table_free (void) 2875 { 2876 bfd_hash_table_free (&_bfd_section_already_linked_table); 2877 } 2878 2879 /* Report warnings as appropriate for duplicate section SEC. 2880 Return FALSE if we decide to keep SEC after all. */ 2881 2882 bfd_boolean 2883 _bfd_handle_already_linked (asection *sec, 2884 struct bfd_section_already_linked *l, 2885 struct bfd_link_info *info) 2886 { 2887 switch (sec->flags & SEC_LINK_DUPLICATES) 2888 { 2889 default: 2890 abort (); 2891 2892 case SEC_LINK_DUPLICATES_DISCARD: 2893 /* If we found an LTO IR match for this comdat group on 2894 the first pass, replace it with the LTO output on the 2895 second pass. We can't simply choose real object 2896 files over IR because the first pass may contain a 2897 mix of LTO and normal objects and we must keep the 2898 first match, be it IR or real. */ 2899 if (sec->owner->lto_output 2900 && (l->sec->owner->flags & BFD_PLUGIN) != 0) 2901 { 2902 l->sec = sec; 2903 return FALSE; 2904 } 2905 break; 2906 2907 case SEC_LINK_DUPLICATES_ONE_ONLY: 2908 info->callbacks->einfo 2909 (_("%B: ignoring duplicate section `%A'\n"), 2910 sec->owner, sec); 2911 break; 2912 2913 case SEC_LINK_DUPLICATES_SAME_SIZE: 2914 if ((l->sec->owner->flags & BFD_PLUGIN) != 0) 2915 ; 2916 else if (sec->size != l->sec->size) 2917 info->callbacks->einfo 2918 (_("%B: duplicate section `%A' has different size\n"), 2919 sec->owner, sec); 2920 break; 2921 2922 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 2923 if ((l->sec->owner->flags & BFD_PLUGIN) != 0) 2924 ; 2925 else if (sec->size != l->sec->size) 2926 info->callbacks->einfo 2927 (_("%B: duplicate section `%A' has different size\n"), 2928 sec->owner, sec); 2929 else if (sec->size != 0) 2930 { 2931 bfd_byte *sec_contents, *l_sec_contents = NULL; 2932 2933 if (!bfd_malloc_and_get_section (sec->owner, sec, &sec_contents)) 2934 info->callbacks->einfo 2935 (_("%B: could not read contents of section `%A'\n"), 2936 sec->owner, sec); 2937 else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec, 2938 &l_sec_contents)) 2939 info->callbacks->einfo 2940 (_("%B: could not read contents of section `%A'\n"), 2941 l->sec->owner, l->sec); 2942 else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0) 2943 info->callbacks->einfo 2944 (_("%B: duplicate section `%A' has different contents\n"), 2945 sec->owner, sec); 2946 2947 if (sec_contents) 2948 free (sec_contents); 2949 if (l_sec_contents) 2950 free (l_sec_contents); 2951 } 2952 break; 2953 } 2954 2955 /* Set the output_section field so that lang_add_section 2956 does not create a lang_input_section structure for this 2957 section. Since there might be a symbol in the section 2958 being discarded, we must retain a pointer to the section 2959 which we are really going to use. */ 2960 sec->output_section = bfd_abs_section_ptr; 2961 sec->kept_section = l->sec; 2962 return TRUE; 2963 } 2964 2965 /* This is used on non-ELF inputs. */ 2966 2967 bfd_boolean 2968 _bfd_generic_section_already_linked (bfd *abfd ATTRIBUTE_UNUSED, 2969 asection *sec, 2970 struct bfd_link_info *info) 2971 { 2972 const char *name; 2973 struct bfd_section_already_linked *l; 2974 struct bfd_section_already_linked_hash_entry *already_linked_list; 2975 2976 if ((sec->flags & SEC_LINK_ONCE) == 0) 2977 return FALSE; 2978 2979 /* The generic linker doesn't handle section groups. */ 2980 if ((sec->flags & SEC_GROUP) != 0) 2981 return FALSE; 2982 2983 /* FIXME: When doing a relocatable link, we may have trouble 2984 copying relocations in other sections that refer to local symbols 2985 in the section being discarded. Those relocations will have to 2986 be converted somehow; as of this writing I'm not sure that any of 2987 the backends handle that correctly. 2988 2989 It is tempting to instead not discard link once sections when 2990 doing a relocatable link (technically, they should be discarded 2991 whenever we are building constructors). However, that fails, 2992 because the linker winds up combining all the link once sections 2993 into a single large link once section, which defeats the purpose 2994 of having link once sections in the first place. */ 2995 2996 name = bfd_get_section_name (abfd, sec); 2997 2998 already_linked_list = bfd_section_already_linked_table_lookup (name); 2999 3000 l = already_linked_list->entry; 3001 if (l != NULL) 3002 { 3003 /* The section has already been linked. See if we should 3004 issue a warning. */ 3005 return _bfd_handle_already_linked (sec, l, info); 3006 } 3007 3008 /* This is the first section with this name. Record it. */ 3009 if (!bfd_section_already_linked_table_insert (already_linked_list, sec)) 3010 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); 3011 return FALSE; 3012 } 3013 3014 /* Choose a neighbouring section to S in OBFD that will be output, or 3015 the absolute section if ADDR is out of bounds of the neighbours. */ 3016 3017 asection * 3018 _bfd_nearby_section (bfd *obfd, asection *s, bfd_vma addr) 3019 { 3020 asection *next, *prev, *best; 3021 3022 /* Find preceding kept section. */ 3023 for (prev = s->prev; prev != NULL; prev = prev->prev) 3024 if ((prev->flags & SEC_EXCLUDE) == 0 3025 && !bfd_section_removed_from_list (obfd, prev)) 3026 break; 3027 3028 /* Find following kept section. Start at prev->next because 3029 other sections may have been added after S was removed. */ 3030 if (s->prev != NULL) 3031 next = s->prev->next; 3032 else 3033 next = s->owner->sections; 3034 for (; next != NULL; next = next->next) 3035 if ((next->flags & SEC_EXCLUDE) == 0 3036 && !bfd_section_removed_from_list (obfd, next)) 3037 break; 3038 3039 /* Choose better of two sections, based on flags. The idea 3040 is to choose a section that will be in the same segment 3041 as S would have been if it was kept. */ 3042 best = next; 3043 if (prev == NULL) 3044 { 3045 if (next == NULL) 3046 best = bfd_abs_section_ptr; 3047 } 3048 else if (next == NULL) 3049 best = prev; 3050 else if (((prev->flags ^ next->flags) 3051 & (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_LOAD)) != 0) 3052 { 3053 if (((next->flags ^ s->flags) 3054 & (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0 3055 /* We prefer to choose a loaded section. Section S 3056 doesn't have SEC_LOAD set (it being excluded, that 3057 part of the flag processing didn't happen) so we 3058 can't compare that flag to those of NEXT and PREV. */ 3059 || ((prev->flags & SEC_LOAD) != 0 3060 && (next->flags & SEC_LOAD) == 0)) 3061 best = prev; 3062 } 3063 else if (((prev->flags ^ next->flags) & SEC_READONLY) != 0) 3064 { 3065 if (((next->flags ^ s->flags) & SEC_READONLY) != 0) 3066 best = prev; 3067 } 3068 else if (((prev->flags ^ next->flags) & SEC_CODE) != 0) 3069 { 3070 if (((next->flags ^ s->flags) & SEC_CODE) != 0) 3071 best = prev; 3072 } 3073 else 3074 { 3075 /* Flags we care about are the same. Prefer the following 3076 section if that will result in a positive valued sym. */ 3077 if (addr < next->vma) 3078 best = prev; 3079 } 3080 3081 return best; 3082 } 3083 3084 /* Convert symbols in excluded output sections to use a kept section. */ 3085 3086 static bfd_boolean 3087 fix_syms (struct bfd_link_hash_entry *h, void *data) 3088 { 3089 bfd *obfd = (bfd *) data; 3090 3091 if (h->type == bfd_link_hash_defined 3092 || h->type == bfd_link_hash_defweak) 3093 { 3094 asection *s = h->u.def.section; 3095 if (s != NULL 3096 && s->output_section != NULL 3097 && (s->output_section->flags & SEC_EXCLUDE) != 0 3098 && bfd_section_removed_from_list (obfd, s->output_section)) 3099 { 3100 asection *op; 3101 3102 h->u.def.value += s->output_offset + s->output_section->vma; 3103 op = _bfd_nearby_section (obfd, s->output_section, h->u.def.value); 3104 h->u.def.value -= op->vma; 3105 h->u.def.section = op; 3106 } 3107 } 3108 3109 return TRUE; 3110 } 3111 3112 void 3113 _bfd_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info) 3114 { 3115 bfd_link_hash_traverse (info->hash, fix_syms, obfd); 3116 } 3117 3118 /* 3119 FUNCTION 3120 bfd_generic_define_common_symbol 3121 3122 SYNOPSIS 3123 bfd_boolean bfd_generic_define_common_symbol 3124 (bfd *output_bfd, struct bfd_link_info *info, 3125 struct bfd_link_hash_entry *h); 3126 3127 DESCRIPTION 3128 Convert common symbol @var{h} into a defined symbol. 3129 Return TRUE on success and FALSE on failure. 3130 3131 .#define bfd_define_common_symbol(output_bfd, info, h) \ 3132 . BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h)) 3133 . 3134 */ 3135 3136 bfd_boolean 3137 bfd_generic_define_common_symbol (bfd *output_bfd, 3138 struct bfd_link_info *info ATTRIBUTE_UNUSED, 3139 struct bfd_link_hash_entry *h) 3140 { 3141 unsigned int power_of_two; 3142 bfd_vma alignment, size; 3143 asection *section; 3144 3145 BFD_ASSERT (h != NULL && h->type == bfd_link_hash_common); 3146 3147 size = h->u.c.size; 3148 power_of_two = h->u.c.p->alignment_power; 3149 section = h->u.c.p->section; 3150 3151 /* Increase the size of the section to align the common symbol. 3152 The alignment must be a power of two. */ 3153 alignment = bfd_octets_per_byte (output_bfd) << power_of_two; 3154 BFD_ASSERT (alignment != 0 && (alignment & -alignment) == alignment); 3155 section->size += alignment - 1; 3156 section->size &= -alignment; 3157 3158 /* Adjust the section's overall alignment if necessary. */ 3159 if (power_of_two > section->alignment_power) 3160 section->alignment_power = power_of_two; 3161 3162 /* Change the symbol from common to defined. */ 3163 h->type = bfd_link_hash_defined; 3164 h->u.def.section = section; 3165 h->u.def.value = section->size; 3166 3167 /* Increase the size of the section. */ 3168 section->size += size; 3169 3170 /* Make sure the section is allocated in memory, and make sure that 3171 it is no longer a common section. */ 3172 section->flags |= SEC_ALLOC; 3173 section->flags &= ~SEC_IS_COMMON; 3174 return TRUE; 3175 } 3176 3177 /* 3178 FUNCTION 3179 bfd_find_version_for_sym 3180 3181 SYNOPSIS 3182 struct bfd_elf_version_tree * bfd_find_version_for_sym 3183 (struct bfd_elf_version_tree *verdefs, 3184 const char *sym_name, bfd_boolean *hide); 3185 3186 DESCRIPTION 3187 Search an elf version script tree for symbol versioning 3188 info and export / don't-export status for a given symbol. 3189 Return non-NULL on success and NULL on failure; also sets 3190 the output @samp{hide} boolean parameter. 3191 3192 */ 3193 3194 struct bfd_elf_version_tree * 3195 bfd_find_version_for_sym (struct bfd_elf_version_tree *verdefs, 3196 const char *sym_name, 3197 bfd_boolean *hide) 3198 { 3199 struct bfd_elf_version_tree *t; 3200 struct bfd_elf_version_tree *local_ver, *global_ver, *exist_ver; 3201 struct bfd_elf_version_tree *star_local_ver, *star_global_ver; 3202 3203 local_ver = NULL; 3204 global_ver = NULL; 3205 star_local_ver = NULL; 3206 star_global_ver = NULL; 3207 exist_ver = NULL; 3208 for (t = verdefs; t != NULL; t = t->next) 3209 { 3210 if (t->globals.list != NULL) 3211 { 3212 struct bfd_elf_version_expr *d = NULL; 3213 3214 while ((d = (*t->match) (&t->globals, d, sym_name)) != NULL) 3215 { 3216 if (d->literal || strcmp (d->pattern, "*") != 0) 3217 global_ver = t; 3218 else 3219 star_global_ver = t; 3220 if (d->symver) 3221 exist_ver = t; 3222 d->script = 1; 3223 /* If the match is a wildcard pattern, keep looking for 3224 a more explicit, perhaps even local, match. */ 3225 if (d->literal) 3226 break; 3227 } 3228 3229 if (d != NULL) 3230 break; 3231 } 3232 3233 if (t->locals.list != NULL) 3234 { 3235 struct bfd_elf_version_expr *d = NULL; 3236 3237 while ((d = (*t->match) (&t->locals, d, sym_name)) != NULL) 3238 { 3239 if (d->literal || strcmp (d->pattern, "*") != 0) 3240 local_ver = t; 3241 else 3242 star_local_ver = t; 3243 /* If the match is a wildcard pattern, keep looking for 3244 a more explicit, perhaps even global, match. */ 3245 if (d->literal) 3246 { 3247 /* An exact match overrides a global wildcard. */ 3248 global_ver = NULL; 3249 star_global_ver = NULL; 3250 break; 3251 } 3252 } 3253 3254 if (d != NULL) 3255 break; 3256 } 3257 } 3258 3259 if (global_ver == NULL && local_ver == NULL) 3260 global_ver = star_global_ver; 3261 3262 if (global_ver != NULL) 3263 { 3264 /* If we already have a versioned symbol that matches the 3265 node for this symbol, then we don't want to create a 3266 duplicate from the unversioned symbol. Instead hide the 3267 unversioned symbol. */ 3268 *hide = exist_ver == global_ver; 3269 return global_ver; 3270 } 3271 3272 if (local_ver == NULL) 3273 local_ver = star_local_ver; 3274 3275 if (local_ver != NULL) 3276 { 3277 *hide = TRUE; 3278 return local_ver; 3279 } 3280 3281 return NULL; 3282 } 3283 3284 /* 3285 FUNCTION 3286 bfd_hide_sym_by_version 3287 3288 SYNOPSIS 3289 bfd_boolean bfd_hide_sym_by_version 3290 (struct bfd_elf_version_tree *verdefs, const char *sym_name); 3291 3292 DESCRIPTION 3293 Search an elf version script tree for symbol versioning 3294 info for a given symbol. Return TRUE if the symbol is hidden. 3295 3296 */ 3297 3298 bfd_boolean 3299 bfd_hide_sym_by_version (struct bfd_elf_version_tree *verdefs, 3300 const char *sym_name) 3301 { 3302 bfd_boolean hidden = FALSE; 3303 bfd_find_version_for_sym (verdefs, sym_name, &hidden); 3304 return hidden; 3305 } 3306