bfd/
[binutils.git] / bfd / i386linux.c
blob99d1c06c5bea1166d524f89c034dff9e09380ca0
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, 2006 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
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
27 #define MACHTYPE_OK(mtype) ((mtype) == M_386 || (mtype) == M_UNKNOWN)
29 #include "bfd.h"
30 #include "sysdep.h"
31 #include "libbfd.h"
32 #include "aout/aout64.h"
33 #include "aout/stab_gnu.h"
34 #include "aout/ar.h"
35 #include "libaout.h" /* BFD a.out internal data structures */
37 #define DEFAULT_ARCH bfd_arch_i386
39 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
40 remove whitespace added here, and thus will fail to concatenate
41 the tokens. */
42 #define MY(OP) CONCAT2 (i386linux_,OP)
43 #define TARGETNAME "a.out-i386-linux"
45 extern const bfd_target MY(vec);
47 /* We always generate QMAGIC files in preference to ZMAGIC files. It
48 would be possible to make this a linker option, if that ever
49 becomes important. */
51 static void MY_final_link_callback
52 PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
53 static bfd_boolean i386linux_bfd_final_link
54 PARAMS ((bfd *, struct bfd_link_info *));
55 static bfd_boolean i386linux_write_object_contents PARAMS ((bfd *));
57 static bfd_boolean
58 i386linux_bfd_final_link (abfd, info)
59 bfd *abfd;
60 struct bfd_link_info *info;
62 obj_aout_subformat (abfd) = q_magic_format;
63 return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
66 #define MY_bfd_final_link i386linux_bfd_final_link
68 /* Set the machine type correctly. */
70 static bfd_boolean
71 i386linux_write_object_contents (abfd)
72 bfd *abfd;
74 struct external_exec exec_bytes;
75 struct internal_exec *execp = exec_hdr (abfd);
77 N_SET_MACHTYPE (*execp, M_386);
79 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
81 WRITE_HEADERS(abfd, execp);
83 return TRUE;
86 #define MY_write_object_contents i386linux_write_object_contents
88 /* Code to link against Linux a.out shared libraries. */
90 /* See if a symbol name is a reference to the global offset table. */
92 #ifndef GOT_REF_PREFIX
93 #define GOT_REF_PREFIX "__GOT_"
94 #endif
96 #define IS_GOT_SYM(name) (CONST_STRNEQ (name, GOT_REF_PREFIX))
98 /* See if a symbol name is a reference to the procedure linkage table. */
100 #ifndef PLT_REF_PREFIX
101 #define PLT_REF_PREFIX "__PLT_"
102 #endif
104 #define IS_PLT_SYM(name) (CONST_STRNEQ (name, PLT_REF_PREFIX))
106 /* This string is used to generate specialized error messages. */
108 #ifndef NEEDS_SHRLIB
109 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
110 #endif
112 /* This special symbol is a set vector that contains a list of
113 pointers to fixup tables. It will be present in any dynamically
114 linked file. The linker generated fixup table should also be added
115 to the list, and it should always appear in the second slot (the
116 first one is a dummy with a magic number that is defined in
117 crt0.o). */
119 #ifndef SHARABLE_CONFLICTS
120 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
121 #endif
123 /* We keep a list of fixups. The terminology is a bit strange, but
124 each fixup contains two 32 bit numbers. A regular fixup contains
125 an address and a pointer, and at runtime we should store the
126 address at the location pointed to by the pointer. A builtin fixup
127 contains two pointers, and we should read the address using one
128 pointer and store it at the location pointed to by the other
129 pointer. Builtin fixups come into play when we have duplicate
130 __GOT__ symbols for the same variable. The builtin fixup will copy
131 the GOT pointer from one over into the other. */
133 struct fixup
135 struct fixup *next;
136 struct linux_link_hash_entry *h;
137 bfd_vma value;
139 /* Nonzero if this is a jump instruction that needs to be fixed,
140 zero if this is just a pointer */
141 char jump;
143 char builtin;
146 /* We don't need a special hash table entry structure, but we do need
147 to keep some information between linker passes, so we use a special
148 hash table. */
150 struct linux_link_hash_entry
152 struct aout_link_hash_entry root;
155 struct linux_link_hash_table
157 struct aout_link_hash_table root;
159 /* First dynamic object found in link. */
160 bfd *dynobj;
162 /* Number of fixups. */
163 size_t fixup_count;
165 /* Number of builtin fixups. */
166 size_t local_builtins;
168 /* List of fixups. */
169 struct fixup *fixup_list;
172 static struct bfd_hash_entry *linux_link_hash_newfunc
173 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
174 static struct bfd_link_hash_table *linux_link_hash_table_create
175 PARAMS ((bfd *));
176 static struct fixup *new_fixup
177 PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
178 bfd_vma, int));
179 static bfd_boolean linux_link_create_dynamic_sections
180 PARAMS ((bfd *, struct bfd_link_info *));
181 static bfd_boolean linux_add_one_symbol
182 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
183 bfd_vma, const char *, bfd_boolean, bfd_boolean,
184 struct bfd_link_hash_entry **));
185 static bfd_boolean linux_tally_symbols
186 PARAMS ((struct linux_link_hash_entry *, PTR));
187 static bfd_boolean linux_finish_dynamic_link
188 PARAMS ((bfd *, struct bfd_link_info *));
190 /* Routine to create an entry in an Linux link hash table. */
192 static struct bfd_hash_entry *
193 linux_link_hash_newfunc (entry, table, string)
194 struct bfd_hash_entry *entry;
195 struct bfd_hash_table *table;
196 const char *string;
198 struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
200 /* Allocate the structure if it has not already been allocated by a
201 subclass. */
202 if (ret == (struct linux_link_hash_entry *) NULL)
203 ret = ((struct linux_link_hash_entry *)
204 bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
205 if (ret == NULL)
206 return (struct bfd_hash_entry *) ret;
208 /* Call the allocation method of the superclass. */
209 ret = ((struct linux_link_hash_entry *)
210 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
211 table, string));
212 if (ret != NULL)
214 /* Set local fields; there aren't any. */
217 return (struct bfd_hash_entry *) ret;
220 /* Create a Linux link hash table. */
222 static struct bfd_link_hash_table *
223 linux_link_hash_table_create (abfd)
224 bfd *abfd;
226 struct linux_link_hash_table *ret;
227 bfd_size_type amt = sizeof (struct linux_link_hash_table);
229 ret = (struct linux_link_hash_table *) bfd_alloc (abfd, amt);
230 if (ret == (struct linux_link_hash_table *) NULL)
231 return (struct bfd_link_hash_table *) NULL;
232 if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
233 linux_link_hash_newfunc,
234 sizeof (struct linux_link_hash_entry)))
236 free (ret);
237 return (struct bfd_link_hash_table *) NULL;
240 ret->dynobj = NULL;
241 ret->fixup_count = 0;
242 ret->local_builtins = 0;
243 ret->fixup_list = NULL;
245 return &ret->root.root;
248 /* Look up an entry in a Linux link hash table. */
250 #define linux_link_hash_lookup(table, string, create, copy, follow) \
251 ((struct linux_link_hash_entry *) \
252 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
253 (follow)))
255 /* Traverse a Linux link hash table. */
257 #define linux_link_hash_traverse(table, func, info) \
258 (aout_link_hash_traverse \
259 (&(table)->root, \
260 (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
261 (info)))
263 /* Get the Linux link hash table from the info structure. This is
264 just a cast. */
266 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
268 /* Store the information for a new fixup. */
270 static struct fixup *
271 new_fixup (info, h, value, builtin)
272 struct bfd_link_info *info;
273 struct linux_link_hash_entry *h;
274 bfd_vma value;
275 int builtin;
277 struct fixup *f;
279 f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
280 sizeof (struct fixup));
281 if (f == NULL)
282 return f;
283 f->next = linux_hash_table (info)->fixup_list;
284 linux_hash_table (info)->fixup_list = f;
285 f->h = h;
286 f->value = value;
287 f->builtin = builtin;
288 f->jump = 0;
289 ++linux_hash_table (info)->fixup_count;
290 return f;
293 /* We come here once we realize that we are going to link to a shared
294 library. We need to create a special section that contains the
295 fixup table, and we ultimately need to add a pointer to this into
296 the set vector for SHARABLE_CONFLICTS. At this point we do not
297 know the size of the section, but that's OK - we just need to
298 create it for now. */
300 static bfd_boolean
301 linux_link_create_dynamic_sections (abfd, info)
302 bfd *abfd;
303 struct bfd_link_info *info ATTRIBUTE_UNUSED;
305 flagword flags;
306 register asection *s;
308 /* Note that we set the SEC_IN_MEMORY flag. */
309 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
311 /* We choose to use the name ".linux-dynamic" for the fixup table.
312 Why not? */
313 s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
314 if (s == NULL
315 || ! bfd_set_section_alignment (abfd, s, 2))
316 return FALSE;
317 s->size = 0;
318 s->contents = 0;
320 return TRUE;
323 /* Function to add a single symbol to the linker hash table. This is
324 a wrapper around _bfd_generic_link_add_one_symbol which handles the
325 tweaking needed for dynamic linking support. */
327 static bfd_boolean
328 linux_add_one_symbol (info, abfd, name, flags, section, value, string,
329 copy, collect, hashp)
330 struct bfd_link_info *info;
331 bfd *abfd;
332 const char *name;
333 flagword flags;
334 asection *section;
335 bfd_vma value;
336 const char *string;
337 bfd_boolean copy;
338 bfd_boolean collect;
339 struct bfd_link_hash_entry **hashp;
341 struct linux_link_hash_entry *h;
342 bfd_boolean insert;
344 /* Look up and see if we already have this symbol in the hash table.
345 If we do, and the defining entry is from a shared library, we
346 need to create the dynamic sections.
348 FIXME: What if abfd->xvec != info->hash->creator? We may want to
349 be able to link Linux a.out and ELF objects together, but serious
350 confusion is possible. */
352 insert = FALSE;
354 if (! info->relocatable
355 && linux_hash_table (info)->dynobj == NULL
356 && strcmp (name, SHARABLE_CONFLICTS) == 0
357 && (flags & BSF_CONSTRUCTOR) != 0
358 && abfd->xvec == info->hash->creator)
360 if (! linux_link_create_dynamic_sections (abfd, info))
361 return FALSE;
362 linux_hash_table (info)->dynobj = abfd;
363 insert = TRUE;
366 if (bfd_is_abs_section (section)
367 && abfd->xvec == info->hash->creator)
369 h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
370 FALSE, FALSE);
371 if (h != NULL
372 && (h->root.root.type == bfd_link_hash_defined
373 || h->root.root.type == bfd_link_hash_defweak))
375 struct fixup *f;
377 if (hashp != NULL)
378 *hashp = (struct bfd_link_hash_entry *) h;
380 f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
381 if (f == NULL)
382 return FALSE;
383 f->jump = IS_PLT_SYM (name);
385 return TRUE;
389 /* Do the usual procedure for adding a symbol. */
390 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
391 value, string, copy, collect,
392 hashp))
393 return FALSE;
395 /* Insert a pointer to our table in the set vector. The dynamic
396 linker requires this information */
397 if (insert)
399 asection *s;
401 /* Here we do our special thing to add the pointer to the
402 dynamic section in the SHARABLE_CONFLICTS set vector. */
403 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
404 ".linux-dynamic");
405 BFD_ASSERT (s != NULL);
407 if (! (_bfd_generic_link_add_one_symbol
408 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
409 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
410 FALSE, FALSE, NULL)))
411 return FALSE;
414 return TRUE;
417 /* We will crawl the hash table and come here for every global symbol.
418 We will examine each entry and see if there are indications that we
419 need to add a fixup. There are two possible cases - one is where
420 you have duplicate definitions of PLT or GOT symbols - these will
421 have already been caught and added as "builtin" fixups. If we find
422 that the corresponding non PLT/GOT symbol is also present, we
423 convert it to a regular fixup instead.
425 This function is called via linux_link_hash_traverse. */
427 static bfd_boolean
428 linux_tally_symbols (h, data)
429 struct linux_link_hash_entry *h;
430 PTR data;
432 struct bfd_link_info *info = (struct bfd_link_info *) data;
433 struct fixup *f, *f1;
434 int is_plt;
435 struct linux_link_hash_entry *h1, *h2;
436 bfd_boolean exists;
438 if (h->root.root.type == bfd_link_hash_warning)
439 h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
441 if (h->root.root.type == bfd_link_hash_undefined
442 && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
444 const char *name;
445 char *p;
446 char *alloc = NULL;
448 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
449 p = strrchr (name, '_');
450 if (p != NULL)
451 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
453 if (p == NULL || alloc == NULL)
454 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
455 name);
456 else
458 strcpy (alloc, name);
459 p = strrchr (alloc, '_');
460 *p++ = '\0';
461 (*_bfd_error_handler)
462 (_("Output file requires shared library `%s.so.%s'\n"),
463 alloc, p);
464 free (alloc);
467 abort ();
470 /* If this symbol is not a PLT/GOT, we do not even need to look at it */
471 is_plt = IS_PLT_SYM (h->root.root.root.string);
473 if (is_plt || IS_GOT_SYM (h->root.root.root.string))
475 /* Look up this symbol twice. Once just as a regular lookup,
476 and then again following all of the indirect links until we
477 reach a real symbol. */
478 h1 = linux_link_hash_lookup (linux_hash_table (info),
479 (h->root.root.root.string
480 + sizeof PLT_REF_PREFIX - 1),
481 FALSE, FALSE, TRUE);
482 /* h2 does not follow indirect symbols. */
483 h2 = linux_link_hash_lookup (linux_hash_table (info),
484 (h->root.root.root.string
485 + sizeof PLT_REF_PREFIX - 1),
486 FALSE, FALSE, FALSE);
488 /* The real symbol must exist but if it is also an ABS symbol,
489 there is no need to have a fixup. This is because they both
490 came from the same library. If on the other hand, we had to
491 use an indirect symbol to get to the real symbol, we add the
492 fixup anyway, since there are cases where these symbols come
493 from different shared libraries */
494 if (h1 != NULL
495 && (((h1->root.root.type == bfd_link_hash_defined
496 || h1->root.root.type == bfd_link_hash_defweak)
497 && ! bfd_is_abs_section (h1->root.root.u.def.section))
498 || h2->root.root.type == bfd_link_hash_indirect))
500 /* See if there is a "builtin" fixup already present
501 involving this symbol. If so, convert it to a regular
502 fixup. In the end, this relaxes some of the requirements
503 about the order of performing fixups. */
504 exists = FALSE;
505 for (f1 = linux_hash_table (info)->fixup_list;
506 f1 != NULL;
507 f1 = f1->next)
509 if ((f1->h != h && f1->h != h1)
510 || (! f1->builtin && ! f1->jump))
511 continue;
512 if (f1->h == h1)
513 exists = TRUE;
514 if (! exists
515 && bfd_is_abs_section (h->root.root.u.def.section))
517 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
518 f->jump = is_plt;
520 f1->h = h1;
521 f1->jump = is_plt;
522 f1->builtin = 0;
523 exists = TRUE;
525 if (! exists
526 && bfd_is_abs_section (h->root.root.u.def.section))
528 f = new_fixup (info, h1, h->root.root.u.def.value, 0);
529 if (f == NULL)
531 /* FIXME: No way to return error. */
532 abort ();
534 f->jump = is_plt;
538 /* Quick and dirty way of stripping these symbols from the
539 symtab. */
540 if (bfd_is_abs_section (h->root.root.u.def.section))
541 h->root.written = TRUE;
544 return TRUE;
547 /* This is called to set the size of the .linux-dynamic section is.
548 It is called by the Linux linker emulation before_allocation
549 routine. We have finished reading all of the input files, and now
550 we just scan the hash tables to find out how many additional fixups
551 are required. */
553 bfd_boolean
554 bfd_i386linux_size_dynamic_sections (output_bfd, info)
555 bfd *output_bfd;
556 struct bfd_link_info *info;
558 struct fixup *f;
559 asection *s;
561 if (output_bfd->xvec != &MY(vec))
562 return TRUE;
564 /* First find the fixups... */
565 linux_link_hash_traverse (linux_hash_table (info),
566 linux_tally_symbols,
567 (PTR) info);
569 /* If there are builtin fixups, leave room for a marker. This is
570 used by the dynamic linker so that it knows that all that follow
571 are builtin fixups instead of regular fixups. */
572 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
574 if (f->builtin)
576 ++linux_hash_table (info)->fixup_count;
577 ++linux_hash_table (info)->local_builtins;
578 break;
582 if (linux_hash_table (info)->dynobj == NULL)
584 if (linux_hash_table (info)->fixup_count > 0)
585 abort ();
586 return TRUE;
589 /* Allocate memory for our fixup table. We will fill it in later. */
590 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
591 ".linux-dynamic");
592 if (s != NULL)
594 s->size = linux_hash_table (info)->fixup_count + 1;
595 s->size *= 8;
596 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
597 if (s->contents == NULL)
598 return FALSE;
601 return TRUE;
604 /* We come here once we are ready to actually write the fixup table to
605 the output file. Scan the fixup tables and so forth and generate
606 the stuff we need. */
608 static bfd_boolean
609 linux_finish_dynamic_link (output_bfd, info)
610 bfd *output_bfd;
611 struct bfd_link_info *info;
613 asection *s, *os, *is;
614 bfd_byte *fixup_table;
615 struct linux_link_hash_entry *h;
616 struct fixup *f;
617 unsigned int new_addr;
618 int section_offset;
619 unsigned int fixups_written;
621 if (linux_hash_table (info)->dynobj == NULL)
622 return TRUE;
624 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
625 ".linux-dynamic");
626 BFD_ASSERT (s != NULL);
627 os = s->output_section;
628 fixups_written = 0;
630 #ifdef LINUX_LINK_DEBUG
631 printf ("Fixup table file offset: %x VMA: %x\n",
632 os->filepos + s->output_offset,
633 os->vma + s->output_offset);
634 #endif
636 fixup_table = s->contents;
637 bfd_put_32 (output_bfd,
638 (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
639 fixup_table += 4;
641 /* Fill in fixup table. */
642 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
644 if (f->builtin)
645 continue;
647 if (f->h->root.root.type != bfd_link_hash_defined
648 && f->h->root.root.type != bfd_link_hash_defweak)
650 (*_bfd_error_handler)
651 (_("Symbol %s not defined for fixups\n"),
652 f->h->root.root.root.string);
653 continue;
656 is = f->h->root.root.u.def.section;
657 section_offset = is->output_section->vma + is->output_offset;
658 new_addr = f->h->root.root.u.def.value + section_offset;
660 #ifdef LINUX_LINK_DEBUG
661 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
662 new_addr, f->value);
663 #endif
665 if (f->jump)
667 /* Relative address */
668 new_addr = new_addr - (f->value + 5);
669 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
670 fixup_table += 4;
671 bfd_put_32 (output_bfd, f->value + 1, fixup_table);
672 fixup_table += 4;
674 else
676 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
677 fixup_table += 4;
678 bfd_put_32 (output_bfd, f->value, fixup_table);
679 fixup_table += 4;
681 ++fixups_written;
684 if (linux_hash_table (info)->local_builtins != 0)
686 /* Special marker so we know to switch to the other type of fixup */
687 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
688 fixup_table += 4;
689 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
690 fixup_table += 4;
691 ++fixups_written;
692 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
694 if (! f->builtin)
695 continue;
697 if (f->h->root.root.type != bfd_link_hash_defined
698 && f->h->root.root.type != bfd_link_hash_defweak)
700 (*_bfd_error_handler)
701 (_("Symbol %s not defined for fixups\n"),
702 f->h->root.root.root.string);
703 continue;
706 is = f->h->root.root.u.def.section;
707 section_offset = is->output_section->vma + is->output_offset;
708 new_addr = f->h->root.root.u.def.value + section_offset;
710 #ifdef LINUX_LINK_DEBUG
711 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
712 new_addr, f->value);
713 #endif
715 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
716 fixup_table += 4;
717 bfd_put_32 (output_bfd, f->value, fixup_table);
718 fixup_table += 4;
719 ++fixups_written;
723 if (linux_hash_table (info)->fixup_count != fixups_written)
725 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
726 while (linux_hash_table (info)->fixup_count > fixups_written)
728 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
729 fixup_table += 4;
730 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
731 fixup_table += 4;
732 ++fixups_written;
736 h = linux_link_hash_lookup (linux_hash_table (info),
737 "__BUILTIN_FIXUPS__",
738 FALSE, FALSE, FALSE);
740 if (h != NULL
741 && (h->root.root.type == bfd_link_hash_defined
742 || h->root.root.type == bfd_link_hash_defweak))
744 is = h->root.root.u.def.section;
745 section_offset = is->output_section->vma + is->output_offset;
746 new_addr = h->root.root.u.def.value + section_offset;
748 #ifdef LINUX_LINK_DEBUG
749 printf ("Builtin fixup table at %x\n", new_addr);
750 #endif
752 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
754 else
755 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
757 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
758 SEEK_SET) != 0)
759 return FALSE;
761 if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
762 return FALSE;
764 return TRUE;
767 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
768 #define MY_add_one_symbol linux_add_one_symbol
769 #define MY_finish_dynamic_link linux_finish_dynamic_link
771 #define MY_zmagic_contiguous 1
773 #include "aout-target.h"