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, 2006 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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) (CONST_STRNEQ (name, GOT_REF_PREFIX)) 98 99/* See if a symbol name is a reference to the procedure linkage table. */ 100 101#ifndef PLT_REF_PREFIX 102#define PLT_REF_PREFIX "__PLT_" 103#endif 104 105#define IS_PLT_SYM(name) (CONST_STRNEQ (name, PLT_REF_PREFIX)) 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 dynamically 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 bfd_boolean linux_link_create_dynamic_sections 181 PARAMS ((bfd *, struct bfd_link_info *)); 182static bfd_boolean linux_add_one_symbol 183 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *, 184 bfd_vma, const char *, bfd_boolean, bfd_boolean, 185 struct bfd_link_hash_entry **)); 186static bfd_boolean linux_tally_symbols 187 PARAMS ((struct linux_link_hash_entry *, PTR)); 188static bfd_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 bfd_size_type amt = sizeof (struct linux_link_hash_table); 229 230 ret = (struct linux_link_hash_table *) bfd_malloc (amt); 231 if (ret == (struct linux_link_hash_table *) NULL) 232 { 233 bfd_set_error (bfd_error_no_memory); 234 return (struct bfd_link_hash_table *) NULL; 235 } 236 if (!NAME(aout,link_hash_table_init) (&ret->root, abfd, 237 linux_link_hash_newfunc, 238 sizeof (struct linux_link_hash_entry))) 239 { 240 free (ret); 241 return (struct bfd_link_hash_table *) NULL; 242 } 243 244 ret->dynobj = NULL; 245 ret->fixup_count = 0; 246 ret->local_builtins = 0; 247 ret->fixup_list = NULL; 248 249 return &ret->root.root; 250} 251 252/* Look up an entry in a Linux link hash table. */ 253 254#define linux_link_hash_lookup(table, string, create, copy, follow) \ 255 ((struct linux_link_hash_entry *) \ 256 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\ 257 (follow))) 258 259/* Traverse a Linux link hash table. */ 260 261#define linux_link_hash_traverse(table, func, info) \ 262 (aout_link_hash_traverse \ 263 (&(table)->root, \ 264 (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \ 265 (info))) 266 267/* Get the Linux link hash table from the info structure. This is 268 just a cast. */ 269 270#define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash)) 271 272/* Store the information for a new fixup. */ 273 274static struct fixup * 275new_fixup (info, h, value, builtin) 276 struct bfd_link_info *info; 277 struct linux_link_hash_entry *h; 278 bfd_vma value; 279 int builtin; 280{ 281 struct fixup *f; 282 283 f = (struct fixup *) bfd_hash_allocate (&info->hash->table, 284 sizeof (struct fixup)); 285 if (f == NULL) 286 return f; 287 f->next = linux_hash_table (info)->fixup_list; 288 linux_hash_table (info)->fixup_list = f; 289 f->h = h; 290 f->value = value; 291 f->builtin = builtin; 292 f->jump = 0; 293 ++linux_hash_table (info)->fixup_count; 294 return f; 295} 296 297/* We come here once we realize that we are going to link to a shared 298 library. We need to create a special section that contains the 299 fixup table, and we ultimately need to add a pointer to this into 300 the set vector for SHARABLE_CONFLICTS. At this point we do not 301 know the size of the section, but that's OK - we just need to 302 create it for now. */ 303 304static bfd_boolean 305linux_link_create_dynamic_sections (abfd, info) 306 bfd *abfd; 307 struct bfd_link_info *info ATTRIBUTE_UNUSED; 308{ 309 flagword flags; 310 register asection *s; 311 312 /* Note that we set the SEC_IN_MEMORY flag. */ 313 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY; 314 315 /* We choose to use the name ".linux-dynamic" for the fixup table. 316 Why not? */ 317 s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags); 318 if (s == NULL 319 || ! bfd_set_section_alignment (abfd, s, 2)) 320 return FALSE; 321 s->size = 0; 322 s->contents = 0; 323 324 return TRUE; 325} 326 327/* Function to add a single symbol to the linker hash table. This is 328 a wrapper around _bfd_generic_link_add_one_symbol which handles the 329 tweaking needed for dynamic linking support. */ 330 331static bfd_boolean 332linux_add_one_symbol (info, abfd, name, flags, section, value, string, 333 copy, collect, hashp) 334 struct bfd_link_info *info; 335 bfd *abfd; 336 const char *name; 337 flagword flags; 338 asection *section; 339 bfd_vma value; 340 const char *string; 341 bfd_boolean copy; 342 bfd_boolean collect; 343 struct bfd_link_hash_entry **hashp; 344{ 345 struct linux_link_hash_entry *h; 346 bfd_boolean insert; 347 348 /* Look up and see if we already have this symbol in the hash table. 349 If we do, and the defining entry is from a shared library, we 350 need to create the dynamic sections. 351 352 FIXME: What if abfd->xvec != info->hash->creator? We may want to 353 be able to link Linux a.out and ELF objects together, but serious 354 confusion is possible. */ 355 356 insert = FALSE; 357 358 if (! info->relocatable 359 && linux_hash_table (info)->dynobj == NULL 360 && strcmp (name, SHARABLE_CONFLICTS) == 0 361 && (flags & BSF_CONSTRUCTOR) != 0 362 && abfd->xvec == info->hash->creator) 363 { 364 if (! linux_link_create_dynamic_sections (abfd, info)) 365 return FALSE; 366 linux_hash_table (info)->dynobj = abfd; 367 insert = TRUE; 368 } 369 370 if (bfd_is_abs_section (section) 371 && abfd->xvec == info->hash->creator) 372 { 373 h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE, 374 FALSE, FALSE); 375 if (h != NULL 376 && (h->root.root.type == bfd_link_hash_defined 377 || h->root.root.type == bfd_link_hash_defweak)) 378 { 379 struct fixup *f; 380 381 if (hashp != NULL) 382 *hashp = (struct bfd_link_hash_entry *) h; 383 384 f = new_fixup (info, h, value, ! IS_PLT_SYM (name)); 385 if (f == NULL) 386 return FALSE; 387 f->jump = IS_PLT_SYM (name); 388 389 return TRUE; 390 } 391 } 392 393 /* Do the usual procedure for adding a symbol. */ 394 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, 395 value, string, copy, collect, 396 hashp)) 397 return FALSE; 398 399 /* Insert a pointer to our table in the set vector. The dynamic 400 linker requires this information */ 401 if (insert) 402 { 403 asection *s; 404 405 /* Here we do our special thing to add the pointer to the 406 dynamic section in the SHARABLE_CONFLICTS set vector. */ 407 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 408 ".linux-dynamic"); 409 BFD_ASSERT (s != NULL); 410 411 if (! (_bfd_generic_link_add_one_symbol 412 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS, 413 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL, 414 FALSE, FALSE, NULL))) 415 return FALSE; 416 } 417 418 return TRUE; 419} 420 421/* We will crawl the hash table and come here for every global symbol. 422 We will examine each entry and see if there are indications that we 423 need to add a fixup. There are two possible cases - one is where 424 you have duplicate definitions of PLT or GOT symbols - these will 425 have already been caught and added as "builtin" fixups. If we find 426 that the corresponding non PLT/GOT symbol is also present, we 427 convert it to a regular fixup instead. 428 429 This function is called via linux_link_hash_traverse. */ 430 431static bfd_boolean 432linux_tally_symbols (h, data) 433 struct linux_link_hash_entry *h; 434 PTR data; 435{ 436 struct bfd_link_info *info = (struct bfd_link_info *) data; 437 struct fixup *f, *f1; 438 int is_plt; 439 struct linux_link_hash_entry *h1, *h2; 440 bfd_boolean exists; 441 442 if (h->root.root.type == bfd_link_hash_warning) 443 h = (struct linux_link_hash_entry *) h->root.root.u.i.link; 444 445 if (h->root.root.type == bfd_link_hash_undefined 446 && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB)) 447 { 448 const char *name; 449 char *p; 450 char *alloc = NULL; 451 452 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1; 453 p = strrchr (name, '_'); 454 if (p != NULL) 455 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1); 456 457 if (p == NULL || alloc == NULL) 458 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"), 459 name); 460 else 461 { 462 strcpy (alloc, name); 463 p = strrchr (alloc, '_'); 464 *p++ = '\0'; 465 (*_bfd_error_handler) 466 (_("Output file requires shared library `%s.so.%s'\n"), 467 alloc, p); 468 free (alloc); 469 } 470 471 abort (); 472 } 473 474 /* If this symbol is not a PLT/GOT, we do not even need to look at it */ 475 is_plt = IS_PLT_SYM (h->root.root.root.string); 476 477 if (is_plt || IS_GOT_SYM (h->root.root.root.string)) 478 { 479 /* Look up this symbol twice. Once just as a regular lookup, 480 and then again following all of the indirect links until we 481 reach a real symbol. */ 482 h1 = linux_link_hash_lookup (linux_hash_table (info), 483 (h->root.root.root.string 484 + sizeof PLT_REF_PREFIX - 1), 485 FALSE, FALSE, TRUE); 486 /* h2 does not follow indirect symbols. */ 487 h2 = linux_link_hash_lookup (linux_hash_table (info), 488 (h->root.root.root.string 489 + sizeof PLT_REF_PREFIX - 1), 490 FALSE, FALSE, FALSE); 491 492 /* The real symbol must exist but if it is also an ABS symbol, 493 there is no need to have a fixup. This is because they both 494 came from the same library. If on the other hand, we had to 495 use an indirect symbol to get to the real symbol, we add the 496 fixup anyway, since there are cases where these symbols come 497 from different shared libraries */ 498 if (h1 != NULL 499 && (((h1->root.root.type == bfd_link_hash_defined 500 || h1->root.root.type == bfd_link_hash_defweak) 501 && ! bfd_is_abs_section (h1->root.root.u.def.section)) 502 || h2->root.root.type == bfd_link_hash_indirect)) 503 { 504 /* See if there is a "builtin" fixup already present 505 involving this symbol. If so, convert it to a regular 506 fixup. In the end, this relaxes some of the requirements 507 about the order of performing fixups. */ 508 exists = FALSE; 509 for (f1 = linux_hash_table (info)->fixup_list; 510 f1 != NULL; 511 f1 = f1->next) 512 { 513 if ((f1->h != h && f1->h != h1) 514 || (! f1->builtin && ! f1->jump)) 515 continue; 516 if (f1->h == h1) 517 exists = TRUE; 518 if (! exists 519 && bfd_is_abs_section (h->root.root.u.def.section)) 520 { 521 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0); 522 f->jump = is_plt; 523 } 524 f1->h = h1; 525 f1->jump = is_plt; 526 f1->builtin = 0; 527 exists = TRUE; 528 } 529 if (! exists 530 && bfd_is_abs_section (h->root.root.u.def.section)) 531 { 532 f = new_fixup (info, h1, h->root.root.u.def.value, 0); 533 if (f == NULL) 534 { 535 /* FIXME: No way to return error. */ 536 abort (); 537 } 538 f->jump = is_plt; 539 } 540 } 541 542 /* Quick and dirty way of stripping these symbols from the 543 symtab. */ 544 if (bfd_is_abs_section (h->root.root.u.def.section)) 545 h->root.written = TRUE; 546 } 547 548 return TRUE; 549} 550 551/* This is called to set the size of the .linux-dynamic section is. 552 It is called by the Linux linker emulation before_allocation 553 routine. We have finished reading all of the input files, and now 554 we just scan the hash tables to find out how many additional fixups 555 are required. */ 556 557bfd_boolean 558bfd_m68klinux_size_dynamic_sections (output_bfd, info) 559 bfd *output_bfd; 560 struct bfd_link_info *info; 561{ 562 struct fixup *f; 563 asection *s; 564 565 if (output_bfd->xvec != &MY(vec)) 566 return TRUE; 567 568 /* First find the fixups... */ 569 linux_link_hash_traverse (linux_hash_table (info), 570 linux_tally_symbols, 571 (PTR) info); 572 573 /* If there are builtin fixups, leave room for a marker. This is 574 used by the dynamic linker so that it knows that all that follow 575 are builtin fixups instead of regular fixups. */ 576 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 577 { 578 if (f->builtin) 579 { 580 ++linux_hash_table (info)->fixup_count; 581 ++linux_hash_table (info)->local_builtins; 582 break; 583 } 584 } 585 586 if (linux_hash_table (info)->dynobj == NULL) 587 { 588 if (linux_hash_table (info)->fixup_count > 0) 589 abort (); 590 return TRUE; 591 } 592 593 /* Allocate memory for our fixup table. We will fill it in later. */ 594 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 595 ".linux-dynamic"); 596 if (s != NULL) 597 { 598 s->size = linux_hash_table (info)->fixup_count + 1; 599 s->size *= 8; 600 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size); 601 if (s->contents == NULL) 602 { 603 bfd_set_error (bfd_error_no_memory); 604 return FALSE; 605 } 606 } 607 608 return TRUE; 609} 610 611/* We come here once we are ready to actually write the fixup table to 612 the output file. Scan the fixup tables and so forth and generate 613 the stuff we need. */ 614 615static bfd_boolean 616linux_finish_dynamic_link (output_bfd, info) 617 bfd *output_bfd; 618 struct bfd_link_info *info; 619{ 620 asection *s, *os, *is; 621 bfd_byte *fixup_table; 622 struct linux_link_hash_entry *h; 623 struct fixup *f; 624 unsigned int new_addr; 625 int section_offset; 626 unsigned int fixups_written; 627 628 if (linux_hash_table (info)->dynobj == NULL) 629 return TRUE; 630 631 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj, 632 ".linux-dynamic"); 633 BFD_ASSERT (s != NULL); 634 os = s->output_section; 635 fixups_written = 0; 636 637#ifdef LINUX_LINK_DEBUG 638 printf ("Fixup table file offset: %x VMA: %x\n", 639 os->filepos + s->output_offset, 640 os->vma + s->output_offset); 641#endif 642 643 fixup_table = s->contents; 644 bfd_put_32 (output_bfd, (bfd_vma) linux_hash_table (info)->fixup_count, 645 fixup_table); 646 fixup_table += 4; 647 648 /* Fill in fixup table. */ 649 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 650 { 651 if (f->builtin) 652 continue; 653 654 if (f->h->root.root.type != bfd_link_hash_defined 655 && f->h->root.root.type != bfd_link_hash_defweak) 656 { 657 (*_bfd_error_handler) 658 (_("Symbol %s not defined for fixups\n"), 659 f->h->root.root.root.string); 660 continue; 661 } 662 663 is = f->h->root.root.u.def.section; 664 section_offset = is->output_section->vma + is->output_offset; 665 new_addr = f->h->root.root.u.def.value + section_offset; 666 667#ifdef LINUX_LINK_DEBUG 668 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string, 669 new_addr, f->value); 670#endif 671 672 if (f->jump) 673 { 674 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); 675 fixup_table += 4; 676 bfd_put_32 (output_bfd, f->value + 2, fixup_table); 677 fixup_table += 4; 678 } 679 else 680 { 681 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); 682 fixup_table += 4; 683 bfd_put_32 (output_bfd, f->value, fixup_table); 684 fixup_table += 4; 685 } 686 ++fixups_written; 687 } 688 689 if (linux_hash_table (info)->local_builtins != 0) 690 { 691 /* Special marker so we know to switch to the other type of fixup */ 692 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); 693 fixup_table += 4; 694 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); 695 fixup_table += 4; 696 ++fixups_written; 697 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next) 698 { 699 if (! f->builtin) 700 continue; 701 702 if (f->h->root.root.type != bfd_link_hash_defined 703 && f->h->root.root.type != bfd_link_hash_defweak) 704 { 705 (*_bfd_error_handler) 706 (_("Symbol %s not defined for fixups\n"), 707 f->h->root.root.root.string); 708 continue; 709 } 710 711 is = f->h->root.root.u.def.section; 712 section_offset = is->output_section->vma + is->output_offset; 713 new_addr = f->h->root.root.u.def.value + section_offset; 714 715#ifdef LINUX_LINK_DEBUG 716 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string, 717 new_addr, f->value); 718#endif 719 720 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); 721 fixup_table += 4; 722 bfd_put_32 (output_bfd, f->value, fixup_table); 723 fixup_table += 4; 724 ++fixups_written; 725 } 726 } 727 728 if (linux_hash_table (info)->fixup_count != fixups_written) 729 { 730 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n")); 731 while (linux_hash_table (info)->fixup_count > fixups_written) 732 { 733 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); 734 fixup_table += 4; 735 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); 736 fixup_table += 4; 737 ++fixups_written; 738 } 739 } 740 741 h = linux_link_hash_lookup (linux_hash_table (info), 742 "__BUILTIN_FIXUPS__", 743 FALSE, FALSE, FALSE); 744 745 if (h != NULL 746 && (h->root.root.type == bfd_link_hash_defined 747 || h->root.root.type == bfd_link_hash_defweak)) 748 { 749 is = h->root.root.u.def.section; 750 section_offset = is->output_section->vma + is->output_offset; 751 new_addr = h->root.root.u.def.value + section_offset; 752 753#ifdef LINUX_LINK_DEBUG 754 printf ("Builtin fixup table at %x\n", new_addr); 755#endif 756 757 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table); 758 } 759 else 760 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table); 761 762 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset), 763 SEEK_SET) != 0) 764 return FALSE; 765 766 if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size) 767 return FALSE; 768 769 return TRUE; 770} 771 772#define MY_bfd_link_hash_table_create linux_link_hash_table_create 773#define MY_add_one_symbol linux_add_one_symbol 774#define MY_finish_dynamic_link linux_finish_dynamic_link 775 776#define MY_zmagic_contiguous 1 777 778#include "aout-target.h" 779