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