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