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