A major rewrite to move the bulk of the linker into BFD so that

	more efficient backend code can be written for specific object
	files.
	* lderror.c, lderror.h, ldindr.c, ldindr.h, ldsym.c, ldsym.h,
	ldwarn.c, ldwarn.h, relax.c, relax.h: Removed.
	* ldctor.c, ldctor.h: Complete rewrite.
	* ldwrite.c, ldwrite.h: Complete rewrite.
	* ld.h (strip_symbols_type, strip_symbols): Removed.  Use
	link_info.strip instead.  Changed all uses.
	(discard_locals_type, discard_locals): Removed.  Use
	link_info.discard instead.  Changed all uses.
	(ld_config_type): Removed relocateable_output field; use
	link_info.relocateable instead; changed all uses.  Added stats
	field.
	(set_asymbol_chain, get_asymbol_chain, get_loader_symbol,
	set_loader_symbol): Removed.
	* ldexp.h (node_class): Added etree_rel.
	(etree_type): Added rel field.
	* ldexp.c (exp_print_token): Bracketed table initialization.
	(exp_relop): New function.
	(fold_name): Use linker hash table rather than ldsym functions.
	(exp_fold_tree): Likewise.  Also, handle etree_rel case.
	(exp_print_tree): Handle etree_rel.
	* ldgram.y (strip_symbols, discard_locals): Removed.
	(OPTION_stats, OPTION_no_keep_memory): New tokens.  Handle them.
	(REL): New token.  Does not appear in grammar, but needed for
	expression code.
	(file): Don't call lang_final; it's called by main anyhow.
	* ldlex.l: Accept -stats and -no-keep-memory options.
	* ldlang.h (fill_type): Make unsigned int, not unsigned short.
	* ldlang.c: Consistently use fill_type for fill argument.
	(lang_init_script_file, script_file): Removed.
	(create_object_symbols): Removed.  Use
	link_info.create_object_symbols_section instead.  Changed all
	uses.
	(lang_add_keepsyms_file): Removed.
	(lookup_name): Call bfd_link_add_symbols instead of
	ldmain_open_file_read_symbol.
	(wild): Don't iterate over script_file.
	(open_output): Create link hash table.
	(lang_place_undefineds): Rewrote.
	(lang_size_sections): Handle relaxing (doesn't work yet).
	(lang_relocate_globals): Removed.
	(lang_finish): Use link hash table rather than ldsym functions.
	(lang_common): Rewrote.
	(lang_one_common): New function.
	(ldlang_add_file): Add file to link_info.input_bfds list.  Set
	usrdata.
	(create_symbol): Removed.
	(lang_process): Don't call lang_init_script_file.  Call
	ldctor_build_sets rather than find_constructors.  Don't call
	lang_relocate_globals.
	(lang_abs_symbol_at_beginning_of): Rewrote.
	(lang_abs_symbol_at_end_of): Rewrote.
	* ldmain.c (had_y): Removed.
	(lprefix, lprefix_len): Removed; use link_info fields instead.
	Changed all uses.
	(multiple_def_count, commons_pending, undefined_global_sym_count,
	total_symbols_seen, total_files_seen): Removed.
	(link_callbacks, link_info): New variables.
	(main): Initialize link_info.  Don't call init_bfd_error_vector or
	ldsym_init.  Don't set now unused variables.  Handle -stats.
	(get_emulation): Removed obsolete and nonfunctional GNU960 code.
	(add_ysym): Rewrote.
	(read_entry_symbols, refize, enter_global_ref, enter_file_symbols,
	search_library, gnu960_check_format, decode_library_subfile,
	linear_library, symdef_library, clear_syms, subfile_wanted_p):
	Removed.
	(add_keepsyms_file, add_archive_element, multiple_definition,
	multiple_common, add_to_set, warning_callback, undefined_symbol,
	reloc_overflow, reloc_dangerous, unattached_reloc, notice_ysym):
	New functions.
	* ldmisc.c (vfinfo): Accept a string for %T, not a symbol.  Don't
	require symbols for %C; look them up instead.
	* emultempl/hppaosf.em: Pass link_info to
	hppa_look_for_stubs_in_section.
	* Makefile.in: Rebuilt dependencies.
	(CFILES): Removed lderror.c, ldindr.c, ldsym.c, ldwarn.c, and
	relax.c.
	(HFILES): Removed lderror.h, ldindr.h, ldsym.h, ldwarn.h, and
	relax.h.
	(EMULATION_OFILES): Depend on bfdlink.h, ldmain.h, ldexp.h,
	ldlang.h and ldctor.h.

	* Makefile.in (ldlex.c): Don't depend on ldgram.h.  Remove
	declarations of free and malloc from flex output.  Change malloc
	to ldmalloc in flex output.

1 files changed, 238 insertions, 74 deletions

diff --git a/ld/ldwrite.c b/ld/ldwrite.c
index c073263..376e650 100644
--- a/ld/ldwrite.c
+++ b/ld/ldwrite.c
@@ -1,4 +1,6 @@
-/* Copyright (C) 1991 Free Software Foundation, Inc.
+/* ldwrite.c -- write out the linked file
+   Copyright (C) 1993 Free Software Foundation, Inc.
+   Written by Steve Chamberlain sac@cygnus.com
 
 This file is part of GLD, the Gnu Linker.
 
@@ -16,109 +18,271 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
-/*
-   This module writes out the final image by reading sections from the
-   input files, relocating them and writing them out
-
-   There are two main paths through this module, one for normal
-   operation and one for partial linking.
-
-   During  normal operation, raw section data is read along with the
-   associated relocation information, the relocation info applied and
-   the section data written out on a section by section basis.
-
-   When partially linking, all the relocation records are read to work
-   out how big the output relocation vector will be. Then raw data is
-   read, relocated and written section by section.
-
-   Written by Steve Chamberlain sac@cygnus.com
-
-*/
-
-
 #include "bfd.h"
 #include "sysdep.h"
+#include "bfdlink.h"
 
 #include "ld.h"
 #include "ldexp.h"
 #include "ldlang.h"
 #include "ldwrite.h"
 #include "ldmisc.h"
-#include "ldsym.h"
 #include "ldgram.h"
 #include "ldmain.h"
-#include "relax.h"
+
+static void build_link_order PARAMS ((lang_statement_union_type *));
+static void print_symbol_table PARAMS ((void));
+static void print_file_stuff PARAMS ((lang_input_statement_type *));
+static boolean print_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
+
+/* Build link_order structures for the BFD linker.  */
 
 static void
-read_relocs (abfd, section, symbols)
-     bfd * abfd;
-     asection * section;
-     asymbol ** symbols;
+build_link_order (statement)
+     lang_statement_union_type *statement;
+{
+  switch (statement->header.type)
+    {
+    case lang_data_statement_enum:
+      /* FIXME: This should probably build a link_order, but instead
+	 it just does the output directly.  */
+      {
+	bfd_vma value = statement->data_statement.value;
+	bfd_byte play_area[LONG_SIZE];
+	unsigned int size = 0;
+	asection *output_section = statement->data_statement.output_section;
+
+	ASSERT (output_section->owner == output_bfd);
+	switch (statement->data_statement.type)
+	  {
+	  case LONG:
+	    bfd_put_32 (output_bfd, value, play_area);
+	    size = LONG_SIZE;
+	    break;
+	  case SHORT:
+	    bfd_put_16 (output_bfd, value, play_area);
+	    size = SHORT_SIZE;
+	    break;
+	  case BYTE:
+	    bfd_put_8 (output_bfd, value, play_area);
+	    size = BYTE_SIZE;
+	    break;
+	  default:
+	    abort ();
+	  }
+
+	if (! bfd_set_section_contents (output_bfd, output_section,
+					play_area,
+					statement->data_statement.output_vma,
+					size))
+	  einfo ("%P%X: writing data failed: %E\n");
+      }
+      break;
+
+    case lang_input_section_enum:
+      /* Create a new link_order in the output section with this
+	 attached */
+      if (statement->input_section.ifile->just_syms_flag == false)
+	{
+	  asection *i = statement->input_section.section;
+	  asection *output_section = i->output_section;
+
+	  ASSERT (output_section->owner == output_bfd);
+
+	  if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
+	    {
+	      struct bfd_link_order *link_order;
+
+	      link_order = bfd_new_link_order (output_bfd, output_section);
+
+	      if (i->flags & SEC_NEVER_LOAD)
+		{
+		  /* We've got a never load section inside one which
+		     is going to be output, we'll change it into a
+		     fill link_order */
+		  link_order->type = bfd_fill_link_order;
+		  link_order->u.fill.value = 0;
+		}
+	      else
+		{
+		  link_order->type = bfd_indirect_link_order;
+		  link_order->u.indirect.section = i;
+		  ASSERT (i->output_section == output_section);
+		}
+	      link_order->size = bfd_section_size (i->owner, i);
+	      link_order->offset = i->output_offset;
+	    }
+	}
+      break;
+
+    case lang_padding_statement_enum:
+      /* Make a new link_order with the right filler */
+      {
+	asection *output_section;
+	struct bfd_link_order *link_order;
+
+	output_section = statement->padding_statement.output_section;
+	ASSERT (statement->padding_statement.output_section->owner
+		== output_bfd);
+	if ((output_section->flags & SEC_HAS_CONTENTS) != 0)
+	  {
+	    link_order = bfd_new_link_order (output_bfd, output_section);
+	    link_order->type = bfd_fill_link_order;
+	    link_order->size = statement->padding_statement.size;
+	    link_order->offset = statement->padding_statement.output_offset;
+	    link_order->u.fill.value = statement->padding_statement.fill;
+	  }
+      }
+      break;
+
+    default:
+      /* All the other ones fall through */
+      break;
+    }
+}
+
+/* Call BFD to write out the linked file.  */
+
+void
+ldwrite ()
 {
-  /* Work out the output section ascociated with this input section */
-  asection *output_section = section->output_section;
+  lang_for_each_statement (build_link_order);
 
-  bfd_size_type reloc_size = bfd_get_reloc_upper_bound (abfd, section);
-  arelent **reloc_vector = (arelent **) ldmalloc (reloc_size);
+  if (! bfd_final_link (output_bfd, &link_info))
+    einfo ("%F%P: %B: %E\n", output_bfd);
 
-  if (bfd_canonicalize_reloc (abfd,
-			      section,
-			      reloc_vector,
-			      symbols))
+  if (config.map_file)
     {
-      output_section->reloc_count += section->reloc_count;
+      print_symbol_table ();
+      lang_map ();
     }
 }
 
+/* Print the symbol table.  */
 
 static void
-setup_rel ()
+print_symbol_table ()
 {
-  /*
-    Run through each section of each file and work work out the total
-    number of relocation records which will finally be in each output
-    section
-    */
-
-  LANG_FOR_EACH_INPUT_SECTION
-  (statement, abfd, section,
-   (read_relocs (abfd, section, statement->asymbols)));
-
-
-
-  /*
-    Now run though all the output sections and allocate the space for
-    all the relocations
-    */
-  LANG_FOR_EACH_OUTPUT_SECTION
-    (section,
-     (section->orelocation =
-      (arelent **) ldmalloc ((bfd_size_type) (sizeof (arelent **) *
-					      section->reloc_count)),
-      section->reloc_count = 0));
+  fprintf (config.map_file, "**FILES**\n\n");
+  lang_for_each_file (print_file_stuff);
+
+  fprintf (config.map_file, "**GLOBAL SYMBOLS**\n\n");
+  fprintf (config.map_file, "offset    section    offset   symbol\n");
+  bfd_link_hash_traverse (link_info.hash, print_symbol, (PTR) NULL);
 }
 
-void
-ldwrite ()
+/* Print information about a file.  */
+
+static void
+print_file_stuff (f)
+     lang_input_statement_type * f;
+{
+  fprintf (config.map_file, "  %s\n", f->filename);
+  if (f->just_syms_flag)
+    {
+      fprintf (config.map_file, " symbols only\n");
+    }
+  else
+    {
+      asection *s;
+      if (true)
+	{
+	  for (s = f->the_bfd->sections;
+	       s != (asection *) NULL;
+	       s = s->next)
+	    {
+	      print_address (s->output_offset);
+	      if (s->reloc_done)
+		{
+		  fprintf (config.map_file, " %08x 2**%2ud %s\n",
+			   (unsigned) bfd_get_section_size_after_reloc (s),
+			   s->alignment_power, s->name);
+		}
+
+	      else
+		{
+		  fprintf (config.map_file, " %08x 2**%2ud %s\n",
+			   (unsigned) bfd_get_section_size_before_reloc (s),
+			   s->alignment_power, s->name);
+		}
+	    }
+	}
+      else
+	{
+	  for (s = f->the_bfd->sections;
+	       s != (asection *) NULL;
+	       s = s->next)
+	    {
+	      fprintf (config.map_file, "%s ", s->name);
+	      print_address (s->output_offset);
+	      fprintf (config.map_file, "(%x)",
+		       (unsigned) bfd_get_section_size_after_reloc (s));
+	    }
+	  fprintf (config.map_file, "hex \n");
+	}
+    }
+  print_nl ();
+}
+
+/* Print a symbol.  */
+
+static boolean
+print_symbol (p, ignore)
+     struct bfd_link_hash_entry *p;
+     PTR ignore;
 {
-  PTR data_area = (PTR) ldmalloc (largest_section);
+  while (p->type == bfd_link_hash_indirect
+	 || p->type == bfd_link_hash_warning)
+    p = p->u.i.link;
+
+  switch (p->type) 
+    {
+    case bfd_link_hash_new:
+      abort ();
 
-  ldsym_write ();
+    case bfd_link_hash_undefined:
+      fprintf (config.map_file, "undefined                     ");
+      fprintf (config.map_file, "%s ", p->root.string);
+      print_nl ();    
+      break;
 
-  if (config.relocateable_output == true)
-    setup_rel ();
+    case bfd_link_hash_weak:
+      fprintf (config.map_file, "weak                          ");
+      fprintf (config.map_file, "%s ", p->root.string);
+      print_nl ();    
+      break;
 
-  write_relax (output_bfd, data_area, config.relocateable_output);
+    case bfd_link_hash_defined:	    
+      {
+	asection *defsec = p->u.def.section;
 
-  free (data_area);
+	print_address (p->u.def.value);
+	if (defsec)
+	  {
+	    fprintf (config.map_file, "  %-10s",
+		     bfd_section_name (output_bfd, defsec));
+	    print_space ();
+	    print_address (p->u.def.value + defsec->vma);
+	  }
+	else
+	  {
+	    fprintf (config.map_file, "         .......");
+	  }
+	fprintf (config.map_file, " %s ", p->root.string);
+      }
+      print_nl ();    
+      break;
 
-  /* Output the symbol table (both globals and locals).  */
+    case bfd_link_hash_common:
+      fprintf (config.map_file, "common               ");
+      print_address (p->u.c.size);
+      fprintf (config.map_file, " %s ", p->root.string);
+      print_nl ();
+      break;
 
-  /* Print a map, if requested and possible.  */
+    default:
+      abort ();
+    }
 
-  if (config.map_file)
-  {
-    ldsym_print_symbol_table ();
-    lang_map ();
-  }
+  return true;
 }