bfd/i386linux.c

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