[patch] to ld: m68k ELF embedded relocs refinement

[msokolov at ivan dot Harhan dot ORG (Michael Sokolov)]

Hi there,

The m68k embedded ELF configuration (m68*-*-elf) always includes the coff-m68k
backend in BFD and specifically supports linking COFF objects into ELF
executables. I have just tested it and made sure that it still works, and made
it work with my embedded relocs feature. While doing this I've made one change
which I believe is the right change anyway. I've made my just-added m68k ELF
embedded relocs feature conditionalised on the m68*-*-elf target, i.e., not for
m68*-*-sysv4 or m68*-*-linux-gnu or whatever. For the embedded relocs feature
to work with cross-format linking, the ld emulation code for m68k ELF has to
call a COFF BFD backend routine. This is fine for the m68*-*-elf embedded
configuration, which always includes the coff-m68k backend in BFD, but not for
other ELF configurations which don't.

My original COFF version of m68k embedded relocs has always been for the
embedded COFF target only. That one is implemented in emultempl/m68kcoff.em,
which is used only by emulparams/m68kcoff.sh, which in turn is only used by the
m68*-*-coff target, but not any System V or Linux or other configurations.
emulparams/m68kelf.sh, OTOH, which pulls in my new emultempl/m68kelf.em, is
used by all m68k ELF configurations. This is currently absolutely harmless, as
the embedded relocs feature is only activated by a special command line option,
but adding cross-format linking support requires limiting it to the embedded
ELF target only. In any case I believe that this is the right thing to do
because it's an embedded feature and that's how it has always worked for COFF.

I believe that the right solution, which the patch below implements, is to keep
using my new emultempl/m68kelf.em for all m68k ELF configurations, but inside
it conditionalise the embedded relocs feature on the m68*-*-elf target. This is
because it's very clean and because I'll be soon adding some other special
features to m68k ELF which will have different enabling conditions.

--
Michael Sokolov		Harhan Engineering Laboratory
Public Service Agent	International Free Computing Task Force
			International Engineering and Science Task Force
			615 N GOOD LATIMER EXPY STE #4
			DALLAS TX 75204-5852 USA

Phone: +1-214-824-7693 (Harhan Eng Lab office)
E-mail: msokolov@ivan.Harhan.ORG (ARPA TCP/SMTP) (UUCP coming soon)

2000-09-16  Michael Sokolov  <msokolov@ivan.Harhan.ORG>

	* emultempl/m68kelf.em: Conditionalise the embedded relocs feature on
	the m68*-*-elf target.  Make it support COFF input objects.

Index: emultempl/m68kelf.em
===================================================================
RCS file: /cvs/src/src/ld/emultempl/m68kelf.em,v
retrieving revision 1.1
diff -c -r1.1 m68kelf.em
*** m68kelf.em	2000/09/15 18:52:52	1.1
--- m68kelf.em	2000/09/16 20:41:58
***************
*** 17,92 ****
  # 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- #
  
! # This file is sourced from elf32.em, and defines extra m68k ELF
! # specific routines.
! #
  cat >>e${EMULATION_NAME}.c <<EOF
  
  static void m68k_elf_after_open PARAMS((void));
  static void check_sections PARAMS ((bfd *, asection *, PTR));
  static void m68k_elf_after_allocation PARAMS ((void));
  
! /* This function is run after all the input files have been opened.
!    We create a .emreloc section for each input file with a non zero
!    .data section.  The BFD backend will fill in these sections with
!    magic numbers which can be used to relocate the data section at run
!    time.  */
  
  static void
  m68k_elf_after_open ()
  {
-   bfd *abfd;
- 
    /* Call the standard elf routine.  */
    gld${EMULATION_NAME}_after_open ();
- 
-   if (! command_line.embedded_relocs
-       || link_info.relocateable)
-     return;
  
!   for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next)
      {
!       asection *datasec;
  
!       /* As first-order business, make sure that each input BFD is ELF. It
!          better be, as we are directly calling a ELF backend function.  */
!       if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
! 	einfo ("%F%B: all input objects must be ELF for --embedded-relocs\n");
! 
!       datasec = bfd_get_section_by_name (abfd, ".data");
! 
!       /* Note that we assume that the reloc_count field has already
!          been set up.  We could call bfd_get_reloc_upper_bound, but
!          that returns the size of a memory buffer rather than a reloc
!          count.  We do not want to call bfd_canonicalize_reloc,
!          because although it would always work it would force us to
!          read in the relocs into BFD canonical form, which would waste
!          a significant amount of time and memory.  */
!       if (datasec != NULL && datasec->reloc_count > 0)
  	{
! 	  asection *relsec;
  
! 	  relsec = bfd_make_section (abfd, ".emreloc");
! 	  if (relsec == NULL
! 	      || ! bfd_set_section_flags (abfd, relsec,
! 					  (SEC_ALLOC
! 					   | SEC_LOAD
! 					   | SEC_HAS_CONTENTS
! 					   | SEC_IN_MEMORY))
! 	      || ! bfd_set_section_alignment (abfd, relsec, 2)
! 	      || ! bfd_set_section_size (abfd, relsec,
! 					 datasec->reloc_count * 12))
! 	    einfo ("%F%B: can not create .emreloc section: %E\n");
  	}
- 
-       /* Double check that all other data sections are empty, as is
-          required for embedded PIC code.  */
-       bfd_map_over_sections (abfd, check_sections, (PTR) datasec);
      }
  }
  
  /* Check that of the data sections, only the .data section has
     relocs.  This is called via bfd_map_over_sections.  */
  
--- 17,108 ----
  # 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  
! # This file is sourced from elf32.em, and defines some extra routines for m68k
! # embedded systems using ELF and for some other systems using m68k ELF. While
! # it is sourced from elf32.em for all m68k ELF configurations, here we include
! # only the features we want depending on the configuration.
! 
! case ${target} in
!   m68*-*-elf)
!     echo "#define SUPPORT_EMBEDDED_RELOCS" >>e${EMULATION_NAME}.c
!     ;;
! esac
! 
  cat >>e${EMULATION_NAME}.c <<EOF
  
  static void m68k_elf_after_open PARAMS((void));
+ #ifdef SUPPORT_EMBEDDED_RELOCS
  static void check_sections PARAMS ((bfd *, asection *, PTR));
+ #endif
  static void m68k_elf_after_allocation PARAMS ((void));
  
! /* This function is run after all the input files have been opened.  */
  
  static void
  m68k_elf_after_open ()
  {
    /* Call the standard elf routine.  */
    gld${EMULATION_NAME}_after_open ();
  
! #ifdef SUPPORT_EMBEDDED_RELOCS
!   if (command_line.embedded_relocs
!       && (! link_info.relocateable))
      {
!       bfd *abfd;
  
!       /* In the embedded relocs mode we create a .emreloc section for each
! 	 input file with a nonzero .data section.  The BFD backend will fill in
! 	 these sections with magic numbers which can be used to relocate the
! 	 data section at run time.  */
! 
!       for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next)
  	{
! 	  asection *datasec;
  
! 	  /* As first-order business, make sure that each input BFD is either
! 	     COFF or ELF.  We need to call a special BFD backend function to
! 	     generate the embedded relocs, and we have such functions only for
! 	     COFF and ELF.  */
! 	  if (bfd_get_flavour (abfd) != bfd_target_coff_flavour
! 	      && bfd_get_flavour (abfd) != bfd_target_elf_flavour)
! 	    einfo ("%F%B: all input objects must be COFF or ELF for --embedded-relocs\n");
! 
! 	  datasec = bfd_get_section_by_name (abfd, ".data");
! 
! 	  /* Note that we assume that the reloc_count field has already
! 	     been set up.  We could call bfd_get_reloc_upper_bound, but
! 	     that returns the size of a memory buffer rather than a reloc
! 	     count.  We do not want to call bfd_canonicalize_reloc,
! 	     because although it would always work it would force us to
! 	     read in the relocs into BFD canonical form, which would waste
! 	     a significant amount of time and memory.  */
! 	  if (datasec != NULL && datasec->reloc_count > 0)
! 	    {
! 	      asection *relsec;
! 
! 	      relsec = bfd_make_section (abfd, ".emreloc");
! 	      if (relsec == NULL
! 		  || ! bfd_set_section_flags (abfd, relsec,
! 					      (SEC_ALLOC
! 					       | SEC_LOAD
! 					       | SEC_HAS_CONTENTS
! 					       | SEC_IN_MEMORY))
! 		  || ! bfd_set_section_alignment (abfd, relsec, 2)
! 		  || ! bfd_set_section_size (abfd, relsec,
! 					     datasec->reloc_count * 12))
! 		einfo ("%F%B: can not create .emreloc section: %E\n");
! 	    }
! 
! 	  /* Double check that all other data sections are empty, as is
! 	     required for embedded PIC code.  */
! 	  bfd_map_over_sections (abfd, check_sections, (PTR) datasec);
  	}
      }
+ #endif /* SUPPORT_EMBEDDED_RELOCS */
  }
  
+ #ifdef SUPPORT_EMBEDDED_RELOCS
  /* Check that of the data sections, only the .data section has
     relocs.  This is called via bfd_map_over_sections.  */
  
***************
*** 102,149 ****
      einfo ("%B%X: section %s has relocs; can not use --embedded-relocs\n",
  	   abfd, bfd_get_section_name (abfd, sec));
  }
  
  /* This function is called after the section sizes and offsets have
!    been set.  If we are generating embedded relocs, it calls a special
!    BFD backend routine to do the work.  */
  
  static void
  m68k_elf_after_allocation ()
  {
-   bfd *abfd;
- 
    /* Call the standard elf routine.  */
    gld${EMULATION_NAME}_before_allocation ();
- 
-   if (! command_line.embedded_relocs
-       || link_info.relocateable)
-     return;
  
!   for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next)
      {
!       asection *datasec, *relsec;
!       char *errmsg;
  
!       datasec = bfd_get_section_by_name (abfd, ".data");
  
!       if (datasec == NULL || datasec->reloc_count == 0)
! 	continue;
  
!       relsec = bfd_get_section_by_name (abfd, ".emreloc");
!       ASSERT (relsec != NULL);
  
!       if (! bfd_m68k_elf32_create_embedded_relocs (abfd, &link_info,
! 						   datasec, relsec,
! 						   &errmsg))
! 	{
! 	  if (errmsg == NULL)
! 	    einfo ("%B%X: can not create runtime reloc information: %E\n",
! 		   abfd);
  	  else
! 	    einfo ("%X%B: can not create runtime reloc information: %s\n",
! 		   abfd, errmsg);
  	}
      }
  }
  
  EOF
--- 118,185 ----
      einfo ("%B%X: section %s has relocs; can not use --embedded-relocs\n",
  	   abfd, bfd_get_section_name (abfd, sec));
  }
+ #endif /* SUPPORT_EMBEDDED_RELOCS */
  
  /* This function is called after the section sizes and offsets have
!    been set.  */
  
  static void
  m68k_elf_after_allocation ()
  {
    /* Call the standard elf routine.  */
    gld${EMULATION_NAME}_before_allocation ();
  
! #ifdef SUPPORT_EMBEDDED_RELOCS
!   if (command_line.embedded_relocs
!       && (! link_info.relocateable))
      {
!       bfd *abfd;
  
!       /* If we are generating embedded relocs, call a special BFD backend
! 	 routine to do the work.  */
  
!       for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link_next)
! 	{
! 	  asection *datasec, *relsec;
! 	  char *errmsg;
  
! 	  datasec = bfd_get_section_by_name (abfd, ".data");
  
! 	  if (datasec == NULL || datasec->reloc_count == 0)
! 	    continue;
! 
! 	  relsec = bfd_get_section_by_name (abfd, ".emreloc");
! 	  ASSERT (relsec != NULL);
! 
! 	  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
! 	    {
! 	      if (! bfd_m68k_coff_create_embedded_relocs (abfd, &link_info,
! 							  datasec, relsec,
! 							  &errmsg))
! 		{
! 		  if (errmsg == NULL)
! 		    einfo ("%B%X: can not create runtime reloc information: %E\n", abfd);
! 		  else
! 		    einfo ("%X%B: can not create runtime reloc information: %s\n", abfd, errmsg);
! 		}
! 	    }
! 	  else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
! 	    {
! 	      if (! bfd_m68k_elf32_create_embedded_relocs (abfd, &link_info,
! 							   datasec, relsec,
! 							   &errmsg))
! 		{
! 		  if (errmsg == NULL)
! 		    einfo ("%B%X: can not create runtime reloc information: %E\n", abfd);
! 		  else
! 		    einfo ("%X%B: can not create runtime reloc information: %s\n", abfd, errmsg);
! 		}
! 	    }
  	  else
! 	    abort ();
  	}
      }
+ #endif /* SUPPORT_EMBEDDED_RELOCS */
  }
  
  EOF