merge from gcc
[binutils.git] / bfd / m68klinux.c
blob996e5161424bb6b8872fa8242a0ae3f625265483
1 /* BFD back-end for linux flavored m68k a.out binaries.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003
3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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_68020 || (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 TARGET_IS_BIG_ENDIAN_P
38 #define DEFAULT_ARCH bfd_arch_m68k
40 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
41 remove whitespace added here, and thus will fail to concatenate
42 the tokens. */
43 #define MY(OP) CONCAT2 (m68klinux_,OP)
44 #define TARGETNAME "a.out-m68k-linux"
46 extern const bfd_target MY(vec);
48 /* We always generate QMAGIC files in preference to ZMAGIC files. It
49 would be possible to make this a linker option, if that ever
50 becomes important. */
52 static void MY_final_link_callback
53 PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
54 static bfd_boolean m68klinux_bfd_final_link
55 PARAMS ((bfd *, struct bfd_link_info *));
56 static bfd_boolean m68klinux_write_object_contents PARAMS ((bfd *));
58 static bfd_boolean
59 m68klinux_bfd_final_link (abfd, info)
60 bfd *abfd;
61 struct bfd_link_info *info;
63 obj_aout_subformat (abfd) = q_magic_format;
64 return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
67 #define MY_bfd_final_link m68klinux_bfd_final_link
69 /* Set the machine type correctly. */
71 static bfd_boolean
72 m68klinux_write_object_contents (abfd)
73 bfd *abfd;
75 struct external_exec exec_bytes;
76 struct internal_exec *execp = exec_hdr (abfd);
78 N_SET_MACHTYPE (*execp, M_68020);
80 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
82 WRITE_HEADERS(abfd, execp);
84 return TRUE;
87 #define MY_write_object_contents m68klinux_write_object_contents
89 /* Code to link against Linux a.out shared libraries. */
91 /* See if a symbol name is a reference to the global offset table. */
93 #ifndef GOT_REF_PREFIX
94 #define GOT_REF_PREFIX "__GOT_"
95 #endif
97 #define IS_GOT_SYM(name) \
98 (strncmp (name, GOT_REF_PREFIX, sizeof GOT_REF_PREFIX - 1) == 0)
100 /* See if a symbol name is a reference to the procedure linkage table. */
102 #ifndef PLT_REF_PREFIX
103 #define PLT_REF_PREFIX "__PLT_"
104 #endif
106 #define IS_PLT_SYM(name) \
107 (strncmp (name, PLT_REF_PREFIX, sizeof PLT_REF_PREFIX - 1) == 0)
109 /* This string is used to generate specialized error messages. */
111 #ifndef NEEDS_SHRLIB
112 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
113 #endif
115 /* This special symbol is a set vector that contains a list of
116 pointers to fixup tables. It will be present in any dynamically
117 linked file. The linker generated fixup table should also be added
118 to the list, and it should always appear in the second slot (the
119 first one is a dummy with a magic number that is defined in
120 crt0.o). */
122 #ifndef SHARABLE_CONFLICTS
123 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
124 #endif
126 /* We keep a list of fixups. The terminology is a bit strange, but
127 each fixup contains two 32 bit numbers. A regular fixup contains
128 an address and a pointer, and at runtime we should store the
129 address at the location pointed to by the pointer. A builtin fixup
130 contains two pointers, and we should read the address using one
131 pointer and store it at the location pointed to by the other
132 pointer. Builtin fixups come into play when we have duplicate
133 __GOT__ symbols for the same variable. The builtin fixup will copy
134 the GOT pointer from one over into the other. */
136 struct fixup
138 struct fixup *next;
139 struct linux_link_hash_entry *h;
140 bfd_vma value;
142 /* Nonzero if this is a jump instruction that needs to be fixed,
143 zero if this is just a pointer */
144 char jump;
146 char builtin;
149 /* We don't need a special hash table entry structure, but we do need
150 to keep some information between linker passes, so we use a special
151 hash table. */
153 struct linux_link_hash_entry
155 struct aout_link_hash_entry root;
158 struct linux_link_hash_table
160 struct aout_link_hash_table root;
162 /* First dynamic object found in link. */
163 bfd *dynobj;
165 /* Number of fixups. */
166 size_t fixup_count;
168 /* Number of builtin fixups. */
169 size_t local_builtins;
171 /* List of fixups. */
172 struct fixup *fixup_list;
175 static struct bfd_hash_entry *linux_link_hash_newfunc
176 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
177 static struct bfd_link_hash_table *linux_link_hash_table_create
178 PARAMS ((bfd *));
179 static struct fixup *new_fixup
180 PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
181 bfd_vma, int));
182 static bfd_boolean linux_link_create_dynamic_sections
183 PARAMS ((bfd *, struct bfd_link_info *));
184 static bfd_boolean linux_add_one_symbol
185 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
186 bfd_vma, const char *, bfd_boolean, bfd_boolean,
187 struct bfd_link_hash_entry **));
188 static bfd_boolean linux_tally_symbols
189 PARAMS ((struct linux_link_hash_entry *, PTR));
190 static bfd_boolean linux_finish_dynamic_link
191 PARAMS ((bfd *, struct bfd_link_info *));
193 /* Routine to create an entry in an Linux link hash table. */
195 static struct bfd_hash_entry *
196 linux_link_hash_newfunc (entry, table, string)
197 struct bfd_hash_entry *entry;
198 struct bfd_hash_table *table;
199 const char *string;
201 struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
203 /* Allocate the structure if it has not already been allocated by a
204 subclass. */
205 if (ret == (struct linux_link_hash_entry *) NULL)
206 ret = ((struct linux_link_hash_entry *)
207 bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
208 if (ret == NULL)
209 return (struct bfd_hash_entry *) ret;
211 /* Call the allocation method of the superclass. */
212 ret = ((struct linux_link_hash_entry *)
213 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
214 table, string));
215 if (ret != NULL)
217 /* Set local fields; there aren't any. */
220 return (struct bfd_hash_entry *) ret;
223 /* Create a Linux link hash table. */
225 static struct bfd_link_hash_table *
226 linux_link_hash_table_create (abfd)
227 bfd *abfd;
229 struct linux_link_hash_table *ret;
230 bfd_size_type amt = sizeof (struct linux_link_hash_table);
232 ret = (struct linux_link_hash_table *) bfd_malloc (amt);
233 if (ret == (struct linux_link_hash_table *) NULL)
235 bfd_set_error (bfd_error_no_memory);
236 return (struct bfd_link_hash_table *) NULL;
238 if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
239 linux_link_hash_newfunc))
241 free (ret);
242 return (struct bfd_link_hash_table *) NULL;
245 ret->dynobj = NULL;
246 ret->fixup_count = 0;
247 ret->local_builtins = 0;
248 ret->fixup_list = NULL;
250 return &ret->root.root;
253 /* Look up an entry in a Linux link hash table. */
255 #define linux_link_hash_lookup(table, string, create, copy, follow) \
256 ((struct linux_link_hash_entry *) \
257 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
258 (follow)))
260 /* Traverse a Linux link hash table. */
262 #define linux_link_hash_traverse(table, func, info) \
263 (aout_link_hash_traverse \
264 (&(table)->root, \
265 (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
266 (info)))
268 /* Get the Linux link hash table from the info structure. This is
269 just a cast. */
271 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
273 /* Store the information for a new fixup. */
275 static struct fixup *
276 new_fixup (info, h, value, builtin)
277 struct bfd_link_info *info;
278 struct linux_link_hash_entry *h;
279 bfd_vma value;
280 int builtin;
282 struct fixup *f;
284 f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
285 sizeof (struct fixup));
286 if (f == NULL)
287 return f;
288 f->next = linux_hash_table (info)->fixup_list;
289 linux_hash_table (info)->fixup_list = f;
290 f->h = h;
291 f->value = value;
292 f->builtin = builtin;
293 f->jump = 0;
294 ++linux_hash_table (info)->fixup_count;
295 return f;
298 /* We come here once we realize that we are going to link to a shared
299 library. We need to create a special section that contains the
300 fixup table, and we ultimately need to add a pointer to this into
301 the set vector for SHARABLE_CONFLICTS. At this point we do not
302 know the size of the section, but that's OK - we just need to
303 create it for now. */
305 static bfd_boolean
306 linux_link_create_dynamic_sections (abfd, info)
307 bfd *abfd;
308 struct bfd_link_info *info ATTRIBUTE_UNUSED;
310 flagword flags;
311 register asection *s;
313 /* Note that we set the SEC_IN_MEMORY flag. */
314 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
316 /* We choose to use the name ".linux-dynamic" for the fixup table.
317 Why not? */
318 s = bfd_make_section (abfd, ".linux-dynamic");
319 if (s == NULL
320 || ! bfd_set_section_flags (abfd, s, flags)
321 || ! bfd_set_section_alignment (abfd, s, 2))
322 return FALSE;
323 s->_raw_size = 0;
324 s->contents = 0;
326 return TRUE;
329 /* Function to add a single symbol to the linker hash table. This is
330 a wrapper around _bfd_generic_link_add_one_symbol which handles the
331 tweaking needed for dynamic linking support. */
333 static bfd_boolean
334 linux_add_one_symbol (info, abfd, name, flags, section, value, string,
335 copy, collect, hashp)
336 struct bfd_link_info *info;
337 bfd *abfd;
338 const char *name;
339 flagword flags;
340 asection *section;
341 bfd_vma value;
342 const char *string;
343 bfd_boolean copy;
344 bfd_boolean collect;
345 struct bfd_link_hash_entry **hashp;
347 struct linux_link_hash_entry *h;
348 bfd_boolean insert;
350 /* Look up and see if we already have this symbol in the hash table.
351 If we do, and the defining entry is from a shared library, we
352 need to create the dynamic sections.
354 FIXME: What if abfd->xvec != info->hash->creator? We may want to
355 be able to link Linux a.out and ELF objects together, but serious
356 confusion is possible. */
358 insert = FALSE;
360 if (! info->relocatable
361 && linux_hash_table (info)->dynobj == NULL
362 && strcmp (name, SHARABLE_CONFLICTS) == 0
363 && (flags & BSF_CONSTRUCTOR) != 0
364 && abfd->xvec == info->hash->creator)
366 if (! linux_link_create_dynamic_sections (abfd, info))
367 return FALSE;
368 linux_hash_table (info)->dynobj = abfd;
369 insert = TRUE;
372 if (bfd_is_abs_section (section)
373 && abfd->xvec == info->hash->creator)
375 h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
376 FALSE, FALSE);
377 if (h != NULL
378 && (h->root.root.type == bfd_link_hash_defined
379 || h->root.root.type == bfd_link_hash_defweak))
381 struct fixup *f;
383 if (hashp != NULL)
384 *hashp = (struct bfd_link_hash_entry *) h;
386 f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
387 if (f == NULL)
388 return FALSE;
389 f->jump = IS_PLT_SYM (name);
391 return TRUE;
395 /* Do the usual procedure for adding a symbol. */
396 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
397 value, string, copy, collect,
398 hashp))
399 return FALSE;
401 /* Insert a pointer to our table in the set vector. The dynamic
402 linker requires this information */
403 if (insert)
405 asection *s;
407 /* Here we do our special thing to add the pointer to the
408 dynamic section in the SHARABLE_CONFLICTS set vector. */
409 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
410 ".linux-dynamic");
411 BFD_ASSERT (s != NULL);
413 if (! (_bfd_generic_link_add_one_symbol
414 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
415 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
416 FALSE, FALSE, NULL)))
417 return FALSE;
420 return TRUE;
423 /* We will crawl the hash table and come here for every global symbol.
424 We will examine each entry and see if there are indications that we
425 need to add a fixup. There are two possible cases - one is where
426 you have duplicate definitions of PLT or GOT symbols - these will
427 have already been caught and added as "builtin" fixups. If we find
428 that the corresponding non PLT/GOT symbol is also present, we
429 convert it to a regular fixup instead.
431 This function is called via linux_link_hash_traverse. */
433 static bfd_boolean
434 linux_tally_symbols (h, data)
435 struct linux_link_hash_entry *h;
436 PTR data;
438 struct bfd_link_info *info = (struct bfd_link_info *) data;
439 struct fixup *f, *f1;
440 int is_plt;
441 struct linux_link_hash_entry *h1, *h2;
442 bfd_boolean exists;
444 if (h->root.root.type == bfd_link_hash_warning)
445 h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
447 if (h->root.root.type == bfd_link_hash_undefined
448 && strncmp (h->root.root.root.string, NEEDS_SHRLIB,
449 sizeof NEEDS_SHRLIB - 1) == 0)
451 const char *name;
452 char *p;
453 char *alloc = NULL;
455 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
456 p = strrchr (name, '_');
457 if (p != NULL)
458 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
460 if (p == NULL || alloc == NULL)
461 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
462 name);
463 else
465 strcpy (alloc, name);
466 p = strrchr (alloc, '_');
467 *p++ = '\0';
468 (*_bfd_error_handler)
469 (_("Output file requires shared library `%s.so.%s'\n"),
470 alloc, p);
471 free (alloc);
474 abort ();
477 /* If this symbol is not a PLT/GOT, we do not even need to look at it */
478 is_plt = IS_PLT_SYM (h->root.root.root.string);
480 if (is_plt || IS_GOT_SYM (h->root.root.root.string))
482 /* Look up this symbol twice. Once just as a regular lookup,
483 and then again following all of the indirect links until we
484 reach a real symbol. */
485 h1 = linux_link_hash_lookup (linux_hash_table (info),
486 (h->root.root.root.string
487 + sizeof PLT_REF_PREFIX - 1),
488 FALSE, FALSE, TRUE);
489 /* h2 does not follow indirect symbols. */
490 h2 = linux_link_hash_lookup (linux_hash_table (info),
491 (h->root.root.root.string
492 + sizeof PLT_REF_PREFIX - 1),
493 FALSE, FALSE, FALSE);
495 /* The real symbol must exist but if it is also an ABS symbol,
496 there is no need to have a fixup. This is because they both
497 came from the same library. If on the other hand, we had to
498 use an indirect symbol to get to the real symbol, we add the
499 fixup anyway, since there are cases where these symbols come
500 from different shared libraries */
501 if (h1 != NULL
502 && (((h1->root.root.type == bfd_link_hash_defined
503 || h1->root.root.type == bfd_link_hash_defweak)
504 && ! bfd_is_abs_section (h1->root.root.u.def.section))
505 || h2->root.root.type == bfd_link_hash_indirect))
507 /* See if there is a "builtin" fixup already present
508 involving this symbol. If so, convert it to a regular
509 fixup. In the end, this relaxes some of the requirements
510 about the order of performing fixups. */
511 exists = FALSE;
512 for (f1 = linux_hash_table (info)->fixup_list;
513 f1 != NULL;
514 f1 = f1->next)
516 if ((f1->h != h && f1->h != h1)
517 || (! f1->builtin && ! f1->jump))
518 continue;
519 if (f1->h == h1)
520 exists = TRUE;
521 if (! exists
522 && bfd_is_abs_section (h->root.root.u.def.section))
524 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
525 f->jump = is_plt;
527 f1->h = h1;
528 f1->jump = is_plt;
529 f1->builtin = 0;
530 exists = TRUE;
532 if (! exists
533 && bfd_is_abs_section (h->root.root.u.def.section))
535 f = new_fixup (info, h1, h->root.root.u.def.value, 0);
536 if (f == NULL)
538 /* FIXME: No way to return error. */
539 abort ();
541 f->jump = is_plt;
545 /* Quick and dirty way of stripping these symbols from the
546 symtab. */
547 if (bfd_is_abs_section (h->root.root.u.def.section))
548 h->root.written = TRUE;
551 return TRUE;
554 /* This is called to set the size of the .linux-dynamic section is.
555 It is called by the Linux linker emulation before_allocation
556 routine. We have finished reading all of the input files, and now
557 we just scan the hash tables to find out how many additional fixups
558 are required. */
560 bfd_boolean
561 bfd_m68klinux_size_dynamic_sections (output_bfd, info)
562 bfd *output_bfd;
563 struct bfd_link_info *info;
565 struct fixup *f;
566 asection *s;
568 if (output_bfd->xvec != &MY(vec))
569 return TRUE;
571 /* First find the fixups... */
572 linux_link_hash_traverse (linux_hash_table (info),
573 linux_tally_symbols,
574 (PTR) info);
576 /* If there are builtin fixups, leave room for a marker. This is
577 used by the dynamic linker so that it knows that all that follow
578 are builtin fixups instead of regular fixups. */
579 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
581 if (f->builtin)
583 ++linux_hash_table (info)->fixup_count;
584 ++linux_hash_table (info)->local_builtins;
585 break;
589 if (linux_hash_table (info)->dynobj == NULL)
591 if (linux_hash_table (info)->fixup_count > 0)
592 abort ();
593 return TRUE;
596 /* Allocate memory for our fixup table. We will fill it in later. */
597 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
598 ".linux-dynamic");
599 if (s != NULL)
601 s->_raw_size = linux_hash_table (info)->fixup_count + 1;
602 s->_raw_size *= 8;
603 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
604 if (s->contents == NULL)
606 bfd_set_error (bfd_error_no_memory);
607 return FALSE;
611 return TRUE;
614 /* We come here once we are ready to actually write the fixup table to
615 the output file. Scan the fixup tables and so forth and generate
616 the stuff we need. */
618 static bfd_boolean
619 linux_finish_dynamic_link (output_bfd, info)
620 bfd *output_bfd;
621 struct bfd_link_info *info;
623 asection *s, *os, *is;
624 bfd_byte *fixup_table;
625 struct linux_link_hash_entry *h;
626 struct fixup *f;
627 unsigned int new_addr;
628 int section_offset;
629 unsigned int fixups_written;
631 if (linux_hash_table (info)->dynobj == NULL)
632 return TRUE;
634 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
635 ".linux-dynamic");
636 BFD_ASSERT (s != NULL);
637 os = s->output_section;
638 fixups_written = 0;
640 #ifdef LINUX_LINK_DEBUG
641 printf ("Fixup table file offset: %x VMA: %x\n",
642 os->filepos + s->output_offset,
643 os->vma + s->output_offset);
644 #endif
646 fixup_table = s->contents;
647 bfd_put_32 (output_bfd, (bfd_vma) linux_hash_table (info)->fixup_count,
648 fixup_table);
649 fixup_table += 4;
651 /* Fill in fixup table. */
652 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
654 if (f->builtin)
655 continue;
657 if (f->h->root.root.type != bfd_link_hash_defined
658 && f->h->root.root.type != bfd_link_hash_defweak)
660 (*_bfd_error_handler)
661 (_("Symbol %s not defined for fixups\n"),
662 f->h->root.root.root.string);
663 continue;
666 is = f->h->root.root.u.def.section;
667 section_offset = is->output_section->vma + is->output_offset;
668 new_addr = f->h->root.root.u.def.value + section_offset;
670 #ifdef LINUX_LINK_DEBUG
671 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
672 new_addr, f->value);
673 #endif
675 if (f->jump)
677 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
678 fixup_table += 4;
679 bfd_put_32 (output_bfd, f->value + 2, fixup_table);
680 fixup_table += 4;
682 else
684 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
685 fixup_table += 4;
686 bfd_put_32 (output_bfd, f->value, fixup_table);
687 fixup_table += 4;
689 ++fixups_written;
692 if (linux_hash_table (info)->local_builtins != 0)
694 /* Special marker so we know to switch to the other type of fixup */
695 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
696 fixup_table += 4;
697 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
698 fixup_table += 4;
699 ++fixups_written;
700 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
702 if (! f->builtin)
703 continue;
705 if (f->h->root.root.type != bfd_link_hash_defined
706 && f->h->root.root.type != bfd_link_hash_defweak)
708 (*_bfd_error_handler)
709 (_("Symbol %s not defined for fixups\n"),
710 f->h->root.root.root.string);
711 continue;
714 is = f->h->root.root.u.def.section;
715 section_offset = is->output_section->vma + is->output_offset;
716 new_addr = f->h->root.root.u.def.value + section_offset;
718 #ifdef LINUX_LINK_DEBUG
719 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
720 new_addr, f->value);
721 #endif
723 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
724 fixup_table += 4;
725 bfd_put_32 (output_bfd, f->value, fixup_table);
726 fixup_table += 4;
727 ++fixups_written;
731 if (linux_hash_table (info)->fixup_count != fixups_written)
733 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
734 while (linux_hash_table (info)->fixup_count > fixups_written)
736 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
737 fixup_table += 4;
738 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
739 fixup_table += 4;
740 ++fixups_written;
744 h = linux_link_hash_lookup (linux_hash_table (info),
745 "__BUILTIN_FIXUPS__",
746 FALSE, FALSE, FALSE);
748 if (h != NULL
749 && (h->root.root.type == bfd_link_hash_defined
750 || h->root.root.type == bfd_link_hash_defweak))
752 is = h->root.root.u.def.section;
753 section_offset = is->output_section->vma + is->output_offset;
754 new_addr = h->root.root.u.def.value + section_offset;
756 #ifdef LINUX_LINK_DEBUG
757 printf ("Builtin fixup table at %x\n", new_addr);
758 #endif
760 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
762 else
763 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
765 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
766 SEEK_SET) != 0)
767 return FALSE;
769 if (bfd_bwrite ((PTR) s->contents, s->_raw_size, output_bfd) != s->_raw_size)
770 return FALSE;
772 return TRUE;
775 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
776 #define MY_add_one_symbol linux_add_one_symbol
777 #define MY_finish_dynamic_link linux_finish_dynamic_link
779 #define MY_zmagic_contiguous 1
781 #include "aout-target.h"