bfd/m68klinux.c

   1 /* BFD back-end for linux flavored m68k a.out binaries.
   2    Copyright (C) 1992-2016 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_68020 || (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 TARGET_IS_BIG_ENDIAN_P
  37 #define DEFAULT_ARCH bfd_arch_m68k
  38
  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 (m68k_aout_linux_,OP)
  43 #define TARGETNAME "a.out-m68k-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 m68klinux_bfd_final_link (bfd *abfd,
  56                           struct bfd_link_info *info)
  57 {
  58   obj_aout_subformat (abfd) = q_magic_format;
  59   return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
  60 }
  61
  62 #define MY_bfd_final_link m68klinux_bfd_final_link
  63
  64 /* Set the machine type correctly.  */
  65
  66 static bfd_boolean
  67 m68klinux_write_object_contents (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)  (CONST_STRNEQ (name, GOT_REF_PREFIX))
  92
  93 /* See if a symbol name is a reference to the procedure linkage table.  */
  94
  95 #ifndef PLT_REF_PREFIX
  96 #define PLT_REF_PREFIX  "__PLT_"
  97 #endif
  98
  99 #define IS_PLT_SYM(name)  (CONST_STRNEQ (name, PLT_REF_PREFIX))
 100
 101 /* This string is used to generate specialized error messages.  */
 102
 103 #ifndef NEEDS_SHRLIB
 104 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
 105 #endif
 106
 107 /* This special symbol is a set vector that contains a list of
 108    pointers to fixup tables.  It will be present in any dynamically
 109    linked file.  The linker generated fixup table should also be added
 110    to the list, and it should always appear in the second slot (the
 111    first one is a dummy with a magic number that is defined in
 112    crt0.o).  */
 113
 114 #ifndef SHARABLE_CONFLICTS
 115 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
 116 #endif
 117
 118 /* We keep a list of fixups.  The terminology is a bit strange, but
 119    each fixup contains two 32 bit numbers.  A regular fixup contains
 120    an address and a pointer, and at runtime we should store the
 121    address at the location pointed to by the pointer.  A builtin fixup
 122    contains two pointers, and we should read the address using one
 123    pointer and store it at the location pointed to by the other
 124    pointer.  Builtin fixups come into play when we have duplicate
 125    __GOT__ symbols for the same variable.  The builtin fixup will copy
 126    the GOT pointer from one over into the other.  */
 127
 128 struct fixup
 129 {
 130   struct fixup *next;
 131   struct linux_link_hash_entry *h;
 132   bfd_vma value;
 133
 134   /* Nonzero if this is a jump instruction that needs to be fixed,
 135      zero if this is just a pointer */
 136   char jump;
 137
 138   char builtin;
 139 };
 140
 141 /* We don't need a special hash table entry structure, but we do need
 142    to keep some information between linker passes, so we use a special
 143    hash table.  */
 144
 145 struct linux_link_hash_entry
 146 {
 147   struct aout_link_hash_entry root;
 148 };
 149
 150 struct linux_link_hash_table
 151 {
 152   struct aout_link_hash_table root;
 153
 154   /* First dynamic object found in link.  */
 155   bfd *dynobj;
 156
 157   /* Number of fixups.  */
 158   size_t fixup_count;
 159
 160   /* Number of builtin fixups.  */
 161   size_t local_builtins;
 162
 163   /* List of fixups.  */
 164   struct fixup *fixup_list;
 165 };
 166
 167 /* Routine to create an entry in an Linux link hash table.  */
 168
 169 static struct bfd_hash_entry *
 170 linux_link_hash_newfunc (struct bfd_hash_entry *entry,
 171                          struct bfd_hash_table *table,
 172                          const char *string)
 173 {
 174   struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
 175
 176   /* Allocate the structure if it has not already been allocated by a
 177      subclass.  */
 178   if (ret == (struct linux_link_hash_entry *) NULL)
 179     ret = ((struct linux_link_hash_entry *)
 180            bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
 181   if (ret == NULL)
 182     return (struct bfd_hash_entry *) ret;
 183
 184   /* Call the allocation method of the superclass.  */
 185   ret = ((struct linux_link_hash_entry *)
 186          NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
 187                                        table, string));
 188   if (ret != NULL)
 189     {
 190       /* Set local fields; there aren't any.  */
 191     }
 192
 193   return (struct bfd_hash_entry *) ret;
 194 }
 195
 196 /* Create a Linux link hash table.  */
 197
 198 static struct bfd_link_hash_table *
 199 linux_link_hash_table_create (bfd *abfd)
 200 {
 201   struct linux_link_hash_table *ret;
 202   bfd_size_type amt = sizeof (struct linux_link_hash_table);
 203
 204   ret = (struct linux_link_hash_table *) bfd_zmalloc (amt);
 205   if (ret == (struct linux_link_hash_table *) NULL)
 206     {
 207       bfd_set_error (bfd_error_no_memory);
 208       return (struct bfd_link_hash_table *) NULL;
 209     }
 210   if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
 211                                         linux_link_hash_newfunc,
 212                                         sizeof (struct linux_link_hash_entry)))
 213     {
 214       free (ret);
 215       return (struct bfd_link_hash_table *) NULL;
 216     }
 217
 218   return &ret->root.root;
 219 }
 220
 221 /* Look up an entry in a Linux link hash table.  */
 222
 223 #define linux_link_hash_lookup(table, string, create, copy, follow) \
 224   ((struct linux_link_hash_entry *) \
 225    aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
 226                           (follow)))
 227
 228 /* Traverse a Linux link hash table.  */
 229
 230 #define linux_link_hash_traverse(table, func, info)                     \
 231   (aout_link_hash_traverse                                              \
 232    (&(table)->root,                                                     \
 233     (bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func),   \
 234     (info)))
 235
 236 /* Get the Linux link hash table from the info structure.  This is
 237    just a cast.  */
 238
 239 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
 240
 241 /* Store the information for a new fixup.  */
 242
 243 static struct fixup *
 244 new_fixup (struct bfd_link_info *info,
 245            struct linux_link_hash_entry *h,
 246            bfd_vma value,
 247            int builtin)
 248 {
 249   struct fixup *f;
 250
 251   f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
 252                                           sizeof (struct fixup));
 253   if (f == NULL)
 254     return f;
 255   f->next = linux_hash_table (info)->fixup_list;
 256   linux_hash_table (info)->fixup_list = f;
 257   f->h = h;
 258   f->value = value;
 259   f->builtin = builtin;
 260   f->jump = 0;
 261   ++linux_hash_table (info)->fixup_count;
 262   return f;
 263 }
 264
 265 /* We come here once we realize that we are going to link to a shared
 266    library.  We need to create a special section that contains the
 267    fixup table, and we ultimately need to add a pointer to this into
 268    the set vector for SHARABLE_CONFLICTS.  At this point we do not
 269    know the size of the section, but that's OK - we just need to
 270    create it for now.  */
 271
 272 static bfd_boolean
 273 linux_link_create_dynamic_sections (bfd *abfd,
 274                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
 275 {
 276   flagword flags;
 277   asection *s;
 278
 279   /* Note that we set the SEC_IN_MEMORY flag.  */
 280   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 281
 282   /* We choose to use the name ".linux-dynamic" for the fixup table.
 283      Why not? */
 284   s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
 285   if (s == NULL
 286       || ! bfd_set_section_alignment (abfd, s, 2))
 287     return FALSE;
 288   s->size = 0;
 289   s->contents = 0;
 290
 291   return TRUE;
 292 }
 293
 294 /* Function to add a single symbol to the linker hash table.  This is
 295    a wrapper around _bfd_generic_link_add_one_symbol which handles the
 296    tweaking needed for dynamic linking support.  */
 297
 298 static bfd_boolean
 299 linux_add_one_symbol (struct bfd_link_info *info,
 300                       bfd *abfd,
 301                       const char *name,
 302                       flagword flags,
 303                       asection *section,
 304                       bfd_vma value,
 305                       const char *string,
 306                       bfd_boolean copy,
 307                       bfd_boolean collect,
 308                       struct bfd_link_hash_entry **hashp)
 309 {
 310   struct linux_link_hash_entry *h;
 311   bfd_boolean insert;
 312
 313   /* Look up and see if we already have this symbol in the hash table.
 314      If we do, and the defining entry is from a shared library, we
 315      need to create the dynamic sections.
 316
 317      FIXME: What if abfd->xvec != info->output_bfd->xvec?  We may
 318      want to be able to link Linux a.out and ELF objects together,
 319      but serious confusion is possible.  */
 320
 321   insert = FALSE;
 322
 323   if (! bfd_link_relocatable (info)
 324       && linux_hash_table (info)->dynobj == NULL
 325       && strcmp (name, SHARABLE_CONFLICTS) == 0
 326       && (flags & BSF_CONSTRUCTOR) != 0
 327       && abfd->xvec == info->output_bfd->xvec)
 328     {
 329       if (! linux_link_create_dynamic_sections (abfd, info))
 330         return FALSE;
 331       linux_hash_table (info)->dynobj = abfd;
 332       insert = TRUE;
 333     }
 334
 335   if (bfd_is_abs_section (section)
 336       && abfd->xvec == info->output_bfd->xvec)
 337     {
 338       h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
 339                                   FALSE, FALSE);
 340       if (h != NULL
 341           && (h->root.root.type == bfd_link_hash_defined
 342               || h->root.root.type == bfd_link_hash_defweak))
 343         {
 344           struct fixup *f;
 345
 346           if (hashp != NULL)
 347             *hashp = (struct bfd_link_hash_entry *) h;
 348
 349           f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
 350           if (f == NULL)
 351             return FALSE;
 352           f->jump = IS_PLT_SYM (name);
 353
 354           return TRUE;
 355         }
 356     }
 357
 358   /* Do the usual procedure for adding a symbol.  */
 359   if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
 360                                           value, string, copy, collect,
 361                                           hashp))
 362     return FALSE;
 363
 364   /* Insert a pointer to our table in the set vector.  The dynamic
 365      linker requires this information */
 366   if (insert)
 367     {
 368       asection *s;
 369
 370       /* Here we do our special thing to add the pointer to the
 371          dynamic section in the SHARABLE_CONFLICTS set vector.  */
 372       s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 373                                    ".linux-dynamic");
 374       BFD_ASSERT (s != NULL);
 375
 376       if (! (_bfd_generic_link_add_one_symbol
 377              (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
 378               BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
 379               FALSE, FALSE, NULL)))
 380         return FALSE;
 381     }
 382
 383   return TRUE;
 384 }
 385
 386 /* We will crawl the hash table and come here for every global symbol.
 387    We will examine each entry and see if there are indications that we
 388    need to add a fixup.  There are two possible cases - one is where
 389    you have duplicate definitions of PLT or GOT symbols - these will
 390    have already been caught and added as "builtin" fixups.  If we find
 391    that the corresponding non PLT/GOT symbol is also present, we
 392    convert it to a regular fixup instead.
 393
 394    This function is called via linux_link_hash_traverse.  */
 395
 396 static bfd_boolean
 397 linux_tally_symbols (struct linux_link_hash_entry *h,
 398                      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 it */
 436   is_plt = IS_PLT_SYM (h->root.root.root.string);
 437
 438   if (is_plt || IS_GOT_SYM (h->root.root.root.string))
 439     {
 440       /* Look up this symbol twice.  Once just as a regular lookup,
 441          and then again following all of the indirect links until we
 442          reach a real symbol.  */
 443       h1 = linux_link_hash_lookup (linux_hash_table (info),
 444                                    (h->root.root.root.string
 445                                     + sizeof PLT_REF_PREFIX - 1),
 446                                    FALSE, FALSE, TRUE);
 447       /* h2 does not follow indirect symbols.  */
 448       h2 = linux_link_hash_lookup (linux_hash_table (info),
 449                                    (h->root.root.root.string
 450                                     + sizeof PLT_REF_PREFIX - 1),
 451                                    FALSE, FALSE, FALSE);
 452
 453       /* The real symbol must exist but if it is also an ABS symbol,
 454          there is no need to have a fixup.  This is because they both
 455          came from the same library.  If on the other hand, we had to
 456          use an indirect symbol to get to the real symbol, we add the
 457          fixup anyway, since there are cases where these symbols come
 458          from different shared libraries */
 459       if (h1 != NULL
 460           && (((h1->root.root.type == bfd_link_hash_defined
 461                 || h1->root.root.type == bfd_link_hash_defweak)
 462                && ! bfd_is_abs_section (h1->root.root.u.def.section))
 463               || h2->root.root.type == bfd_link_hash_indirect))
 464         {
 465           /* See if there is a "builtin" fixup already present
 466              involving this symbol.  If so, convert it to a regular
 467              fixup.  In the end, this relaxes some of the requirements
 468              about the order of performing fixups.  */
 469           exists = FALSE;
 470           for (f1 = linux_hash_table (info)->fixup_list;
 471                f1 != NULL;
 472                f1 = f1->next)
 473             {
 474               if ((f1->h != h && f1->h != h1)
 475                   || (! f1->builtin && ! f1->jump))
 476                 continue;
 477               if (f1->h == h1)
 478                 exists = TRUE;
 479               if (! exists
 480                   && bfd_is_abs_section (h->root.root.u.def.section))
 481                 {
 482                   f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
 483                   f->jump = is_plt;
 484                 }
 485               f1->h = h1;
 486               f1->jump = is_plt;
 487               f1->builtin = 0;
 488               exists = TRUE;
 489             }
 490           if (! exists
 491               && bfd_is_abs_section (h->root.root.u.def.section))
 492             {
 493               f = new_fixup (info, h1, h->root.root.u.def.value, 0);
 494               if (f == NULL)
 495                 {
 496                   /* FIXME: No way to return error.  */
 497                   abort ();
 498                 }
 499               f->jump = is_plt;
 500             }
 501         }
 502
 503       /* Quick and dirty way of stripping these symbols from the
 504          symtab.  */
 505       if (bfd_is_abs_section (h->root.root.u.def.section))
 506         h->root.written = TRUE;
 507     }
 508
 509   return TRUE;
 510 }
 511
 512 /* This is called to set the size of the .linux-dynamic section is.
 513    It is called by the Linux linker emulation before_allocation
 514    routine.  We have finished reading all of the input files, and now
 515    we just scan the hash tables to find out how many additional fixups
 516    are required.  */
 517
 518 bfd_boolean
 519 bfd_m68klinux_size_dynamic_sections (bfd *output_bfd,
 520                                      struct bfd_link_info *info)
 521 {
 522   struct fixup *f;
 523   asection *s;
 524
 525   if (output_bfd->xvec != &MY(vec))
 526     return TRUE;
 527
 528   /* First find the fixups...  */
 529   linux_link_hash_traverse (linux_hash_table (info),
 530                             linux_tally_symbols,
 531                             info);
 532
 533   /* If there are builtin fixups, leave room for a marker.  This is
 534      used by the dynamic linker so that it knows that all that follow
 535      are builtin fixups instead of regular fixups.  */
 536   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 537     {
 538       if (f->builtin)
 539         {
 540           ++linux_hash_table (info)->fixup_count;
 541           ++linux_hash_table (info)->local_builtins;
 542           break;
 543         }
 544     }
 545
 546   if (linux_hash_table (info)->dynobj == NULL)
 547     {
 548       if (linux_hash_table (info)->fixup_count > 0)
 549         abort ();
 550       return TRUE;
 551     }
 552
 553   /* Allocate memory for our fixup table.  We will fill it in later.  */
 554   s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 555                                ".linux-dynamic");
 556   if (s != NULL)
 557     {
 558       s->size = linux_hash_table (info)->fixup_count + 1;
 559       s->size *= 8;
 560       s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
 561       if (s->contents == NULL)
 562         {
 563           bfd_set_error (bfd_error_no_memory);
 564           return FALSE;
 565         }
 566     }
 567
 568   return TRUE;
 569 }
 570
 571 /* We come here once we are ready to actually write the fixup table to
 572    the output file.  Scan the fixup tables and so forth and generate
 573    the stuff we need.  */
 574
 575 static bfd_boolean
 576 linux_finish_dynamic_link (bfd *output_bfd, struct bfd_link_info *info)
 577 {
 578   asection *s, *os, *is;
 579   bfd_byte *fixup_table;
 580   struct linux_link_hash_entry *h;
 581   struct fixup *f;
 582   unsigned int new_addr;
 583   int section_offset;
 584   unsigned int fixups_written;
 585
 586   if (linux_hash_table (info)->dynobj == NULL)
 587     return TRUE;
 588
 589   s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
 590                                ".linux-dynamic");
 591   BFD_ASSERT (s != NULL);
 592   os = s->output_section;
 593   fixups_written = 0;
 594
 595 #ifdef LINUX_LINK_DEBUG
 596   printf ("Fixup table file offset: %x  VMA: %x\n",
 597           os->filepos + s->output_offset,
 598           os->vma + s->output_offset);
 599 #endif
 600
 601   fixup_table = s->contents;
 602   bfd_put_32 (output_bfd, (bfd_vma) linux_hash_table (info)->fixup_count,
 603               fixup_table);
 604   fixup_table += 4;
 605
 606   /* Fill in fixup table.  */
 607   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
 608     {
 609       if (f->builtin)
 610         continue;
 611
 612       if (f->h->root.root.type != bfd_link_hash_defined
 613           && f->h->root.root.type != bfd_link_hash_defweak)
 614         {
 615           (*_bfd_error_handler)
 616             (_("Symbol %s not defined for fixups\n"),
 617              f->h->root.root.root.string);
 618           continue;
 619         }
 620
 621       is = f->h->root.root.u.def.section;
 622       section_offset = is->output_section->vma + is->output_offset;
 623       new_addr = f->h->root.root.u.def.value + section_offset;
 624
 625 #ifdef LINUX_LINK_DEBUG
 626       printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
 627               new_addr, f->value);
 628 #endif
 629
 630       if (f->jump)
 631         {
 632           bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
 633           fixup_table += 4;
 634           bfd_put_32 (output_bfd, f->value + 2, 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"