bfd/m68klinux.c

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