1 /* BFD back-end for linux flavored sparc a.out binaries.
2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 2000, 2001
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,
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
27 #define BYTES_IN_WORD 4
29 #define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN)
34 #include "aout/aout64.h"
35 #include "aout/stab_gnu.h"
37 #include "libaout.h" /* BFD a.out internal data structures */
39 #define DEFAULT_ARCH bfd_arch_sparc
40 #define MY(OP) CAT(sparclinux_,OP)
41 #define TARGETNAME "a.out-sparc-linux"
43 extern const bfd_target MY(vec);
45 /* We always generate QMAGIC files in preference to ZMAGIC files. It
46 would be possible to make this a linker option, if that ever
49 static void MY_final_link_callback
50 PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
52 static boolean sparclinux_bfd_final_link
53 PARAMS ((bfd *abfd, struct bfd_link_info *info));
56 sparclinux_bfd_final_link (abfd, info)
58 struct bfd_link_info *info;
60 obj_aout_subformat (abfd) = q_magic_format;
61 return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
64 #define MY_bfd_final_link sparclinux_bfd_final_link
66 /* Set the machine type correctly. */
68 static boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
71 sparclinux_write_object_contents (abfd)
74 struct external_exec exec_bytes;
75 struct internal_exec *execp = exec_hdr (abfd);
77 N_SET_MACHTYPE (*execp, M_SPARC);
79 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
81 WRITE_HEADERS(abfd, execp);
86 #define MY_write_object_contents sparclinux_write_object_contents
87 /* Code to link against Linux a.out shared libraries. */
89 /* See if a symbol name is a reference to the global offset table. */
91 #ifndef GOT_REF_PREFIX
92 #define GOT_REF_PREFIX "__GOT_"
95 #define IS_GOT_SYM(name) \
96 (strncmp (name, GOT_REF_PREFIX, sizeof GOT_REF_PREFIX - 1) == 0)
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_"
104 #define IS_PLT_SYM(name) \
105 (strncmp (name, PLT_REF_PREFIX, sizeof PLT_REF_PREFIX - 1) == 0)
107 /* This string is used to generate specialized error messages. */
110 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
113 /* This special symbol is a set vector that contains a list of
114 pointers to fixup tables. It will be present in any dynamicly
115 linked file. The linker generated fixup table should also be added
116 to the list, and it should always appear in the second slot (the
117 first one is a dummy with a magic number that is defined in
120 #ifndef SHARABLE_CONFLICTS
121 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
124 /* We keep a list of fixups. The terminology is a bit strange, but
125 each fixup contains two 32 bit numbers. A regular fixup contains
126 an address and a pointer, and at runtime we should store the
127 address at the location pointed to by the pointer. A builtin fixup
128 contains two pointers, and we should read the address using one
129 pointer and store it at the location pointed to by the other
130 pointer. Builtin fixups come into play when we have duplicate
131 __GOT__ symbols for the same variable. The builtin fixup will copy
132 the GOT pointer from one over into the other. */
137 struct linux_link_hash_entry *h;
140 /* Nonzero if this is a jump instruction that needs to be fixed,
141 zero if this is just a pointer */
147 /* We don't need a special hash table entry structure, but we do need
148 to keep some information between linker passes, so we use a special
151 struct linux_link_hash_entry
153 struct aout_link_hash_entry root;
156 struct linux_link_hash_table
158 struct aout_link_hash_table root;
160 /* First dynamic object found in link. */
163 /* Number of fixups. */
166 /* Number of builtin fixups. */
167 size_t local_builtins;
169 /* List of fixups. */
170 struct fixup *fixup_list;
173 static struct bfd_hash_entry *linux_link_hash_newfunc
174 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
175 static struct bfd_link_hash_table *linux_link_hash_table_create
177 static struct fixup *new_fixup
178 PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
180 static boolean linux_link_create_dynamic_sections
181 PARAMS ((bfd *, struct bfd_link_info *));
182 static boolean linux_add_one_symbol
183 PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
184 bfd_vma, const char *, boolean, boolean,
185 struct bfd_link_hash_entry **));
186 static boolean linux_tally_symbols
187 PARAMS ((struct linux_link_hash_entry *, PTR));
188 static boolean linux_finish_dynamic_link
189 PARAMS ((bfd *, struct bfd_link_info *));
191 /* Routine to create an entry in an Linux link hash table. */
193 static struct bfd_hash_entry *
194 linux_link_hash_newfunc (entry, table, string)
195 struct bfd_hash_entry *entry;
196 struct bfd_hash_table *table;
199 struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
201 /* Allocate the structure if it has not already been allocated by a
203 if (ret == (struct linux_link_hash_entry *) NULL)
204 ret = ((struct linux_link_hash_entry *)
205 bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
207 return (struct bfd_hash_entry *) ret;
209 /* Call the allocation method of the superclass. */
210 ret = ((struct linux_link_hash_entry *)
211 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
215 /* Set local fields; there aren't any. */
218 return (struct bfd_hash_entry *) ret;
221 /* Create a Linux link hash table. */
223 static struct bfd_link_hash_table *
224 linux_link_hash_table_create (abfd)
227 struct linux_link_hash_table *ret;
228 bfd_size_type amt = sizeof (struct linux_link_hash_table);
230 ret = (struct linux_link_hash_table *) bfd_alloc (abfd, amt);
231 if (ret == (struct linux_link_hash_table *) NULL)
232 return (struct bfd_link_hash_table *) NULL;
233 if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
234 linux_link_hash_newfunc))
237 return (struct bfd_link_hash_table *) 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),\
255 /* Traverse a Linux link hash table. */
257 #define linux_link_hash_traverse(table, func, info) \
258 (aout_link_hash_traverse \
260 (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
263 /* Get the Linux link hash table from the info structure. This is
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;
279 f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
280 sizeof (struct fixup));
283 f->next = linux_hash_table (info)->fixup_list;
284 linux_hash_table (info)->fixup_list = f;
287 f->builtin = builtin;
289 ++linux_hash_table (info)->fixup_count;
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. */
301 linux_link_create_dynamic_sections (abfd, info)
303 struct bfd_link_info *info ATTRIBUTE_UNUSED;
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.
313 s = bfd_make_section (abfd, ".linux-dynamic");
315 || ! bfd_set_section_flags (abfd, s, flags)
316 || ! bfd_set_section_alignment (abfd, s, 2))
324 /* Function to add a single symbol to the linker hash table. This is
325 a wrapper around _bfd_generic_link_add_one_symbol which handles the
326 tweaking needed for dynamic linking support. */
329 linux_add_one_symbol (info, abfd, name, flags, section, value, string,
330 copy, collect, hashp)
331 struct bfd_link_info *info;
340 struct bfd_link_hash_entry **hashp;
342 struct linux_link_hash_entry *h;
345 /* Look up and see if we already have this symbol in the hash table.
346 If we do, and the defining entry is from a shared library, we
347 need to create the dynamic sections.
349 FIXME: What if abfd->xvec != info->hash->creator? We may want to
350 be able to link Linux a.out and ELF objects together, but serious
351 confusion is possible. */
355 if (! info->relocateable
356 && linux_hash_table (info)->dynobj == NULL
357 && strcmp (name, SHARABLE_CONFLICTS) == 0
358 && (flags & BSF_CONSTRUCTOR) != 0
359 && abfd->xvec == info->hash->creator)
361 if (! linux_link_create_dynamic_sections (abfd, info))
363 linux_hash_table (info)->dynobj = abfd;
367 if (bfd_is_abs_section (section)
368 && abfd->xvec == info->hash->creator)
370 h = linux_link_hash_lookup (linux_hash_table (info), name, false,
373 && (h->root.root.type == bfd_link_hash_defined
374 || h->root.root.type == bfd_link_hash_defweak))
379 *hashp = (struct bfd_link_hash_entry *) h;
381 f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
384 f->jump = IS_PLT_SYM (name);
390 /* Do the usual procedure for adding a symbol. */
391 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
392 value, string, copy, collect,
396 /* Insert a pointer to our table in the set vector. The dynamic
397 linker requires this information */
402 /* Here we do our special thing to add the pointer to the
403 dynamic section in the SHARABLE_CONFLICTS set vector. */
404 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
406 BFD_ASSERT (s != NULL);
408 if (! (_bfd_generic_link_add_one_symbol
409 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
410 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
411 false, false, NULL)))
418 /* We will crawl the hash table and come here for every global symbol.
419 We will examine each entry and see if there are indications that we
420 need to add a fixup. There are two possible cases - one is where
421 you have duplicate definitions of PLT or GOT symbols - these will
422 have already been caught and added as "builtin" fixups. If we find
423 that the corresponding non PLT/GOT symbol is also present, we
424 convert it to a regular fixup instead.
426 This function is called via linux_link_hash_traverse. */
429 linux_tally_symbols (h, data)
430 struct linux_link_hash_entry *h;
433 struct bfd_link_info *info = (struct bfd_link_info *) data;
434 struct fixup *f, *f1;
436 struct linux_link_hash_entry *h1, *h2;
439 if (h->root.root.type == bfd_link_hash_undefined
440 && strncmp (h->root.root.root.string, NEEDS_SHRLIB,
441 sizeof NEEDS_SHRLIB - 1) == 0)
447 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
448 p = strrchr (name, '_');
450 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
452 if (p == NULL || alloc == NULL)
453 (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
457 strcpy (alloc, name);
458 p = strrchr (alloc, '_');
460 (*_bfd_error_handler)
461 (_("Output file requires shared library `%s.so.%s'\n"),
469 /* If this symbol is not a PLT/GOT, we do not even need to look at
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),
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 */
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. */
505 for (f1 = linux_hash_table (info)->fixup_list;
509 if ((f1->h != h && f1->h != h1)
510 || (! f1->builtin && ! f1->jump))
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);
526 && bfd_is_abs_section (h->root.root.u.def.section))
528 f = new_fixup (info, h1, h->root.root.u.def.value, 0);
531 /* FIXME: No way to return error. */
538 /* Quick and dirty way of stripping these symbols from the
540 if (bfd_is_abs_section (h->root.root.u.def.section))
541 h->root.written = 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
554 bfd_sparclinux_size_dynamic_sections (output_bfd, info)
556 struct bfd_link_info *info;
561 if (output_bfd->xvec != &MY(vec))
564 /* First find the fixups... */
565 linux_link_hash_traverse (linux_hash_table (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)
576 ++linux_hash_table (info)->fixup_count;
577 ++linux_hash_table (info)->local_builtins;
582 if (linux_hash_table (info)->dynobj == NULL)
584 if (linux_hash_table (info)->fixup_count > 0)
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,
594 s->_raw_size = linux_hash_table (info)->fixup_count + 1;
596 s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
597 if (s->contents == NULL)
599 memset (s->contents, 0, (size_t) s->_raw_size);
605 /* We come here once we are ready to actually write the fixup table to
606 the output file. Scan the fixup tables and so forth and generate
607 the stuff we need. */
610 linux_finish_dynamic_link (output_bfd, info)
612 struct bfd_link_info *info;
614 asection *s, *os, *is;
615 bfd_byte *fixup_table;
616 struct linux_link_hash_entry *h;
618 unsigned int new_addr;
620 unsigned int fixups_written;
622 if (linux_hash_table (info)->dynobj == NULL)
625 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
627 BFD_ASSERT (s != NULL);
628 os = s->output_section;
631 #ifdef LINUX_LINK_DEBUG
632 printf ("Fixup table file offset: %x VMA: %x\n",
633 os->filepos + s->output_offset,
634 os->vma + s->output_offset);
637 fixup_table = s->contents;
638 bfd_put_32 (output_bfd,
639 (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
642 /* Fill in fixup table. */
643 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
648 if (f->h->root.root.type != bfd_link_hash_defined
649 && f->h->root.root.type != bfd_link_hash_defweak)
651 (*_bfd_error_handler)
652 (_("Symbol %s not defined for fixups\n"),
653 f->h->root.root.root.string);
657 is = f->h->root.root.u.def.section;
658 section_offset = is->output_section->vma + is->output_offset;
659 new_addr = f->h->root.root.u.def.value + section_offset;
661 #ifdef LINUX_LINK_DEBUG
662 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
668 /* Relative address */
669 new_addr = new_addr - (f->value + 5);
670 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
672 bfd_put_32 (output_bfd, f->value + 1, fixup_table);
677 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
679 bfd_put_32 (output_bfd, f->value, fixup_table);
685 if (linux_hash_table (info)->local_builtins != 0)
687 /* Special marker so we know to switch to the other type of fixup */
688 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
690 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
693 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
698 if (f->h->root.root.type != bfd_link_hash_defined
699 && f->h->root.root.type != bfd_link_hash_defweak)
701 (*_bfd_error_handler)
702 (_("Symbol %s not defined for fixups\n"),
703 f->h->root.root.root.string);
707 is = f->h->root.root.u.def.section;
708 section_offset = is->output_section->vma + is->output_offset;
709 new_addr = f->h->root.root.u.def.value + section_offset;
711 #ifdef LINUX_LINK_DEBUG
712 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
716 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
718 bfd_put_32 (output_bfd, f->value, fixup_table);
724 if (linux_hash_table (info)->fixup_count != fixups_written)
726 (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
727 while (linux_hash_table (info)->fixup_count > fixups_written)
729 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
731 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
737 h = linux_link_hash_lookup (linux_hash_table (info),
738 "__BUILTIN_FIXUPS__",
739 false, false, false);
742 && (h->root.root.type == bfd_link_hash_defined
743 || h->root.root.type == bfd_link_hash_defweak))
745 is = h->root.root.u.def.section;
746 section_offset = is->output_section->vma + is->output_offset;
747 new_addr = h->root.root.u.def.value + section_offset;
749 #ifdef LINUX_LINK_DEBUG
750 printf ("Builtin fixup table at %x\n", new_addr);
753 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
756 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
758 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
762 if (bfd_bwrite ((PTR) s->contents, s->_raw_size, output_bfd)
769 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
770 #define MY_add_one_symbol linux_add_one_symbol
771 #define MY_finish_dynamic_link linux_finish_dynamic_link
773 #define MY_zmagic_contiguous 1
775 #include "aout-target.h"