X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=ld%2Femultempl%2Fhppaelf.em;h=7c47e9918f2f04df43b531fd77840f458dd8452f;hb=f809832224cc45eb58812f6d4bb03cbf52fad980;hp=128cddadf778bc945c5888a8ac4d193425a04ad6;hpb=a62494c41be4df5acbb36f1fac4ac6018771e60c;p=deliverable%2Fbinutils-gdb.git

diff --git a/ld/emultempl/hppaelf.em b/ld/emultempl/hppaelf.em
index 128cddadf7..7c47e9918f 100644
--- a/ld/emultempl/hppaelf.em
+++ b/ld/emultempl/hppaelf.em
@@ -1,303 +1,363 @@
 # This shell script emits a C file. -*- C -*-
-# It does some substitutions.
-cat >em_${EMULATION_NAME}.c <<EOF
-/* An emulation for HP PA-RISC ELF linkers.
-   Copyright (C) 1991, 1993 Free Software Foundation, Inc.
-   Written by Steve Chamberlain steve@cygnus.com
-
-This file is part of GLD, the Gnu Linker.
-
-This program 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 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-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.  */
-
-#include "bfd.h"
-#include "sysdep.h"
-#include "bfdlink.h"
-
-#include "ld.h"
-#include "config.h"
-#include "ldemul.h"
-#include "ldfile.h"
-#include "ldexp.h"
-#include "ldlang.h"
-#include "ldmisc.h"
-#include "ldmain.h"
+#   Copyright (C) 1991-2020 Free Software Foundation, Inc.
+#
+# This file is part of the GNU Binutils.
+#
+# This program 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 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
+#
+
+# This file is sourced from elf.em, and defines extra hppa-elf
+# specific routines.
+#
+fragment <<EOF
+
 #include "ldctor.h"
+#include "elf32-hppa.h"
+
+
+/* Fake input file for stubs.  */
+static lang_input_statement_type *stub_file;
+
+/* Type of import/export stubs to build.  For a single sub-space model,
+   we can build smaller import stubs and there is no need for export
+   stubs.  */
+static int multi_subspace = 0;
+
+/* Whether we need to call hppa_layout_sections_again.  */
+static int need_laying_out = 0;
+
+/* Maximum size of a group of input sections that can be handled by
+   one stub section.  A value of +/-1 indicates the bfd back-end
+   should use a suitable default size.  */
+static bfd_signed_vma group_size = 1;
+
+/* Stops the linker merging .text sections on a relocatable link,
+   and adds millicode library to the list of input files.  */
 
-static void hppaelf_before_parse()
+static void
+hppaelf_after_parse (void)
 {
-  link_info.lprefix = "L$";
-  link_info.lprefix_len = 2;
+  if (bfd_link_relocatable (&link_info))
+    lang_add_unique (".text");
 
-  ldfile_output_architecture = bfd_arch_hppa;
-}
+  /* Enable this once we split millicode stuff from libgcc:
+     lang_add_input_file ("milli",
+			  lang_input_file_is_l_enum,
+			  NULL);
+  */
 
-static lang_input_statement_type *stub_file = 0;
+  ldelf_after_parse ();
+}
 
-static lang_input_section_type *stub_input_section = NULL;
+/* This is called before the input files are opened.  We create a new
+   fake input file to hold the stub sections.  */
 
 static void
-hppaelf_search_for_padding_statements(s,prev)
-	lang_statement_union_type *s;
-	lang_statement_union_type **prev;
+hppaelf_create_output_section_statements (void)
 {
-  lang_statement_union_type *sprev = NULL;
-  for (; s != (lang_statement_union_type *) NULL; s = s->next)
+  if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
+	&& (elf_object_id (link_info.output_bfd) == HPPA32_ELF_DATA
+	    || elf_object_id (link_info.output_bfd) == HPPA64_ELF_DATA)))
+    return;
+
+  stub_file = lang_add_input_file ("linker stubs",
+				   lang_input_file_is_fake_enum,
+				   NULL);
+  stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
+  if (stub_file->the_bfd == NULL
+      || ! bfd_set_arch_mach (stub_file->the_bfd,
+			      bfd_get_arch (link_info.output_bfd),
+			      bfd_get_mach (link_info.output_bfd)))
+    {
+      einfo (_("%F%P: can not create BFD: %E\n"));
+      return;
+    }
+
+  stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
+  ldlang_add_file (stub_file);
+  elf32_hppa_init_stub_bfd (stub_file->the_bfd, &link_info);
+}
+
+
+struct hook_stub_info
+{
+  lang_statement_list_type add;
+  asection *input_section;
+};
+
+/* Traverse the linker tree to find the spot where the stub goes.  */
+
+static bfd_boolean
+hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
+{
+  lang_statement_union_type *l;
+  bfd_boolean ret;
+
+  for (; (l = *lp) != NULL; lp = &l->header.next)
     {
-      switch (s->header.type)
+      switch (l->header.type)
 	{
 	case lang_constructors_statement_enum:
-	  hppaelf_search_for_padding_statements (constructor_list.head,&constructor_list.head);
+	  ret = hook_in_stub (info, &constructor_list.head);
+	  if (ret)
+	    return ret;
 	  break;
+
 	case lang_output_section_statement_enum:
-	  hppaelf_search_for_padding_statements
-	    (s->output_section_statement.children.head,&s->output_section_statement.children.head);
+	  ret = hook_in_stub (info,
+			      &l->output_section_statement.children.head);
+	  if (ret)
+	    return ret;
 	  break;
+
 	case lang_wild_statement_enum:
-	  hppaelf_search_for_padding_statements
-	    (s->wild_statement.children.head,&s->wild_statement.children.head);
+	  ret = hook_in_stub (info, &l->wild_statement.children.head);
+	  if (ret)
+	    return ret;
+	  break;
+
+	case lang_group_statement_enum:
+	  ret = hook_in_stub (info, &l->group_statement.children.head);
+	  if (ret)
+	    return ret;
 	  break;
+
+	case lang_input_section_enum:
+	  if (l->input_section.section == info->input_section)
+	    {
+	      /* We've found our section.  Insert the stub immediately
+		 before its associated input section.  */
+	      *lp = info->add.head;
+	      *(info->add.tail) = l;
+	      return TRUE;
+	    }
+	  break;
+
 	case lang_data_statement_enum:
+	case lang_reloc_statement_enum:
 	case lang_object_symbols_statement_enum:
 	case lang_output_statement_enum:
 	case lang_target_statement_enum:
-	case lang_input_section_enum:
 	case lang_input_statement_enum:
 	case lang_assignment_statement_enum:
-	case lang_address_statement_enum:
-	  break;
 	case lang_padding_statement_enum:
-	  if ( sprev )
-	    {
-	      sprev->header.next = s->header.next;
-	    }
-	  else
-	    {
-	      **prev = *s;
-	    }
+	case lang_address_statement_enum:
+	case lang_fill_statement_enum:
 	  break;
+
 	default:
 	  FAIL ();
 	  break;
 	}
-      sprev = s;
     }
+  return FALSE;
 }
 
-static void
-hppaelf_finish()
-{
-  extern asymbol *hppa_look_for_stubs_in_section();
 
-  if (link_info.relocateable == false)
-    {
-      /* check for needed stubs */
-      extern lang_statement_list_type file_chain;
-      lang_input_statement_type *statement;
+/* Call-back for elf32_hppa_size_stubs.  */
 
-      for (statement = (lang_input_statement_type *)file_chain.head;
-	   statement != (lang_input_statement_type *)NULL;
-	   statement = (lang_input_statement_type *)statement->next)
-	{
-	  asection *section;
-	  bfd *abfd = statement->the_bfd;
-	  for (section = abfd->sections;
-	       section != (asection *)NULL;
-	       section = section ->next)
-	    {
-	      int new_sym_cnt = 0;
-	      int i,j;
-	      asymbol *syms;
-
-	      syms = hppa_look_for_stubs_in_section (stub_file->the_bfd,
-						     abfd,
-						     output_bfd,
-						     section,
-						     statement->asymbols,
-						     &new_sym_cnt,
-						     &link_info);
-
-	      if ( (new_sym_cnt > 0) && syms )
-		{
-		  struct symbol_cache_entry **old_asymbols;
-
-		  old_asymbols = stub_file->asymbols;
-
-		  stub_file->asymbols = xmalloc((stub_file->symbol_count + new_sym_cnt) * sizeof(asymbol *));
-
-		  for ( j = 0; j < stub_file->symbol_count; j++ )
-		    stub_file->asymbols[j] = old_asymbols[j];
-		
-		  for ( j = 0, i = stub_file->symbol_count; j < new_sym_cnt; j++, i++ )
-		    stub_file->asymbols[i] = &syms[j];
-		
-		  stub_file->symbol_count += new_sym_cnt;
-		}
-	    }
-        }
-      /* Add a statement to get the linker stubs included in the output */
-      lang_add_wild(".hppa_linker_stubs",NULL);
+/* Create a new stub section, and arrange for it to be linked
+   immediately before INPUT_SECTION.  */
 
-      /* If we've added stubs,remove the padding_statements because */
-      /* they are no longer valid */
-      hppaelf_search_for_padding_statements(stat_ptr->head,&(stat_ptr->head));
-    }
-  /* Size up the sections again.  */
-  lang_size_sections (stat_ptr->head,
-		      abs_output_section,
-		      &(stat_ptr->head), 0, (bfd_vma) 0, false);
+static asection *
+hppaelf_add_stub_section (const char *stub_sec_name, asection *input_section)
+{
+  asection *stub_sec;
+  flagword flags;
+  asection *output_section;
+  lang_output_section_statement_type *os;
+  struct hook_stub_info info;
+
+  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
+	   | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
+  stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
+						 stub_sec_name, flags);
+  if (stub_sec == NULL)
+    goto err_ret;
+
+  output_section = input_section->output_section;
+  os = lang_output_section_get (output_section);
+
+  info.input_section = input_section;
+  lang_list_init (&info.add);
+  lang_add_section (&info.add, stub_sec, NULL, os);
+
+  if (info.add.head == NULL)
+    goto err_ret;
+
+  if (hook_in_stub (&info, &os->children.head))
+    return stub_sec;
+
+ err_ret:
+  einfo (_("%X%P: can not make stub section: %E\n"));
+  return NULL;
+}
 
+
+/* Another call-back for elf32_hppa_size_stubs.  */
+
+static void
+hppaelf_layout_sections_again (void)
+{
+  /* If we have changed sizes of the stub sections, then we need
+     to recalculate all the section offsets.  This may mean we need to
+     add even more stubs.  */
+  ldelf_map_segments (TRUE);
+  need_laying_out = -1;
 }
 
+
 static void
-hppaelf_create_output_section_statements()
+build_section_lists (lang_statement_union_type *statement)
 {
-  asection *stub_sec;
-  asection *output_text_sec = bfd_make_section_old_way(output_bfd,".text");
-  lang_input_section_type *new_input_sec;
-  
-  stub_file = lang_add_input_file ("linker stubs",
-				   lang_input_file_is_fake_enum,
-				   (char *) NULL);
-  stub_file->the_bfd = bfd_create ("linker stubs", output_bfd);
-  stub_file->symbol_count = 0;
-  stub_file->the_bfd->sections = 0;
-  
-  stub_sec = bfd_make_section_old_way(stub_file->the_bfd,".hppa_linker_stubs");
-  stub_sec->output_section = output_text_sec;
-  bfd_set_section_flags(stub_file->the_bfd, stub_sec, SEC_HAS_CONTENTS | SEC_ALLOC | SEC_CODE | SEC_RELOC );
-  
-  /* The user data of a bfd points to the input statement attached */
-  stub_file->the_bfd->usrdata  = (void *)stub_file;
-  stub_file->common_section =
-    bfd_make_section(stub_file->the_bfd,"COMMON");
-
-  new_input_sec = (lang_input_section_type *)stat_alloc(sizeof(lang_input_section_type));
-  if ( new_input_sec )
+  if (statement->header.type == lang_input_section_enum)
     {
-	lang_output_section_statement_type *text_output_sec;
-	lang_statement_union_type *stmt;
-	lang_wild_statement_type *stub_statement;
-	new_input_sec->section = stub_sec;
-	new_input_sec->ifile = stub_file;
-	new_input_sec->header.type = lang_input_section_enum;
-	new_input_sec->header.next = NULL;
-
-	stub_input_section = new_input_sec;
-
-	/* Find the output_section_statement for .text, */
-	/* then find the wild_statement for .hppa_linker_stubs */
-
-	text_output_sec = lang_output_section_find(".text");
-
-	stmt = text_output_sec->children.head;
-
-	while (stmt && stmt->header.type != lang_wild_statement_enum)
-	  {
-		stmt = stmt->header.next;
-	  }
-	
-	if ( stmt )
-	  {
-		lang_wild_statement_type *wstmt = (lang_wild_statement_type *)stmt;
-		lang_list_init(&wstmt->children);	    
-		lang_statement_append(&wstmt->children,
-				      (lang_statement_union_type *)new_input_sec,
-				      &new_input_sec->header.next);
-	  }
+      asection *i = statement->input_section.section;
+
+      if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
+	  && (i->flags & SEC_EXCLUDE) == 0
+	  && i->output_section != NULL
+	  && i->output_section->owner == link_info.output_bfd)
+	{
+	  elf32_hppa_next_input_section (&link_info, i);
+	}
     }
 }
 
+
+/* For the PA we use this opportunity to size and build linker stubs.  */
+
 static void
-hppaelf_set_output_arch()
+gld${EMULATION_NAME}_after_allocation (void)
 {
-  /* Set the output architecture and machine if possible */
-  unsigned long  machine = 0;
-  bfd_set_arch_mach(output_bfd, ldfile_output_architecture, machine);
-}
+  int ret;
+
+  /* bfd_elf_discard_info just plays with data and debugging sections,
+     ie. doesn't affect code size, so we can delay resizing the
+     sections.  It's likely we'll resize everything in the process of
+     adding stubs.  */
+  ret = bfd_elf_discard_info (link_info.output_bfd, &link_info);
+  if (ret < 0)
+    {
+      einfo (_("%X%P: .eh_frame/.stab edit: %E\n"));
+      return;
+    }
+  else if (ret > 0)
+    need_laying_out = 1;
 
-static char *
-hppaelf_get_script(isfile)
-     int *isfile;
-EOF
+  /* If generating a relocatable output file, then we don't
+     have to examine the relocs.  */
+  if (stub_file != NULL && !bfd_link_relocatable (&link_info))
+    {
+      ret = elf32_hppa_setup_section_lists (link_info.output_bfd, &link_info);
+      if (ret != 0)
+	{
+	  if (ret < 0)
+	    {
+	      einfo (_("%X%P: can not size stub section: %E\n"));
+	      return;
+	    }
 
-if test -n "$COMPILE_IN"
-then
-# Scripts compiled in.
+	  lang_for_each_statement (build_section_lists);
 
-# sed commands to quote an ld script as a C string.
-sc='s/["\\]/\\&/g
-s/$/\\n\\/
-1s/^/"/
-$s/$/n"/
-'
+	  /* Call into the BFD backend to do the real work.  */
+	  if (! elf32_hppa_size_stubs (link_info.output_bfd,
+				       stub_file->the_bfd,
+				       &link_info,
+				       multi_subspace,
+				       group_size,
+				       &hppaelf_add_stub_section,
+				       &hppaelf_layout_sections_again))
+	    {
+	      einfo (_("%X%P: can not size stub section: %E\n"));
+	      return;
+	    }
+	}
+    }
 
-cat >>em_${EMULATION_NAME}.c <<EOF
-{			     
-  *isfile = 0;
-
-  if (link_info.relocateable == true && config.build_constructors == true)
-    return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
-  else if (link_info.relocateable == true)
-    return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
-  else if (!config.text_read_only)
-    return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
-  else if (!config.magic_demand_paged)
-    return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
-  else
-    return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
-}
-EOF
+  if (need_laying_out != -1)
+    ldelf_map_segments (need_laying_out);
+
+  if (!bfd_link_relocatable (&link_info))
+    {
+      /* Set the global data pointer.  */
+      if (! elf32_hppa_set_gp (link_info.output_bfd, &link_info))
+	{
+	  einfo (_("%X%P: can not set gp\n"));
+	  return;
+	}
 
-else
-# Scripts read from the filesystem.
-
-cat >>em_${EMULATION_NAME}.c <<EOF
-{			     
-  *isfile = 1;
-
-  if (link_info.relocateable == true && config.build_constructors == true)
-    return "ldscripts/${EMULATION_NAME}.xu";
-  else if (link_info.relocateable == true)
-    return "ldscripts/${EMULATION_NAME}.xr";
-  else if (!config.text_read_only)
-    return "ldscripts/${EMULATION_NAME}.xbn";
-  else if (!config.magic_demand_paged)
-    return "ldscripts/${EMULATION_NAME}.xn";
-  else
-    return "ldscripts/${EMULATION_NAME}.x";
+      /* Now build the linker stubs.  */
+      if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
+	{
+	  if (! elf32_hppa_build_stubs (&link_info))
+	    einfo (_("%X%P: can not build stubs: %E\n"));
+	}
+    }
 }
+
 EOF
 
-fi
+# Define some shell vars to insert bits of code into the standard elf
+# parse_args and list_options functions.
+#
+PARSE_AND_LIST_PROLOGUE='
+#define OPTION_MULTI_SUBSPACE		301
+#define OPTION_STUBGROUP_SIZE		(OPTION_MULTI_SUBSPACE + 1)
+'
 
-cat >>em_${EMULATION_NAME}.c <<EOF
+PARSE_AND_LIST_LONGOPTS='
+  { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
+  { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
+'
 
-struct ld_emulation_xfer_struct ld_hppaelf_emulation = 
-{
-  hppaelf_before_parse,
-  syslib_default,
-  hll_default,
-  after_parse_default,
-  after_allocation_default,
-  hppaelf_set_output_arch,
-  ldemul_default_target,
-  before_allocation_default,
-  hppaelf_get_script,
-  "hppaelf",
-  "elf32-hppa",
-  hppaelf_finish,
-  hppaelf_create_output_section_statements
-};
-EOF
+PARSE_AND_LIST_OPTIONS='
+  fprintf (file, _("\
+  --multi-subspace            Generate import and export stubs to support\n\
+                                multiple sub-space shared libraries\n"
+		   ));
+  fprintf (file, _("\
+  --stub-group-size=N         Maximum size of a group of input sections that\n\
+                                can be handled by one stub section.  A negative\n\
+                                value locates all stubs before their branches\n\
+                                (with a group size of -N), while a positive\n\
+                                value allows two groups of input sections, one\n\
+                                before, and one after each stub section.\n\
+                                Values of +/-1 indicate the linker should\n\
+                                choose suitable defaults.\n"
+		   ));
+'
+
+PARSE_AND_LIST_ARGS_CASES='
+    case OPTION_MULTI_SUBSPACE:
+      multi_subspace = 1;
+      break;
+
+    case OPTION_STUBGROUP_SIZE:
+      {
+	const char *end;
+	group_size = bfd_scan_vma (optarg, &end, 0);
+	if (*end)
+	  einfo (_("%F%P: invalid number `%s'\''\n"), optarg);
+      }
+      break;
+'
+
+# Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
+#
+LDEMUL_AFTER_PARSE=hppaelf_after_parse
+LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
+LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements