-/* Copyright (C) 1991 Free Software Foundation, Inc.
+/* ldctor.c -- constructor support routines
+ Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
+ Free Software Foundation, Inc.
+ By Steve Chamberlain <sac@cygnus.com>
This file is part of GLD, the Gnu Linker.
GLD is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GLD is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GLD; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/*
- * By steve chamberlain
- * steve@cygnus.com
- */
+along with GLD; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "bfd.h"
-#include "sysdep.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+
+#include <ctype.h>
+
#include "ld.h"
#include "ldexp.h"
#include "ldlang.h"
-#include "ldsym.h"
#include "ldmisc.h"
#include "ldgram.h"
+#include "ldmain.h"
+#include "ldctor.h"
+
+static int ctor_prio PARAMS ((const char *));
+static int ctor_cmp PARAMS ((const PTR, const PTR));
-/* exported list of statements needed to handle constructors */
+/* The list of statements needed to handle constructors. These are
+ invoked by the command CONSTRUCTORS in the linker script. */
lang_statement_list_type constructor_list;
+/* Whether the constructors should be sorted. Note that this is
+ global for the entire link; we assume that there is only a single
+ CONSTRUCTORS command in the linker script. */
+boolean constructors_sorted;
+/* The sets we have seen. */
+struct set_info *sets;
-typedef struct constructor_list
-{
- CONST char *name;
- struct constructor_list *next;
-} constructor_list_type;
-
-static constructor_list_type *constructor_name_list;
+/* Add an entry to a set. H is the entry in the linker hash table.
+ RELOC is the relocation to use for an entry in the set. SECTION
+ and VALUE are the value to add. This is called during the first
+ phase of the link, when we are still gathering symbols together.
+ We just record the information now. The ldctor_find_constructors
+ function will construct the sets. */
-static void
-add_constructor_name (name)
- CONST char *name;
+void
+ldctor_add_set_entry (h, reloc, name, section, value)
+ struct bfd_link_hash_entry *h;
+ bfd_reloc_code_real_type reloc;
+ const char *name;
+ asection *section;
+ bfd_vma value;
{
- register constructor_list_type *ptr = constructor_name_list;
- for (; ptr != (constructor_list_type *)NULL; ptr = ptr->next) {
- if (strcmp (ptr->name, name) == 0)
- return;
+ struct set_info *p;
+ struct set_element *e;
+ struct set_element **epp;
+
+ for (p = sets; p != (struct set_info *) NULL; p = p->next)
+ if (p->h == h)
+ break;
+
+ if (p == (struct set_info *) NULL)
+ {
+ p = (struct set_info *) xmalloc (sizeof (struct set_info));
+ p->next = sets;
+ sets = p;
+ p->h = h;
+ p->reloc = reloc;
+ p->count = 0;
+ p->elements = NULL;
}
+ else
+ {
+ if (p->reloc != reloc)
+ {
+ einfo (_("%P%X: Different relocs used in set %s\n"), h->root.string);
+ return;
+ }
+
+ /* Don't permit a set to be constructed from different object
+ file formats. The same reloc may have different results. We
+ actually could sometimes handle this, but the case is
+ unlikely to ever arise. Sometimes constructor symbols are in
+ unusual sections, such as the absolute section--this appears
+ to be the case in Linux a.out--and in such cases we just
+ assume everything is OK. */
+ if (p->elements != NULL
+ && section->owner != NULL
+ && p->elements->section->owner != NULL
+ && strcmp (bfd_get_target (section->owner),
+ bfd_get_target (p->elements->section->owner)) != 0)
+ {
+ einfo (_("%P%X: Different object file formats composing set %s\n"),
+ h->root.string);
+ return;
+ }
+ }
+
+ e = (struct set_element *) xmalloc (sizeof (struct set_element));
+ e->next = NULL;
+ e->name = name;
+ e->section = section;
+ e->value = value;
+
+ for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
+ ;
+ *epp = e;
- /* There isn't an entry, so add one */
- ptr = (constructor_list_type *) ldmalloc (sizeof(constructor_list_type));
- ptr->next = constructor_name_list;
- ptr->name = name;
- constructor_name_list = ptr;
+ ++p->count;
}
-void
-ldlang_add_constructor (name)
- ldsym_type *name;
+/* Get the priority of a g++ global constructor or destructor from the
+ symbol name. */
+
+static int
+ctor_prio (name)
+ const char *name;
{
- if (name->flags & SYM_CONSTRUCTOR) return;
- add_constructor_name (name->name);
- name->flags |= SYM_CONSTRUCTOR;
+ /* The name will look something like _GLOBAL_$I$65535$test02__Fv.
+ There might be extra leading underscores, and the $ characters
+ might be something else. The I might be a D. */
+
+ while (*name == '_')
+ ++name;
+
+ if (strncmp (name, "GLOBAL_", sizeof "GLOBAL_" - 1) != 0)
+ return -1;
+
+ name += sizeof "GLOBAL_" - 1;
+
+ if (name[0] != name[2])
+ return -1;
+ if (name[1] != 'I' && name[1] != 'D')
+ return -1;
+ if (! isdigit ((unsigned char) name[3]))
+ return -1;
+
+ return atoi (name + 3);
}
+/* This function is used to sort constructor elements by priority. It
+ is called via qsort. */
+
+static int
+ctor_cmp (p1, p2)
+ const PTR p1;
+ const PTR p2;
+{
+ const struct set_element **pe1 = (const struct set_element **) p1;
+ const struct set_element **pe2 = (const struct set_element **) p2;
+ const char *n1;
+ const char *n2;
+ int prio1;
+ int prio2;
+
+ n1 = (*pe1)->name;
+ if (n1 == NULL)
+ n1 = "";
+ n2 = (*pe2)->name;
+ if (n2 == NULL)
+ n2 = "";
+
+ /* We need to sort in reverse order by priority. When two
+ constructors have the same priority, we should maintain their
+ current relative position. */
+
+ prio1 = ctor_prio (n1);
+ prio2 = ctor_prio (n2);
+
+ /* We sort in reverse order because that is what g++ expects. */
+ if (prio1 < prio2)
+ return 1;
+ else if (prio1 > prio2)
+ return -1;
+
+ /* Force a stable sort. */
-/* this function looks through the sections attached to the supplied
- bfd to see if any of them are magical constructor sections. If so
- their names are remembered and added to the list of constructors */
+ if (pe1 < pe2)
+ return -1;
+ else if (pe1 > pe2)
+ return 1;
+ else
+ return 0;
+}
+
+/* This function is called after the first phase of the link and
+ before the second phase. At this point all set information has
+ been gathered. We now put the statements to build the sets
+ themselves into constructor_list. */
void
-ldlang_check_for_constructors (entry)
- struct lang_input_statement_struct *entry;
+ldctor_build_sets ()
{
- asection *section;
+ static boolean called;
+ lang_statement_list_type *old;
+ boolean header_printed;
+ struct set_info *p;
- for (section = entry->the_bfd->sections;
- section != (asection *)NULL;
- section = section->next)
+ /* The emulation code may call us directly, but we only want to do
+ this once. */
+ if (called)
+ return;
+ called = true;
+
+ if (constructors_sorted)
{
- if (section->flags & SEC_CONSTRUCTOR)
- add_constructor_name (section->name);
- }
-}
+ for (p = sets; p != NULL; p = p->next)
+ {
+ int c, i;
+ struct set_element *e;
+ struct set_element **array;
+ if (p->elements == NULL)
+ continue;
-/* run through the symbol table, find all the symbols which are
- constructors and for each one, create statements to do something
- like..
+ c = 0;
+ for (e = p->elements; e != NULL; e = e->next)
+ ++c;
- for something like "__CTOR_LIST__, foo" in the assembler
+ array = (struct set_element **) xmalloc (c * sizeof *array);
- __CTOR_LIST__ = . ;
- LONG(__CTOR_LIST_END - . / 4 - 2)
- *(foo)
- __CTOR_LIST_END= .
+ i = 0;
+ for (e = p->elements; e != NULL; e = e->next)
+ {
+ array[i] = e;
+ ++i;
+ }
- Put these statements onto a special list.
+ qsort (array, c, sizeof *array, ctor_cmp);
-*/
+ e = array[0];
+ p->elements = e;
+ for (i = 0; i < c - 1; i++)
+ array[i]->next = array[i + 1];
+ array[i]->next = NULL;
+ free (array);
+ }
+ }
-void
-find_constructors ()
-{
- lang_statement_list_type *old = stat_ptr;
- constructor_list_type *p = constructor_name_list;
- stat_ptr = & constructor_list;
- lang_list_init(stat_ptr);
- while (p != (constructor_list_type *)NULL)
+ old = stat_ptr;
+ stat_ptr = &constructor_list;
+
+ lang_list_init (stat_ptr);
+
+ header_printed = false;
+ for (p = sets; p != (struct set_info *) NULL; p = p->next)
{
- /* Have we already done this one ? */
- CONST char *name = p->name;
- ldsym_type *lookup = ldsym_get_soft(name);
+ struct set_element *e;
+ reloc_howto_type *howto;
+ int reloc_size, size;
- /* If ld is invoked from collect, then the constructor list
- will already have been defined, so don't do it again. */
+ /* If the symbol is defined, we may have been invoked from
+ collect, and the sets may already have been built, so we do
+ not do anything. */
+ if (p->h->type == bfd_link_hash_defined
+ || p->h->type == bfd_link_hash_defweak)
+ continue;
+
+ /* For each set we build:
+ set:
+ .long number_of_elements
+ .long element0
+ ...
+ .long elementN
+ .long 0
+ except that we use the right size instead of .long. When
+ generating relocateable output, we generate relocs instead of
+ addresses. */
+ howto = bfd_reloc_type_lookup (output_bfd, p->reloc);
+ if (howto == (reloc_howto_type *) NULL)
+ {
+ if (link_info.relocateable)
+ {
+ einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
+ bfd_get_target (output_bfd),
+ bfd_get_reloc_code_name (p->reloc),
+ p->h->root.string);
+ continue;
+ }
- if (lookup->sdefs_chain == (asymbol **)NULL)
+ /* If this is not a relocateable link, all we need is the
+ size, which we can get from the input BFD. */
+ if (p->elements->section->owner != NULL)
+ howto = bfd_reloc_type_lookup (p->elements->section->owner,
+ p->reloc);
+ if (howto == NULL)
{
- size_t len = strlen(name);
- char *end = ldmalloc(len+3);
- strcpy(end, name);
- strcat(end,"$e");
-
- lang_add_assignment
- ( exp_assop('=',name, exp_nameop(NAME,".")));
-
- lang_add_data
- (LONG, exp_binop('-',
- exp_binop ( '/',
- exp_binop ( '-',
- exp_nameop(NAME, end),
- exp_nameop(NAME,".")),
- exp_intop(4)),
-
- exp_intop(2)));
-
-
- lang_add_wild(name, (char *)NULL);
- lang_add_data(LONG, exp_intop(0));
- lang_add_assignment
- (exp_assop('=', end, exp_nameop(NAME,".")));
+ einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
+ bfd_get_target (p->elements->section->owner),
+ bfd_get_reloc_code_name (p->reloc),
+ p->h->root.string);
+ continue;
}
- p = p->next;
+ }
+
+ reloc_size = bfd_get_reloc_size (howto);
+ switch (reloc_size)
+ {
+ case 1: size = BYTE; break;
+ case 2: size = SHORT; break;
+ case 4: size = LONG; break;
+ case 8:
+ if (howto->complain_on_overflow == complain_overflow_signed)
+ size = SQUAD;
+ else
+ size = QUAD;
+ break;
+ default:
+ einfo (_("%P%X: Unsupported size %d for set %s\n"),
+ bfd_get_reloc_size (howto), p->h->root.string);
+ size = LONG;
+ break;
+ }
+
+ lang_add_assignment (exp_assop ('=', ".",
+ exp_unop (ALIGN_K,
+ exp_intop (reloc_size))));
+ lang_add_assignment (exp_assop ('=', p->h->root.string,
+ exp_nameop (NAME, ".")));
+ lang_add_data (size, exp_intop ((bfd_vma) p->count));
+
+ for (e = p->elements; e != (struct set_element *) NULL; e = e->next)
+ {
+ if (config.map_file != NULL)
+ {
+ int len;
+
+ if (! header_printed)
+ {
+ minfo (_("\nSet Symbol\n\n"));
+ header_printed = true;
+ }
+
+ minfo ("%s", p->h->root.string);
+ len = strlen (p->h->root.string);
+
+ if (len >= 19)
+ {
+ print_nl ();
+ len = 0;
+ }
+ while (len < 20)
+ {
+ print_space ();
+ ++len;
+ }
+
+ if (e->name != NULL)
+ minfo ("%T\n", e->name);
+ else
+ minfo ("%G\n", e->section->owner, e->section, e->value);
+ }
+
+ /* Need SEC_KEEP for --gc-sections */
+ if (! bfd_is_abs_section (e->section))
+ e->section->flags |= SEC_KEEP;
+
+ if (link_info.relocateable)
+ lang_add_reloc (p->reloc, howto, e->section, e->name,
+ exp_intop (e->value));
+ else
+ lang_add_data (size, exp_relop (e->section, e->value));
+ }
+
+ lang_add_data (size, exp_intop (0));
}
- stat_ptr = old;
-}
+ stat_ptr = old;
+}
projects / deliverable / binutils-gdb.git / blobdiff