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