daily update
[binutils.git] / bfd / sparclinux.c
blobd8659eec16ba67a82aa2b7dab46da2138b8459b8
1 /* BFD back-end for linux flavored sparc a.out binaries.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
3 2003, 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,
20 USA. */
22 #define TARGET_PAGE_SIZE 4096
23 #define ZMAGIC_DISK_BLOCK_SIZE 1024
24 #define SEGMENT_SIZE TARGET_PAGE_SIZE
25 #define TEXT_START_ADDR 0x0
26 #define N_SHARED_LIB(x) 0
28 #define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN)
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "libbfd.h"
33 #include "aout/aout64.h"
34 #include "aout/stab_gnu.h"
35 #include "aout/ar.h"
36 #include "libaout.h" /* BFD a.out internal data structures */
38 #define DEFAULT_ARCH bfd_arch_sparc
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 (sparclinux_,OP)
43 #define TARGETNAME "a.out-sparc-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 *));
54 static bfd_boolean sparclinux_bfd_final_link
55 PARAMS ((bfd *abfd, struct bfd_link_info *info));
57 static bfd_boolean
58 sparclinux_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 sparclinux_bfd_final_link
68 /* Set the machine type correctly. */
70 static bfd_boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
72 static bfd_boolean
73 sparclinux_write_object_contents (abfd)
74 bfd *abfd;
76 struct external_exec exec_bytes;
77 struct internal_exec *execp = exec_hdr (abfd);
79 N_SET_MACHTYPE (*execp, M_SPARC);
81 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
83 WRITE_HEADERS(abfd, execp);
85 return TRUE;
88 #define MY_write_object_contents sparclinux_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)
234 return (struct bfd_link_hash_table *) NULL;
235 if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
236 linux_link_hash_newfunc,
237 sizeof (struct linux_link_hash_entry)))
239 free (ret);
240 return (struct bfd_link_hash_table *) NULL;
243 ret->dynobj = NULL;
244 ret->fixup_count = 0;
245 ret->local_builtins = 0;
246 ret->fixup_list = NULL;
248 return &ret->root.root;
251 /* Look up an entry in a Linux link hash table. */
253 #define linux_link_hash_lookup(table, string, create, copy, follow) \
254 ((struct linux_link_hash_entry *) \
255 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
256 (follow)))
258 /* Traverse a Linux link hash table. */
260 #define linux_link_hash_traverse(table, func, info) \
261 (aout_link_hash_traverse \
262 (&(table)->root, \
263 (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
264 (info)))
266 /* Get the Linux link hash table from the info structure. This is
267 just a cast. */
269 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
271 /* Store the information for a new fixup. */
273 static struct fixup *
274 new_fixup (info, h, value, builtin)
275 struct bfd_link_info *info;
276 struct linux_link_hash_entry *h;
277 bfd_vma value;
278 int builtin;
280 struct fixup *f;
282 f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
283 sizeof (struct fixup));
284 if (f == NULL)
285 return f;
286 f->next = linux_hash_table (info)->fixup_list;
287 linux_hash_table (info)->fixup_list = f;
288 f->h = h;
289 f->value = value;
290 f->builtin = builtin;
291 f->jump = 0;
292 ++linux_hash_table (info)->fixup_count;
293 return f;
296 /* We come here once we realize that we are going to link to a shared
297 library. We need to create a special section that contains the
298 fixup table, and we ultimately need to add a pointer to this into
299 the set vector for SHARABLE_CONFLICTS. At this point we do not
300 know the size of the section, but that's OK - we just need to
301 create it for now. */
303 static bfd_boolean
304 linux_link_create_dynamic_sections (abfd, info)
305 bfd *abfd;
306 struct bfd_link_info *info ATTRIBUTE_UNUSED;
308 flagword flags;
309 register asection *s;
311 /* Note that we set the SEC_IN_MEMORY flag. */
312 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
314 /* We choose to use the name ".linux-dynamic" for the fixup table.
315 Why not? */
316 s = bfd_make_section (abfd, ".linux-dynamic");
317 if (s == NULL
318 || ! bfd_set_section_flags (abfd, s, flags)
319 || ! bfd_set_section_alignment (abfd, s, 2))
320 return FALSE;
321 s->size = 0;
322 s->contents = 0;
324 return TRUE;
327 /* Function to add a single symbol to the linker hash table. This is
328 a wrapper around _bfd_generic_link_add_one_symbol which handles the
329 tweaking needed for dynamic linking support. */
331 static bfd_boolean
332 linux_add_one_symbol (info, abfd, name, flags, section, value, string,
333 copy, collect, hashp)
334 struct bfd_link_info *info;
335 bfd *abfd;
336 const char *name;
337 flagword flags;
338 asection *section;
339 bfd_vma value;
340 const char *string;
341 bfd_boolean copy;
342 bfd_boolean collect;
343 struct bfd_link_hash_entry **hashp;
345 struct linux_link_hash_entry *h;
346 bfd_boolean insert;
348 /* Look up and see if we already have this symbol in the hash table.
349 If we do, and the defining entry is from a shared library, we
350 need to create the dynamic sections.
352 FIXME: What if abfd->xvec != info->hash->creator? We may want to
353 be able to link Linux a.out and ELF objects together, but serious
354 confusion is possible. */
356 insert = FALSE;
358 if (! info->relocatable
359 && linux_hash_table (info)->dynobj == NULL
360 && strcmp (name, SHARABLE_CONFLICTS) == 0
361 && (flags & BSF_CONSTRUCTOR) != 0
362 && abfd->xvec == info->hash->creator)
364 if (! linux_link_create_dynamic_sections (abfd, info))
365 return FALSE;
366 linux_hash_table (info)->dynobj = abfd;
367 insert = TRUE;
370 if (bfd_is_abs_section (section)
371 && abfd->xvec == info->hash->creator)
373 h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
374 FALSE, FALSE);
375 if (h != NULL
376 && (h->root.root.type == bfd_link_hash_defined
377 || h->root.root.type == bfd_link_hash_defweak))
379 struct fixup *f;
381 if (hashp != NULL)
382 *hashp = (struct bfd_link_hash_entry *) h;
384 f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
385 if (f == NULL)
386 return FALSE;
387 f->jump = IS_PLT_SYM (name);
389 return TRUE;
393 /* Do the usual procedure for adding a symbol. */
394 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
395 value, string, copy, collect,
396 hashp))
397 return FALSE;
399 /* Insert a pointer to our table in the set vector. The dynamic
400 linker requires this information. */
401 if (insert)
403 asection *s;
405 /* Here we do our special thing to add the pointer to the
406 dynamic section in the SHARABLE_CONFLICTS set vector. */
407 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
408 ".linux-dynamic");
409 BFD_ASSERT (s != NULL);
411 if (! (_bfd_generic_link_add_one_symbol
412 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
413 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
414 FALSE, FALSE, NULL)))
415 return FALSE;
418 return TRUE;
421 /* We will crawl the hash table and come here for every global symbol.
422 We will examine each entry and see if there are indications that we
423 need to add a fixup. There are two possible cases - one is where
424 you have duplicate definitions of PLT or GOT symbols - these will
425 have already been caught and added as "builtin" fixups. If we find
426 that the corresponding non PLT/GOT symbol is also present, we
427 convert it to a regular fixup instead.
429 This function is called via linux_link_hash_traverse. */
431 static bfd_boolean
432 linux_tally_symbols (h, data)
433 struct linux_link_hash_entry *h;
434 PTR data;
436 struct bfd_link_info *info = (struct bfd_link_info *) data;
437 struct fixup *f, *f1;
438 int is_plt;
439 struct linux_link_hash_entry *h1, *h2;
440 bfd_boolean exists;
442 if (h->root.root.type == bfd_link_hash_warning)
443 h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
445 if (h->root.root.type == bfd_link_hash_undefined
446 && strncmp (h->root.root.root.string, NEEDS_SHRLIB,
447 sizeof NEEDS_SHRLIB - 1) == 0)
449 const char *name;
450 char *p;
451 char *alloc = NULL;
453 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
454 p = strrchr (name, '_');
455 if (p != NULL)
456 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
458 if (p == NULL || alloc == NULL)
459 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
460 name);
461 else
463 strcpy (alloc, name);
464 p = strrchr (alloc, '_');
465 *p++ = '\0';
466 (*_bfd_error_handler)
467 (_("Output file requires shared library `%s.so.%s'\n"),
468 alloc, p);
469 free (alloc);
472 abort ();
475 /* If this symbol is not a PLT/GOT, we do not even need to look at
476 it. */
477 is_plt = IS_PLT_SYM (h->root.root.root.string);
479 if (is_plt || IS_GOT_SYM (h->root.root.root.string))
481 /* Look up this symbol twice. Once just as a regular lookup,
482 and then again following all of the indirect links until we
483 reach a real symbol. */
484 h1 = linux_link_hash_lookup (linux_hash_table (info),
485 (h->root.root.root.string
486 + sizeof PLT_REF_PREFIX - 1),
487 FALSE, FALSE, TRUE);
488 /* h2 does not follow indirect symbols. */
489 h2 = linux_link_hash_lookup (linux_hash_table (info),
490 (h->root.root.root.string
491 + sizeof PLT_REF_PREFIX - 1),
492 FALSE, FALSE, FALSE);
494 /* The real symbol must exist but if it is also an ABS symbol,
495 there is no need to have a fixup. This is because they both
496 came from the same library. If on the other hand, we had to
497 use an indirect symbol to get to the real symbol, we add the
498 fixup anyway, since there are cases where these symbols come
499 from different shared libraries */
500 if (h1 != NULL
501 && (((h1->root.root.type == bfd_link_hash_defined
502 || h1->root.root.type == bfd_link_hash_defweak)
503 && ! bfd_is_abs_section (h1->root.root.u.def.section))
504 || h2->root.root.type == bfd_link_hash_indirect))
506 /* See if there is a "builtin" fixup already present
507 involving this symbol. If so, convert it to a regular
508 fixup. In the end, this relaxes some of the requirements
509 about the order of performing fixups. */
510 exists = FALSE;
511 for (f1 = linux_hash_table (info)->fixup_list;
512 f1 != NULL;
513 f1 = f1->next)
515 if ((f1->h != h && f1->h != h1)
516 || (! f1->builtin && ! f1->jump))
517 continue;
518 if (f1->h == h1)
519 exists = TRUE;
520 if (! exists
521 && bfd_is_abs_section (h->root.root.u.def.section))
523 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
524 f->jump = is_plt;
526 f1->h = h1;
527 f1->jump = is_plt;
528 f1->builtin = 0;
529 exists = TRUE;
531 if (! exists
532 && bfd_is_abs_section (h->root.root.u.def.section))
534 f = new_fixup (info, h1, h->root.root.u.def.value, 0);
535 if (f == NULL)
537 /* FIXME: No way to return error. */
538 abort ();
540 f->jump = is_plt;
544 /* Quick and dirty way of stripping these symbols from the
545 symtab. */
546 if (bfd_is_abs_section (h->root.root.u.def.section))
547 h->root.written = TRUE;
550 return TRUE;
553 /* This is called to set the size of the .linux-dynamic section is.
554 It is called by the Linux linker emulation before_allocation
555 routine. We have finished reading all of the input files, and now
556 we just scan the hash tables to find out how many additional fixups
557 are required. */
559 bfd_boolean
560 bfd_sparclinux_size_dynamic_sections (output_bfd, info)
561 bfd *output_bfd;
562 struct bfd_link_info *info;
564 struct fixup *f;
565 asection *s;
567 if (output_bfd->xvec != &MY(vec))
568 return TRUE;
570 /* First find the fixups... */
571 linux_link_hash_traverse (linux_hash_table (info),
572 linux_tally_symbols,
573 (PTR) info);
575 /* If there are builtin fixups, leave room for a marker. This is
576 used by the dynamic linker so that it knows that all that follow
577 are builtin fixups instead of regular fixups. */
578 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
580 if (f->builtin)
582 ++linux_hash_table (info)->fixup_count;
583 ++linux_hash_table (info)->local_builtins;
584 break;
588 if (linux_hash_table (info)->dynobj == NULL)
590 if (linux_hash_table (info)->fixup_count > 0)
591 abort ();
592 return TRUE;
595 /* Allocate memory for our fixup table. We will fill it in later. */
596 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
597 ".linux-dynamic");
598 if (s != NULL)
600 s->size = linux_hash_table (info)->fixup_count + 1;
601 s->size *= 8;
602 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
603 if (s->contents == NULL)
604 return FALSE;
607 return TRUE;
610 /* We come here once we are ready to actually write the fixup table to
611 the output file. Scan the fixup tables and so forth and generate
612 the stuff we need. */
614 static bfd_boolean
615 linux_finish_dynamic_link (output_bfd, info)
616 bfd *output_bfd;
617 struct bfd_link_info *info;
619 asection *s, *os, *is;
620 bfd_byte *fixup_table;
621 struct linux_link_hash_entry *h;
622 struct fixup *f;
623 unsigned int new_addr;
624 int section_offset;
625 unsigned int fixups_written;
627 if (linux_hash_table (info)->dynobj == NULL)
628 return TRUE;
630 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
631 ".linux-dynamic");
632 BFD_ASSERT (s != NULL);
633 os = s->output_section;
634 fixups_written = 0;
636 #ifdef LINUX_LINK_DEBUG
637 printf ("Fixup table file offset: %x VMA: %x\n",
638 os->filepos + s->output_offset,
639 os->vma + s->output_offset);
640 #endif
642 fixup_table = s->contents;
643 bfd_put_32 (output_bfd,
644 (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
645 fixup_table += 4;
647 /* Fill in fixup table. */
648 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
650 if (f->builtin)
651 continue;
653 if (f->h->root.root.type != bfd_link_hash_defined
654 && f->h->root.root.type != bfd_link_hash_defweak)
656 (*_bfd_error_handler)
657 (_("Symbol %s not defined for fixups\n"),
658 f->h->root.root.root.string);
659 continue;
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;
666 #ifdef LINUX_LINK_DEBUG
667 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
668 new_addr, f->value);
669 #endif
671 if (f->jump)
673 /* Relative address */
674 new_addr = new_addr - (f->value + 5);
675 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
676 fixup_table += 4;
677 bfd_put_32 (output_bfd, f->value + 1, fixup_table);
678 fixup_table += 4;
680 else
682 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
683 fixup_table += 4;
684 bfd_put_32 (output_bfd, f->value, fixup_table);
685 fixup_table += 4;
687 ++fixups_written;
690 if (linux_hash_table (info)->local_builtins != 0)
692 /* Special marker so we know to switch to the other type of fixup */
693 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
694 fixup_table += 4;
695 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
696 fixup_table += 4;
697 ++fixups_written;
698 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
700 if (! f->builtin)
701 continue;
703 if (f->h->root.root.type != bfd_link_hash_defined
704 && f->h->root.root.type != bfd_link_hash_defweak)
706 (*_bfd_error_handler)
707 (_("Symbol %s not defined for fixups\n"),
708 f->h->root.root.root.string);
709 continue;
712 is = f->h->root.root.u.def.section;
713 section_offset = is->output_section->vma + is->output_offset;
714 new_addr = f->h->root.root.u.def.value + section_offset;
716 #ifdef LINUX_LINK_DEBUG
717 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
718 new_addr, f->value);
719 #endif
721 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
722 fixup_table += 4;
723 bfd_put_32 (output_bfd, f->value, fixup_table);
724 fixup_table += 4;
725 ++fixups_written;
729 if (linux_hash_table (info)->fixup_count != fixups_written)
731 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
732 while (linux_hash_table (info)->fixup_count > fixups_written)
734 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
735 fixup_table += 4;
736 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
737 fixup_table += 4;
738 ++fixups_written;
742 h = linux_link_hash_lookup (linux_hash_table (info),
743 "__BUILTIN_FIXUPS__",
744 FALSE, FALSE, FALSE);
746 if (h != NULL
747 && (h->root.root.type == bfd_link_hash_defined
748 || h->root.root.type == bfd_link_hash_defweak))
750 is = h->root.root.u.def.section;
751 section_offset = is->output_section->vma + is->output_offset;
752 new_addr = h->root.root.u.def.value + section_offset;
754 #ifdef LINUX_LINK_DEBUG
755 printf ("Builtin fixup table at %x\n", new_addr);
756 #endif
758 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
760 else
761 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
763 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
764 SEEK_SET) != 0)
765 return FALSE;
767 if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
768 return FALSE;
770 return TRUE;
773 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
774 #define MY_add_one_symbol linux_add_one_symbol
775 #define MY_finish_dynamic_link linux_finish_dynamic_link
777 #define MY_zmagic_contiguous 1
779 #include "aout-target.h"