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