bfd/i386linux.c

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