bfd/m68klinux.c

   1 /* BFD back-end for linux flavored m68k a.out binaries.
   2    Copyright (C) 1992, 93, 94, 95, 96, 1997 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 #include "bfd.h"
  28 #include "sysdep.h"
  29 #include "libbfd.h"
  30 #include "aout/aout64.h"
  31 #include "aout/stab_gnu.h"
  32 #include "aout/ar.h"
  33 #include "libaout.h"           /* BFD a.out internal data structures */
  34
  35 #define TARGET_IS_BIG_ENDIAN_P
  36 #define DEFAULT_ARCH bfd_arch_m68k
  37 #define MY(OP) CAT(m68klinux_,OP)
  38 #define TARGETNAME "a.out-m68k-linux"
  39
  40 extern const bfd_target MY(vec);
  41
  42 /* We always generate QMAGIC files in preference to ZMAGIC files.  It
  43    would be possible to make this a linker option, if that ever
  44    becomes important.  */
  45
  46 static void MY_final_link_callback
  47   PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
  48 static boolean m68klinux_bfd_final_link
  49   PARAMS ((bfd *, struct bfd_link_info *));
  50 static boolean m68klinux_write_object_contents PARAMS ((bfd *));
  51
  52 static boolean
  53 m68klinux_bfd_final_link (abfd, info)
  54      bfd *abfd;
  55      struct bfd_link_info *info;
  56 {
  57   obj_aout_subformat (abfd) = q_magic_format;
  58   return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
  59 }
  60
  61 #define MY_bfd_final_link m68klinux_bfd_final_link
  62
  63 /* Set the machine type correctly.  */
  64
  65 static boolean
  66 m68klinux_write_object_contents (abfd)
  67      bfd *abfd;
  68 {
  69   struct external_exec exec_bytes;
  70   struct internal_exec *execp = exec_hdr (abfd);
  71
  72   N_SET_MACHTYPE (*execp, M_68020);
  73
  74   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
  75
  76   WRITE_HEADERS(abfd, execp);
  77
  78   return true;
  79 }
  80
  81 #define MY_write_object_contents m68klinux_write_object_contents
  82 \f
  83 /* Code to link against Linux a.out shared libraries.  */
  84
  85 /* See if a symbol name is a reference to the global offset table.  */
  86
  87 #ifndef GOT_REF_PREFIX
  88 #define GOT_REF_PREFIX  "__GOT_"
  89 #endif
  90
  91 #define IS_GOT_SYM(name) \
  92   (strncmp (name, GOT_REF_PREFIX, sizeof GOT_REF_PREFIX - 1) == 0)
  93
  94 /* See if a symbol name is a reference to the procedure linkage table.  */
  95
  96 #ifndef PLT_REF_PREFIX
  97 #define PLT_REF_PREFIX  "__PLT_"
  98 #endif
  99
 100 #define IS_PLT_SYM(name) \
 101   (strncmp (name, PLT_REF_PREFIX, sizeof PLT_REF_PREFIX - 1) == 0)
 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 dynamicly
 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 static struct bfd_hash_entry *linux_link_hash_newfunc
 170   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 171 static struct bfd_link_hash_table *linux_link_hash_table_create
 172   PARAMS ((bfd *));
 173 static struct fixup *new_fixup
 174   PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
 175            bfd_vma, int));
 176 static boolean linux_link_create_dynamic_sections
 177   PARAMS ((bfd *, struct bfd_link_info *));
 178 static boolean linux_add_one_symbol
 179   PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
 180            bfd_vma, const char *, boolean, boolean,
 181            struct bfd_link_hash_entry **));
 182 static boolean linux_tally_symbols
 183   PARAMS ((struct linux_link_hash_entry *, PTR));
 184 static boolean linux_finish_dynamic_link
 185   PARAMS ((bfd *, struct bfd_link_info *));
 186
 187 /* Routine to create an entry in an Linux link hash table.  */
 188
 189 static struct bfd_hash_entry *
 190 linux_link_hash_newfunc (entry, table, string)
 191      struct bfd_hash_entry *entry;
 192      struct bfd_hash_table *table;
 193      const char *string;
 194 {
 195   struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
 196
 197   /* Allocate the structure if it has not already been allocated by a
 198      subclass.  */
 199   if (ret == (struct linux_link_hash_entry *) NULL)
 200     ret = ((struct linux_link_hash_entry *)
 201            bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
 202   if (ret == NULL)
 203     return (struct bfd_hash_entry *) ret;
 204
 205   /* Call the allocation method of the superclass.  */
 206   ret = ((struct linux_link_hash_entry *)
 207          NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
 208                                        table, string));
 209   if (ret != NULL)
 210     {
 211       /* Set local fields; there aren't any.  */
 212     }
 213
 214   return (struct bfd_hash_entry *) ret;
 215 }
 216
 217 /* Create a Linux link hash table.  */
 218
 219 static struct bfd_link_hash_table *
 220 linux_link_hash_table_create (abfd)
 221      bfd *abfd;
 222 {
 223   struct linux_link_hash_table *ret;
 224
 225   ret = ((struct linux_link_hash_table *)
 226          bfd_alloc (abfd, sizeof (struct linux_link_hash_table)));
 227   if (ret == (struct linux_link_hash_table *) NULL)
 228     {
 229       bfd_set_error (bfd_error_no_memory);
 230       return (struct bfd_link_hash_table *) NULL;
 231     }
 232   if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
 233                                          linux_link_hash_newfunc))
 234     {
 235       free (ret);
 236       return (struct bfd_link_hash_table *) NULL;
 237     }
 238
 239   ret->dynobj = NULL;
 240   ret->fixup_count = 0;
 241   ret->local_builtins = 0;
 242   ret->fixup_list = NULL;
 243
 244   return &ret->root.root;
 245 }
 246
 247 /* Look up an entry in a Linux link hash table.  */
 248
 249 #define linux_link_hash_lookup(table, string, create, copy, follow) \
 250   ((struct linux_link_hash_entry *) \
 251    aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
 252                           (follow)))
 253
 254 /* Traverse a Linux link hash table.  */
 255
 256 #define linux_link_hash_traverse(table, func, info)                     \
 257   (aout_link_hash_traverse                                              \
 258    (&(table)->root,                                                     \
 259     (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
 260     (info)))
 261
 262 /* Get the Linux link hash table from the info structure.  This is
 263    just a cast.  */
 264
 265 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
 266
 267 /* Store the information for a new fixup.  */
 268
 269 static struct fixup *
 270 new_fixup (info, h, value, builtin)
 271      struct bfd_link_info *info;
 272      struct linux_link_hash_entry *h;
 273      bfd_vma value;
 274      int builtin;
 275 {
 276   struct fixup *f;
 277
 278   f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
 279                                           sizeof (struct fixup));
 280   if (f == NULL)
 281     return f;
 282   f->next = linux_hash_table (info)->fixup_list;
 283   linux_hash_table (info)->fixup_list = f;
 284   f->h = h;
 285   f->value = value;
 286   f->builtin = builtin;
 287   f->jump = 0;
 288   ++linux_hash_table (info)->fixup_count;
 289   return f;
 290 }
 291
 292 /* We come here once we realize that we are going to link to a shared
 293    library.  We need to create a special section that contains the
 294    fixup table, and we ultimately need to add a pointer to this into
 295    the set vector for SHARABLE_CONFLICTS.  At this point we do not
 296    know the size of the section, but that's OK - we just need to
 297    create it for now.  */
 298
 299 static boolean
 300 linux_link_create_dynamic_sections (abfd, info)
 301      bfd *abfd;
 302      struct bfd_link_info *info;
 303 {
 304   flagword flags;
 305   register asection *s;
 306
 307   /* Note that we set the SEC_IN_MEMORY flag.  */
 308   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 309
 310   /* We choose to use the name ".linux-dynamic" for the fixup table.
 311      Why not? */
 312   s = bfd_make_section (abfd, ".linux-dynamic");
 313   if (s == NULL
 314       || ! bfd_set_section_flags (abfd, s, flags)
 315       || ! bfd_set_section_alignment (abfd, s, 2))
 316     return false;
 317   s->_raw_size = 0;
 318   s->contents = 0;
 319
 320   return true;
 321 }
 322
 323 /* Function to add a single symbol to the linker hash table.  This is
 324    a wrapper around _bfd_generic_link_add_one_symbol which handles the
 325    tweaking needed for dynamic linking support.  */
 326
 327 static boolean
 328 linux_add_one_symbol (info, abfd, name, flags, section, value, string,
 329                       copy, collect, hashp)
 330      struct bfd_link_info *info;
 331      bfd *abfd;
 332      const char *name;
 333      flagword flags;
 334      asection *section;
 335      bfd_vma value;
 336      const char *string;
 337      boolean copy;
 338      boolean collect;
 339      struct bfd_link_hash_entry **hashp;
 340 {
 341   struct linux_link_hash_entry *h;
 342   boolean insert;
 343
 344   /* Look up and see if we already have this symbol in the hash table.
 345      If we do, and the defining entry is from a shared library, we
 346      need to create the dynamic sections.
 347
 348      FIXME: What if abfd->xvec != info->hash->creator?  We may want to
 349      be able to link Linux a.out and ELF objects together, but serious
 350      confusion is possible.  */
 351
 352   insert = false;
 353
 354   if (! info->relocateable
 355       && linux_hash_table (info)->dynobj == NULL
 356       && strcmp (name, SHARABLE_CONFLICTS) == 0
 357       && (flags & BSF_CONSTRUCTOR) != 0
 358       && abfd->xvec == info->hash->creator)
 359     {
 360       if (! linux_link_create_dynamic_sections (abfd, info))
 361         return false;
 362       linux_hash_table (info)->dynobj = abfd;
 363       insert = true;
 364     }
 365
 366   if (bfd_is_abs_section (section)
 367       && abfd->xvec == info->hash->creator)
 368     {
 369       h = linux_link_hash_lookup (linux_hash_table (info), name, false,
 370                                   false, false);
 371       if (h != NULL
 372           && (h->root.root.type == bfd_link_hash_defined
 373               || h->root.root.type == bfd_link_hash_defweak))
 374         {
 375           struct fixup *f;
 376
 377           if (hashp != NULL)
 378             *hashp = (struct bfd_link_hash_entry *) h;
 379
 380           f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
 381           if (f == NULL)
 382             return false;
 383           f->jump = IS_PLT_SYM (name);
 384
 385           return true;
 386         }
 387     }
 388
 389   /* Do the usual procedure for adding a symbol.  */
 390   if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
 391                                           value, string, copy, collect,
 392                                           hashp))
 393     return false;
 394
 395   /* Insert a pointer to our table in the set vector.  The dynamic
 396      linker requires this information */
 397   if (insert)
 398     {
 399       asection *s;
 400
 401       /* Here we do our special thing to add the pointer to the
 402          dynamic section in the SHARABLE_CONFLICTS set vector.  */
 403       s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 404                                    ".linux-dynamic");
 405       BFD_ASSERT (s != NULL);
 406
 407       if (! (_bfd_generic_link_add_one_symbol
 408              (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
 409               BSF_GLOBAL | BSF_CONSTRUCTOR, s, 0, NULL, 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 (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_m68klinux_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 = 8 + linux_hash_table (info)->fixup_count * 8;
 592       s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
 593       if (s->contents == NULL)
 594         {
 595           bfd_set_error (bfd_error_no_memory);
 596           return false;
 597         }
 598       memset (s->contents, 0, (size_t) s->_raw_size);
 599     }
 600
 601   return true;
 602 }
 603
 604 /* We come here once we are ready to actually write the fixup table to
 605    the output file.  Scan the fixup tables and so forth and generate
 606    the stuff we need.  */
 607
 608 static boolean
 609 linux_finish_dynamic_link (output_bfd, info)
 610      bfd *output_bfd;
 611      struct bfd_link_info *info;
 612 {
 613   asection *s, *os, *is;
 614   bfd_byte *fixup_table;
 615   struct linux_link_hash_entry *h;
 616   struct fixup *f;
 617   unsigned int new_addr;
 618   int section_offset;
 619   unsigned int fixups_written;
 620
 621   if (linux_hash_table (info)->dynobj == NULL)
 622     return true;
 623
 624   s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 625                                ".linux-dynamic");
 626   BFD_ASSERT (s != NULL);
 627   os = s->output_section;
 628   fixups_written = 0;
 629
 630 #ifdef LINUX_LINK_DEBUG
 631   printf ("Fixup table file offset: %x  VMA: %x\n",
 632           os->filepos + s->output_offset,
 633           os->vma + s->output_offset);
 634 #endif
 635
 636   fixup_table = s->contents;
 637   bfd_put_32 (output_bfd, linux_hash_table (info)->fixup_count, fixup_table);
 638   fixup_table += 4;
 639
 640   /* Fill in fixup table.  */
 641   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 642     {
 643       if (f->builtin)
 644         continue;
 645
 646       if (f->h->root.root.type != bfd_link_hash_defined
 647           && f->h->root.root.type != bfd_link_hash_defweak)
 648         {
 649           (*_bfd_error_handler)
 650             ("Symbol %s not defined for fixups\n",
 651              f->h->root.root.root.string);
 652           continue;
 653         }
 654
 655       is = f->h->root.root.u.def.section;
 656       section_offset = is->output_section->vma + is->output_offset;
 657       new_addr = f->h->root.root.u.def.value + section_offset;
 658
 659 #ifdef LINUX_LINK_DEBUG
 660       printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
 661               new_addr, f->value);
 662 #endif
 663
 664       if (f->jump)
 665         {
 666           bfd_put_32 (output_bfd, new_addr, fixup_table);
 667           fixup_table += 4;
 668           bfd_put_32 (output_bfd, f->value + 2, fixup_table);
 669           fixup_table += 4;
 670         }
 671       else
 672         {
 673           bfd_put_32 (output_bfd, new_addr, fixup_table);
 674           fixup_table += 4;
 675           bfd_put_32 (output_bfd, f->value, fixup_table);
 676           fixup_table += 4;
 677         }
 678       ++fixups_written;
 679     }
 680
 681   if (linux_hash_table (info)->local_builtins != 0)
 682     {
 683       /* Special marker so we know to switch to the other type of fixup */
 684       bfd_put_32 (output_bfd, 0, fixup_table);
 685       fixup_table += 4;
 686       bfd_put_32 (output_bfd, 0, fixup_table);
 687       fixup_table += 4;
 688       ++fixups_written;
 689       for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 690         {
 691           if (! f->builtin)
 692             continue;
 693
 694           if (f->h->root.root.type != bfd_link_hash_defined
 695               && f->h->root.root.type != bfd_link_hash_defweak)
 696             {
 697               (*_bfd_error_handler)
 698                 ("Symbol %s not defined for fixups\n",
 699                  f->h->root.root.root.string);
 700               continue;
 701             }
 702
 703           is = f->h->root.root.u.def.section;
 704           section_offset = is->output_section->vma + is->output_offset;
 705           new_addr = f->h->root.root.u.def.value + section_offset;
 706
 707 #ifdef LINUX_LINK_DEBUG
 708           printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
 709                   new_addr, f->value);
 710 #endif
 711
 712           bfd_put_32 (output_bfd, new_addr, fixup_table);
 713           fixup_table += 4;
 714           bfd_put_32 (output_bfd, f->value, fixup_table);
 715           fixup_table += 4;
 716           ++fixups_written;
 717         }
 718   }
 719
 720   if (linux_hash_table (info)->fixup_count != fixups_written)
 721     {
 722       (*_bfd_error_handler) ("Warning: fixup count mismatch\n");
 723       while (linux_hash_table (info)->fixup_count > fixups_written)
 724         {
 725           bfd_put_32 (output_bfd, 0, fixup_table);
 726           fixup_table += 4;
 727           bfd_put_32 (output_bfd, 0, fixup_table);
 728           fixup_table += 4;
 729           ++fixups_written;
 730         }
 731     }
 732
 733   h = linux_link_hash_lookup (linux_hash_table (info),
 734                               "__BUILTIN_FIXUPS__",
 735                               false, false, false);
 736
 737   if (h != NULL
 738       && (h->root.root.type == bfd_link_hash_defined
 739           || h->root.root.type == bfd_link_hash_defweak))
 740     {
 741       is = h->root.root.u.def.section;
 742       section_offset = is->output_section->vma + is->output_offset;
 743       new_addr = h->root.root.u.def.value + section_offset;
 744
 745 #ifdef LINUX_LINK_DEBUG
 746       printf ("Builtin fixup table at %x\n", new_addr);
 747 #endif
 748
 749       bfd_put_32 (output_bfd, new_addr, fixup_table);
 750     }
 751   else
 752     bfd_put_32 (output_bfd, 0, fixup_table);
 753
 754   if (bfd_seek (output_bfd, os->filepos + s->output_offset, SEEK_SET) != 0)
 755     return false;
 756
 757   if (bfd_write ((PTR) s->contents, 1, s->_raw_size, output_bfd)
 758       != s->_raw_size)
 759     return false;
 760
 761   return true;
 762 }
 763
 764 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
 765 #define MY_add_one_symbol linux_add_one_symbol
 766 #define MY_finish_dynamic_link linux_finish_dynamic_link
 767
 768 #define MY_zmagic_contiguous 1
 769
 770 #include "aout-target.h"