1 /* linker.c -- BFD linker routines 2 Copyright (C) 1993-2016 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 (!bfd_link_relocatable (info) 1479 && strcmp (name, "__gnu_lto_slim") == 0) 1480 (*_bfd_error_handler) 1481 (_("%s: plugin needed to handle lto object"), 1482 bfd_get_filename (abfd)); 1483 } 1484 else 1485 row = DEF_ROW; 1486 1487 if (hashp != NULL && *hashp != NULL) 1488 h = *hashp; 1489 else 1490 { 1491 if (row == UNDEF_ROW || row == UNDEFW_ROW) 1492 h = bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE); 1493 else 1494 h = bfd_link_hash_lookup (info->hash, name, TRUE, copy, FALSE); 1495 if (h == NULL) 1496 { 1497 if (hashp != NULL) 1498 *hashp = NULL; 1499 return FALSE; 1500 } 1501 } 1502 1503 if (info->notice_all 1504 || (info->notice_hash != NULL 1505 && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)) 1506 { 1507 if (! (*info->callbacks->notice) (info, h, inh, 1508 abfd, section, value, flags)) 1509 return FALSE; 1510 } 1511 1512 if (hashp != NULL) 1513 *hashp = h; 1514 1515 do 1516 { 1517 enum link_action action; 1518 1519 cycle = FALSE; 1520 action = link_action[(int) row][(int) h->type]; 1521 switch (action) 1522 { 1523 case FAIL: 1524 abort (); 1525 1526 case NOACT: 1527 /* Do nothing. */ 1528 break; 1529 1530 case UND: 1531 /* Make a new undefined symbol. */ 1532 h->type = bfd_link_hash_undefined; 1533 h->u.undef.abfd = abfd; 1534 bfd_link_add_undef (info->hash, h); 1535 break; 1536 1537 case WEAK: 1538 /* Make a new weak undefined symbol. */ 1539 h->type = bfd_link_hash_undefweak; 1540 h->u.undef.abfd = abfd; 1541 break; 1542 1543 case CDEF: 1544 /* We have found a definition for a symbol which was 1545 previously common. */ 1546 BFD_ASSERT (h->type == bfd_link_hash_common); 1547 (*info->callbacks->multiple_common) (info, h, abfd, 1548 bfd_link_hash_defined, 0); 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 (*info->callbacks->constructor) (info, c == 'I', 1606 h->root.string, abfd, 1607 section, value); 1608 } 1609 } 1610 } 1611 } 1612 1613 break; 1614 1615 case COM: 1616 /* We have found a common definition for a symbol. */ 1617 if (h->type == bfd_link_hash_new) 1618 bfd_link_add_undef (info->hash, h); 1619 h->type = bfd_link_hash_common; 1620 h->u.c.p = (struct bfd_link_hash_common_entry *) 1621 bfd_hash_allocate (&info->hash->table, 1622 sizeof (struct bfd_link_hash_common_entry)); 1623 if (h->u.c.p == NULL) 1624 return FALSE; 1625 1626 h->u.c.size = value; 1627 1628 /* Select a default alignment based on the size. This may 1629 be overridden by the caller. */ 1630 { 1631 unsigned int power; 1632 1633 power = bfd_log2 (value); 1634 if (power > 4) 1635 power = 4; 1636 h->u.c.p->alignment_power = power; 1637 } 1638 1639 /* The section of a common symbol is only used if the common 1640 symbol is actually allocated. It basically provides a 1641 hook for the linker script to decide which output section 1642 the common symbols should be put in. In most cases, the 1643 section of a common symbol will be bfd_com_section_ptr, 1644 the code here will choose a common symbol section named 1645 "COMMON", and the linker script will contain *(COMMON) in 1646 the appropriate place. A few targets use separate common 1647 sections for small symbols, and they require special 1648 handling. */ 1649 if (section == bfd_com_section_ptr) 1650 { 1651 h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON"); 1652 h->u.c.p->section->flags |= SEC_ALLOC; 1653 } 1654 else if (section->owner != abfd) 1655 { 1656 h->u.c.p->section = bfd_make_section_old_way (abfd, 1657 section->name); 1658 h->u.c.p->section->flags |= SEC_ALLOC; 1659 } 1660 else 1661 h->u.c.p->section = section; 1662 h->linker_def = 0; 1663 break; 1664 1665 case REF: 1666 /* A reference to a defined symbol. */ 1667 if (h->u.undef.next == NULL && info->hash->undefs_tail != h) 1668 h->u.undef.next = h; 1669 break; 1670 1671 case BIG: 1672 /* We have found a common definition for a symbol which 1673 already had a common definition. Use the maximum of the 1674 two sizes, and use the section required by the larger symbol. */ 1675 BFD_ASSERT (h->type == bfd_link_hash_common); 1676 (*info->callbacks->multiple_common) (info, h, abfd, 1677 bfd_link_hash_common, value); 1678 if (value > h->u.c.size) 1679 { 1680 unsigned int power; 1681 1682 h->u.c.size = value; 1683 1684 /* Select a default alignment based on the size. This may 1685 be overridden by the caller. */ 1686 power = bfd_log2 (value); 1687 if (power > 4) 1688 power = 4; 1689 h->u.c.p->alignment_power = power; 1690 1691 /* Some systems have special treatment for small commons, 1692 hence we want to select the section used by the larger 1693 symbol. This makes sure the symbol does not go in a 1694 small common section if it is now too large. */ 1695 if (section == bfd_com_section_ptr) 1696 { 1697 h->u.c.p->section 1698 = bfd_make_section_old_way (abfd, "COMMON"); 1699 h->u.c.p->section->flags |= SEC_ALLOC; 1700 } 1701 else if (section->owner != abfd) 1702 { 1703 h->u.c.p->section 1704 = bfd_make_section_old_way (abfd, section->name); 1705 h->u.c.p->section->flags |= SEC_ALLOC; 1706 } 1707 else 1708 h->u.c.p->section = section; 1709 } 1710 break; 1711 1712 case CREF: 1713 /* We have found a common definition for a symbol which 1714 was already defined. */ 1715 (*info->callbacks->multiple_common) (info, h, abfd, 1716 bfd_link_hash_common, value); 1717 break; 1718 1719 case MIND: 1720 /* Multiple indirect symbols. This is OK if they both point 1721 to the same symbol. */ 1722 if (strcmp (h->u.i.link->root.string, string) == 0) 1723 break; 1724 /* Fall through. */ 1725 case MDEF: 1726 /* Handle a multiple definition. */ 1727 (*info->callbacks->multiple_definition) (info, h, 1728 abfd, section, value); 1729 break; 1730 1731 case CIND: 1732 /* Create an indirect symbol from an existing common symbol. */ 1733 BFD_ASSERT (h->type == bfd_link_hash_common); 1734 (*info->callbacks->multiple_common) (info, h, abfd, 1735 bfd_link_hash_indirect, 0); 1736 /* Fall through. */ 1737 case IND: 1738 if (inh->type == bfd_link_hash_indirect 1739 && inh->u.i.link == h) 1740 { 1741 (*_bfd_error_handler) 1742 (_("%B: indirect symbol `%s' to `%s' is a loop"), 1743 abfd, name, string); 1744 bfd_set_error (bfd_error_invalid_operation); 1745 return FALSE; 1746 } 1747 if (inh->type == bfd_link_hash_new) 1748 { 1749 inh->type = bfd_link_hash_undefined; 1750 inh->u.undef.abfd = abfd; 1751 bfd_link_add_undef (info->hash, inh); 1752 } 1753 1754 /* If the indirect symbol has been referenced, we need to 1755 push the reference down to the symbol we are referencing. */ 1756 if (h->type != bfd_link_hash_new) 1757 { 1758 /* ??? If inh->type == bfd_link_hash_undefweak this 1759 converts inh to bfd_link_hash_undefined. */ 1760 row = UNDEF_ROW; 1761 cycle = TRUE; 1762 } 1763 1764 h->type = bfd_link_hash_indirect; 1765 h->u.i.link = inh; 1766 /* Not setting h = h->u.i.link here means that when cycle is 1767 set above we'll always go to REFC, and then cycle again 1768 to the indirected symbol. This means that any successful 1769 change of an existing symbol to indirect counts as a 1770 reference. ??? That may not be correct when the existing 1771 symbol was defweak. */ 1772 break; 1773 1774 case SET: 1775 /* Add an entry to a set. */ 1776 (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR, 1777 abfd, section, value); 1778 break; 1779 1780 case WARNC: 1781 /* Issue a warning and cycle, except when the reference is 1782 in LTO IR. */ 1783 if (h->u.i.warning != NULL 1784 && (abfd->flags & BFD_PLUGIN) == 0) 1785 { 1786 (*info->callbacks->warning) (info, h->u.i.warning, 1787 h->root.string, abfd, NULL, 0); 1788 /* Only issue a warning once. */ 1789 h->u.i.warning = NULL; 1790 } 1791 /* Fall through. */ 1792 case CYCLE: 1793 /* Try again with the referenced symbol. */ 1794 h = h->u.i.link; 1795 cycle = TRUE; 1796 break; 1797 1798 case REFC: 1799 /* A reference to an indirect symbol. */ 1800 if (h->u.undef.next == NULL && info->hash->undefs_tail != h) 1801 h->u.undef.next = h; 1802 h = h->u.i.link; 1803 cycle = TRUE; 1804 break; 1805 1806 case WARN: 1807 /* Warn if this symbol has been referenced already from non-IR, 1808 otherwise add a warning. */ 1809 if ((!info->lto_plugin_active 1810 && (h->u.undef.next != NULL || info->hash->undefs_tail == h)) 1811 || h->non_ir_ref) 1812 { 1813 (*info->callbacks->warning) (info, string, h->root.string, 1814 hash_entry_bfd (h), NULL, 0); 1815 break; 1816 } 1817 /* Fall through. */ 1818 case MWARN: 1819 /* Make a warning symbol. */ 1820 { 1821 struct bfd_link_hash_entry *sub; 1822 1823 /* STRING is the warning to give. */ 1824 sub = ((struct bfd_link_hash_entry *) 1825 ((*info->hash->table.newfunc) 1826 (NULL, &info->hash->table, h->root.string))); 1827 if (sub == NULL) 1828 return FALSE; 1829 *sub = *h; 1830 sub->type = bfd_link_hash_warning; 1831 sub->u.i.link = h; 1832 if (! copy) 1833 sub->u.i.warning = string; 1834 else 1835 { 1836 char *w; 1837 size_t len = strlen (string) + 1; 1838 1839 w = (char *) bfd_hash_allocate (&info->hash->table, len); 1840 if (w == NULL) 1841 return FALSE; 1842 memcpy (w, string, len); 1843 sub->u.i.warning = w; 1844 } 1845 1846 bfd_hash_replace (&info->hash->table, 1847 (struct bfd_hash_entry *) h, 1848 (struct bfd_hash_entry *) sub); 1849 if (hashp != NULL) 1850 *hashp = sub; 1851 } 1852 break; 1853 } 1854 } 1855 while (cycle); 1856 1857 return TRUE; 1858 } 1859 1860 /* Generic final link routine. */ 1861 1862 bfd_boolean 1863 _bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info) 1864 { 1865 bfd *sub; 1866 asection *o; 1867 struct bfd_link_order *p; 1868 size_t outsymalloc; 1869 struct generic_write_global_symbol_info wginfo; 1870 1871 bfd_get_outsymbols (abfd) = NULL; 1872 bfd_get_symcount (abfd) = 0; 1873 outsymalloc = 0; 1874 1875 /* Mark all sections which will be included in the output file. */ 1876 for (o = abfd->sections; o != NULL; o = o->next) 1877 for (p = o->map_head.link_order; p != NULL; p = p->next) 1878 if (p->type == bfd_indirect_link_order) 1879 p->u.indirect.section->linker_mark = TRUE; 1880 1881 /* Build the output symbol table. */ 1882 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 1883 if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc)) 1884 return FALSE; 1885 1886 /* Accumulate the global symbols. */ 1887 wginfo.info = info; 1888 wginfo.output_bfd = abfd; 1889 wginfo.psymalloc = &outsymalloc; 1890 _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info), 1891 _bfd_generic_link_write_global_symbol, 1892 &wginfo); 1893 1894 /* Make sure we have a trailing NULL pointer on OUTSYMBOLS. We 1895 shouldn't really need one, since we have SYMCOUNT, but some old 1896 code still expects one. */ 1897 if (! generic_add_output_symbol (abfd, &outsymalloc, NULL)) 1898 return FALSE; 1899 1900 if (bfd_link_relocatable (info)) 1901 { 1902 /* Allocate space for the output relocs for each section. */ 1903 for (o = abfd->sections; o != NULL; o = o->next) 1904 { 1905 o->reloc_count = 0; 1906 for (p = o->map_head.link_order; p != NULL; p = p->next) 1907 { 1908 if (p->type == bfd_section_reloc_link_order 1909 || p->type == bfd_symbol_reloc_link_order) 1910 ++o->reloc_count; 1911 else if (p->type == bfd_indirect_link_order) 1912 { 1913 asection *input_section; 1914 bfd *input_bfd; 1915 long relsize; 1916 arelent **relocs; 1917 asymbol **symbols; 1918 long reloc_count; 1919 1920 input_section = p->u.indirect.section; 1921 input_bfd = input_section->owner; 1922 relsize = bfd_get_reloc_upper_bound (input_bfd, 1923 input_section); 1924 if (relsize < 0) 1925 return FALSE; 1926 relocs = (arelent **) bfd_malloc (relsize); 1927 if (!relocs && relsize != 0) 1928 return FALSE; 1929 symbols = _bfd_generic_link_get_symbols (input_bfd); 1930 reloc_count = bfd_canonicalize_reloc (input_bfd, 1931 input_section, 1932 relocs, 1933 symbols); 1934 free (relocs); 1935 if (reloc_count < 0) 1936 return FALSE; 1937 BFD_ASSERT ((unsigned long) reloc_count 1938 == input_section->reloc_count); 1939 o->reloc_count += reloc_count; 1940 } 1941 } 1942 if (o->reloc_count > 0) 1943 { 1944 bfd_size_type amt; 1945 1946 amt = o->reloc_count; 1947 amt *= sizeof (arelent *); 1948 o->orelocation = (struct reloc_cache_entry **) bfd_alloc (abfd, amt); 1949 if (!o->orelocation) 1950 return FALSE; 1951 o->flags |= SEC_RELOC; 1952 /* Reset the count so that it can be used as an index 1953 when putting in the output relocs. */ 1954 o->reloc_count = 0; 1955 } 1956 } 1957 } 1958 1959 /* Handle all the link order information for the sections. */ 1960 for (o = abfd->sections; o != NULL; o = o->next) 1961 { 1962 for (p = o->map_head.link_order; p != NULL; p = p->next) 1963 { 1964 switch (p->type) 1965 { 1966 case bfd_section_reloc_link_order: 1967 case bfd_symbol_reloc_link_order: 1968 if (! _bfd_generic_reloc_link_order (abfd, info, o, p)) 1969 return FALSE; 1970 break; 1971 case bfd_indirect_link_order: 1972 if (! default_indirect_link_order (abfd, info, o, p, TRUE)) 1973 return FALSE; 1974 break; 1975 default: 1976 if (! _bfd_default_link_order (abfd, info, o, p)) 1977 return FALSE; 1978 break; 1979 } 1980 } 1981 } 1982 1983 return TRUE; 1984 } 1985 1986 /* Add an output symbol to the output BFD. */ 1987 1988 static bfd_boolean 1989 generic_add_output_symbol (bfd *output_bfd, size_t *psymalloc, asymbol *sym) 1990 { 1991 if (bfd_get_symcount (output_bfd) >= *psymalloc) 1992 { 1993 asymbol **newsyms; 1994 bfd_size_type amt; 1995 1996 if (*psymalloc == 0) 1997 *psymalloc = 124; 1998 else 1999 *psymalloc *= 2; 2000 amt = *psymalloc; 2001 amt *= sizeof (asymbol *); 2002 newsyms = (asymbol **) bfd_realloc (bfd_get_outsymbols (output_bfd), amt); 2003 if (newsyms == NULL) 2004 return FALSE; 2005 bfd_get_outsymbols (output_bfd) = newsyms; 2006 } 2007 2008 bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym; 2009 if (sym != NULL) 2010 ++ bfd_get_symcount (output_bfd); 2011 2012 return TRUE; 2013 } 2014 2015 /* Handle the symbols for an input BFD. */ 2016 2017 bfd_boolean 2018 _bfd_generic_link_output_symbols (bfd *output_bfd, 2019 bfd *input_bfd, 2020 struct bfd_link_info *info, 2021 size_t *psymalloc) 2022 { 2023 asymbol **sym_ptr; 2024 asymbol **sym_end; 2025 2026 if (!bfd_generic_link_read_symbols (input_bfd)) 2027 return FALSE; 2028 2029 /* Create a filename symbol if we are supposed to. */ 2030 if (info->create_object_symbols_section != NULL) 2031 { 2032 asection *sec; 2033 2034 for (sec = input_bfd->sections; sec != NULL; sec = sec->next) 2035 { 2036 if (sec->output_section == info->create_object_symbols_section) 2037 { 2038 asymbol *newsym; 2039 2040 newsym = bfd_make_empty_symbol (input_bfd); 2041 if (!newsym) 2042 return FALSE; 2043 newsym->name = input_bfd->filename; 2044 newsym->value = 0; 2045 newsym->flags = BSF_LOCAL | BSF_FILE; 2046 newsym->section = sec; 2047 2048 if (! generic_add_output_symbol (output_bfd, psymalloc, 2049 newsym)) 2050 return FALSE; 2051 2052 break; 2053 } 2054 } 2055 } 2056 2057 /* Adjust the values of the globally visible symbols, and write out 2058 local symbols. */ 2059 sym_ptr = _bfd_generic_link_get_symbols (input_bfd); 2060 sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd); 2061 for (; sym_ptr < sym_end; sym_ptr++) 2062 { 2063 asymbol *sym; 2064 struct generic_link_hash_entry *h; 2065 bfd_boolean output; 2066 2067 h = NULL; 2068 sym = *sym_ptr; 2069 if ((sym->flags & (BSF_INDIRECT 2070 | BSF_WARNING 2071 | BSF_GLOBAL 2072 | BSF_CONSTRUCTOR 2073 | BSF_WEAK)) != 0 2074 || bfd_is_und_section (bfd_get_section (sym)) 2075 || bfd_is_com_section (bfd_get_section (sym)) 2076 || bfd_is_ind_section (bfd_get_section (sym))) 2077 { 2078 if (sym->udata.p != NULL) 2079 h = (struct generic_link_hash_entry *) sym->udata.p; 2080 else if ((sym->flags & BSF_CONSTRUCTOR) != 0) 2081 { 2082 /* This case normally means that the main linker code 2083 deliberately ignored this constructor symbol. We 2084 should just pass it through. This will screw up if 2085 the constructor symbol is from a different, 2086 non-generic, object file format, but the case will 2087 only arise when linking with -r, which will probably 2088 fail anyhow, since there will be no way to represent 2089 the relocs in the output format being used. */ 2090 h = NULL; 2091 } 2092 else if (bfd_is_und_section (bfd_get_section (sym))) 2093 h = ((struct generic_link_hash_entry *) 2094 bfd_wrapped_link_hash_lookup (output_bfd, info, 2095 bfd_asymbol_name (sym), 2096 FALSE, FALSE, TRUE)); 2097 else 2098 h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info), 2099 bfd_asymbol_name (sym), 2100 FALSE, FALSE, TRUE); 2101 2102 if (h != NULL) 2103 { 2104 /* Force all references to this symbol to point to 2105 the same area in memory. It is possible that 2106 this routine will be called with a hash table 2107 other than a generic hash table, so we double 2108 check that. */ 2109 if (info->output_bfd->xvec == input_bfd->xvec) 2110 { 2111 if (h->sym != NULL) 2112 *sym_ptr = sym = h->sym; 2113 } 2114 2115 switch (h->root.type) 2116 { 2117 default: 2118 case bfd_link_hash_new: 2119 abort (); 2120 case bfd_link_hash_undefined: 2121 break; 2122 case bfd_link_hash_undefweak: 2123 sym->flags |= BSF_WEAK; 2124 break; 2125 case bfd_link_hash_indirect: 2126 h = (struct generic_link_hash_entry *) h->root.u.i.link; 2127 /* fall through */ 2128 case bfd_link_hash_defined: 2129 sym->flags |= BSF_GLOBAL; 2130 sym->flags &=~ (BSF_WEAK | BSF_CONSTRUCTOR); 2131 sym->value = h->root.u.def.value; 2132 sym->section = h->root.u.def.section; 2133 break; 2134 case bfd_link_hash_defweak: 2135 sym->flags |= BSF_WEAK; 2136 sym->flags &=~ BSF_CONSTRUCTOR; 2137 sym->value = h->root.u.def.value; 2138 sym->section = h->root.u.def.section; 2139 break; 2140 case bfd_link_hash_common: 2141 sym->value = h->root.u.c.size; 2142 sym->flags |= BSF_GLOBAL; 2143 if (! bfd_is_com_section (sym->section)) 2144 { 2145 BFD_ASSERT (bfd_is_und_section (sym->section)); 2146 sym->section = bfd_com_section_ptr; 2147 } 2148 /* We do not set the section of the symbol to 2149 h->root.u.c.p->section. That value was saved so 2150 that we would know where to allocate the symbol 2151 if it was defined. In this case the type is 2152 still bfd_link_hash_common, so we did not define 2153 it, so we do not want to use that section. */ 2154 break; 2155 } 2156 } 2157 } 2158 2159 /* This switch is straight from the old code in 2160 write_file_locals in ldsym.c. */ 2161 if (info->strip == strip_all 2162 || (info->strip == strip_some 2163 && bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym), 2164 FALSE, FALSE) == NULL)) 2165 output = FALSE; 2166 else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0) 2167 { 2168 /* If this symbol is marked as occurring now, rather 2169 than at the end, output it now. This is used for 2170 COFF C_EXT FCN symbols. FIXME: There must be a 2171 better way. */ 2172 if (bfd_asymbol_bfd (sym) == input_bfd 2173 && (sym->flags & BSF_NOT_AT_END) != 0) 2174 output = TRUE; 2175 else 2176 output = FALSE; 2177 } 2178 else if (bfd_is_ind_section (sym->section)) 2179 output = FALSE; 2180 else if ((sym->flags & BSF_DEBUGGING) != 0) 2181 { 2182 if (info->strip == strip_none) 2183 output = TRUE; 2184 else 2185 output = FALSE; 2186 } 2187 else if (bfd_is_und_section (sym->section) 2188 || bfd_is_com_section (sym->section)) 2189 output = FALSE; 2190 else if ((sym->flags & BSF_LOCAL) != 0) 2191 { 2192 if ((sym->flags & BSF_WARNING) != 0) 2193 output = FALSE; 2194 else 2195 { 2196 switch (info->discard) 2197 { 2198 default: 2199 case discard_all: 2200 output = FALSE; 2201 break; 2202 case discard_sec_merge: 2203 output = TRUE; 2204 if (bfd_link_relocatable (info) 2205 || ! (sym->section->flags & SEC_MERGE)) 2206 break; 2207 /* FALLTHROUGH */ 2208 case discard_l: 2209 if (bfd_is_local_label (input_bfd, sym)) 2210 output = FALSE; 2211 else 2212 output = TRUE; 2213 break; 2214 case discard_none: 2215 output = TRUE; 2216 break; 2217 } 2218 } 2219 } 2220 else if ((sym->flags & BSF_CONSTRUCTOR)) 2221 { 2222 if (info->strip != strip_all) 2223 output = TRUE; 2224 else 2225 output = FALSE; 2226 } 2227 else if (sym->flags == 0 2228 && (sym->section->owner->flags & BFD_PLUGIN) != 0) 2229 /* LTO doesn't set symbol information. We get here with the 2230 generic linker for a symbol that was "common" but no longer 2231 needs to be global. */ 2232 output = FALSE; 2233 else 2234 abort (); 2235 2236 /* If this symbol is in a section which is not being included 2237 in the output file, then we don't want to output the 2238 symbol. */ 2239 if (!bfd_is_abs_section (sym->section) 2240 && bfd_section_removed_from_list (output_bfd, 2241 sym->section->output_section)) 2242 output = FALSE; 2243 2244 if (output) 2245 { 2246 if (! generic_add_output_symbol (output_bfd, psymalloc, sym)) 2247 return FALSE; 2248 if (h != NULL) 2249 h->written = TRUE; 2250 } 2251 } 2252 2253 return TRUE; 2254 } 2255 2256 /* Set the section and value of a generic BFD symbol based on a linker 2257 hash table entry. */ 2258 2259 static void 2260 set_symbol_from_hash (asymbol *sym, struct bfd_link_hash_entry *h) 2261 { 2262 switch (h->type) 2263 { 2264 default: 2265 abort (); 2266 break; 2267 case bfd_link_hash_new: 2268 /* This can happen when a constructor symbol is seen but we are 2269 not building constructors. */ 2270 if (sym->section != NULL) 2271 { 2272 BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0); 2273 } 2274 else 2275 { 2276 sym->flags |= BSF_CONSTRUCTOR; 2277 sym->section = bfd_abs_section_ptr; 2278 sym->value = 0; 2279 } 2280 break; 2281 case bfd_link_hash_undefined: 2282 sym->section = bfd_und_section_ptr; 2283 sym->value = 0; 2284 break; 2285 case bfd_link_hash_undefweak: 2286 sym->section = bfd_und_section_ptr; 2287 sym->value = 0; 2288 sym->flags |= BSF_WEAK; 2289 break; 2290 case bfd_link_hash_defined: 2291 sym->section = h->u.def.section; 2292 sym->value = h->u.def.value; 2293 break; 2294 case bfd_link_hash_defweak: 2295 sym->flags |= BSF_WEAK; 2296 sym->section = h->u.def.section; 2297 sym->value = h->u.def.value; 2298 break; 2299 case bfd_link_hash_common: 2300 sym->value = h->u.c.size; 2301 if (sym->section == NULL) 2302 sym->section = bfd_com_section_ptr; 2303 else if (! bfd_is_com_section (sym->section)) 2304 { 2305 BFD_ASSERT (bfd_is_und_section (sym->section)); 2306 sym->section = bfd_com_section_ptr; 2307 } 2308 /* Do not set the section; see _bfd_generic_link_output_symbols. */ 2309 break; 2310 case bfd_link_hash_indirect: 2311 case bfd_link_hash_warning: 2312 /* FIXME: What should we do here? */ 2313 break; 2314 } 2315 } 2316 2317 /* Write out a global symbol, if it hasn't already been written out. 2318 This is called for each symbol in the hash table. */ 2319 2320 bfd_boolean 2321 _bfd_generic_link_write_global_symbol (struct generic_link_hash_entry *h, 2322 void *data) 2323 { 2324 struct generic_write_global_symbol_info *wginfo = 2325 (struct generic_write_global_symbol_info *) data; 2326 asymbol *sym; 2327 2328 if (h->written) 2329 return TRUE; 2330 2331 h->written = TRUE; 2332 2333 if (wginfo->info->strip == strip_all 2334 || (wginfo->info->strip == strip_some 2335 && bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string, 2336 FALSE, FALSE) == NULL)) 2337 return TRUE; 2338 2339 if (h->sym != NULL) 2340 sym = h->sym; 2341 else 2342 { 2343 sym = bfd_make_empty_symbol (wginfo->output_bfd); 2344 if (!sym) 2345 return FALSE; 2346 sym->name = h->root.root.string; 2347 sym->flags = 0; 2348 } 2349 2350 set_symbol_from_hash (sym, &h->root); 2351 2352 sym->flags |= BSF_GLOBAL; 2353 2354 if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc, 2355 sym)) 2356 { 2357 /* FIXME: No way to return failure. */ 2358 abort (); 2359 } 2360 2361 return TRUE; 2362 } 2363 2364 /* Create a relocation. */ 2365 2366 bfd_boolean 2367 _bfd_generic_reloc_link_order (bfd *abfd, 2368 struct bfd_link_info *info, 2369 asection *sec, 2370 struct bfd_link_order *link_order) 2371 { 2372 arelent *r; 2373 2374 if (! bfd_link_relocatable (info)) 2375 abort (); 2376 if (sec->orelocation == NULL) 2377 abort (); 2378 2379 r = (arelent *) bfd_alloc (abfd, sizeof (arelent)); 2380 if (r == NULL) 2381 return FALSE; 2382 2383 r->address = link_order->offset; 2384 r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc); 2385 if (r->howto == 0) 2386 { 2387 bfd_set_error (bfd_error_bad_value); 2388 return FALSE; 2389 } 2390 2391 /* Get the symbol to use for the relocation. */ 2392 if (link_order->type == bfd_section_reloc_link_order) 2393 r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr; 2394 else 2395 { 2396 struct generic_link_hash_entry *h; 2397 2398 h = ((struct generic_link_hash_entry *) 2399 bfd_wrapped_link_hash_lookup (abfd, info, 2400 link_order->u.reloc.p->u.name, 2401 FALSE, FALSE, TRUE)); 2402 if (h == NULL 2403 || ! h->written) 2404 { 2405 (*info->callbacks->unattached_reloc) 2406 (info, link_order->u.reloc.p->u.name, NULL, NULL, 0); 2407 bfd_set_error (bfd_error_bad_value); 2408 return FALSE; 2409 } 2410 r->sym_ptr_ptr = &h->sym; 2411 } 2412 2413 /* If this is an inplace reloc, write the addend to the object file. 2414 Otherwise, store it in the reloc addend. */ 2415 if (! r->howto->partial_inplace) 2416 r->addend = link_order->u.reloc.p->addend; 2417 else 2418 { 2419 bfd_size_type size; 2420 bfd_reloc_status_type rstat; 2421 bfd_byte *buf; 2422 bfd_boolean ok; 2423 file_ptr loc; 2424 2425 size = bfd_get_reloc_size (r->howto); 2426 buf = (bfd_byte *) bfd_zmalloc (size); 2427 if (buf == NULL && size != 0) 2428 return FALSE; 2429 rstat = _bfd_relocate_contents (r->howto, abfd, 2430 (bfd_vma) link_order->u.reloc.p->addend, 2431 buf); 2432 switch (rstat) 2433 { 2434 case bfd_reloc_ok: 2435 break; 2436 default: 2437 case bfd_reloc_outofrange: 2438 abort (); 2439 case bfd_reloc_overflow: 2440 (*info->callbacks->reloc_overflow) 2441 (info, NULL, 2442 (link_order->type == bfd_section_reloc_link_order 2443 ? bfd_section_name (abfd, link_order->u.reloc.p->u.section) 2444 : link_order->u.reloc.p->u.name), 2445 r->howto->name, link_order->u.reloc.p->addend, 2446 NULL, NULL, 0); 2447 break; 2448 } 2449 loc = link_order->offset * bfd_octets_per_byte (abfd); 2450 ok = bfd_set_section_contents (abfd, sec, buf, loc, size); 2451 free (buf); 2452 if (! ok) 2453 return FALSE; 2454 2455 r->addend = 0; 2456 } 2457 2458 sec->orelocation[sec->reloc_count] = r; 2459 ++sec->reloc_count; 2460 2461 return TRUE; 2462 } 2463 2464 /* Allocate a new link_order for a section. */ 2465 2466 struct bfd_link_order * 2467 bfd_new_link_order (bfd *abfd, asection *section) 2468 { 2469 bfd_size_type amt = sizeof (struct bfd_link_order); 2470 struct bfd_link_order *new_lo; 2471 2472 new_lo = (struct bfd_link_order *) bfd_zalloc (abfd, amt); 2473 if (!new_lo) 2474 return NULL; 2475 2476 new_lo->type = bfd_undefined_link_order; 2477 2478 if (section->map_tail.link_order != NULL) 2479 section->map_tail.link_order->next = new_lo; 2480 else 2481 section->map_head.link_order = new_lo; 2482 section->map_tail.link_order = new_lo; 2483 2484 return new_lo; 2485 } 2486 2487 /* Default link order processing routine. Note that we can not handle 2488 the reloc_link_order types here, since they depend upon the details 2489 of how the particular backends generates relocs. */ 2490 2491 bfd_boolean 2492 _bfd_default_link_order (bfd *abfd, 2493 struct bfd_link_info *info, 2494 asection *sec, 2495 struct bfd_link_order *link_order) 2496 { 2497 switch (link_order->type) 2498 { 2499 case bfd_undefined_link_order: 2500 case bfd_section_reloc_link_order: 2501 case bfd_symbol_reloc_link_order: 2502 default: 2503 abort (); 2504 case bfd_indirect_link_order: 2505 return default_indirect_link_order (abfd, info, sec, link_order, 2506 FALSE); 2507 case bfd_data_link_order: 2508 return default_data_link_order (abfd, info, sec, link_order); 2509 } 2510 } 2511 2512 /* Default routine to handle a bfd_data_link_order. */ 2513 2514 static bfd_boolean 2515 default_data_link_order (bfd *abfd, 2516 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2517 asection *sec, 2518 struct bfd_link_order *link_order) 2519 { 2520 bfd_size_type size; 2521 size_t fill_size; 2522 bfd_byte *fill; 2523 file_ptr loc; 2524 bfd_boolean result; 2525 2526 BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0); 2527 2528 size = link_order->size; 2529 if (size == 0) 2530 return TRUE; 2531 2532 fill = link_order->u.data.contents; 2533 fill_size = link_order->u.data.size; 2534 if (fill_size == 0) 2535 { 2536 fill = abfd->arch_info->fill (size, bfd_big_endian (abfd), 2537 (sec->flags & SEC_CODE) != 0); 2538 if (fill == NULL) 2539 return FALSE; 2540 } 2541 else if (fill_size < size) 2542 { 2543 bfd_byte *p; 2544 fill = (bfd_byte *) bfd_malloc (size); 2545 if (fill == NULL) 2546 return FALSE; 2547 p = fill; 2548 if (fill_size == 1) 2549 memset (p, (int) link_order->u.data.contents[0], (size_t) size); 2550 else 2551 { 2552 do 2553 { 2554 memcpy (p, link_order->u.data.contents, fill_size); 2555 p += fill_size; 2556 size -= fill_size; 2557 } 2558 while (size >= fill_size); 2559 if (size != 0) 2560 memcpy (p, link_order->u.data.contents, (size_t) size); 2561 size = link_order->size; 2562 } 2563 } 2564 2565 loc = link_order->offset * bfd_octets_per_byte (abfd); 2566 result = bfd_set_section_contents (abfd, sec, fill, loc, size); 2567 2568 if (fill != link_order->u.data.contents) 2569 free (fill); 2570 return result; 2571 } 2572 2573 /* Default routine to handle a bfd_indirect_link_order. */ 2574 2575 static bfd_boolean 2576 default_indirect_link_order (bfd *output_bfd, 2577 struct bfd_link_info *info, 2578 asection *output_section, 2579 struct bfd_link_order *link_order, 2580 bfd_boolean generic_linker) 2581 { 2582 asection *input_section; 2583 bfd *input_bfd; 2584 bfd_byte *contents = NULL; 2585 bfd_byte *new_contents; 2586 bfd_size_type sec_size; 2587 file_ptr loc; 2588 2589 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); 2590 2591 input_section = link_order->u.indirect.section; 2592 input_bfd = input_section->owner; 2593 if (input_section->size == 0) 2594 return TRUE; 2595 2596 BFD_ASSERT (input_section->output_section == output_section); 2597 BFD_ASSERT (input_section->output_offset == link_order->offset); 2598 BFD_ASSERT (input_section->size == link_order->size); 2599 2600 if (bfd_link_relocatable (info) 2601 && input_section->reloc_count > 0 2602 && output_section->orelocation == NULL) 2603 { 2604 /* Space has not been allocated for the output relocations. 2605 This can happen when we are called by a specific backend 2606 because somebody is attempting to link together different 2607 types of object files. Handling this case correctly is 2608 difficult, and sometimes impossible. */ 2609 (*_bfd_error_handler) 2610 (_("Attempt to do relocatable link with %s input and %s output"), 2611 bfd_get_target (input_bfd), bfd_get_target (output_bfd)); 2612 bfd_set_error (bfd_error_wrong_format); 2613 return FALSE; 2614 } 2615 2616 if (! generic_linker) 2617 { 2618 asymbol **sympp; 2619 asymbol **symppend; 2620 2621 /* Get the canonical symbols. The generic linker will always 2622 have retrieved them by this point, but we are being called by 2623 a specific linker, presumably because we are linking 2624 different types of object files together. */ 2625 if (!bfd_generic_link_read_symbols (input_bfd)) 2626 return FALSE; 2627 2628 /* Since we have been called by a specific linker, rather than 2629 the generic linker, the values of the symbols will not be 2630 right. They will be the values as seen in the input file, 2631 not the values of the final link. We need to fix them up 2632 before we can relocate the section. */ 2633 sympp = _bfd_generic_link_get_symbols (input_bfd); 2634 symppend = sympp + _bfd_generic_link_get_symcount (input_bfd); 2635 for (; sympp < symppend; sympp++) 2636 { 2637 asymbol *sym; 2638 struct bfd_link_hash_entry *h; 2639 2640 sym = *sympp; 2641 2642 if ((sym->flags & (BSF_INDIRECT 2643 | BSF_WARNING 2644 | BSF_GLOBAL 2645 | BSF_CONSTRUCTOR 2646 | BSF_WEAK)) != 0 2647 || bfd_is_und_section (bfd_get_section (sym)) 2648 || bfd_is_com_section (bfd_get_section (sym)) 2649 || bfd_is_ind_section (bfd_get_section (sym))) 2650 { 2651 /* sym->udata may have been set by 2652 generic_link_add_symbol_list. */ 2653 if (sym->udata.p != NULL) 2654 h = (struct bfd_link_hash_entry *) sym->udata.p; 2655 else if (bfd_is_und_section (bfd_get_section (sym))) 2656 h = bfd_wrapped_link_hash_lookup (output_bfd, info, 2657 bfd_asymbol_name (sym), 2658 FALSE, FALSE, TRUE); 2659 else 2660 h = bfd_link_hash_lookup (info->hash, 2661 bfd_asymbol_name (sym), 2662 FALSE, FALSE, TRUE); 2663 if (h != NULL) 2664 set_symbol_from_hash (sym, h); 2665 } 2666 } 2667 } 2668 2669 if ((output_section->flags & (SEC_GROUP | SEC_LINKER_CREATED)) == SEC_GROUP 2670 && input_section->size != 0) 2671 { 2672 /* Group section contents are set by bfd_elf_set_group_contents. */ 2673 if (!output_bfd->output_has_begun) 2674 { 2675 /* FIXME: This hack ensures bfd_elf_set_group_contents is called. */ 2676 if (!bfd_set_section_contents (output_bfd, output_section, "", 0, 1)) 2677 goto error_return; 2678 } 2679 new_contents = output_section->contents; 2680 BFD_ASSERT (new_contents != NULL); 2681 BFD_ASSERT (input_section->output_offset == 0); 2682 } 2683 else 2684 { 2685 /* Get and relocate the section contents. */ 2686 sec_size = (input_section->rawsize > input_section->size 2687 ? input_section->rawsize 2688 : input_section->size); 2689 contents = (bfd_byte *) bfd_malloc (sec_size); 2690 if (contents == NULL && sec_size != 0) 2691 goto error_return; 2692 new_contents = (bfd_get_relocated_section_contents 2693 (output_bfd, info, link_order, contents, 2694 bfd_link_relocatable (info), 2695 _bfd_generic_link_get_symbols (input_bfd))); 2696 if (!new_contents) 2697 goto error_return; 2698 } 2699 2700 /* Output the section contents. */ 2701 loc = input_section->output_offset * bfd_octets_per_byte (output_bfd); 2702 if (! bfd_set_section_contents (output_bfd, output_section, 2703 new_contents, loc, input_section->size)) 2704 goto error_return; 2705 2706 if (contents != NULL) 2707 free (contents); 2708 return TRUE; 2709 2710 error_return: 2711 if (contents != NULL) 2712 free (contents); 2713 return FALSE; 2714 } 2715 2716 /* A little routine to count the number of relocs in a link_order 2717 list. */ 2718 2719 unsigned int 2720 _bfd_count_link_order_relocs (struct bfd_link_order *link_order) 2721 { 2722 register unsigned int c; 2723 register struct bfd_link_order *l; 2724 2725 c = 0; 2726 for (l = link_order; l != NULL; l = l->next) 2727 { 2728 if (l->type == bfd_section_reloc_link_order 2729 || l->type == bfd_symbol_reloc_link_order) 2730 ++c; 2731 } 2732 2733 return c; 2734 } 2735 2736 /* 2737 FUNCTION 2738 bfd_link_split_section 2739 2740 SYNOPSIS 2741 bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec); 2742 2743 DESCRIPTION 2744 Return nonzero if @var{sec} should be split during a 2745 reloceatable or final link. 2746 2747 .#define bfd_link_split_section(abfd, sec) \ 2748 . BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec)) 2749 . 2750 2751 */ 2752 2753 bfd_boolean 2754 _bfd_generic_link_split_section (bfd *abfd ATTRIBUTE_UNUSED, 2755 asection *sec ATTRIBUTE_UNUSED) 2756 { 2757 return FALSE; 2758 } 2759 2760 /* 2761 FUNCTION 2762 bfd_section_already_linked 2763 2764 SYNOPSIS 2765 bfd_boolean bfd_section_already_linked (bfd *abfd, 2766 asection *sec, 2767 struct bfd_link_info *info); 2768 2769 DESCRIPTION 2770 Check if @var{data} has been already linked during a reloceatable 2771 or final link. Return TRUE if it has. 2772 2773 .#define bfd_section_already_linked(abfd, sec, info) \ 2774 . BFD_SEND (abfd, _section_already_linked, (abfd, sec, info)) 2775 . 2776 2777 */ 2778 2779 /* Sections marked with the SEC_LINK_ONCE flag should only be linked 2780 once into the output. This routine checks each section, and 2781 arrange to discard it if a section of the same name has already 2782 been linked. This code assumes that all relevant sections have the 2783 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the 2784 section name. bfd_section_already_linked is called via 2785 bfd_map_over_sections. */ 2786 2787 /* The hash table. */ 2788 2789 static struct bfd_hash_table _bfd_section_already_linked_table; 2790 2791 /* Support routines for the hash table used by section_already_linked, 2792 initialize the table, traverse, lookup, fill in an entry and remove 2793 the table. */ 2794 2795 void 2796 bfd_section_already_linked_table_traverse 2797 (bfd_boolean (*func) (struct bfd_section_already_linked_hash_entry *, 2798 void *), void *info) 2799 { 2800 bfd_hash_traverse (&_bfd_section_already_linked_table, 2801 (bfd_boolean (*) (struct bfd_hash_entry *, 2802 void *)) func, 2803 info); 2804 } 2805 2806 struct bfd_section_already_linked_hash_entry * 2807 bfd_section_already_linked_table_lookup (const char *name) 2808 { 2809 return ((struct bfd_section_already_linked_hash_entry *) 2810 bfd_hash_lookup (&_bfd_section_already_linked_table, name, 2811 TRUE, FALSE)); 2812 } 2813 2814 bfd_boolean 2815 bfd_section_already_linked_table_insert 2816 (struct bfd_section_already_linked_hash_entry *already_linked_list, 2817 asection *sec) 2818 { 2819 struct bfd_section_already_linked *l; 2820 2821 /* Allocate the memory from the same obstack as the hash table is 2822 kept in. */ 2823 l = (struct bfd_section_already_linked *) 2824 bfd_hash_allocate (&_bfd_section_already_linked_table, sizeof *l); 2825 if (l == NULL) 2826 return FALSE; 2827 l->sec = sec; 2828 l->next = already_linked_list->entry; 2829 already_linked_list->entry = l; 2830 return TRUE; 2831 } 2832 2833 static struct bfd_hash_entry * 2834 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED, 2835 struct bfd_hash_table *table, 2836 const char *string ATTRIBUTE_UNUSED) 2837 { 2838 struct bfd_section_already_linked_hash_entry *ret = 2839 (struct bfd_section_already_linked_hash_entry *) 2840 bfd_hash_allocate (table, sizeof *ret); 2841 2842 if (ret == NULL) 2843 return NULL; 2844 2845 ret->entry = NULL; 2846 2847 return &ret->root; 2848 } 2849 2850 bfd_boolean 2851 bfd_section_already_linked_table_init (void) 2852 { 2853 return bfd_hash_table_init_n (&_bfd_section_already_linked_table, 2854 already_linked_newfunc, 2855 sizeof (struct bfd_section_already_linked_hash_entry), 2856 42); 2857 } 2858 2859 void 2860 bfd_section_already_linked_table_free (void) 2861 { 2862 bfd_hash_table_free (&_bfd_section_already_linked_table); 2863 } 2864 2865 /* Report warnings as appropriate for duplicate section SEC. 2866 Return FALSE if we decide to keep SEC after all. */ 2867 2868 bfd_boolean 2869 _bfd_handle_already_linked (asection *sec, 2870 struct bfd_section_already_linked *l, 2871 struct bfd_link_info *info) 2872 { 2873 switch (sec->flags & SEC_LINK_DUPLICATES) 2874 { 2875 default: 2876 abort (); 2877 2878 case SEC_LINK_DUPLICATES_DISCARD: 2879 /* If we found an LTO IR match for this comdat group on 2880 the first pass, replace it with the LTO output on the 2881 second pass. We can't simply choose real object 2882 files over IR because the first pass may contain a 2883 mix of LTO and normal objects and we must keep the 2884 first match, be it IR or real. */ 2885 if (sec->owner->lto_output 2886 && (l->sec->owner->flags & BFD_PLUGIN) != 0) 2887 { 2888 l->sec = sec; 2889 return FALSE; 2890 } 2891 break; 2892 2893 case SEC_LINK_DUPLICATES_ONE_ONLY: 2894 info->callbacks->einfo 2895 (_("%B: ignoring duplicate section `%A'\n"), 2896 sec->owner, sec); 2897 break; 2898 2899 case SEC_LINK_DUPLICATES_SAME_SIZE: 2900 if ((l->sec->owner->flags & BFD_PLUGIN) != 0) 2901 ; 2902 else if (sec->size != l->sec->size) 2903 info->callbacks->einfo 2904 (_("%B: duplicate section `%A' has different size\n"), 2905 sec->owner, sec); 2906 break; 2907 2908 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 2909 if ((l->sec->owner->flags & BFD_PLUGIN) != 0) 2910 ; 2911 else if (sec->size != l->sec->size) 2912 info->callbacks->einfo 2913 (_("%B: duplicate section `%A' has different size\n"), 2914 sec->owner, sec); 2915 else if (sec->size != 0) 2916 { 2917 bfd_byte *sec_contents, *l_sec_contents = NULL; 2918 2919 if (!bfd_malloc_and_get_section (sec->owner, sec, &sec_contents)) 2920 info->callbacks->einfo 2921 (_("%B: could not read contents of section `%A'\n"), 2922 sec->owner, sec); 2923 else if (!bfd_malloc_and_get_section (l->sec->owner, l->sec, 2924 &l_sec_contents)) 2925 info->callbacks->einfo 2926 (_("%B: could not read contents of section `%A'\n"), 2927 l->sec->owner, l->sec); 2928 else if (memcmp (sec_contents, l_sec_contents, sec->size) != 0) 2929 info->callbacks->einfo 2930 (_("%B: duplicate section `%A' has different contents\n"), 2931 sec->owner, sec); 2932 2933 if (sec_contents) 2934 free (sec_contents); 2935 if (l_sec_contents) 2936 free (l_sec_contents); 2937 } 2938 break; 2939 } 2940 2941 /* Set the output_section field so that lang_add_section 2942 does not create a lang_input_section structure for this 2943 section. Since there might be a symbol in the section 2944 being discarded, we must retain a pointer to the section 2945 which we are really going to use. */ 2946 sec->output_section = bfd_abs_section_ptr; 2947 sec->kept_section = l->sec; 2948 return TRUE; 2949 } 2950 2951 /* This is used on non-ELF inputs. */ 2952 2953 bfd_boolean 2954 _bfd_generic_section_already_linked (bfd *abfd ATTRIBUTE_UNUSED, 2955 asection *sec, 2956 struct bfd_link_info *info) 2957 { 2958 const char *name; 2959 struct bfd_section_already_linked *l; 2960 struct bfd_section_already_linked_hash_entry *already_linked_list; 2961 2962 if ((sec->flags & SEC_LINK_ONCE) == 0) 2963 return FALSE; 2964 2965 /* The generic linker doesn't handle section groups. */ 2966 if ((sec->flags & SEC_GROUP) != 0) 2967 return FALSE; 2968 2969 /* FIXME: When doing a relocatable link, we may have trouble 2970 copying relocations in other sections that refer to local symbols 2971 in the section being discarded. Those relocations will have to 2972 be converted somehow; as of this writing I'm not sure that any of 2973 the backends handle that correctly. 2974 2975 It is tempting to instead not discard link once sections when 2976 doing a relocatable link (technically, they should be discarded 2977 whenever we are building constructors). However, that fails, 2978 because the linker winds up combining all the link once sections 2979 into a single large link once section, which defeats the purpose 2980 of having link once sections in the first place. */ 2981 2982 name = bfd_get_section_name (abfd, sec); 2983 2984 already_linked_list = bfd_section_already_linked_table_lookup (name); 2985 2986 l = already_linked_list->entry; 2987 if (l != NULL) 2988 { 2989 /* The section has already been linked. See if we should 2990 issue a warning. */ 2991 return _bfd_handle_already_linked (sec, l, info); 2992 } 2993 2994 /* This is the first section with this name. Record it. */ 2995 if (!bfd_section_already_linked_table_insert (already_linked_list, sec)) 2996 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); 2997 return FALSE; 2998 } 2999 3000 /* Choose a neighbouring section to S in OBFD that will be output, or 3001 the absolute section if ADDR is out of bounds of the neighbours. */ 3002 3003 asection * 3004 _bfd_nearby_section (bfd *obfd, asection *s, bfd_vma addr) 3005 { 3006 asection *next, *prev, *best; 3007 3008 /* Find preceding kept section. */ 3009 for (prev = s->prev; prev != NULL; prev = prev->prev) 3010 if ((prev->flags & SEC_EXCLUDE) == 0 3011 && !bfd_section_removed_from_list (obfd, prev)) 3012 break; 3013 3014 /* Find following kept section. Start at prev->next because 3015 other sections may have been added after S was removed. */ 3016 if (s->prev != NULL) 3017 next = s->prev->next; 3018 else 3019 next = s->owner->sections; 3020 for (; next != NULL; next = next->next) 3021 if ((next->flags & SEC_EXCLUDE) == 0 3022 && !bfd_section_removed_from_list (obfd, next)) 3023 break; 3024 3025 /* Choose better of two sections, based on flags. The idea 3026 is to choose a section that will be in the same segment 3027 as S would have been if it was kept. */ 3028 best = next; 3029 if (prev == NULL) 3030 { 3031 if (next == NULL) 3032 best = bfd_abs_section_ptr; 3033 } 3034 else if (next == NULL) 3035 best = prev; 3036 else if (((prev->flags ^ next->flags) 3037 & (SEC_ALLOC | SEC_THREAD_LOCAL | SEC_LOAD)) != 0) 3038 { 3039 if (((next->flags ^ s->flags) 3040 & (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0 3041 /* We prefer to choose a loaded section. Section S 3042 doesn't have SEC_LOAD set (it being excluded, that 3043 part of the flag processing didn't happen) so we 3044 can't compare that flag to those of NEXT and PREV. */ 3045 || ((prev->flags & SEC_LOAD) != 0 3046 && (next->flags & SEC_LOAD) == 0)) 3047 best = prev; 3048 } 3049 else if (((prev->flags ^ next->flags) & SEC_READONLY) != 0) 3050 { 3051 if (((next->flags ^ s->flags) & SEC_READONLY) != 0) 3052 best = prev; 3053 } 3054 else if (((prev->flags ^ next->flags) & SEC_CODE) != 0) 3055 { 3056 if (((next->flags ^ s->flags) & SEC_CODE) != 0) 3057 best = prev; 3058 } 3059 else 3060 { 3061 /* Flags we care about are the same. Prefer the following 3062 section if that will result in a positive valued sym. */ 3063 if (addr < next->vma) 3064 best = prev; 3065 } 3066 3067 return best; 3068 } 3069 3070 /* Convert symbols in excluded output sections to use a kept section. */ 3071 3072 static bfd_boolean 3073 fix_syms (struct bfd_link_hash_entry *h, void *data) 3074 { 3075 bfd *obfd = (bfd *) data; 3076 3077 if (h->type == bfd_link_hash_defined 3078 || h->type == bfd_link_hash_defweak) 3079 { 3080 asection *s = h->u.def.section; 3081 if (s != NULL 3082 && s->output_section != NULL 3083 && (s->output_section->flags & SEC_EXCLUDE) != 0 3084 && bfd_section_removed_from_list (obfd, s->output_section)) 3085 { 3086 asection *op; 3087 3088 h->u.def.value += s->output_offset + s->output_section->vma; 3089 op = _bfd_nearby_section (obfd, s->output_section, h->u.def.value); 3090 h->u.def.value -= op->vma; 3091 h->u.def.section = op; 3092 } 3093 } 3094 3095 return TRUE; 3096 } 3097 3098 void 3099 _bfd_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info) 3100 { 3101 bfd_link_hash_traverse (info->hash, fix_syms, obfd); 3102 } 3103 3104 /* 3105 FUNCTION 3106 bfd_generic_define_common_symbol 3107 3108 SYNOPSIS 3109 bfd_boolean bfd_generic_define_common_symbol 3110 (bfd *output_bfd, struct bfd_link_info *info, 3111 struct bfd_link_hash_entry *h); 3112 3113 DESCRIPTION 3114 Convert common symbol @var{h} into a defined symbol. 3115 Return TRUE on success and FALSE on failure. 3116 3117 .#define bfd_define_common_symbol(output_bfd, info, h) \ 3118 . BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h)) 3119 . 3120 */ 3121 3122 bfd_boolean 3123 bfd_generic_define_common_symbol (bfd *output_bfd, 3124 struct bfd_link_info *info ATTRIBUTE_UNUSED, 3125 struct bfd_link_hash_entry *h) 3126 { 3127 unsigned int power_of_two; 3128 bfd_vma alignment, size; 3129 asection *section; 3130 3131 BFD_ASSERT (h != NULL && h->type == bfd_link_hash_common); 3132 3133 size = h->u.c.size; 3134 power_of_two = h->u.c.p->alignment_power; 3135 section = h->u.c.p->section; 3136 3137 /* Increase the size of the section to align the common symbol. 3138 The alignment must be a power of two. */ 3139 alignment = bfd_octets_per_byte (output_bfd) << power_of_two; 3140 BFD_ASSERT (alignment != 0 && (alignment & -alignment) == alignment); 3141 section->size += alignment - 1; 3142 section->size &= -alignment; 3143 3144 /* Adjust the section's overall alignment if necessary. */ 3145 if (power_of_two > section->alignment_power) 3146 section->alignment_power = power_of_two; 3147 3148 /* Change the symbol from common to defined. */ 3149 h->type = bfd_link_hash_defined; 3150 h->u.def.section = section; 3151 h->u.def.value = section->size; 3152 3153 /* Increase the size of the section. */ 3154 section->size += size; 3155 3156 /* Make sure the section is allocated in memory, and make sure that 3157 it is no longer a common section. */ 3158 section->flags |= SEC_ALLOC; 3159 section->flags &= ~SEC_IS_COMMON; 3160 return TRUE; 3161 } 3162 3163 /* 3164 FUNCTION 3165 bfd_find_version_for_sym 3166 3167 SYNOPSIS 3168 struct bfd_elf_version_tree * bfd_find_version_for_sym 3169 (struct bfd_elf_version_tree *verdefs, 3170 const char *sym_name, bfd_boolean *hide); 3171 3172 DESCRIPTION 3173 Search an elf version script tree for symbol versioning 3174 info and export / don't-export status for a given symbol. 3175 Return non-NULL on success and NULL on failure; also sets 3176 the output @samp{hide} boolean parameter. 3177 3178 */ 3179 3180 struct bfd_elf_version_tree * 3181 bfd_find_version_for_sym (struct bfd_elf_version_tree *verdefs, 3182 const char *sym_name, 3183 bfd_boolean *hide) 3184 { 3185 struct bfd_elf_version_tree *t; 3186 struct bfd_elf_version_tree *local_ver, *global_ver, *exist_ver; 3187 struct bfd_elf_version_tree *star_local_ver, *star_global_ver; 3188 3189 local_ver = NULL; 3190 global_ver = NULL; 3191 star_local_ver = NULL; 3192 star_global_ver = NULL; 3193 exist_ver = NULL; 3194 for (t = verdefs; t != NULL; t = t->next) 3195 { 3196 if (t->globals.list != NULL) 3197 { 3198 struct bfd_elf_version_expr *d = NULL; 3199 3200 while ((d = (*t->match) (&t->globals, d, sym_name)) != NULL) 3201 { 3202 if (d->literal || strcmp (d->pattern, "*") != 0) 3203 global_ver = t; 3204 else 3205 star_global_ver = t; 3206 if (d->symver) 3207 exist_ver = t; 3208 d->script = 1; 3209 /* If the match is a wildcard pattern, keep looking for 3210 a more explicit, perhaps even local, match. */ 3211 if (d->literal) 3212 break; 3213 } 3214 3215 if (d != NULL) 3216 break; 3217 } 3218 3219 if (t->locals.list != NULL) 3220 { 3221 struct bfd_elf_version_expr *d = NULL; 3222 3223 while ((d = (*t->match) (&t->locals, d, sym_name)) != NULL) 3224 { 3225 if (d->literal || strcmp (d->pattern, "*") != 0) 3226 local_ver = t; 3227 else 3228 star_local_ver = t; 3229 /* If the match is a wildcard pattern, keep looking for 3230 a more explicit, perhaps even global, match. */ 3231 if (d->literal) 3232 { 3233 /* An exact match overrides a global wildcard. */ 3234 global_ver = NULL; 3235 star_global_ver = NULL; 3236 break; 3237 } 3238 } 3239 3240 if (d != NULL) 3241 break; 3242 } 3243 } 3244 3245 if (global_ver == NULL && local_ver == NULL) 3246 global_ver = star_global_ver; 3247 3248 if (global_ver != NULL) 3249 { 3250 /* If we already have a versioned symbol that matches the 3251 node for this symbol, then we don't want to create a 3252 duplicate from the unversioned symbol. Instead hide the 3253 unversioned symbol. */ 3254 *hide = exist_ver == global_ver; 3255 return global_ver; 3256 } 3257 3258 if (local_ver == NULL) 3259 local_ver = star_local_ver; 3260 3261 if (local_ver != NULL) 3262 { 3263 *hide = TRUE; 3264 return local_ver; 3265 } 3266 3267 return NULL; 3268 } 3269 3270 /* 3271 FUNCTION 3272 bfd_hide_sym_by_version 3273 3274 SYNOPSIS 3275 bfd_boolean bfd_hide_sym_by_version 3276 (struct bfd_elf_version_tree *verdefs, const char *sym_name); 3277 3278 DESCRIPTION 3279 Search an elf version script tree for symbol versioning 3280 info for a given symbol. Return TRUE if the symbol is hidden. 3281 3282 */ 3283 3284 bfd_boolean 3285 bfd_hide_sym_by_version (struct bfd_elf_version_tree *verdefs, 3286 const char *sym_name) 3287 { 3288 bfd_boolean hidden = FALSE; 3289 bfd_find_version_for_sym (verdefs, sym_name, &hidden); 3290 return hidden; 3291 } 3292 3293 /* 3294 FUNCTION 3295 bfd_link_check_relocs 3296 3297 SYNOPSIS 3298 bfd_boolean bfd_link_check_relocs 3299 (bfd *abfd, struct bfd_link_info *info); 3300 3301 DESCRIPTION 3302 Checks the relocs in ABFD for validity. 3303 Does not execute the relocs. 3304 Return TRUE if everything is OK, FALSE otherwise. 3305 This is the external entry point to this code. 3306 */ 3307 3308 bfd_boolean 3309 bfd_link_check_relocs (bfd *abfd, struct bfd_link_info *info) 3310 { 3311 return BFD_SEND (abfd, _bfd_link_check_relocs, (abfd, info)); 3312 } 3313 3314 /* 3315 FUNCTION 3316 _bfd_generic_link_check_relocs 3317 3318 SYNOPSIS 3319 bfd_boolean _bfd_generic_link_check_relocs 3320 (bfd *abfd, struct bfd_link_info *info); 3321 3322 DESCRIPTION 3323 Stub function for targets that do not implement reloc checking. 3324 Return TRUE. 3325 This is an internal function. It should not be called from 3326 outside the BFD library. 3327 */ 3328 3329 bfd_boolean 3330 _bfd_generic_link_check_relocs (bfd *abfd ATTRIBUTE_UNUSED, 3331 struct bfd_link_info *info ATTRIBUTE_UNUSED) 3332 { 3333 return TRUE; 3334 } 3335