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