bfd/sparclinux.c

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