bfd/i386linux.c

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