sparclinux.c revision 60484
1/* BFD back-end for linux flavored sparc a.out binaries. 2 Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 1999 3 Free Software Foundation, Inc. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 20USA. */ 21 22#define TARGET_PAGE_SIZE 4096 23#define ZMAGIC_DISK_BLOCK_SIZE 1024 24#define SEGMENT_SIZE TARGET_PAGE_SIZE 25#define TEXT_START_ADDR 0x0 26#define N_SHARED_LIB(x) 0 27#define BYTES_IN_WORD 4 28 29#define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN) 30 31#include "bfd.h" 32#include "sysdep.h" 33#include "libbfd.h" 34#include "aout/aout64.h" 35#include "aout/stab_gnu.h" 36#include "aout/ar.h" 37#include "libaout.h" /* BFD a.out internal data structures */ 38 39#define DEFAULT_ARCH bfd_arch_sparc 40#define MY(OP) CAT(sparclinux_,OP) 41#define TARGETNAME "a.out-sparc-linux" 42 43extern const bfd_target MY(vec); 44 45/* We always generate QMAGIC files in preference to ZMAGIC files. It 46 would be possible to make this a linker option, if that ever 47 becomes important. */ 48 49static void MY_final_link_callback 50 PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *)); 51 52static boolean sparclinux_bfd_final_link 53 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 54 55static boolean 56sparclinux_bfd_final_link (abfd, info) 57 bfd *abfd; 58 struct bfd_link_info *info; 59{ 60 obj_aout_subformat (abfd) = q_magic_format; 61 return NAME(aout,final_link) (abfd, info, MY_final_link_callback); 62} 63 64#define MY_bfd_final_link sparclinux_bfd_final_link 65 66/* Set the machine type correctly. */ 67 68static boolean sparclinux_write_object_contents PARAMS ((bfd *abfd)); 69 70static boolean 71sparclinux_write_object_contents (abfd) 72 bfd *abfd; 73{ 74 struct external_exec exec_bytes; 75 struct internal_exec *execp = exec_hdr (abfd); 76 77 N_SET_MACHTYPE (*execp, M_SPARC); 78 79 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE; 80 81 WRITE_HEADERS(abfd, execp); 82 83 return true; 84} 85 86#define MY_write_object_contents sparclinux_write_object_contents 87/* Code to link against Linux a.out shared libraries. */ 88 89/* See if a symbol name is a reference to the global offset table. */ 90 91#ifndef GOT_REF_PREFIX 92#define GOT_REF_PREFIX "__GOT_" 93#endif 94 95#define IS_GOT_SYM(name) \ 96 (strncmp (name, GOT_REF_PREFIX, sizeof GOT_REF_PREFIX - 1) == 0) 97 98/* See if a symbol name is a reference to the procedure linkage table. */ 99 100#ifndef PLT_REF_PREFIX 101#define PLT_REF_PREFIX "__PLT_" 102#endif 103 104#define IS_PLT_SYM(name) \ 105 (strncmp (name, PLT_REF_PREFIX, sizeof PLT_REF_PREFIX - 1) == 0) 106 107/* This string is used to generate specialized error messages. */ 108 109#ifndef NEEDS_SHRLIB 110#define NEEDS_SHRLIB "__NEEDS_SHRLIB_" 111#endif 112 113/* This special symbol is a set vector that contains a list of 114 pointers to fixup tables. It will be present in any dynamicly 115 linked file. The linker generated fixup table should also be added 116 to the list, and it should always appear in the second slot (the 117 first one is a dummy with a magic number that is defined in 118 crt0.o). */ 119 120#ifndef SHARABLE_CONFLICTS 121#define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__" 122#endif 123 124/* We keep a list of fixups. The terminology is a bit strange, but 125 each fixup contains two 32 bit numbers. A regular fixup contains 126 an address and a pointer, and at runtime we should store the 127 address at the location pointed to by the pointer. A builtin fixup 128 contains two pointers, and we should read the address using one 129 pointer and store it at the location pointed to by the other 130 pointer. Builtin fixups come into play when we have duplicate 131 __GOT__ symbols for the same variable. The builtin fixup will copy 132 the GOT pointer from one over into the other. */ 133 134struct fixup 135{ 136 struct fixup *next; 137 struct linux_link_hash_entry *h; 138 bfd_vma value; 139 140 /* Nonzero if this is a jump instruction that needs to be fixed, 141 zero if this is just a pointer */ 142 char jump; 143 144 char builtin; 145}; 146 147/* We don't need a special hash table entry structure, but we do need 148 to keep some information between linker passes, so we use a special 149 hash table. */ 150 151struct linux_link_hash_entry 152{ 153 struct aout_link_hash_entry root; 154}; 155 156struct linux_link_hash_table 157{ 158 struct aout_link_hash_table root; 159 160 /* First dynamic object found in link. */ 161 bfd *dynobj; 162 163 /* Number of fixups. */ 164 size_t fixup_count; 165 166 /* Number of builtin fixups. */ 167 size_t local_builtins; 168 169 /* List of fixups. */ 170 struct fixup *fixup_list; 171}; 172 173static struct bfd_hash_entry *linux_link_hash_newfunc 174 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 175static struct bfd_link_hash_table *linux_link_hash_table_create 176 PARAMS ((bfd *)); 177static struct fixup *new_fixup 178 PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *, 179 bfd_vma, int)); 180static boolean linux_link_create_dynamic_sections 181 PARAMS ((bfd *, struct bfd_link_info *)); 182static boolean linux_add_one_symbol 183 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *, 184 bfd_vma, const char *, boolean, boolean, 185 struct bfd_link_hash_entry **)); 186static boolean linux_tally_symbols 187 PARAMS ((struct linux_link_hash_entry *, PTR)); 188static boolean linux_finish_dynamic_link 189 PARAMS ((bfd *, struct bfd_link_info *)); 190 191/* Routine to create an entry in an Linux link hash table. */ 192 193static struct bfd_hash_entry * 194linux_link_hash_newfunc (entry, table, string) 195 struct bfd_hash_entry *entry; 196 struct bfd_hash_table *table; 197 const char *string; 198{ 199 struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry; 200 201 /* Allocate the structure if it has not already been allocated by a 202 subclass. */ 203 if (ret == (struct linux_link_hash_entry *) NULL) 204 ret = ((struct linux_link_hash_entry *) 205 bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry))); 206 if (ret == NULL) 207 return (struct bfd_hash_entry *) ret; 208 209 /* Call the allocation method of the superclass. */ 210 ret = ((struct linux_link_hash_entry *) 211 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret, 212 table, string)); 213 if (ret != NULL) 214 { 215 /* Set local fields; there aren't any. */ 216 } 217 218 return (struct bfd_hash_entry *) ret; 219} 220 221/* Create a Linux link hash table. */ 222 223static struct bfd_link_hash_table * 224linux_link_hash_table_create (abfd) 225 bfd *abfd; 226{ 227 struct linux_link_hash_table *ret; 228 229 ret = ((struct linux_link_hash_table *) 230 bfd_alloc (abfd, sizeof (struct linux_link_hash_table))); 231 if (ret == (struct linux_link_hash_table *) NULL) 232 return (struct bfd_link_hash_table *) NULL; 233 if (! NAME(aout,link_hash_table_init) (&ret->root, abfd, 234 linux_link_hash_newfunc)) 235 { 236 free (ret); 237 return (struct bfd_link_hash_table *) NULL; 238 } 239 240 ret->dynobj = NULL; 241 ret->fixup_count = 0; 242 ret->local_builtins = 0; 243 ret->fixup_list = NULL; 244 245 return &ret->root.root; 246} 247 248/* Look up an entry in a Linux link hash table. */ 249 250#define linux_link_hash_lookup(table, string, create, copy, follow) \ 251 ((struct linux_link_hash_entry *) \ 252 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\ 253 (follow))) 254 255/* Traverse a Linux link hash table. */ 256 257#define linux_link_hash_traverse(table, func, info) \ 258 (aout_link_hash_traverse \ 259 (&(table)->root, \ 260 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \ 261 (info))) 262 263/* Get the Linux link hash table from the info structure. This is 264 just a cast. */ 265 266#define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash)) 267 268/* Store the information for a new fixup. */ 269 270static struct fixup * 271new_fixup (info, h, value, builtin) 272 struct bfd_link_info *info; 273 struct linux_link_hash_entry *h; 274 bfd_vma value; 275 int builtin; 276{ 277 struct fixup *f; 278 279 f = (struct fixup *) bfd_hash_allocate (&info->hash->table, 280 sizeof (struct fixup)); 281 if (f == NULL) 282 return f; 283 f->next = linux_hash_table (info)->fixup_list; 284 linux_hash_table (info)->fixup_list = f; 285 f->h = h; 286 f->value = value; 287 f->builtin = builtin; 288 f->jump = 0; 289 ++linux_hash_table (info)->fixup_count; 290 return f; 291} 292 293/* We come here once we realize that we are going to link to a shared 294 library. We need to create a special section that contains the 295 fixup table, and we ultimately need to add a pointer to this into 296 the set vector for SHARABLE_CONFLICTS. At this point we do not 297 know the size of the section, but that's OK - we just need to 298 create it for now. */ 299 300static boolean 301linux_link_create_dynamic_sections (abfd, info) 302 bfd *abfd; 303 struct bfd_link_info *info ATTRIBUTE_UNUSED; 304{ 305 flagword flags; 306 register asection *s; 307 308 /* Note that we set the SEC_IN_MEMORY flag. */ 309 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY; 310 311 /* We choose to use the name ".linux-dynamic" for the fixup table. 312 Why not? */ 313 s = bfd_make_section (abfd, ".linux-dynamic"); 314 if (s == NULL 315 || ! bfd_set_section_flags (abfd, s, flags) 316 || ! bfd_set_section_alignment (abfd, s, 2)) 317 return false; 318 s->_raw_size = 0; 319 s->contents = 0; 320 321 return true; 322} 323 324/* Function to add a single symbol to the linker hash table. This is 325 a wrapper around _bfd_generic_link_add_one_symbol which handles the 326 tweaking needed for dynamic linking support. */ 327 328static boolean 329linux_add_one_symbol (info, abfd, name, flags, section, value, string, 330 copy, collect, hashp) 331 struct bfd_link_info *info; 332 bfd *abfd; 333 const char *name; 334 flagword flags; 335 asection *section; 336 bfd_vma value; 337 const char *string; 338 boolean copy; 339 boolean collect; 340 struct bfd_link_hash_entry **hashp; 341{ 342 struct linux_link_hash_entry *h; 343 boolean insert; 344 345 /* Look up and see if we already have this symbol in the hash table. 346 If we do, and the defining entry is from a shared library, we 347 need to create the dynamic sections. 348 349 FIXME: What if abfd->xvec != info->hash->creator? We may want to 350 be able to link Linux a.out and ELF objects together, but serious 351 confusion is possible. */ 352 353 insert = false; 354 355 if (! info->relocateable 356 && linux_hash_table (info)->dynobj == NULL 357 && strcmp (name, SHARABLE_CONFLICTS) == 0 358 && (flags & BSF_CONSTRUCTOR) != 0 359 && abfd->xvec == info->hash->creator) 360 { 361 if (! linux_link_create_dynamic_sections (abfd, info)) 362 return false; 363 linux_hash_table (info)->dynobj = abfd; 364 insert = true; 365 } 366 367 if (bfd_is_abs_section (section) 368 && abfd->xvec == info->hash->creator) 369 { 370 h = linux_link_hash_lookup (linux_hash_table (info), name, false, 371 false, false); 372 if (h != NULL 373 && (h->root.root.type == bfd_link_hash_defined 374 || h->root.root.type == bfd_link_hash_defweak)) 375 { 376 struct fixup *f; 377 378 if (hashp != NULL) 379 *hashp = (struct bfd_link_hash_entry *) h; 380 381 f = new_fixup (info, h, value, ! IS_PLT_SYM (name)); 382 if (f == NULL) 383 return false; 384 f->jump = IS_PLT_SYM (name); 385 386 return true; 387 } 388 } 389 390 /* Do the usual procedure for adding a symbol. */ 391 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, 392 value, string, copy, collect, 393 hashp)) 394 return false; 395 396 /* Insert a pointer to our table in the set vector. The dynamic 397 linker requires this information */ 398 if (insert) 399 { 400 asection *s; 401 402 /* Here we do our special thing to add the pointer to the 403 dynamic section in the SHARABLE_CONFLICTS set vector. */ 404 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 405 ".linux-dynamic"); 406 BFD_ASSERT (s != NULL); 407 408 if (! (_bfd_generic_link_add_one_symbol 409 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS, 410 BSF_GLOBAL | BSF_CONSTRUCTOR, s, 0, NULL, false, false, NULL))) 411 return false; 412 } 413 414 return true; 415} 416 417/* We will crawl the hash table and come here for every global symbol. 418 We will examine each entry and see if there are indications that we 419 need to add a fixup. There are two possible cases - one is where 420 you have duplicate definitions of PLT or GOT symbols - these will 421 have already been caught and added as "builtin" fixups. If we find 422 that the corresponding non PLT/GOT symbol is also present, we 423 convert it to a regular fixup instead. 424 425 This function is called via linux_link_hash_traverse. */ 426 427static boolean 428linux_tally_symbols (h, data) 429 struct linux_link_hash_entry *h; 430 PTR data; 431{ 432 struct bfd_link_info *info = (struct bfd_link_info *) data; 433 struct fixup *f, *f1; 434 int is_plt; 435 struct linux_link_hash_entry *h1, *h2; 436 boolean exists; 437 438 if (h->root.root.type == bfd_link_hash_undefined 439 && strncmp (h->root.root.root.string, NEEDS_SHRLIB, 440 sizeof NEEDS_SHRLIB - 1) == 0) 441 { 442 const char *name; 443 char *p; 444 char *alloc = NULL; 445 446 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1; 447 p = strrchr (name, '_'); 448 if (p != NULL) 449 alloc = (char *) bfd_malloc (strlen (name) + 1); 450 451 if (p == NULL || alloc == NULL) 452 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"), 453 name); 454 else 455 { 456 strcpy (alloc, name); 457 p = strrchr (alloc, '_'); 458 *p++ = '\0'; 459 (*_bfd_error_handler) 460 (_("Output file requires shared library `%s.so.%s'\n"), 461 alloc, p); 462 free (alloc); 463 } 464 465 abort (); 466 } 467 468 /* If this symbol is not a PLT/GOT, we do not even need to look at 469 it. */ 470 is_plt = IS_PLT_SYM (h->root.root.root.string); 471 472 if (is_plt || IS_GOT_SYM (h->root.root.root.string)) 473 { 474 /* Look up this symbol twice. Once just as a regular lookup, 475 and then again following all of the indirect links until we 476 reach a real symbol. */ 477 h1 = linux_link_hash_lookup (linux_hash_table (info), 478 (h->root.root.root.string 479 + sizeof PLT_REF_PREFIX - 1), 480 false, false, true); 481 /* h2 does not follow indirect symbols. */ 482 h2 = linux_link_hash_lookup (linux_hash_table (info), 483 (h->root.root.root.string 484 + sizeof PLT_REF_PREFIX - 1), 485 false, false, false); 486 487 /* The real symbol must exist but if it is also an ABS symbol, 488 there is no need to have a fixup. This is because they both 489 came from the same library. If on the other hand, we had to 490 use an indirect symbol to get to the real symbol, we add the 491 fixup anyway, since there are cases where these symbols come 492 from different shared libraries */ 493 if (h1 != NULL 494 && (((h1->root.root.type == bfd_link_hash_defined 495 || h1->root.root.type == bfd_link_hash_defweak) 496 && ! bfd_is_abs_section (h1->root.root.u.def.section)) 497 || h2->root.root.type == bfd_link_hash_indirect)) 498 { 499 /* See if there is a "builtin" fixup already present 500 involving this symbol. If so, convert it to a regular 501 fixup. In the end, this relaxes some of the requirements 502 about the order of performing fixups. */ 503 exists = false; 504 for (f1 = linux_hash_table (info)->fixup_list; 505 f1 != NULL; 506 f1 = f1->next) 507 { 508 if ((f1->h != h && f1->h != h1) 509 || (! f1->builtin && ! f1->jump)) 510 continue; 511 if (f1->h == h1) 512 exists = true; 513 if (! exists 514 && bfd_is_abs_section (h->root.root.u.def.section)) 515 { 516 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0); 517 f->jump = is_plt; 518 } 519 f1->h = h1; 520 f1->jump = is_plt; 521 f1->builtin = 0; 522 exists = true; 523 } 524 if (! exists 525 && bfd_is_abs_section (h->root.root.u.def.section)) 526 { 527 f = new_fixup (info, h1, h->root.root.u.def.value, 0); 528 if (f == NULL) 529 { 530 /* FIXME: No way to return error. */ 531 abort (); 532 } 533 f->jump = is_plt; 534 } 535 } 536 537 /* Quick and dirty way of stripping these symbols from the 538 symtab. */ 539 if (bfd_is_abs_section (h->root.root.u.def.section)) 540 h->root.written = true; 541 } 542 543 return true; 544} 545 546/* This is called to set the size of the .linux-dynamic section is. 547 It is called by the Linux linker emulation before_allocation 548 routine. We have finished reading all of the input files, and now 549 we just scan the hash tables to find out how many additional fixups 550 are required. */ 551 552boolean 553bfd_sparclinux_size_dynamic_sections (output_bfd, info) 554 bfd *output_bfd; 555 struct bfd_link_info *info; 556{ 557 struct fixup *f; 558 asection *s; 559 560 if (output_bfd->xvec != &MY(vec)) 561 return true; 562 563 /* First find the fixups... */ 564 linux_link_hash_traverse (linux_hash_table (info), 565 linux_tally_symbols, 566 (PTR) info); 567 568 /* If there are builtin fixups, leave room for a marker. This is 569 used by the dynamic linker so that it knows that all that follow 570 are builtin fixups instead of regular fixups. */ 571 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 572 { 573 if (f->builtin) 574 { 575 ++linux_hash_table (info)->fixup_count; 576 ++linux_hash_table (info)->local_builtins; 577 break; 578 } 579 } 580 581 if (linux_hash_table (info)->dynobj == NULL) 582 { 583 if (linux_hash_table (info)->fixup_count > 0) 584 abort (); 585 return true; 586 } 587 588 /* Allocate memory for our fixup table. We will fill it in later. */ 589 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 590 ".linux-dynamic"); 591 if (s != NULL) 592 { 593 s->_raw_size = 8 + linux_hash_table (info)->fixup_count * 8; 594 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size); 595 if (s->contents == NULL) 596 return false; 597 memset (s->contents, 0, (size_t) s->_raw_size); 598 } 599 600 return true; 601} 602 603/* We come here once we are ready to actually write the fixup table to 604 the output file. Scan the fixup tables and so forth and generate 605 the stuff we need. */ 606 607static boolean 608linux_finish_dynamic_link (output_bfd, info) 609 bfd *output_bfd; 610 struct bfd_link_info *info; 611{ 612 asection *s, *os, *is; 613 bfd_byte *fixup_table; 614 struct linux_link_hash_entry *h; 615 struct fixup *f; 616 unsigned int new_addr; 617 int section_offset; 618 unsigned int fixups_written; 619 620 if (linux_hash_table (info)->dynobj == NULL) 621 return true; 622 623 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 624 ".linux-dynamic"); 625 BFD_ASSERT (s != NULL); 626 os = s->output_section; 627 fixups_written = 0; 628 629#ifdef LINUX_LINK_DEBUG 630 printf ("Fixup table file offset: %x VMA: %x\n", 631 os->filepos + s->output_offset, 632 os->vma + s->output_offset); 633#endif 634 635 fixup_table = s->contents; 636 bfd_put_32 (output_bfd, linux_hash_table (info)->fixup_count, fixup_table); 637 fixup_table += 4; 638 639 /* Fill in fixup table. */ 640 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 641 { 642 if (f->builtin) 643 continue; 644 645 if (f->h->root.root.type != bfd_link_hash_defined 646 && f->h->root.root.type != bfd_link_hash_defweak) 647 { 648 (*_bfd_error_handler) 649 (_("Symbol %s not defined for fixups\n"), 650 f->h->root.root.root.string); 651 continue; 652 } 653 654 is = f->h->root.root.u.def.section; 655 section_offset = is->output_section->vma + is->output_offset; 656 new_addr = f->h->root.root.u.def.value + section_offset; 657 658#ifdef LINUX_LINK_DEBUG 659 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string, 660 new_addr, f->value); 661#endif 662 663 if (f->jump) 664 { 665 /* Relative address */ 666 new_addr = new_addr - (f->value + 5); 667 bfd_put_32 (output_bfd, new_addr, fixup_table); 668 fixup_table += 4; 669 bfd_put_32 (output_bfd, f->value + 1, fixup_table); 670 fixup_table += 4; 671 } 672 else 673 { 674 bfd_put_32 (output_bfd, new_addr, fixup_table); 675 fixup_table += 4; 676 bfd_put_32 (output_bfd, f->value, fixup_table); 677 fixup_table += 4; 678 } 679 ++fixups_written; 680 } 681 682 if (linux_hash_table (info)->local_builtins != 0) 683 { 684 /* Special marker so we know to switch to the other type of fixup */ 685 bfd_put_32 (output_bfd, 0, fixup_table); 686 fixup_table += 4; 687 bfd_put_32 (output_bfd, 0, fixup_table); 688 fixup_table += 4; 689 ++fixups_written; 690 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 691 { 692 if (! f->builtin) 693 continue; 694 695 if (f->h->root.root.type != bfd_link_hash_defined 696 && f->h->root.root.type != bfd_link_hash_defweak) 697 { 698 (*_bfd_error_handler) 699 (_("Symbol %s not defined for fixups\n"), 700 f->h->root.root.root.string); 701 continue; 702 } 703 704 is = f->h->root.root.u.def.section; 705 section_offset = is->output_section->vma + is->output_offset; 706 new_addr = f->h->root.root.u.def.value + section_offset; 707 708#ifdef LINUX_LINK_DEBUG 709 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string, 710 new_addr, f->value); 711#endif 712 713 bfd_put_32 (output_bfd, new_addr, fixup_table); 714 fixup_table += 4; 715 bfd_put_32 (output_bfd, f->value, fixup_table); 716 fixup_table += 4; 717 ++fixups_written; 718 } 719 } 720 721 if (linux_hash_table (info)->fixup_count != fixups_written) 722 { 723 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n")); 724 while (linux_hash_table (info)->fixup_count > fixups_written) 725 { 726 bfd_put_32 (output_bfd, 0, fixup_table); 727 fixup_table += 4; 728 bfd_put_32 (output_bfd, 0, fixup_table); 729 fixup_table += 4; 730 ++fixups_written; 731 } 732 } 733 734 h = linux_link_hash_lookup (linux_hash_table (info), 735 "__BUILTIN_FIXUPS__", 736 false, false, false); 737 738 if (h != NULL 739 && (h->root.root.type == bfd_link_hash_defined 740 || h->root.root.type == bfd_link_hash_defweak)) 741 { 742 is = h->root.root.u.def.section; 743 section_offset = is->output_section->vma + is->output_offset; 744 new_addr = h->root.root.u.def.value + section_offset; 745 746#ifdef LINUX_LINK_DEBUG 747 printf ("Builtin fixup table at %x\n", new_addr); 748#endif 749 750 bfd_put_32 (output_bfd, new_addr, fixup_table); 751 } 752 else 753 bfd_put_32 (output_bfd, 0, fixup_table); 754 755 if (bfd_seek (output_bfd, os->filepos + s->output_offset, SEEK_SET) != 0) 756 return false; 757 758 if (bfd_write ((PTR) s->contents, 1, s->_raw_size, output_bfd) 759 != s->_raw_size) 760 return false; 761 762 return true; 763} 764 765#define MY_bfd_link_hash_table_create linux_link_hash_table_create 766#define MY_add_one_symbol linux_add_one_symbol 767#define MY_finish_dynamic_link linux_finish_dynamic_link 768 769#define MY_zmagic_contiguous 1 770 771#include "aout-target.h" 772