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_malloc (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   ret->dynobj = NULL;
 221   ret->fixup_count = 0;
 222   ret->local_builtins = 0;
 223   ret->fixup_list = NULL;
 224
 225   return &ret->root.root;
 226 }
 227
 228 /* Look up an entry in a Linux link hash table.  */
 229
 230 #define linux_link_hash_lookup(table, string, create, copy, follow) \
 231   ((struct linux_link_hash_entry *) \
 232    aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
 233                           (follow)))
 234
 235 /* Traverse a Linux link hash table.  */
 236
 237 #define linux_link_hash_traverse(table, func, info)                     \
 238   (aout_link_hash_traverse                                              \
 239    (&(table)->root,                                                     \
 240     (bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func),   \
 241     (info)))
 242
 243 /* Get the Linux link hash table from the info structure.  This is
 244    just a cast.  */
 245
 246 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
 247
 248 /* Store the information for a new fixup.  */
 249
 250 static struct fixup *
 251 new_fixup (struct bfd_link_info *info,
 252            struct linux_link_hash_entry *h,
 253            bfd_vma value,
 254            int builtin)
 255 {
 256   struct fixup *f;
 257
 258   f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
 259                                           sizeof (struct fixup));
 260   if (f == NULL)
 261     return f;
 262   f->next = linux_hash_table (info)->fixup_list;
 263   linux_hash_table (info)->fixup_list = f;
 264   f->h = h;
 265   f->value = value;
 266   f->builtin = builtin;
 267   f->jump = 0;
 268   ++linux_hash_table (info)->fixup_count;
 269   return f;
 270 }
 271
 272 /* We come here once we realize that we are going to link to a shared
 273    library.  We need to create a special section that contains the
 274    fixup table, and we ultimately need to add a pointer to this into
 275    the set vector for SHARABLE_CONFLICTS.  At this point we do not
 276    know the size of the section, but that's OK - we just need to
 277    create it for now.  */
 278
 279 static bfd_boolean
 280 linux_link_create_dynamic_sections (bfd *abfd,
 281                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
 282 {
 283   flagword flags;
 284   asection *s;
 285
 286   /* Note that we set the SEC_IN_MEMORY flag.  */
 287   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 288
 289   /* We choose to use the name ".linux-dynamic" for the fixup table.
 290      Why not? */
 291   s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
 292   if (s == NULL
 293       || ! bfd_set_section_alignment (abfd, s, 2))
 294     return FALSE;
 295   s->size = 0;
 296   s->contents = 0;
 297
 298   return TRUE;
 299 }
 300
 301 /* Function to add a single symbol to the linker hash table.  This is
 302    a wrapper around _bfd_generic_link_add_one_symbol which handles the
 303    tweaking needed for dynamic linking support.  */
 304
 305 static bfd_boolean
 306 linux_add_one_symbol (struct bfd_link_info *info,
 307                       bfd *abfd,
 308                       const char *name,
 309                       flagword flags,
 310                       asection *section,
 311                       bfd_vma value,
 312                       const char *string,
 313                       bfd_boolean copy,
 314                       bfd_boolean collect,
 315                       struct bfd_link_hash_entry **hashp)
 316 {
 317   struct linux_link_hash_entry *h;
 318   bfd_boolean insert;
 319
 320   /* Look up and see if we already have this symbol in the hash table.
 321      If we do, and the defining entry is from a shared library, we
 322      need to create the dynamic sections.
 323
 324      FIXME: What if abfd->xvec != info->output_bfd->xvec?  We may
 325      want to be able to link Linux a.out and ELF objects together,
 326      but serious confusion is possible.  */
 327
 328   insert = FALSE;
 329
 330   if (! info->relocatable
 331       && linux_hash_table (info)->dynobj == NULL
 332       && strcmp (name, SHARABLE_CONFLICTS) == 0
 333       && (flags & BSF_CONSTRUCTOR) != 0
 334       && abfd->xvec == info->output_bfd->xvec)
 335     {
 336       if (! linux_link_create_dynamic_sections (abfd, info))
 337         return FALSE;
 338       linux_hash_table (info)->dynobj = abfd;
 339       insert = TRUE;
 340     }
 341
 342   if (bfd_is_abs_section (section)
 343       && abfd->xvec == info->output_bfd->xvec)
 344     {
 345       h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
 346                                   FALSE, FALSE);
 347       if (h != NULL
 348           && (h->root.root.type == bfd_link_hash_defined
 349               || h->root.root.type == bfd_link_hash_defweak))
 350         {
 351           struct fixup *f;
 352
 353           if (hashp != NULL)
 354             *hashp = (struct bfd_link_hash_entry *) h;
 355
 356           f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
 357           if (f == NULL)
 358             return FALSE;
 359           f->jump = IS_PLT_SYM (name);
 360
 361           return TRUE;
 362         }
 363     }
 364
 365   /* Do the usual procedure for adding a symbol.  */
 366   if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
 367                                           value, string, copy, collect,
 368                                           hashp))
 369     return FALSE;
 370
 371   /* Insert a pointer to our table in the set vector.  The dynamic
 372      linker requires this information */
 373   if (insert)
 374     {
 375       asection *s;
 376
 377       /* Here we do our special thing to add the pointer to the
 378          dynamic section in the SHARABLE_CONFLICTS set vector.  */
 379       s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 380                                    ".linux-dynamic");
 381       BFD_ASSERT (s != NULL);
 382
 383       if (! (_bfd_generic_link_add_one_symbol
 384              (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
 385               BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
 386               FALSE, FALSE, NULL)))
 387         return FALSE;
 388     }
 389
 390   return TRUE;
 391 }
 392
 393 /* We will crawl the hash table and come here for every global symbol.
 394    We will examine each entry and see if there are indications that we
 395    need to add a fixup.  There are two possible cases - one is where
 396    you have duplicate definitions of PLT or GOT symbols - these will
 397    have already been caught and added as "builtin" fixups.  If we find
 398    that the corresponding non PLT/GOT symbol is also present, we
 399    convert it to a regular fixup instead.
 400
 401    This function is called via linux_link_hash_traverse.  */
 402
 403 static bfd_boolean
 404 linux_tally_symbols (struct linux_link_hash_entry *h,
 405                      void * data)
 406 {
 407   struct bfd_link_info *info = (struct bfd_link_info *) data;
 408   struct fixup *f, *f1;
 409   int is_plt;
 410   struct linux_link_hash_entry *h1, *h2;
 411   bfd_boolean exists;
 412
 413   if (h->root.root.type == bfd_link_hash_undefined
 414       && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
 415     {
 416       const char *name;
 417       char *p;
 418       char *alloc = NULL;
 419
 420       name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
 421       p = strrchr (name, '_');
 422       if (p != NULL)
 423         alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
 424
 425       if (p == NULL || alloc == NULL)
 426         (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
 427                                name);
 428       else
 429         {
 430           strcpy (alloc, name);
 431           p = strrchr (alloc, '_');
 432           *p++ = '\0';
 433           (*_bfd_error_handler)
 434             (_("Output file requires shared library `%s.so.%s'\n"),
 435              alloc, p);
 436           free (alloc);
 437         }
 438
 439       abort ();
 440     }
 441
 442   /* If this symbol is not a PLT/GOT, we do not even need to look at it */
 443   is_plt = IS_PLT_SYM (h->root.root.root.string);
 444
 445   if (is_plt || IS_GOT_SYM (h->root.root.root.string))
 446     {
 447       /* Look up this symbol twice.  Once just as a regular lookup,
 448          and then again following all of the indirect links until we
 449          reach a real symbol.  */
 450       h1 = linux_link_hash_lookup (linux_hash_table (info),
 451                                    (h->root.root.root.string
 452                                     + sizeof PLT_REF_PREFIX - 1),
 453                                    FALSE, FALSE, TRUE);
 454       /* h2 does not follow indirect symbols.  */
 455       h2 = linux_link_hash_lookup (linux_hash_table (info),
 456                                    (h->root.root.root.string
 457                                     + sizeof PLT_REF_PREFIX - 1),
 458                                    FALSE, FALSE, FALSE);
 459
 460       /* The real symbol must exist but if it is also an ABS symbol,
 461          there is no need to have a fixup.  This is because they both
 462          came from the same library.  If on the other hand, we had to
 463          use an indirect symbol to get to the real symbol, we add the
 464          fixup anyway, since there are cases where these symbols come
 465          from different shared libraries */
 466       if (h1 != NULL
 467           && (((h1->root.root.type == bfd_link_hash_defined
 468                 || h1->root.root.type == bfd_link_hash_defweak)
 469                && ! bfd_is_abs_section (h1->root.root.u.def.section))
 470               || h2->root.root.type == bfd_link_hash_indirect))
 471         {
 472           /* See if there is a "builtin" fixup already present
 473              involving this symbol.  If so, convert it to a regular
 474              fixup.  In the end, this relaxes some of the requirements
 475              about the order of performing fixups.  */
 476           exists = FALSE;
 477           for (f1 = linux_hash_table (info)->fixup_list;
 478                f1 != NULL;
 479                f1 = f1->next)
 480             {
 481               if ((f1->h != h && f1->h != h1)
 482                   || (! f1->builtin && ! f1->jump))
 483                 continue;
 484               if (f1->h == h1)
 485                 exists = TRUE;
 486               if (! exists
 487                   && bfd_is_abs_section (h->root.root.u.def.section))
 488                 {
 489                   f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
 490                   f->jump = is_plt;
 491                 }
 492               f1->h = h1;
 493               f1->jump = is_plt;
 494               f1->builtin = 0;
 495               exists = TRUE;
 496             }
 497           if (! exists
 498               && bfd_is_abs_section (h->root.root.u.def.section))
 499             {
 500               f = new_fixup (info, h1, h->root.root.u.def.value, 0);
 501               if (f == NULL)
 502                 {
 503                   /* FIXME: No way to return error.  */
 504                   abort ();
 505                 }
 506               f->jump = is_plt;
 507             }
 508         }
 509
 510       /* Quick and dirty way of stripping these symbols from the
 511          symtab.  */
 512       if (bfd_is_abs_section (h->root.root.u.def.section))
 513         h->root.written = TRUE;
 514     }
 515
 516   return TRUE;
 517 }
 518
 519 /* This is called to set the size of the .linux-dynamic section is.
 520    It is called by the Linux linker emulation before_allocation
 521    routine.  We have finished reading all of the input files, and now
 522    we just scan the hash tables to find out how many additional fixups
 523    are required.  */
 524
 525 bfd_boolean
 526 bfd_m68klinux_size_dynamic_sections (bfd *output_bfd,
 527                                      struct bfd_link_info *info)
 528 {
 529   struct fixup *f;
 530   asection *s;
 531
 532   if (output_bfd->xvec != &MY(vec))
 533     return TRUE;
 534
 535   /* First find the fixups...  */
 536   linux_link_hash_traverse (linux_hash_table (info),
 537                             linux_tally_symbols,
 538                             info);
 539
 540   /* If there are builtin fixups, leave room for a marker.  This is
 541      used by the dynamic linker so that it knows that all that follow
 542      are builtin fixups instead of regular fixups.  */
 543   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 544     {
 545       if (f->builtin)
 546         {
 547           ++linux_hash_table (info)->fixup_count;
 548           ++linux_hash_table (info)->local_builtins;
 549           break;
 550         }
 551     }
 552
 553   if (linux_hash_table (info)->dynobj == NULL)
 554     {
 555       if (linux_hash_table (info)->fixup_count > 0)
 556         abort ();
 557       return TRUE;
 558     }
 559
 560   /* Allocate memory for our fixup table.  We will fill it in later.  */
 561   s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 562                                ".linux-dynamic");
 563   if (s != NULL)
 564     {
 565       s->size = linux_hash_table (info)->fixup_count + 1;
 566       s->size *= 8;
 567       s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
 568       if (s->contents == NULL)
 569         {
 570           bfd_set_error (bfd_error_no_memory);
 571           return FALSE;
 572         }
 573     }
 574
 575   return TRUE;
 576 }
 577
 578 /* We come here once we are ready to actually write the fixup table to
 579    the output file.  Scan the fixup tables and so forth and generate
 580    the stuff we need.  */
 581
 582 static bfd_boolean
 583 linux_finish_dynamic_link (bfd *output_bfd, struct bfd_link_info *info)
 584 {
 585   asection *s, *os, *is;
 586   bfd_byte *fixup_table;
 587   struct linux_link_hash_entry *h;
 588   struct fixup *f;
 589   unsigned int new_addr;
 590   int section_offset;
 591   unsigned int fixups_written;
 592
 593   if (linux_hash_table (info)->dynobj == NULL)
 594     return TRUE;
 595
 596   s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 597                                ".linux-dynamic");
 598   BFD_ASSERT (s != NULL);
 599   os = s->output_section;
 600   fixups_written = 0;
 601
 602 #ifdef LINUX_LINK_DEBUG
 603   printf ("Fixup table file offset: %x  VMA: %x\n",
 604           os->filepos + s->output_offset,
 605           os->vma + s->output_offset);
 606 #endif
 607
 608   fixup_table = s->contents;
 609   bfd_put_32 (output_bfd, (bfd_vma) linux_hash_table (info)->fixup_count,
 610               fixup_table);
 611   fixup_table += 4;
 612
 613   /* Fill in fixup table.  */
 614   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 615     {
 616       if (f->builtin)
 617         continue;
 618
 619       if (f->h->root.root.type != bfd_link_hash_defined
 620           && f->h->root.root.type != bfd_link_hash_defweak)
 621         {
 622           (*_bfd_error_handler)
 623             (_("Symbol %s not defined for fixups\n"),
 624              f->h->root.root.root.string);
 625           continue;
 626         }
 627
 628       is = f->h->root.root.u.def.section;
 629       section_offset = is->output_section->vma + is->output_offset;
 630       new_addr = f->h->root.root.u.def.value + section_offset;
 631
 632 #ifdef LINUX_LINK_DEBUG
 633       printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
 634               new_addr, f->value);
 635 #endif
 636
 637       if (f->jump)
 638         {
 639           bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
 640           fixup_table += 4;
 641           bfd_put_32 (output_bfd, f->value + 2, fixup_table);
 642           fixup_table += 4;
 643         }
 644       else
 645         {
 646           bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
 647           fixup_table += 4;
 648           bfd_put_32 (output_bfd, f->value, fixup_table);
 649           fixup_table += 4;
 650         }
 651       ++fixups_written;
 652     }
 653
 654   if (linux_hash_table (info)->local_builtins != 0)
 655     {
 656       /* Special marker so we know to switch to the other type of fixup */
 657       bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 658       fixup_table += 4;
 659       bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 660       fixup_table += 4;
 661       ++fixups_written;
 662       for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 663         {
 664           if (! f->builtin)
 665             continue;
 666
 667           if (f->h->root.root.type != bfd_link_hash_defined
 668               && f->h->root.root.type != bfd_link_hash_defweak)
 669             {
 670               (*_bfd_error_handler)
 671                 (_("Symbol %s not defined for fixups\n"),
 672                  f->h->root.root.root.string);
 673               continue;
 674             }
 675
 676           is = f->h->root.root.u.def.section;
 677           section_offset = is->output_section->vma + is->output_offset;
 678           new_addr = f->h->root.root.u.def.value + section_offset;
 679
 680 #ifdef LINUX_LINK_DEBUG
 681           printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
 682                   new_addr, f->value);
 683 #endif
 684
 685           bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
 686           fixup_table += 4;
 687           bfd_put_32 (output_bfd, f->value, fixup_table);
 688           fixup_table += 4;
 689           ++fixups_written;
 690         }
 691   }
 692
 693   if (linux_hash_table (info)->fixup_count != fixups_written)
 694     {
 695       (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
 696       while (linux_hash_table (info)->fixup_count > fixups_written)
 697         {
 698           bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 699           fixup_table += 4;
 700           bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 701           fixup_table += 4;
 702           ++fixups_written;
 703         }
 704     }
 705
 706   h = linux_link_hash_lookup (linux_hash_table (info),
 707                               "__BUILTIN_FIXUPS__",
 708                               FALSE, FALSE, FALSE);
 709
 710   if (h != NULL
 711       && (h->root.root.type == bfd_link_hash_defined
 712           || h->root.root.type == bfd_link_hash_defweak))
 713     {
 714       is = h->root.root.u.def.section;
 715       section_offset = is->output_section->vma + is->output_offset;
 716       new_addr = h->root.root.u.def.value + section_offset;
 717
 718 #ifdef LINUX_LINK_DEBUG
 719       printf ("Builtin fixup table at %x\n", new_addr);
 720 #endif
 721
 722       bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
 723     }
 724   else
 725     bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 726
 727   if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
 728                 SEEK_SET) != 0)
 729     return FALSE;
 730
 731   if (bfd_bwrite (s->contents, s->size, output_bfd) != s->size)
 732     return FALSE;
 733
 734   return TRUE;
 735 }
 736
 737 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
 738 #define MY_add_one_symbol linux_add_one_symbol
 739 #define MY_finish_dynamic_link linux_finish_dynamic_link
 740
 741 #define MY_zmagic_contiguous 1
 742
 743 #include "aout-target.h"