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