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