[PATCH] Support for R_SPARC_OLO10 relocations

[PATCH] Support for R_SPARC_OLO10 relocations

[Jakub Jelinek]

Hi!

This patch adds support for R_SPARC_OLO10 relocation.
It is in fact a compound relocation equal to R_SPARC_LO10 and R_SPARC_13
with no symbol applied on top of it, so I have modelled the support from
elf64-mips.c which already supports compound relocations.
The syntax in the assembler is obvious:
	ld [%o1 + %lo(ab+12)], %o1
will generate normal R_SPARC_LO10 relocation with addend 12, while
	ld [%o1 + %lo(ab+12) + 24], %o1
will generate R_SPARC_OLO10 relocation with addend 12 and secondary addend
(stored in upper 24 bits of ELF64_R_TYPE) 24.
slurp_reloc_table will read all OLO10 relocations as LO10 and 13, because
there is no place to store secondary addend in arelent.
OLO10 is IMHO very useful, because gcc can now add constants to symbols
without having to worry about the symbol alignment. It should speed up
access to array members at constant offsets if a routine accesses more than
two different ones.

1999-07-05  Jakub Jelinek  <jj@ultra.linux.cz>

	* bfd/elf64-sparc.c (sparc64_elf_info_to_howto): Use ELF64_R_TYPE_ID.
	(sparc64_elf_get_reloc_upper_bound,
	sparc64_elf_get_dynamic_reloc_upper_bound,
	sparc64_elf_slurp_one_reloc_table, sparc64_elf_slurp_reloc_table,
	sparc64_elf_canonicalize_dynamic_reloc, sparc64_elf_write_relocs):
	New functions.
	(sparc64_elf_check_relocs, sparc64_elf_relocate_section): Use
	ELF64_R_TYPE_ID/DATA where appropriate.
	* binutils/readelf.c (guess_is_rela): Sparcv9 and v8plus use rela.
	(dump_relocations): Use ELF64_R_TYPE_ID for Sparc, for R_SPARC_OLO10
	print the secondary addend.
	(get_machine_flags): Print Sparc machine flags.
	(get_symbol_type): Print STT_REGISTER.
	* include/elf/sparc.h (ELF64_R_TYPE_DATA): Sign extend the value.
	(ELF64_R_TYPE_INFO): Mask out all but low 24 bits of data.
	* opcodes/sparc-dis.c (print_insn_sparc): Differentiate between
	addition and oring when guessing symbol for comment.
	* gas/config/tc-sparc.c (sparc_ip): Allow OLO10 relocations
	on -64 and not pic.
	(output_insn): Put OLO10's secondary addend into tc_fix_data.
	(md_apply_fix3): Handle BFD_RELOC_SPARC_OLO10.
	(tc_gen_reloc): Return two relocs for OLO10, LO10 and SPARC13.
	* gas/config/tc-sparc.h (RELOC_EXPANSION_POSSIBLE,
	MAX_RELOC_EXPANSION): Define.
	(TC_FIX_TYPE, TC_INIT_FIX_DATA, TC_FIX_DATA_PRINT): Likewise.

--- ./bfd/elf64-sparc.c.jj	Tue Jun 29 10:47:08 1999
+++ ./bfd/elf64-sparc.c	Mon Jul  5 17:11:20 1999
@@ -61,6 +61,15 @@ static boolean sparc64_elf_relocate_sect
   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
 	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
 static boolean sparc64_elf_object_p PARAMS ((bfd *));
+static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *));
+static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
+static boolean sparc64_elf_slurp_one_reloc_table
+  PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean));
+static boolean sparc64_elf_slurp_reloc_table
+  PARAMS ((bfd *, asection *, asymbol **, boolean));
+static long sparc64_elf_canonicalize_dynamic_reloc
+  PARAMS ((bfd *, arelent **, asymbol **));
+static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR));
 \f
 /* The relocation "howto" table.  */
 
@@ -213,8 +222,380 @@ sparc64_elf_info_to_howto (abfd, cache_p
      arelent *cache_ptr;
      Elf64_Internal_Rela *dst;
 {
-  BFD_ASSERT (ELF64_R_TYPE (dst->r_info) < (unsigned int) R_SPARC_max_std);
-  cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE (dst->r_info)];
+  BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std);
+  cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)];
+}
+\f
+/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
+   section can represent up to two relocs, we must tell the user to allocate
+   more space.  */
+   
+static long
+sparc64_elf_get_reloc_upper_bound (abfd, sec)
+     bfd *abfd;
+     asection *sec;
+{
+  return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
+}
+
+static long
+sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
+     bfd *abfd;
+{
+  return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
+}
+
+/* Read  relocations for ASECT from REL_HDR.  There are RELOC_COUNT of 
+   them.  We cannot use generic elf routines for this,  because R_SPARC_OLO10
+   has secondary addend in ELF64_R_TYPE_DATA.  We handle it as two relocations
+   for the same location,  R_SPARC_LO10 and R_SPARC_13.  */
+
+static boolean
+sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
+     bfd *abfd;
+     asection *asect;
+     Elf_Internal_Shdr *rel_hdr;
+     asymbol **symbols;
+     boolean dynamic;
+{
+  struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
+  PTR allocated = NULL;
+  bfd_byte *native_relocs;
+  arelent *relent;
+  unsigned int i;
+  int entsize;
+  bfd_size_type count;
+  arelent *relents;
+
+  allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
+  if (allocated == NULL)
+    goto error_return;
+
+  if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
+      || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
+	  != rel_hdr->sh_size))
+    goto error_return;
+
+  native_relocs = (bfd_byte *) allocated;
+
+  relents = asect->relocation + asect->reloc_count;
+
+  entsize = rel_hdr->sh_entsize;
+  BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
+  
+  count = rel_hdr->sh_size / entsize;
+
+  for (i = 0, relent = relents; i < count;
+       i++, relent++, native_relocs += entsize)
+    {
+      Elf_Internal_Rela rela;
+
+      bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela);
+
+      /* The address of an ELF reloc is section relative for an object
+	 file, and absolute for an executable file or shared library.
+	 The address of a normal BFD reloc is always section relative,
+	 and the address of a dynamic reloc is absolute..  */
+      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
+	relent->address = rela.r_offset;
+      else
+	relent->address = rela.r_offset - asect->vma;
+
+      if (ELF64_R_SYM (rela.r_info) == 0)
+	relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+      else
+	{
+	  asymbol **ps, *s;
+
+	  ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
+	  s = *ps;
+
+	  /* Canonicalize ELF section symbols.  FIXME: Why?  */
+	  if ((s->flags & BSF_SECTION_SYM) == 0)
+	    relent->sym_ptr_ptr = ps;
+	  else
+	    relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
+	}
+
+      relent->addend = rela.r_addend;
+
+      BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std);
+      if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10)
+	{
+	  relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10];
+	  relent[1].address = relent->address;
+	  relent++;
+	  relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+	  relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
+	  relent->howto = &sparc64_elf_howto_table[R_SPARC_13];
+	}
+      else
+	relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)];
+    }
+
+  asect->reloc_count += relent - relents;
+
+  if (allocated != NULL)
+    free (allocated);
+
+  return true;
+
+ error_return:
+  if (allocated != NULL)
+    free (allocated);
+  return false;
+}
+
+/* Read in and swap the external relocs.  */
+
+static boolean
+sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
+     bfd *abfd;
+     asection *asect;
+     asymbol **symbols;
+     boolean dynamic;
+{
+  struct bfd_elf_section_data * const d = elf_section_data (asect);
+  Elf_Internal_Shdr *rel_hdr;
+  Elf_Internal_Shdr *rel_hdr2;
+
+  if (asect->relocation != NULL)
+    return true;
+
+  if (! dynamic)
+    {
+      if ((asect->flags & SEC_RELOC) == 0
+	  || asect->reloc_count == 0)
+	return true;
+
+      rel_hdr = &d->rel_hdr;
+      rel_hdr2 = d->rel_hdr2;
+
+      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
+		  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
+    }
+  else
+    {
+      /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
+	 case because relocations against this section may use the
+	 dynamic symbol table, and in that case bfd_section_from_shdr
+	 in elf.c does not update the RELOC_COUNT.  */
+      if (asect->_raw_size == 0)
+	return true;
+
+      rel_hdr = &d->this_hdr;
+      asect->reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize;
+      rel_hdr2 = NULL;
+    }
+
+  asect->relocation = ((arelent *) 
+		       bfd_alloc (abfd, 
+				  asect->reloc_count * 2 * sizeof (arelent)));
+  if (asect->relocation == NULL)
+    return false;
+
+  /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count.  */
+  asect->reloc_count = 0;
+    
+  if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
+					  dynamic))
+    return false;
+  
+  if (rel_hdr2 
+      && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
+					     dynamic))
+    return false;
+
+  return true;
+}
+
+/* Canonicalize the dynamic relocation entries.  Note that we return
+   the dynamic relocations as a single block, although they are
+   actually associated with particular sections; the interface, which
+   was designed for SunOS style shared libraries, expects that there
+   is only one set of dynamic relocs.  Any section that was actually
+   installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
+   the dynamic symbol table, is considered to be a dynamic reloc
+   section.  */
+
+static long
+sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
+     bfd *abfd;
+     arelent **storage;
+     asymbol **syms;
+{
+  asection *s;
+  long ret;
+
+  if (elf_dynsymtab (abfd) == 0)
+    {
+      bfd_set_error (bfd_error_invalid_operation);
+      return -1;
+    }
+
+  ret = 0;
+  for (s = abfd->sections; s != NULL; s = s->next)
+    {
+      if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
+	  && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
+	{
+	  arelent *p;
+	  long count, i;
+
+	  if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true))
+	    return -1;
+	  count = s->reloc_count;
+	  p = s->relocation;
+	  for (i = 0; i < count; i++)
+	    *storage++ = p++;
+	  ret += count;
+	}
+    }
+
+  *storage = NULL;
+
+  return ret;
+}
+
+/* Write out the relocs.  */
+
+static void
+sparc64_elf_write_relocs (abfd, sec, data)
+     bfd *abfd;
+     asection *sec;
+     PTR data;
+{
+  boolean *failedp = (boolean *) data;
+  Elf_Internal_Shdr *rela_hdr;
+  Elf64_External_Rela *outbound_relocas;
+  unsigned int idx, count;
+  asymbol *last_sym = 0;
+  int last_sym_idx = 0;
+
+  /* If we have already failed, don't do anything.  */
+  if (*failedp)
+    return;
+
+  if ((sec->flags & SEC_RELOC) == 0)
+    return;
+
+  /* The linker backend writes the relocs out itself, and sets the
+     reloc_count field to zero to inhibit writing them here.  Also,
+     sometimes the SEC_RELOC flag gets set even when there aren't any
+     relocs.  */
+  if (sec->reloc_count == 0)
+    return;
+
+  /* We can combine two relocs that refer to the same address
+     into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
+     latter is R_SPARC_13 with no associated symbol.  */
+  count = 0;
+  for (idx = 0; idx < sec->reloc_count; idx++)
+    {
+      bfd_vma addr;
+      unsigned int i;
+
+      ++count;
+
+      addr = sec->orelocation[idx]->address;
+      if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
+	  && idx < sec->reloc_count + 1)
+	{
+	  arelent *r = sec->orelocation[idx + 1];
+
+	  if (r->howto->type == R_SPARC_13
+	      && r->address == addr
+	      && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
+	      && (*r->sym_ptr_ptr)->value == 0)
+	    ++idx;
+	}
+    }
+
+  rela_hdr = &elf_section_data (sec)->rel_hdr;
+
+  rela_hdr->sh_size = rela_hdr->sh_entsize * count;
+  rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
+  if (rela_hdr->contents == NULL)
+    {
+      *failedp = true;
+      return;
+    }
+
+  /* Figure out whether the relocations are RELA or REL relocations.  */
+  if (rela_hdr->sh_type != SHT_RELA)
+    abort ();
+
+  /* orelocation has the data, reloc_count has the count... */
+  outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
+
+  for (idx = 0; idx < sec->reloc_count; idx++)
+    {
+      Elf_Internal_Rela dst_rela;
+      Elf64_External_Rela *src_rela;
+      arelent *ptr;
+      asymbol *sym;
+      int n;
+
+      ptr = sec->orelocation[idx];
+      src_rela = outbound_relocas + idx;
+
+      /* The address of an ELF reloc is section relative for an object
+	 file, and absolute for an executable file or shared library.
+	 The address of a BFD reloc is always section relative.  */
+      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
+	dst_rela.r_offset = ptr->address;
+      else
+	dst_rela.r_offset = ptr->address + sec->vma;
+
+      sym = *ptr->sym_ptr_ptr;
+      if (sym == last_sym)
+	n = last_sym_idx;
+      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
+	n = STN_UNDEF;
+      else
+	{
+	  last_sym = sym;
+	  n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
+	  if (n < 0)
+	    {
+	      *failedp = true;
+	      return;
+	    }
+	  last_sym_idx = n;
+	}
+
+      if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
+	  && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
+	  && ! _bfd_elf_validate_reloc (abfd, ptr))
+	{
+	  *failedp = true;
+	  return;
+	}
+
+      if (ptr->howto->type == R_SPARC_LO10
+	  && idx < sec->reloc_count - 1)
+	{
+	  arelent *r = sec->orelocation[idx + 1];
+
+	  if (r->howto->type == R_SPARC_13
+	      && r->address == ptr->address
+	      && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
+	      && (*r->sym_ptr_ptr)->value == 0)
+	    {
+	      idx++;
+	      dst_rela.r_info
+		= ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
+						      R_SPARC_OLO10));
+	    }
+	  else
+	    dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
+	}
+      else
+	dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
+
+      dst_rela.r_addend = ptr->addend;
+      bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela);
+    }
 }
 \f
 /* Utility for performing the standard initial work of an instruction
@@ -570,7 +951,7 @@ sparc64_elf_check_relocs (abfd, info, se
       else
 	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 
-      switch (ELF64_R_TYPE (rel->r_info))
+      switch (ELF64_R_TYPE_ID (rel->r_info))
 	{
 	case R_SPARC_GOT10:
 	case R_SPARC_GOT13:
@@ -809,7 +1190,7 @@ sparc64_elf_check_relocs (abfd, info, se
 	default:
 	  (*_bfd_error_handler)(_("%s: check_relocs: unhandled reloc type %d"),
 				bfd_get_filename(abfd),
-				ELF64_R_TYPE (rel->r_info));
+				ELF64_R_TYPE_ID (rel->r_info));
 	  return false;
 	}
     }
@@ -1245,7 +1626,7 @@ sparc64_elf_relocate_section (output_bfd
       bfd_vma relocation;
       bfd_reloc_status_type r;
 
-      r_type = ELF64_R_TYPE (rel->r_info);
+      r_type = ELF64_R_TYPE_ID (rel->r_info);
       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
 	{
 	  bfd_set_error (bfd_error_bad_value);
@@ -1531,7 +1912,11 @@ sparc64_elf_relocate_section (output_bfd
 				 & ELF_LINK_HASH_DEF_REGULAR) == 0))
 		  {
 		    BFD_ASSERT (h->dynindx != -1);
-		    outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
+		    outrel.r_info
+		      = ELF64_R_INFO (h->dynindx,
+				      ELF64_R_TYPE_INFO (
+					ELF64_R_TYPE_DATA (rel->r_info),
+							   r_type));
 		    outrel.r_addend = rel->r_addend;
 		  }
 		else
@@ -1581,7 +1966,11 @@ sparc64_elf_relocate_section (output_bfd
 			      }
 			  }
 
-			outrel.r_info = ELF64_R_INFO (indx, r_type);
+			outrel.r_info
+			  = ELF64_R_INFO (indx,
+					  ELF64_R_TYPE_INFO (
+					    ELF64_R_TYPE_DATA (rel->r_info),
+							       r_type));
 
 			/* For non-RELATIVE dynamic relocations, we keep the
 			   same symbol, and so generally the same addend.  But
@@ -1605,7 +1994,7 @@ sparc64_elf_relocate_section (output_bfd
 		   reloc in an unallocated section.  */
 		if (skip
 		    || (input_section->flags & SEC_ALLOC) != 0
-		    || ELF64_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE)
+		    || ELF64_R_TYPE_ID (outrel.r_info) != R_SPARC_RELATIVE)
 		  continue;
 	      }
 	    break;
@@ -2225,6 +2614,34 @@ sparc64_elf_object_p (abfd)
   return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
 }
 
+/* Relocations in the 64 bit SPARC ELF ABI are more complex than in
+   standard ELF, because R_SPARC_OLO10 has secondary addend in
+   ELF64_R_TYPE_DATA field.  This structure is used to redirect the
+   relocation handling routines.  */
+
+const struct elf_size_info sparc64_elf_size_info =
+{
+  sizeof (Elf64_External_Ehdr),
+  sizeof (Elf64_External_Phdr),
+  sizeof (Elf64_External_Shdr),
+  sizeof (Elf64_External_Rel),
+  sizeof (Elf64_External_Rela),
+  sizeof (Elf64_External_Sym),
+  sizeof (Elf64_External_Dyn),
+  sizeof (Elf_External_Note),
+  64,		/* arch_size */
+  8,		/* file_align */
+  ELFCLASS64,
+  EV_CURRENT,
+  bfd_elf64_write_out_phdrs,
+  bfd_elf64_write_shdrs_and_ehdr,
+  sparc64_elf_write_relocs,
+  bfd_elf64_swap_symbol_out,
+  sparc64_elf_slurp_reloc_table,
+  bfd_elf64_slurp_symbol_table,
+  bfd_elf64_swap_dyn_in
+};
+
 #define TARGET_BIG_SYM	bfd_elf64_sparc_vec
 #define TARGET_BIG_NAME	"elf64-sparc"
 #define ELF_ARCH	bfd_arch_sparc
@@ -2238,6 +2655,12 @@ sparc64_elf_object_p (abfd)
 
 #define elf_info_to_howto \
   sparc64_elf_info_to_howto
+#define bfd_elf64_get_reloc_upper_bound \
+  sparc64_elf_get_reloc_upper_bound
+#define bfd_elf64_get_dynamic_reloc_upper_bound \
+  sparc64_elf_get_dynamic_reloc_upper_bound
+#define bfd_elf64_canonicalize_dynamic_reloc \
+  sparc64_elf_canonicalize_dynamic_reloc
 #define bfd_elf64_bfd_reloc_type_lookup \
   sparc64_elf_reloc_type_lookup
 
@@ -2259,6 +2682,8 @@ sparc64_elf_object_p (abfd)
 #define bfd_elf64_bfd_merge_private_bfd_data \
   sparc64_elf_merge_private_bfd_data
 
+#define elf_backend_size_info \
+  sparc64_elf_size_info
 #define elf_backend_object_p \
   sparc64_elf_object_p
 
--- ./binutils/readelf.c.jj	Tue Jun 29 10:48:20 1999
+++ ./binutils/readelf.c	Mon Jul  5 14:55:30 1999
@@ -414,6 +414,8 @@ guess_is_rela (e_machine)
       
       /* Targets that use RELA relocations.  */
     case EM_68K:
+    case EM_SPARC32PLUS:
+    case EM_SPARCV9:
     case EM_SPARC:
     case EM_PPC:
     case EM_CYGNUS_V850:
@@ -605,7 +607,10 @@ dump_relocations (file, rel_offset, rel_
 	}
       else
 	{
-	  type         = ELF64_R_TYPE (info);
+	  if (elf_header.e_machine == EM_SPARCV9)
+	    type       = ELF64_R_TYPE_ID (info);
+	  else
+	    type       = ELF64_R_TYPE (info);
 	  symtab_index = ELF64_R_SYM  (info);
 	}
 
@@ -742,6 +747,10 @@ dump_relocations (file, rel_offset, rel_
       else if (is_rela)
 	printf ("%34c%lx", ' ', (unsigned long) relas[i].r_addend);
 
+      if (elf_header.e_machine == EM_SPARCV9
+	  && !strcmp (rtype, "R_SPARC_OLO10"))
+	printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
+
       putchar ('\n');
     }
 
@@ -1062,6 +1071,29 @@ get_machine_flags (e_flags, e_machine)
 	  if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
 	    strcat (buf, ", mips4");
 	  break;
+
+	case EM_SPARCV9:
+	  if (e_flags & EF_SPARC_32PLUS)
+	    strcat (buf, ", v8+");
+
+	  if (e_flags & EF_SPARC_SUN_US1)
+	    strcat (buf, ", ultrasparc");
+
+	  if (e_flags & EF_SPARC_HAL_R1)
+	    strcat (buf, ", halr1");
+
+	  if (e_flags & EF_SPARC_LEDATA)
+	    strcat (buf, ", ledata");
+
+	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
+	    strcat (buf, ", tso");
+
+	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
+	    strcat (buf, ", pso");
+
+	  if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
+	    strcat (buf, ", rmo");
+	  break;
 	}
     }
 
@@ -3393,6 +3425,9 @@ get_symbol_type (type)
 	{
 	  if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
 	    return _("THUMB_FUNC");
+	    
+	  if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
+	    return _("REGISTER");
 	  
 	  sprintf (buff, _("<processor specific>: %d"), type);
 	}
--- ./include/elf/sparc.h.jj	Tue Jun 29 10:51:49 1999
+++ ./include/elf/sparc.h	Mon Jul  5 14:44:35 1999
@@ -138,9 +138,9 @@ END_RELOC_NUMBERS
 
 /* Relocation macros.  */
 
-#define ELF64_R_TYPE_DATA(info)		(((bfd_vma) (info) << 32) >> 40)
+#define ELF64_R_TYPE_DATA(info)		(((bfd_signed_vma) (info) << 32) >> 40)
 #define ELF64_R_TYPE_ID(info)		(((bfd_vma) (info) << 56) >> 56)
-#define ELF64_R_TYPE_INFO(data, type)	(((bfd_vma) (data) << 8) \
+#define ELF64_R_TYPE_INFO(data, type)	(((((bfd_vma) (data)) & 0xffffff) << 8) \
 					 + (bfd_vma) (type))
 
 #define DT_SPARC_REGISTER	0x70000001
--- ./opcodes/sparc-dis.c.jj	Mon May  3 09:29:00 1999
+++ ./opcodes/sparc-dis.c	Mon Jul  5 17:17:50 1999
@@ -283,6 +283,7 @@ print_insn_sparc (memaddr, info)
 	  /* Nonzero means that we have found an instruction which has
 	     the effect of adding or or'ing the imm13 field to rs1.  */
 	  int imm_added_to_rs1 = 0;
+	  int imm_ored_to_rs1 = 0;
 
 	  /* Nonzero means that we have found a plus sign in the args
 	     field of the opcode table.  */
@@ -293,8 +294,9 @@ print_insn_sparc (memaddr, info)
 
 	  /* Do we have an `add' or `or' instruction combining an
              immediate with rs1?  */
-	  if (opcode->match == 0x80102000 || opcode->match == 0x80002000)
-	  /*			  (or)				 (add)  */
+	  if (opcode->match == 0x80102000) /* or */
+	    imm_ored_to_rs1 = 1;
+	  if (opcode->match == 0x80002000) /* add */
 	    imm_added_to_rs1 = 1;
 
 	  if (X_RS1 (insn) != X_RD (insn)
@@ -670,7 +672,7 @@ print_insn_sparc (memaddr, info)
 	     If so, attempt to print the result of the add or
 	     or (in this context add and or do the same thing)
 	     and its symbolic value.  */
-	  if (imm_added_to_rs1)
+	  if (imm_ored_to_rs1 || imm_added_to_rs1)
 	    {
 	      unsigned long prev_insn;
 	      int errcode;
@@ -709,8 +711,11 @@ print_insn_sparc (memaddr, info)
 		    {
 		      (*info->fprintf_func) (stream, "\t! ");
 		      info->target = 
-			(0xFFFFFFFF & (int) X_IMM22 (prev_insn) << 10)
-			| X_SIMM (insn, 13);
+			(0xFFFFFFFF & (int) X_IMM22 (prev_insn) << 10);
+		      if (imm_added_to_rs1)
+			info->target += X_SIMM (insn, 13);
+		      else
+			info->target |= X_SIMM (insn, 13);
 		      (*info->print_address_func) (info->target, info);
 		      info->insn_type = dis_dref;
 		      info->data_size = 4;  /* FIXME!!! */
--- ./gas/config/tc-sparc.c.jj	Sat Jul  3 18:31:35 1999
+++ ./gas/config/tc-sparc.c	Mon Jul  5 14:31:44 1999
@@ -2248,7 +2248,7 @@ sparc_ip (str, pinsn)
 		      }
 		    else
 		      {
-			if (1 || old_reloc != BFD_RELOC_SPARC13
+			if (old_reloc != BFD_RELOC_SPARC13
 			    || the_insn.reloc != BFD_RELOC_LO10
 			    || sparc_arch_size != 64
 			    || sparc_pic_code)
@@ -2667,6 +2667,8 @@ output_insn (insn, the_insn)
 	 the insn size is 4 and fixup_segment will signal an overflow for
 	 large 8 byte quantities.  */
       fixP->fx_no_overflow = 1;
+      if (the_insn->reloc == BFD_RELOC_SPARC_OLO10)
+	fixP->tc_fix_data = the_insn->exp2.X_add_number;
     }
 
   last_insn = insn;
@@ -3001,6 +3003,11 @@ md_apply_fix3 (fixP, value, segment)
 	    }
 	  break;
 
+	case BFD_RELOC_SPARC_OLO10:
+	  val &= 0x3ff;
+	  val += fixP->tc_fix_data;
+	  /* intentional fallthrough */
+
 	case BFD_RELOC_SPARC13:
 	  if (! in_signed_range (val, 0x1fff))
 	    as_bad_where (fixP->fx_file, fixP->fx_line,
@@ -3070,15 +3077,17 @@ md_apply_fix3 (fixP, value, segment)
 
 /* Translate internal representation of relocation info to BFD target
    format.  */
-arelent *
+arelent **
 tc_gen_reloc (section, fixp)
      asection *section;
      fixS *fixp;
 {
+  static arelent *relocs[3];
   arelent *reloc;
   bfd_reloc_code_real_type code;
 
-  reloc = (arelent *) xmalloc (sizeof (arelent));
+  relocs[0] = reloc = (arelent *) xmalloc (sizeof (arelent));
+  relocs[1] = NULL;
 
   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
@@ -3115,6 +3124,7 @@ tc_gen_reloc (section, fixp)
     case BFD_RELOC_SPARC_HIX22:
     case BFD_RELOC_SPARC_LOX10:
     case BFD_RELOC_SPARC_REV32:
+    case BFD_RELOC_SPARC_OLO10:
     case BFD_RELOC_VTABLE_ENTRY:
     case BFD_RELOC_VTABLE_INHERIT:
       code = fixp->fx_r_type;
@@ -3168,13 +3178,18 @@ tc_gen_reloc (section, fixp)
     }
 #endif /* defined (OBJ_ELF) || defined (OBJ_AOUT) */
 
-  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
+  if (code == BFD_RELOC_SPARC_OLO10)
+    reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO10);
+  else
+    reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
   if (reloc->howto == 0)
     {
       as_bad_where (fixp->fx_file, fixp->fx_line,
 		    _("internal error: can't export reloc type %d (`%s')"),
 		    fixp->fx_r_type, bfd_get_reloc_code_name (code));
-      return 0;
+      xfree (reloc);
+      relocs[0] = NULL;
+      return relocs;
     }
 
   /* @@ Why fx_addnumber sometimes and fx_offset other times?  */
@@ -3209,7 +3224,21 @@ tc_gen_reloc (section, fixp)
     reloc->addend = fixp->fx_offset;
 #endif
 
-  return reloc;
+  /* We expand R_SPARC_OLO10 to R_SPARC_LO10 and R_SPARC_13
+     on the same location.  */
+  if (code == BFD_RELOC_SPARC_OLO10)
+    {
+      relocs[1] = reloc = (arelent *) xmalloc (sizeof (arelent));
+      relocs[2] = NULL;
+
+      reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+      *reloc->sym_ptr_ptr = symbol_get_bfdsym (section_symbol (absolute_section));
+      reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
+      reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_SPARC13);
+      reloc->addend = fixp->tc_fix_data;
+    }
+
+  return relocs;
 }
 \f
 /* We have no need to default values of symbols. */
--- ./gas/config/tc-sparc.h.jj	Tue Jun 29 10:49:38 1999
+++ ./gas/config/tc-sparc.h	Mon Jul  5 14:15:17 1999
@@ -35,6 +35,9 @@ struct frag;
 extern const char *sparc_target_format PARAMS ((void));
 #define TARGET_FORMAT sparc_target_format ()
 
+#define RELOC_EXPANSION_POSSIBLE
+#define MAX_RELOC_EXPANSION 2
+
 #if 0
 #ifdef TE_SPARCAOUT
 /* Bi-endian support may eventually be unconditional, but until things are
@@ -160,5 +163,22 @@ extern void sparc_md_end PARAMS ((void))
 #define TC_CONS_FIX_NEW cons_fix_new_sparc
 extern void cons_fix_new_sparc
   PARAMS ((struct frag *, int, unsigned int, struct expressionS *));
+
+#define TC_FIX_TYPE	valueT
+
+#define TC_INIT_FIX_DATA(X)			\
+  do						\
+     {						\
+       (X)->tc_fix_data = 0;			\
+     }						\
+  while(0)
+
+#define TC_FIX_DATA_PRINT(FILE, FIXP)					\
+  do									\
+    {									\
+      fprintf((FILE), "addend2=%ld\n",   				\
+	      (unsigned long) (FIXP)->tc_fix_data);			\
+    }									\
+  while(0)
 
 /* end of tc-sparc.h */

Cheers,
    Jakub
___________________________________________________________________
Jakub Jelinek | jj@sunsite.mff.cuni.cz | http://sunsite.mff.cuni.cz
Administrator of SunSITE Czech Republic, MFF, Charles University
___________________________________________________________________
UltraLinux  |  http://ultra.linux.cz/  |  http://ultra.penguin.cz/
Linux version 2.2.10 on a sparc64 machine (1343.49 BogoMips)
___________________________________________________________________

Re: [PATCH] Support for R_SPARC_OLO10 relocations

[Richard Henderson]

On Mon, Jul 05, 1999 at 05:47:29PM +0200, Jakub Jelinek wrote:
> This patch adds support for R_SPARC_OLO10 relocation.

I'm getting errors compiling this code.

gcc -DHAVE_CONFIG_H -I. -I../../../binutils/bfd -I. -D_GNU_SOURCE -I. -I../../..
/binutils/bfd -I../../../binutils/bfd/../include -I../../../binutils/bfd/../intl
 -I../intl -g -O2 -c ../../../binutils/bfd/elf64-sparc.c -o elf64-sparc.o
.../elf64-sparc.c:2636: warning: initialization makes integer from pointer without a cast
.../elf64-sparc.c:2636: initializer element is not computable at load time
.../elf64-sparc.c:2636: (near initialization for `sparc64_elf_size_info.elfclass')
.../elf64-sparc.c:2637: warning: initialization makes integer from pointer without a cast
.../elf64-sparc.c:2637: initializer element is not computable at load time
...elf64-sparc.c:2637: (near initialization for `sparc64_elf_size_info.ev_current')
.../elf64-sparc.c:2638: warning: initialization from incompatible pointer type
.../elf64-sparc.c:2639: warning: initialization from incompatible pointer type
.../elf64-sparc.c:2640: warning: initialization from incompatible pointer type
.../elf64-sparc.c:2641: warning: initialization from incompatible pointer type
.../elf64-sparc.c:2643: warning: initialization from incompatible pointer type

Would you please update from cvs and make a new patch?

> 	* binutils/readelf.c (guess_is_rela): Sparcv9 and v8plus use rela.
> 	(dump_relocations): Use ELF64_R_TYPE_ID for Sparc, for R_SPARC_OLO10
> 	print the secondary addend.
> 	(get_machine_flags): Print Sparc machine flags.
> 	(get_symbol_type): Print STT_REGISTER.
> 	* include/elf/sparc.h (ELF64_R_TYPE_DATA): Sign extend the value.
> 	(ELF64_R_TYPE_INFO): Mask out all but low 24 bits of data.
> 	* opcodes/sparc-dis.c (print_insn_sparc): Differentiate between
> 	addition and oring when guessing symbol for comment.

These bits I went ahead and put in.


r~

Re: [PATCH] Support for R_SPARC_OLO10 relocations

[Richard Henderson]

On Mon, Jul 05, 1999 at 05:47:29PM +0200, Jakub Jelinek wrote:
> 	* include/elf/sparc.h (ELF64_R_TYPE_DATA): Sign extend the value.
> 	(ELF64_R_TYPE_INFO): Mask out all but low 24 bits of data.

Actually, these macros macros made assumptions about the size
of bfd_vma.  They did before your patch too, so I don't hold
that against you, but that doesn't mean it doesn't want fixing.

Plus I went ahead and killed DT_SPARC_PLTFMT.  It was me that
added it in the first place, before we had a real ABI.

I committed this.


r~


Index: sparc.h
===================================================================
RCS file: /cvs/binutils/binutils/include/elf/sparc.h,v
retrieving revision 1.2
diff -c -p -d -r1.2 sparc.h
*** sparc.h	1999/06/10 21:00:53	1.2
--- sparc.h	1999/07/08 23:00:24
*************** END_RELOC_NUMBERS
*** 138,158 ****
  
  /* Relocation macros.  */
  
! #define ELF64_R_TYPE_DATA(info)		(((bfd_vma) (info) << 32) >> 40)
! #define ELF64_R_TYPE_ID(info)		(((bfd_vma) (info) << 56) >> 56)
! #define ELF64_R_TYPE_INFO(data, type)	(((bfd_vma) (data) << 8) \
! 					 + (bfd_vma) (type))
! 
! #define DT_SPARC_REGISTER	0x70000001
  
! /*
!  * FIXME: NOT ABI -- GET RID OF THIS
!  * Defines the format used by the .plt.  Currently defined values are
!  *   0 -- reserved to SI
!  *   1 -- absolute address in .got.plt
!  *   2 -- got-relative address in .got.plt
!  */
  
! #define DT_SPARC_PLTFMT		0x70000001
  
  #endif /* _ELF_SPARC_H */
--- 138,152 ----
  
  /* Relocation macros.  */
  
! #define ELF64_R_TYPE_DATA(info) \
!   (((bfd_signed_vma)((info) >> 8) ^ 0x800000) - 0x800000)
! #define ELF64_R_TYPE_ID(info) \
!   ((info) & 0xff)
! #define ELF64_R_TYPE_INFO(data, type) \
!   (((bfd_vma) ((data) & 0xffffff) << 8) | (bfd_vma) (type))
  
! /* Values for Elf64_Dyn.d_tag.  */
  
! #define DT_SPARC_REGISTER	0x70000001
  
  #endif /* _ELF_SPARC_H */

Re: [PATCH] Support for R_SPARC_OLO10 relocations

[Ian Lance Taylor]

   Date: Mon, 5 Jul 1999 17:47:29 +0200
   From: Jakub Jelinek <jj@sunsite.ms.mff.cuni.cz>

   This patch adds support for R_SPARC_OLO10 relocation.
   It is in fact a compound relocation equal to R_SPARC_LO10 and R_SPARC_13
   with no symbol applied on top of it, so I have modelled the support from
   elf64-mips.c which already supports compound relocations.

Are you copying some existing ABI?  I ask because this implementation
seems overly complex.  There is already a place to store the addend:
the instruction itself.  I don't see any reason to store an additional
addend in the Rela structure.  The range of possible values would seem
to be limited by the nature of the relocation.

This patch seems to have several parts which are unrelated to
R_SPARC_OLO10 support, such as the readelf.c and the sparc-dis.c
patches.  Please submit unrelated patches separately.  That will speed
the process of checking them in.  Thanks.

   --- ./include/elf/sparc.h.jj	Tue Jun 29 10:51:49 1999
   +++ ./include/elf/sparc.h	Mon Jul  5 14:44:35 1999
   @@ -138,9 +138,9 @@ END_RELOC_NUMBERS

    /* Relocation macros.  */

   -#define ELF64_R_TYPE_DATA(info)		(((bfd_vma) (info) << 32) >> 40)
   +#define ELF64_R_TYPE_DATA(info)		(((bfd_signed_vma) (info) << 32) >> 40)

This bit of the patch appears to assume that a right shift of a signed
value does an arithmetic shift.  However, C does not guarantee this:
the result of a right shift of a signed negative value is
implementation defined.

Ian

Re: [PATCH] Support for R_SPARC_OLO10 relocations

[Jakub Jelinek]

On Thu, Jul 08, 1999 at 09:20:46PM -0400, Ian Lance Taylor wrote:
>    Date: Mon, 5 Jul 1999 17:47:29 +0200
>    From: Jakub Jelinek <jj@sunsite.ms.mff.cuni.cz>
> 
>    This patch adds support for R_SPARC_OLO10 relocation.
>    It is in fact a compound relocation equal to R_SPARC_LO10 and R_SPARC_13
>    with no symbol applied on top of it, so I have modelled the support from
>    elf64-mips.c which already supports compound relocations.
> 
> Are you copying some existing ABI?  I ask because this implementation
> seems overly complex.  There is already a place to store the addend:
> the instruction itself.  I don't see any reason to store an additional
> addend in the Rela structure.  The range of possible values would seem
> to be limited by the nature of the relocation.

Yes, R_SPARC_OLO10 is part of the SYSV ABI sparc64 supplement.
And it has a reason to have two addends: it is used for instructions which
have signed 13bit field for the immediate, but the standard way of
constructing addresses is sethi into some register, which sets upper 22 bits
and then the second instruction fills in just 10 bits in the 13bit
immediate. So, one usually does
	sethi %hi(ab-24), %g1
	ld [%g1 + %lo(ab-24)], %g2
which means 3 bits in the second instruction's immediate are always 0.
So the R_SPARC_OLO10 makes me use those 3 bits, so that the sethi can be
shared among multiple instructions. The relocation is computed as
(((SYMBOL + ADDEND) & 0x3ff) + SECONDARYADDEND) & 0x1fff. The secondary
addend really does not behave like the normal addend in there, because bfd
should not change it ever, no matter how is symbol moved.
> 
> This patch seems to have several parts which are unrelated to
> R_SPARC_OLO10 support, such as the readelf.c and the sparc-dis.c
> patches.  Please submit unrelated patches separately.  That will speed
> the process of checking them in.  Thanks.

I'll cvs update to what is in CVS now and post separate patches.
> 
>    --- ./include/elf/sparc.h.jj	Tue Jun 29 10:51:49 1999
>    +++ ./include/elf/sparc.h	Mon Jul  5 14:44:35 1999
>    @@ -138,9 +138,9 @@ END_RELOC_NUMBERS
> 
>     /* Relocation macros.  */
> 
>    -#define ELF64_R_TYPE_DATA(info)		(((bfd_vma) (info) << 32) >> 40)
>    +#define ELF64_R_TYPE_DATA(info)		(((bfd_signed_vma) (info) << 32) >> 40)
> 
> This bit of the patch appears to assume that a right shift of a signed
> value does an arithmetic shift.  However, C does not guarantee this:
> the result of a right shift of a signed negative value is
> implementation defined.

That's just a cosmetic thing. For actual linking it really does not matter,
because bfd will shift the value back and mask again into 24 bits, so it
will only appear in objdump/readelf output.

Cheers,
    Jakub
___________________________________________________________________
Jakub Jelinek | jj@sunsite.mff.cuni.cz | http://sunsite.mff.cuni.cz
Administrator of SunSITE Czech Republic, MFF, Charles University
___________________________________________________________________
UltraLinux  |  http://ultra.linux.cz/  |  http://ultra.penguin.cz/
Linux version 2.2.10 on a sparc64 machine (1343.49 BogoMips)
___________________________________________________________________

[PATCH] My current SPARC patches

[Jakub Jelinek]

On Thu, Jul 08, 1999 at 03:50:13PM -0700, Richard Henderson wrote:
> On Mon, Jul 05, 1999 at 05:47:29PM +0200, Jakub Jelinek wrote:
> > This patch adds support for R_SPARC_OLO10 relocation.
> 
> I'm getting errors compiling this code.
> 
> gcc -DHAVE_CONFIG_H -I. -I../../../binutils/bfd -I. -D_GNU_SOURCE -I. -I../../..
> /binutils/bfd -I../../../binutils/bfd/../include -I../../../binutils/bfd/../intl
>  -I../intl -g -O2 -c ../../../binutils/bfd/elf64-sparc.c -o elf64-sparc.o
> .../elf64-sparc.c:2636: warning: initialization makes integer from pointer without a cast
> .../elf64-sparc.c:2636: initializer element is not computable at load time

That's because of the mips64 changes which went in two days ago after I
submited my patch. Below are all my current patches against current cvs
with the exception of the emulparams/elf64_sparc.sh.
> 
> These bits I went ahead and put in.

Thanks.

elf64-sparc.c was not compiling because it used DT_SPARC_PLTFMT, which is
now removed. This is the Diff-pltfmt patch.
ELF64_R_TYPE_DATA is always used on the whole r_info, so the macro has to
mask out ELF64_R_TYPE bits. This is the second patch,
Diff-elf64-r-type-data.
Then there is a c-sparc.texi update and then STT_REGISTER and R_SPARC_OLO10
patches.

Cheers,
    Jakub
___________________________________________________________________
Jakub Jelinek | jj@sunsite.mff.cuni.cz | http://sunsite.mff.cuni.cz
Administrator of SunSITE Czech Republic, MFF, Charles University
___________________________________________________________________
UltraLinux  |  http://ultra.linux.cz/  |  http://ultra.penguin.cz/
Linux version 2.2.10 on a sparc64 machine (1343.49 BogoMips)
___________________________________________________________________

Re: [PATCH] Support for R_SPARC_OLO10 relocations

[Ian Lance Taylor]

   Date: Fri, 9 Jul 1999 08:34:24 +0200
   From: Jakub Jelinek <jj@sunsite.ms.mff.cuni.cz>

   Yes, R_SPARC_OLO10 is part of the SYSV ABI sparc64 supplement.

OK.

   And it has a reason to have two addends: it is used for instructions which
   have signed 13bit field for the immediate, but the standard way of
   constructing addresses is sethi into some register, which sets upper 22 bits
   and then the second instruction fills in just 10 bits in the 13bit
   immediate. So, one usually does
	   sethi %hi(ab-24), %g1
	   ld [%g1 + %lo(ab-24)], %g2
   which means 3 bits in the second instruction's immediate are always 0.
   So the R_SPARC_OLO10 makes me use those 3 bits, so that the sethi can be
   shared among multiple instructions. The relocation is computed as
   (((SYMBOL + ADDEND) & 0x3ff) + SECONDARYADDEND) & 0x1fff. The secondary
   addend really does not behave like the normal addend in there, because bfd
   should not change it ever, no matter how is symbol moved.

My point was that the second addend could simply have been stored in
the object file itself.  The second addend can only be 13 bits, and
there are 13 bits available in the object file.  There was no need to
store it in the Rela structure.

However, since there is an existing ABI which acts differently, there
is no point.

Ian

Re: [PATCH] My current SPARC patches

[Richard Henderson]

On Fri, Jul 09, 1999 at 02:40:03PM +0200, Jakub Jelinek wrote:
> 	* bfd/elf64-sparc.c (sparc64_elf_size_dynamic_sections): Remove
> 	DT_SPARC_PLTFMT.
[...]
> 	* sparc.h (ELF64_R_TYPE_DATA): Only use ELF64_R_TYPE bits, not
> 	ELF64_R_SYM bits.
[...]
> 	* gas/doc/c-sparc.texi: Document .register and .nword pseudo-ops.
[...]
> 	* bfd/elf64-sparc.c (sparc64_elf_info_to_howto): Use ELF64_R_TYPE_ID.
> 	(sparc64_elf_get_reloc_upper_bound,
> 	sparc64_elf_get_dynamic_reloc_upper_bound,
> 	sparc64_elf_slurp_one_reloc_table, sparc64_elf_slurp_reloc_table,
> 	sparc64_elf_canonicalize_dynamic_reloc, sparc64_elf_write_relocs):
> 	New functions.
> 	(sparc64_elf_check_relocs, sparc64_elf_relocate_section): Use
> 	ELF64_R_TYPE_ID/DATA where appropriate.
> 	* gas/config/tc-sparc.c (sparc_ip): Allow OLO10 relocations
> 	on -64 and not pic.
> 	(output_insn): Put OLO10's secondary addend into tc_fix_data.
> 	(md_apply_fix3): Handle BFD_RELOC_SPARC_OLO10.
> 	(tc_gen_reloc): Return two relocs for OLO10, LO10 and SPARC13.
> 	* gas/config/tc-sparc.h (RELOC_EXPANSION_POSSIBLE,
> 	MAX_RELOC_EXPANSION): Define.
> 	(TC_FIX_TYPE, TC_INIT_FIX_DATA, TC_FIX_DATA_PRINT): Likewise.

All applied.

Thanks.



r~