bfd/sparclinux.c

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