bfd/i386linux.c

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