bfd/i386linux.c

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