1 /* BFD back-end for linux flavored i386 a.out binaries.
2 Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
9 (at your option) any later version.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 #define PAGE_SIZE 4096
21 #define ZMAGIC_DISK_BLOCK_SIZE 1024
22 #define SEGMENT_SIZE 4096
23 #define TEXT_START_ADDR 0x0
24 #define N_SHARED_LIB(x) 0
25 #define BYTES_IN_WORD 4
30 #include "aout/aout64.h"
31 #include "aout/stab_gnu.h"
33 #include "libaout.h" /* BFD a.out internal data structures */
35 #define DEFAULT_ARCH bfd_arch_i386
36 #define MY(OP) CAT(i386linux_,OP)
37 #define TARGETNAME "a.out-i386-linux"
39 /* We always generate QMAGIC files in preference to ZMAGIC files. It
40 would be possible to make this a linker option, if that ever
43 static void MY_final_link_callback
44 PARAMS ((bfd
*, file_ptr
*, file_ptr
*, file_ptr
*));
47 i386linux_bfd_final_link (abfd
, info
)
49 struct bfd_link_info
*info
;
51 obj_aout_subformat (abfd
) = q_magic_format
;
52 return NAME(aout
,final_link
) (abfd
, info
, MY_final_link_callback
);
55 #define MY_bfd_final_link i386linux_bfd_final_link
57 /* Set the machine type correctly. */
60 i386linux_write_object_contents (abfd
)
63 struct external_exec exec_bytes
;
64 struct internal_exec
*execp
= exec_hdr (abfd
);
66 N_SET_MACHTYPE (*execp
, M_386
);
68 obj_reloc_entry_size (abfd
) = RELOC_STD_SIZE
;
70 WRITE_HEADERS(abfd
, execp
);
75 #define MY_write_object_contents i386linux_write_object_contents
77 /* Code to link against Linux a.out shared libraries. */
79 /* See if a symbol name is a reference to the global offset table. */
81 #ifndef GOT_REF_PREFIX
82 #define GOT_REF_PREFIX "__GOT_"
85 #define IS_GOT_SYM(name) \
86 (strncmp (name, GOT_REF_PREFIX, sizeof GOT_REF_PREFIX - 1) == 0)
88 /* See if a symbol name is a reference to the procedure linkage table. */
90 #ifndef PLT_REF_PREFIX
91 #define PLT_REF_PREFIX "__PLT_"
94 #define IS_PLT_SYM(name) \
95 (strncmp (name, PLT_REF_PREFIX, sizeof PLT_REF_PREFIX - 1) == 0)
97 /* This string is used to generate specialized error messages. */
100 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
103 /* This special symbol is a set vector that contains a list of
104 pointers to fixup tables. It will be present in any dynamicly
105 linked file. The linker generated fixup table should also be added
106 to the list, and it should always appear in the second slot (the
107 first one is a dummy with a magic number that is defined in
110 #ifndef SHARABLE_CONFLICTS
111 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
114 /* We keep a list of fixups. The terminology is a bit strange, but
115 each fixup contains two 32 bit numbers. A regular fixup contains
116 an address and a pointer, and at runtime we should store the
117 address at the location pointed to by the pointer. A builtin fixup
118 contains two pointers, and we should read the address using one
119 pointer and store it at the location pointed to by the other
120 pointer. Builtin fixups come into play when we have duplicate
121 __GOT__ symbols for the same variable. The builtin fixup will copy
122 the GOT pointer from one over into the other. */
127 struct linux_link_hash_entry
*h
;
130 /* Nonzero if this is a jump instruction that needs to be fixed,
131 zero if this is just a pointer */
137 /* We don't need a special hash table entry structure, but we do need
138 to keep some information between linker passes, so we use a special
141 struct linux_link_hash_entry
143 struct aout_link_hash_entry root
;
146 struct linux_link_hash_table
148 struct aout_link_hash_table root
;
150 /* First dynamic object found in link. */
153 /* Number of fixups. */
156 /* Number of builtin fixups. */
157 size_t local_builtins
;
159 /* List of fixups. */
160 struct fixup
*fixup_list
;
163 static struct bfd_hash_entry
*linux_link_hash_newfunc
164 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
165 static struct bfd_link_hash_table
*linux_link_hash_table_create
167 static struct fixup
*new_fixup
168 PARAMS ((struct bfd_link_info
*, struct linux_link_hash_entry
*,
170 static boolean linux_link_create_dynamic_sections
171 PARAMS ((bfd
*, struct bfd_link_info
*));
172 static boolean linux_add_one_symbol
173 PARAMS ((struct bfd_link_info
*, bfd
*, const char *, flagword
, asection
*,
174 bfd_vma
, const char *, boolean
, boolean
,
175 struct bfd_link_hash_entry
**));
176 static boolean linux_tally_symbols
177 PARAMS ((struct linux_link_hash_entry
*, PTR
));
178 static boolean linux_finish_dynamic_link
179 PARAMS ((bfd
*, struct bfd_link_info
*));
181 /* Routine to create an entry in an Linux link hash table. */
183 static struct bfd_hash_entry
*
184 linux_link_hash_newfunc (entry
, table
, string
)
185 struct bfd_hash_entry
*entry
;
186 struct bfd_hash_table
*table
;
189 struct linux_link_hash_entry
*ret
= (struct linux_link_hash_entry
*) entry
;
191 /* Allocate the structure if it has not already been allocated by a
193 if (ret
== (struct linux_link_hash_entry
*) NULL
)
194 ret
= ((struct linux_link_hash_entry
*)
195 bfd_hash_allocate (table
, sizeof (struct linux_link_hash_entry
)));
197 return (struct bfd_hash_entry
*) ret
;
199 /* Call the allocation method of the superclass. */
200 ret
= ((struct linux_link_hash_entry
*)
201 NAME(aout
,link_hash_newfunc
) ((struct bfd_hash_entry
*) ret
,
205 /* Set local fields; there aren't any. */
208 return (struct bfd_hash_entry
*) ret
;
211 /* Create a Linux link hash table. */
213 static struct bfd_link_hash_table
*
214 linux_link_hash_table_create (abfd
)
217 struct linux_link_hash_table
*ret
;
219 ret
= ((struct linux_link_hash_table
*)
220 malloc (sizeof (struct linux_link_hash_table
)));
221 if (ret
== (struct linux_link_hash_table
*) NULL
)
223 bfd_set_error (bfd_error_no_memory
);
224 return (struct bfd_link_hash_table
*) NULL
;
226 if (! NAME(aout
,link_hash_table_init
) (&ret
->root
, abfd
,
227 linux_link_hash_newfunc
))
230 return (struct bfd_link_hash_table
*) NULL
;
234 ret
->fixup_count
= 0;
235 ret
->local_builtins
= 0;
236 ret
->fixup_list
= NULL
;
238 return &ret
->root
.root
;
241 /* Look up an entry in a Linux link hash table. */
243 #define linux_link_hash_lookup(table, string, create, copy, follow) \
244 ((struct linux_link_hash_entry *) \
245 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
248 /* Traverse a Linux link hash table. */
250 #define linux_link_hash_traverse(table, func, info) \
251 (aout_link_hash_traverse \
253 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
256 /* Get the Linux link hash table from the info structure. This is
259 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
261 /* Store the information for a new fixup. */
263 static struct fixup
*
264 new_fixup (info
, h
, value
, builtin
)
265 struct bfd_link_info
*info
;
266 struct linux_link_hash_entry
*h
;
272 f
= (struct fixup
*) bfd_hash_allocate (&info
->hash
->table
,
273 sizeof (struct fixup
));
276 f
->next
= linux_hash_table (info
)->fixup_list
;
277 linux_hash_table (info
)->fixup_list
= f
;
280 f
->builtin
= builtin
;
282 ++linux_hash_table (info
)->fixup_count
;
286 /* We come here once we realize that we are going to link to a shared
287 library. We need to create a special section that contains the
288 fixup table, and we ultimately need to add a pointer to this into
289 the set vector for SHARABLE_CONFLICTS. At this point we do not
290 know the size of the section, but that's OK - we just need to
291 create it for now. */
294 linux_link_create_dynamic_sections (abfd
, info
)
296 struct bfd_link_info
*info
;
299 register asection
*s
;
301 /* Note that we set the SEC_IN_MEMORY flag. */
302 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
304 /* We choose to use the name ".linux-dynamic" for the fixup table.
306 s
= bfd_make_section (abfd
, ".linux-dynamic");
308 || ! bfd_set_section_flags (abfd
, s
, flags
)
309 || ! bfd_set_section_alignment (abfd
, s
, 2))
317 /* Function to add a single symbol to the linker hash table. This is
318 a wrapper around _bfd_generic_link_add_one_symbol which handles the
319 tweaking needed for dynamic linking support. */
322 linux_add_one_symbol (info
, abfd
, name
, flags
, section
, value
, string
,
323 copy
, collect
, hashp
)
324 struct bfd_link_info
*info
;
333 struct bfd_link_hash_entry
**hashp
;
335 struct linux_link_hash_entry
*h
;
338 /* Look up and see if we already have this symbol in the hash table.
339 If we do, and the defining entry is from a shared library, we
340 need to create the dynamic sections.
342 FIXME: What if abfd->xvec != info->hash->creator? We may want to
343 be able to link Linux a.out and ELF objects together, but serious
344 confusion is possible. */
348 if (! info
->relocateable
349 && linux_hash_table (info
)->dynobj
== NULL
350 && strcmp (name
, SHARABLE_CONFLICTS
) == 0
351 && (flags
& BSF_CONSTRUCTOR
) != 0
352 && abfd
->xvec
== info
->hash
->creator
)
354 if (! linux_link_create_dynamic_sections (abfd
, info
))
356 linux_hash_table (info
)->dynobj
= abfd
;
360 if (bfd_is_abs_section (section
)
361 && abfd
->xvec
== info
->hash
->creator
)
363 h
= linux_link_hash_lookup (linux_hash_table (info
), name
, false,
366 && (h
->root
.root
.type
== bfd_link_hash_defined
367 || h
->root
.root
.type
== bfd_link_hash_defweak
))
372 *hashp
= (struct bfd_link_hash_entry
*) h
;
374 f
= new_fixup (info
, h
, value
, ! IS_PLT_SYM (name
));
377 f
->jump
= IS_PLT_SYM (name
);
383 /* Do the usual procedure for adding a symbol. */
384 if (! _bfd_generic_link_add_one_symbol (info
, abfd
, name
, flags
, section
,
385 value
, string
, copy
, collect
,
389 /* Insert a pointer to our table in the set vector. The dynamic
390 linker requires this information */
395 /* Here we do our special thing to add the pointer to the
396 dynamic section in the SHARABLE_CONFLICTS set vector. */
397 s
= bfd_get_section_by_name (linux_hash_table (info
)->dynobj
,
399 BFD_ASSERT (s
!= NULL
);
401 if (! (_bfd_generic_link_add_one_symbol
402 (info
, linux_hash_table (info
)->dynobj
, SHARABLE_CONFLICTS
,
403 BSF_GLOBAL
| BSF_CONSTRUCTOR
, s
, 0, NULL
, false, false, NULL
)))
410 /* We will crawl the hash table and come here for every global symbol.
411 We will examine each entry and see if there are indications that we
412 need to add a fixup. There are two possible cases - one is where
413 you have duplicate definitions of PLT or GOT symbols - these will
414 have already been caught and added as "builtin" fixups. If we find
415 that the corresponding non PLT/GOT symbol is also present, we
416 convert it to a regular fixup instead.
418 This function is called via linux_link_hash_traverse. */
421 linux_tally_symbols (h
, data
)
422 struct linux_link_hash_entry
*h
;
425 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
426 struct fixup
*f
, *f1
;
428 struct linux_link_hash_entry
*h1
, *h2
;
431 if (h
->root
.root
.type
== bfd_link_hash_undefined
432 && strncmp (h
->root
.root
.root
.string
, NEEDS_SHRLIB
,
433 sizeof NEEDS_SHRLIB
- 1) == 0)
439 name
= h
->root
.root
.root
.string
+ sizeof NEEDS_SHRLIB
- 1;
440 p
= strrchr (name
, '_');
442 alloc
= (char *) malloc (strlen (name
) + 1);
444 /* FIXME! BFD should not call printf! */
445 if (p
== NULL
|| alloc
== NULL
)
446 fprintf (stderr
, "Output file requires shared library `%s'\n", name
);
449 strcpy (alloc
, name
);
450 p
= strrchr (alloc
, '_');
453 "Output file requires shared library `%s.so.%s'\n",
461 /* If this symbol is not a PLT/GOT, we do not even need to look at it */
462 is_plt
= IS_PLT_SYM (h
->root
.root
.root
.string
);
464 if (is_plt
|| IS_GOT_SYM (h
->root
.root
.root
.string
))
466 /* Look up this symbol twice. Once just as a regular lookup,
467 and then again following all of the indirect links until we
468 reach a real symbol. */
469 h1
= linux_link_hash_lookup (linux_hash_table (info
),
470 (h
->root
.root
.root
.string
471 + sizeof PLT_REF_PREFIX
- 1),
473 /* h2 does not follow indirect symbols. */
474 h2
= linux_link_hash_lookup (linux_hash_table (info
),
475 (h
->root
.root
.root
.string
476 + sizeof PLT_REF_PREFIX
- 1),
477 false, false, false);
479 /* The real symbol must exist but if it is also an ABS symbol,
480 there is no need to have a fixup. This is because they both
481 came from the same library. If on the other hand, we had to
482 use an indirect symbol to get to the real symbol, we add the
483 fixup anyway, since there are cases where these symbols come
484 from different shared libraries */
486 && (((h1
->root
.root
.type
== bfd_link_hash_defined
487 || h1
->root
.root
.type
== bfd_link_hash_defweak
)
488 && ! bfd_is_abs_section (h1
->root
.root
.u
.def
.section
))
489 || h2
->root
.root
.type
== bfd_link_hash_indirect
))
491 /* See if there is a "builtin" fixup already present
492 involving this symbol. If so, convert it to a regular
493 fixup. In the end, this relaxes some of the requirements
494 about the order of performing fixups. */
496 for (f1
= linux_hash_table (info
)->fixup_list
;
500 if ((f1
->h
!= h
&& f1
->h
!= h1
)
501 || (! f1
->builtin
&& ! f1
->jump
))
506 && bfd_is_abs_section (h
->root
.root
.u
.def
.section
))
508 f
= new_fixup (info
, h1
, f1
->h
->root
.root
.u
.def
.value
, 0);
517 && bfd_is_abs_section (h
->root
.root
.u
.def
.section
))
519 f
= new_fixup (info
, h1
, h
->root
.root
.u
.def
.value
, 0);
522 /* FIXME: No way to return error. */
529 /* Quick and dirty way of stripping these symbols from the
531 if (bfd_is_abs_section (h
->root
.root
.u
.def
.section
))
532 h
->root
.written
= true;
538 /* This is called to set the size of the .linux-dynamic section is.
539 It is called by the Linux linker emulation before_allocation
540 routine. We have finished reading all of the input files, and now
541 we just scan the hash tables to find out how many additional fixups
545 bfd_linux_size_dynamic_sections (output_bfd
, info
)
547 struct bfd_link_info
*info
;
552 /* First find the fixups... */
553 linux_link_hash_traverse (linux_hash_table (info
),
557 /* If there are builtin fixups, leave room for a marker. This is
558 used by the dynamic linker so that it knows that all that follow
559 are builtin fixups instead of regular fixups. */
560 for (f
= linux_hash_table (info
)->fixup_list
; f
!= NULL
; f
= f
->next
)
564 ++linux_hash_table (info
)->fixup_count
;
565 ++linux_hash_table (info
)->local_builtins
;
570 if (linux_hash_table (info
)->dynobj
== NULL
)
572 if (linux_hash_table (info
)->fixup_count
> 0)
577 /* Allocate memory for our fixup table. We will fill it in later. */
578 s
= bfd_get_section_by_name (linux_hash_table (info
)->dynobj
,
582 s
->_raw_size
= 8 + linux_hash_table (info
)->fixup_count
* 8;
583 s
->contents
= (bfd_byte
*) bfd_alloc (output_bfd
, s
->_raw_size
);
584 if (s
->contents
== NULL
)
586 bfd_set_error (bfd_error_no_memory
);
589 memset (s
->contents
, 0, s
->_raw_size
);
595 /* We come here once we are ready to actually write the fixup table to
596 the output file. Scan the fixup tables and so forth and generate
597 the stuff we need. */
600 linux_finish_dynamic_link (output_bfd
, info
)
602 struct bfd_link_info
*info
;
604 asection
*s
, *os
, *is
;
605 bfd_byte
*fixup_table
;
606 struct linux_link_hash_entry
*h
;
608 unsigned int new_addr
;
612 if (linux_hash_table (info
)->dynobj
== NULL
)
615 s
= bfd_get_section_by_name (linux_hash_table (info
)->dynobj
,
617 BFD_ASSERT (s
!= NULL
);
618 os
= s
->output_section
;
621 #ifdef LINUX_LINK_DEBUG
622 printf ("Fixup table file offset: %x VMA: %x\n",
623 os
->filepos
+ s
->output_offset
,
624 os
->vma
+ s
->output_offset
);
627 fixup_table
= s
->contents
;
628 bfd_put_32 (output_bfd
, linux_hash_table (info
)->fixup_count
, fixup_table
);
631 /* Fill in fixup table. */
632 for (f
= linux_hash_table (info
)->fixup_list
; f
!= NULL
; f
= f
->next
)
637 if (f
->h
->root
.root
.type
!= bfd_link_hash_defined
638 && f
->h
->root
.root
.type
!= bfd_link_hash_defweak
)
642 "Symbol %s not defined for fixups\n",
643 f
->h
->root
.root
.root
.string
);
647 is
= f
->h
->root
.root
.u
.def
.section
;
648 section_offset
= is
->output_section
->vma
+ is
->output_offset
;
649 new_addr
= f
->h
->root
.root
.u
.def
.value
+ section_offset
;
651 #ifdef LINUX_LINK_DEBUG
652 printf ("Fixup(%d) %s: %x %x\n",f
->jump
, f
->h
->root
.root
.string
,
658 /* Relative address */
659 new_addr
= new_addr
- (f
->value
+ 5);
660 bfd_put_32 (output_bfd
, new_addr
, fixup_table
);
662 bfd_put_32 (output_bfd
, f
->value
+ 1, fixup_table
);
667 bfd_put_32 (output_bfd
, new_addr
, fixup_table
);
669 bfd_put_32 (output_bfd
, f
->value
, fixup_table
);
675 if (linux_hash_table (info
)->local_builtins
!= 0)
677 /* Special marker so we know to switch to the other type of fixup */
678 bfd_put_32 (output_bfd
, 0, fixup_table
);
680 bfd_put_32 (output_bfd
, 0, fixup_table
);
683 for (f
= linux_hash_table (info
)->fixup_list
; f
!= NULL
; f
= f
->next
)
688 if (f
->h
->root
.root
.type
!= bfd_link_hash_defined
689 && f
->h
->root
.root
.type
!= bfd_link_hash_defweak
)
693 "Symbol %s not defined for fixups\n",
694 f
->h
->root
.root
.root
.string
);
698 is
= f
->h
->root
.root
.u
.def
.section
;
699 section_offset
= is
->output_section
->vma
+ is
->output_offset
;
700 new_addr
= f
->h
->root
.root
.u
.def
.value
+ section_offset
;
702 #ifdef LINUX_LINK_DEBUG
703 printf ("Fixup(B) %s: %x %x\n", f
->h
->root
.root
.string
,
707 bfd_put_32 (output_bfd
, new_addr
, fixup_table
);
709 bfd_put_32 (output_bfd
, f
->value
, fixup_table
);
715 if (linux_hash_table (info
)->fixup_count
!= fixups_written
)
718 fprintf (stderr
, "Warning: fixup count mismatch\n");
719 while (linux_hash_table (info
)->fixup_count
> fixups_written
)
721 bfd_put_32 (output_bfd
, 0, fixup_table
);
723 bfd_put_32 (output_bfd
, 0, fixup_table
);
729 h
= linux_link_hash_lookup (linux_hash_table (info
),
730 "__BUILTIN_FIXUPS__",
731 false, false, false);
734 && (h
->root
.root
.type
== bfd_link_hash_defined
735 || h
->root
.root
.type
== bfd_link_hash_defweak
))
737 is
= h
->root
.root
.u
.def
.section
;
738 section_offset
= is
->output_section
->vma
+ is
->output_offset
;
739 new_addr
= h
->root
.root
.u
.def
.value
+ section_offset
;
741 #ifdef LINUX_LINK_DEBUG
742 printf ("Builtin fixup table at %x\n", new_addr
);
745 bfd_put_32 (output_bfd
, new_addr
, fixup_table
);
748 bfd_put_32 (output_bfd
, 0, fixup_table
);
750 if (bfd_seek (output_bfd
, os
->filepos
+ s
->output_offset
, SEEK_SET
) != 0)
753 if (bfd_write ((PTR
) s
->contents
, 1, s
->_raw_size
, output_bfd
)
760 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
761 #define MY_add_one_symbol linux_add_one_symbol
762 #define MY_finish_dynamic_link linux_finish_dynamic_link
764 #define MY_zmagic_contiguous 1
766 #include "aout-target.h"