Update my e-mail address.
[binutils-gdb.git] / bfd / sparclinux.c
blob661b50b652a066a97b3a5a9c82819bcda0a98a2f
1 /* BFD back-end for linux flavored sparc a.out binaries.
2 Copyright (C) 1992-2017 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, 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
26 #define MACHTYPE_OK(mtype) ((mtype) == M_SPARC || (mtype) == M_UNKNOWN)
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 */
36 #define DEFAULT_ARCH bfd_arch_sparc
37 /* Do not "beautify" the CONCAT* macro args. Traditional C will not
38 remove whitespace added here, and thus will fail to concatenate
39 the tokens. */
40 #define MY(OP) CONCAT2 (sparc_aout_linux_,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
47 becomes important. */
49 static void MY_final_link_callback
50 (bfd *, file_ptr *, file_ptr *, file_ptr *);
52 static bfd_boolean
53 sparclinux_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
55 obj_aout_subformat (abfd) = q_magic_format;
56 return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
59 #define MY_bfd_final_link sparclinux_bfd_final_link
61 /* Set the machine type correctly. */
63 static bfd_boolean
64 sparclinux_write_object_contents (bfd *abfd)
66 struct external_exec exec_bytes;
67 struct internal_exec *execp = exec_hdr (abfd);
69 N_SET_MACHTYPE (execp, M_SPARC);
71 obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
73 WRITE_HEADERS (abfd, execp);
75 return TRUE;
78 #define MY_write_object_contents sparclinux_write_object_contents
79 /* Code to link against Linux a.out shared libraries. */
81 /* See if a symbol name is a reference to the global offset table. */
83 #ifndef GOT_REF_PREFIX
84 #define GOT_REF_PREFIX "__GOT_"
85 #endif
87 #define IS_GOT_SYM(name) (CONST_STRNEQ (name, GOT_REF_PREFIX))
89 /* See if a symbol name is a reference to the procedure linkage table. */
91 #ifndef PLT_REF_PREFIX
92 #define PLT_REF_PREFIX "__PLT_"
93 #endif
95 #define IS_PLT_SYM(name) (CONST_STRNEQ (name, PLT_REF_PREFIX))
97 /* This string is used to generate specialized error messages. */
99 #ifndef NEEDS_SHRLIB
100 #define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
101 #endif
103 /* This special symbol is a set vector that contains a list of
104 pointers to fixup tables. It will be present in any dynamically
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
108 crt0.o). */
110 #ifndef SHARABLE_CONFLICTS
111 #define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
112 #endif
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. */
124 struct fixup
126 struct fixup *next;
127 struct linux_link_hash_entry *h;
128 bfd_vma value;
130 /* Nonzero if this is a jump instruction that needs to be fixed,
131 zero if this is just a pointer */
132 char jump;
134 char builtin;
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
139 hash table. */
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. */
151 bfd *dynobj;
153 /* Number of fixups. */
154 size_t fixup_count;
156 /* Number of builtin fixups. */
157 size_t local_builtins;
159 /* List of fixups. */
160 struct fixup *fixup_list;
164 /* Routine to create an entry in an Linux link hash table. */
166 static struct bfd_hash_entry *
167 linux_link_hash_newfunc (struct bfd_hash_entry *entry,
168 struct bfd_hash_table *table,
169 const char *string)
171 struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
173 /* Allocate the structure if it has not already been allocated by a
174 subclass. */
175 if (ret == (struct linux_link_hash_entry *) NULL)
176 ret = ((struct linux_link_hash_entry *)
177 bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
178 if (ret == NULL)
179 return (struct bfd_hash_entry *) ret;
181 /* Call the allocation method of the superclass. */
182 ret = ((struct linux_link_hash_entry *)
183 NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
184 table, string));
185 if (ret != NULL)
187 /* Set local fields; there aren't any. */
190 return (struct bfd_hash_entry *) ret;
193 /* Create a Linux link hash table. */
195 static struct bfd_link_hash_table *
196 linux_link_hash_table_create (bfd *abfd)
198 struct linux_link_hash_table *ret;
199 bfd_size_type amt = sizeof (struct linux_link_hash_table);
201 ret = (struct linux_link_hash_table *) bfd_zmalloc (amt);
202 if (ret == (struct linux_link_hash_table *) NULL)
203 return (struct bfd_link_hash_table *) NULL;
204 if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
205 linux_link_hash_newfunc,
206 sizeof (struct linux_link_hash_entry)))
208 free (ret);
209 return (struct bfd_link_hash_table *) NULL;
212 return &ret->root.root;
215 /* Look up an entry in a Linux link hash table. */
217 #define linux_link_hash_lookup(table, string, create, copy, follow) \
218 ((struct linux_link_hash_entry *) \
219 aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
220 (follow)))
222 /* Traverse a Linux link hash table. */
224 #define linux_link_hash_traverse(table, func, info) \
225 (aout_link_hash_traverse \
226 (&(table)->root, \
227 (bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func), \
228 (info)))
230 /* Get the Linux link hash table from the info structure. This is
231 just a cast. */
233 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
235 /* Store the information for a new fixup. */
237 static struct fixup *
238 new_fixup (struct bfd_link_info *info,
239 struct linux_link_hash_entry *h,
240 bfd_vma value,
241 int builtin)
243 struct fixup *f;
245 f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
246 sizeof (struct fixup));
247 if (f == NULL)
248 return f;
249 f->next = linux_hash_table (info)->fixup_list;
250 linux_hash_table (info)->fixup_list = f;
251 f->h = h;
252 f->value = value;
253 f->builtin = builtin;
254 f->jump = 0;
255 ++linux_hash_table (info)->fixup_count;
256 return f;
259 /* We come here once we realize that we are going to link to a shared
260 library. We need to create a special section that contains the
261 fixup table, and we ultimately need to add a pointer to this into
262 the set vector for SHARABLE_CONFLICTS. At this point we do not
263 know the size of the section, but that's OK - we just need to
264 create it for now. */
266 static bfd_boolean
267 linux_link_create_dynamic_sections (bfd *abfd,
268 struct bfd_link_info *info ATTRIBUTE_UNUSED)
270 flagword flags;
271 asection *s;
273 /* Note that we set the SEC_IN_MEMORY flag. */
274 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
276 /* We choose to use the name ".linux-dynamic" for the fixup table.
277 Why not? */
278 s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
279 if (s == NULL
280 || ! bfd_set_section_alignment (abfd, s, 2))
281 return FALSE;
282 s->size = 0;
283 s->contents = 0;
285 return TRUE;
288 /* Function to add a single symbol to the linker hash table. This is
289 a wrapper around _bfd_generic_link_add_one_symbol which handles the
290 tweaking needed for dynamic linking support. */
292 static bfd_boolean
293 linux_add_one_symbol (struct bfd_link_info *info,
294 bfd *abfd,
295 const char *name,
296 flagword flags,
297 asection *section,
298 bfd_vma value,
299 const char *string,
300 bfd_boolean copy,
301 bfd_boolean collect,
302 struct bfd_link_hash_entry **hashp)
304 struct linux_link_hash_entry *h;
305 bfd_boolean insert;
307 /* Look up and see if we already have this symbol in the hash table.
308 If we do, and the defining entry is from a shared library, we
309 need to create the dynamic sections.
311 FIXME: What if abfd->xvec != info->output_bfd->xvec? We may
312 want to be able to link Linux a.out and ELF objects together,
313 but serious confusion is possible. */
315 insert = FALSE;
317 if (! bfd_link_relocatable (info)
318 && linux_hash_table (info)->dynobj == NULL
319 && strcmp (name, SHARABLE_CONFLICTS) == 0
320 && (flags & BSF_CONSTRUCTOR) != 0
321 && abfd->xvec == info->output_bfd->xvec)
323 if (! linux_link_create_dynamic_sections (abfd, info))
324 return FALSE;
325 linux_hash_table (info)->dynobj = abfd;
326 insert = TRUE;
329 if (bfd_is_abs_section (section)
330 && abfd->xvec == info->output_bfd->xvec)
332 h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
333 FALSE, FALSE);
334 if (h != NULL
335 && (h->root.root.type == bfd_link_hash_defined
336 || h->root.root.type == bfd_link_hash_defweak))
338 struct fixup *f;
340 if (hashp != NULL)
341 *hashp = (struct bfd_link_hash_entry *) h;
343 f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
344 if (f == NULL)
345 return FALSE;
346 f->jump = IS_PLT_SYM (name);
348 return TRUE;
352 /* Do the usual procedure for adding a symbol. */
353 if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
354 value, string, copy, collect,
355 hashp))
356 return FALSE;
358 /* Insert a pointer to our table in the set vector. The dynamic
359 linker requires this information. */
360 if (insert)
362 asection *s;
364 /* Here we do our special thing to add the pointer to the
365 dynamic section in the SHARABLE_CONFLICTS set vector. */
366 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
367 ".linux-dynamic");
368 BFD_ASSERT (s != NULL);
370 if (! (_bfd_generic_link_add_one_symbol
371 (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
372 BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
373 FALSE, FALSE, NULL)))
374 return FALSE;
377 return TRUE;
380 /* We will crawl the hash table and come here for every global symbol.
381 We will examine each entry and see if there are indications that we
382 need to add a fixup. There are two possible cases - one is where
383 you have duplicate definitions of PLT or GOT symbols - these will
384 have already been caught and added as "builtin" fixups. If we find
385 that the corresponding non PLT/GOT symbol is also present, we
386 convert it to a regular fixup instead.
388 This function is called via linux_link_hash_traverse. */
390 static bfd_boolean
391 linux_tally_symbols (struct linux_link_hash_entry *h, void * data)
393 struct bfd_link_info *info = (struct bfd_link_info *) data;
394 struct fixup *f, *f1;
395 int is_plt;
396 struct linux_link_hash_entry *h1, *h2;
397 bfd_boolean exists;
399 if (h->root.root.type == bfd_link_hash_undefined
400 && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
402 const char *name;
403 char *p;
404 char *alloc = NULL;
406 name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
407 p = strrchr (name, '_');
408 if (p != NULL)
409 alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
411 if (p == NULL || alloc == NULL)
412 _bfd_error_handler (_("Output file requires shared library `%s'\n"),
413 name);
414 else
416 strcpy (alloc, name);
417 p = strrchr (alloc, '_');
418 *p++ = '\0';
419 _bfd_error_handler
420 /* xgettext:c-format */
421 (_("Output file requires shared library `%s.so.%s'\n"),
422 alloc, p);
423 free (alloc);
426 abort ();
429 /* If this symbol is not a PLT/GOT, we do not even need to look at
430 it. */
431 is_plt = IS_PLT_SYM (h->root.root.root.string);
433 if (is_plt || IS_GOT_SYM (h->root.root.root.string))
435 /* Look up this symbol twice. Once just as a regular lookup,
436 and then again following all of the indirect links until we
437 reach a real symbol. */
438 h1 = linux_link_hash_lookup (linux_hash_table (info),
439 (h->root.root.root.string
440 + sizeof PLT_REF_PREFIX - 1),
441 FALSE, FALSE, TRUE);
442 /* h2 does not follow indirect symbols. */
443 h2 = linux_link_hash_lookup (linux_hash_table (info),
444 (h->root.root.root.string
445 + sizeof PLT_REF_PREFIX - 1),
446 FALSE, FALSE, FALSE);
448 /* The real symbol must exist but if it is also an ABS symbol,
449 there is no need to have a fixup. This is because they both
450 came from the same library. If on the other hand, we had to
451 use an indirect symbol to get to the real symbol, we add the
452 fixup anyway, since there are cases where these symbols come
453 from different shared libraries */
454 if (h1 != NULL
455 && (((h1->root.root.type == bfd_link_hash_defined
456 || h1->root.root.type == bfd_link_hash_defweak)
457 && ! bfd_is_abs_section (h1->root.root.u.def.section))
458 || h2->root.root.type == bfd_link_hash_indirect))
460 /* See if there is a "builtin" fixup already present
461 involving this symbol. If so, convert it to a regular
462 fixup. In the end, this relaxes some of the requirements
463 about the order of performing fixups. */
464 exists = FALSE;
465 for (f1 = linux_hash_table (info)->fixup_list;
466 f1 != NULL;
467 f1 = f1->next)
469 if ((f1->h != h && f1->h != h1)
470 || (! f1->builtin && ! f1->jump))
471 continue;
472 if (f1->h == h1)
473 exists = TRUE;
474 if (! exists
475 && bfd_is_abs_section (h->root.root.u.def.section))
477 f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
478 f->jump = is_plt;
480 f1->h = h1;
481 f1->jump = is_plt;
482 f1->builtin = 0;
483 exists = TRUE;
485 if (! exists
486 && bfd_is_abs_section (h->root.root.u.def.section))
488 f = new_fixup (info, h1, h->root.root.u.def.value, 0);
489 if (f == NULL)
491 /* FIXME: No way to return error. */
492 abort ();
494 f->jump = is_plt;
498 /* Quick and dirty way of stripping these symbols from the
499 symtab. */
500 if (bfd_is_abs_section (h->root.root.u.def.section))
501 h->root.written = TRUE;
504 return TRUE;
507 /* This is called to set the size of the .linux-dynamic section is.
508 It is called by the Linux linker emulation before_allocation
509 routine. We have finished reading all of the input files, and now
510 we just scan the hash tables to find out how many additional fixups
511 are required. */
513 bfd_boolean
514 bfd_sparclinux_size_dynamic_sections (bfd *output_bfd,
515 struct bfd_link_info *info)
517 struct fixup *f;
518 asection *s;
520 if (output_bfd->xvec != &MY(vec))
521 return TRUE;
523 /* First find the fixups... */
524 linux_link_hash_traverse (linux_hash_table (info),
525 linux_tally_symbols,
526 info);
528 /* If there are builtin fixups, leave room for a marker. This is
529 used by the dynamic linker so that it knows that all that follow
530 are builtin fixups instead of regular fixups. */
531 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
533 if (f->builtin)
535 ++linux_hash_table (info)->fixup_count;
536 ++linux_hash_table (info)->local_builtins;
537 break;
541 if (linux_hash_table (info)->dynobj == NULL)
543 if (linux_hash_table (info)->fixup_count > 0)
544 abort ();
545 return TRUE;
548 /* Allocate memory for our fixup table. We will fill it in later. */
549 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
550 ".linux-dynamic");
551 if (s != NULL)
553 s->size = linux_hash_table (info)->fixup_count + 1;
554 s->size *= 8;
555 s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
556 if (s->contents == NULL)
557 return FALSE;
560 return TRUE;
563 /* We come here once we are ready to actually write the fixup table to
564 the output file. Scan the fixup tables and so forth and generate
565 the stuff we need. */
567 static bfd_boolean
568 linux_finish_dynamic_link (bfd *output_bfd, struct bfd_link_info *info)
570 asection *s, *os, *is;
571 bfd_byte *fixup_table;
572 struct linux_link_hash_entry *h;
573 struct fixup *f;
574 unsigned int new_addr;
575 int section_offset;
576 unsigned int fixups_written;
578 if (linux_hash_table (info)->dynobj == NULL)
579 return TRUE;
581 s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
582 ".linux-dynamic");
583 BFD_ASSERT (s != NULL);
584 os = s->output_section;
585 fixups_written = 0;
587 #ifdef LINUX_LINK_DEBUG
588 printf ("Fixup table file offset: %x VMA: %x\n",
589 os->filepos + s->output_offset,
590 os->vma + s->output_offset);
591 #endif
593 fixup_table = s->contents;
594 bfd_put_32 (output_bfd,
595 (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
596 fixup_table += 4;
598 /* Fill in fixup table. */
599 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
601 if (f->builtin)
602 continue;
604 if (f->h->root.root.type != bfd_link_hash_defined
605 && f->h->root.root.type != bfd_link_hash_defweak)
607 _bfd_error_handler
608 (_("Symbol %s not defined for fixups\n"),
609 f->h->root.root.root.string);
610 continue;
613 is = f->h->root.root.u.def.section;
614 section_offset = is->output_section->vma + is->output_offset;
615 new_addr = f->h->root.root.u.def.value + section_offset;
617 #ifdef LINUX_LINK_DEBUG
618 printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
619 new_addr, f->value);
620 #endif
622 if (f->jump)
624 /* Relative address */
625 new_addr = new_addr - (f->value + 5);
626 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
627 fixup_table += 4;
628 bfd_put_32 (output_bfd, f->value + 1, fixup_table);
629 fixup_table += 4;
631 else
633 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
634 fixup_table += 4;
635 bfd_put_32 (output_bfd, f->value, fixup_table);
636 fixup_table += 4;
638 ++fixups_written;
641 if (linux_hash_table (info)->local_builtins != 0)
643 /* Special marker so we know to switch to the other type of fixup */
644 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
645 fixup_table += 4;
646 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
647 fixup_table += 4;
648 ++fixups_written;
649 for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
651 if (! f->builtin)
652 continue;
654 if (f->h->root.root.type != bfd_link_hash_defined
655 && f->h->root.root.type != bfd_link_hash_defweak)
657 _bfd_error_handler
658 (_("Symbol %s not defined for fixups\n"),
659 f->h->root.root.root.string);
660 continue;
663 is = f->h->root.root.u.def.section;
664 section_offset = is->output_section->vma + is->output_offset;
665 new_addr = f->h->root.root.u.def.value + section_offset;
667 #ifdef LINUX_LINK_DEBUG
668 printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
669 new_addr, f->value);
670 #endif
672 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
673 fixup_table += 4;
674 bfd_put_32 (output_bfd, f->value, fixup_table);
675 fixup_table += 4;
676 ++fixups_written;
680 if (linux_hash_table (info)->fixup_count != fixups_written)
682 _bfd_error_handler (_("Warning: fixup count mismatch\n"));
683 while (linux_hash_table (info)->fixup_count > fixups_written)
685 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
686 fixup_table += 4;
687 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
688 fixup_table += 4;
689 ++fixups_written;
693 h = linux_link_hash_lookup (linux_hash_table (info),
694 "__BUILTIN_FIXUPS__",
695 FALSE, FALSE, FALSE);
697 if (h != NULL
698 && (h->root.root.type == bfd_link_hash_defined
699 || h->root.root.type == bfd_link_hash_defweak))
701 is = h->root.root.u.def.section;
702 section_offset = is->output_section->vma + is->output_offset;
703 new_addr = h->root.root.u.def.value + section_offset;
705 #ifdef LINUX_LINK_DEBUG
706 printf ("Builtin fixup table at %x\n", new_addr);
707 #endif
709 bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
711 else
712 bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
714 if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
715 SEEK_SET) != 0)
716 return FALSE;
718 if (bfd_bwrite (s->contents, s->size, output_bfd) != s->size)
719 return FALSE;
721 return TRUE;
724 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
725 #define MY_add_one_symbol linux_add_one_symbol
726 #define MY_finish_dynamic_link linux_finish_dynamic_link
728 #define MY_zmagic_contiguous 1
730 #include "aout-target.h"