* ldctor.c (ldctor_add_set_entry): Don't dump core if a

	constructor entry is in the absolute section.

1 files changed, 173 insertions, 104 deletions

diff --git a/ld/ldctor.c b/ld/ldctor.c
index 2a7e9b0..8ba866c 100644
--- a/ld/ldctor.c
+++ b/ld/ldctor.c
@@ -1,10 +1,12 @@
-/* Copyright (C) 1991 Free Software Foundation, Inc.
+/* ldctor.c -- constructor support routines
+   Copyright (C) 1991, 92, 93, 94 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,
@@ -16,140 +18,207 @@ 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
- */
-
 #include "bfd.h"
-#include "sysdep.h" 
+#include "sysdep.h"
+#include "bfdlink.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"
 
-/* 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;
 
+/* We keep a list of these structures for each sets we build.  */
 
-
-typedef struct constructor_list 
+struct set_info
 {
-   CONST char *name;
-    struct constructor_list *next;
-}  constructor_list_type;
-   
-static constructor_list_type *constructor_name_list;
-
-static void
-add_constructor_name (name)
-     CONST char *name;
+  struct set_info *next;		/* Next set.  */
+  struct bfd_link_hash_entry *h;	/* Hash table entry.  */
+  bfd_reloc_code_real_type reloc;	/* Reloc to use for an entry.  */
+  size_t count;				/* Number of elements.  */
+  struct set_element *elements;		/* Elements in set.  */
+};
+
+struct set_element
 {
-    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_element *next;		/* Next element.  */
+  asection *section;			/* Section of value.  */
+  bfd_vma value;			/* Value.  */
+};
 
-    /* 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;
-}
+/* The sets we have seen.  */
 
-void
-ldlang_add_constructor (name)
-     ldsym_type *name;
-{
-  if (name->flags & SYM_CONSTRUCTOR) return;
-  add_constructor_name (name->name);
-  name->flags |= SYM_CONSTRUCTOR;
-}
+static struct set_info *sets;
 
-
-/* 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 */
+/* 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.  */
 
 void
-ldlang_check_for_constructors (entry)
-     struct lang_input_statement_struct *entry;
+ldctor_add_set_entry (h, reloc, section, value)
+     struct bfd_link_hash_entry *h;
+     bfd_reloc_code_real_type reloc;
+     asection *section;
+     bfd_vma value;
 {
-    asection *section;
+  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;
 
-    for (section = entry->the_bfd->sections;
-	 section != (asection *)NULL;
-	 section = section->next) 
+  if (p == (struct set_info *) NULL)
     {
-	if (section->flags & SEC_CONSTRUCTOR) 
-	    add_constructor_name (section->name);
+      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->section = section;
+  e->value = value;
 
-/* run through the symbol table, find all the symbols which are
-   constructors and for each one, create statements to do something
-   like..
+  for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
+    ;
+  *epp = e;
 
-   for something like "__CTOR_LIST__, foo" in the assembler
+  ++p->count;
+}
 
-   __CTOR_LIST__ = . ;
-   LONG(__CTOR_LIST_END - . / 4 - 2)
-   *(foo)
-   __CTOR_LIST_END= .
+/* 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.  */
 
-   Put these statements onto a special list.
+void
+ldctor_build_sets ()
+{
+  lang_statement_list_type *old;
+  struct set_info *p;
 
-*/
+  old = stat_ptr;
+  stat_ptr = &constructor_list;
 
+  lang_list_init (stat_ptr);
 
-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) 
+  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);
-
-	/* If ld is invoked from collect, then the constructor list
-	   will already have been defined, so don't do it again. */
+      struct set_element *e;
+      reloc_howto_type *howto;
+      int size;
+
+      /* 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)
+	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.  */
+	  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;		    
+	}
+
+      switch (bfd_get_reloc_size (howto))
+	{
+	case 1: size = BYTE; break;
+	case 2: size = SHORT; break;
+	case 4: size = LONG; break;
+	case 8: 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 ('=', 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 (link_info.relocateable)
+	    lang_add_reloc (p->reloc, howto, e->section,
+			    (const char *) NULL, 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;
+}