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