[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c

/* SPARC-specific support for 32-bit ELF
   Copyright (C) 1993-2016 Free Software Foundation, Inc.

   This file is part of BFD, the Binary File Descriptor library.

   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.  */

#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/sparc.h"
#include "opcode/sparc.h"
#include "elfxx-sparc.h"
#include "elf-vxworks.h"

/* Support for core dump NOTE sections.  */

static bfd_boolean
elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
  switch (note->descsz)
    {
    default:
      return FALSE;

    case 260:			/* Solaris prpsinfo_t.  */
      elf_tdata (abfd)->core->program
	= _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
      elf_tdata (abfd)->core->command
	= _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
      break;

    case 336:			/* Solaris psinfo_t.  */
      elf_tdata (abfd)->core->program
	= _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
      elf_tdata (abfd)->core->command
	= _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
      break;
    }

  return TRUE;
}

/* Functions for dealing with the e_flags field.

   We don't define set_private_flags or copy_private_bfd_data because
   the only currently defined values are based on the bfd mach number,
   so we use the latter instead and defer setting e_flags until the
   file is written out.  */

/* Merge backend specific data from an object file to the output
   object file when linking.  */

static bfd_boolean
elf32_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
{
  bfd_boolean error;
  unsigned long ibfd_mach;
  /* FIXME: This should not be static.  */
  static unsigned long previous_ibfd_e_flags = (unsigned long) -1;

  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
    return TRUE;

  error = FALSE;

  ibfd_mach = bfd_get_mach (ibfd);
  if (bfd_mach_sparc_64bit_p (ibfd_mach))
    {
      error = TRUE;
      (*_bfd_error_handler)
	(_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
    }
  else if ((ibfd->flags & DYNAMIC) == 0)
    {
      if (bfd_get_mach (obfd) < ibfd_mach)
	bfd_set_arch_mach (obfd, bfd_arch_sparc, ibfd_mach);
    }

  if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
       != previous_ibfd_e_flags)
      && previous_ibfd_e_flags != (unsigned long) -1)
    {
      (*_bfd_error_handler)
	(_("%B: linking little endian files with big endian files"), ibfd);
      error = TRUE;
    }
  previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;

  if (error)
    {
      bfd_set_error (bfd_error_bad_value);
      return FALSE;
    }

  return _bfd_sparc_elf_merge_private_bfd_data (ibfd, obfd);
}

/* The final processing done just before writing out the object file.
   We need to set the e_machine field appropriately.  */

static void
elf32_sparc_final_write_processing (bfd *abfd,
				    bfd_boolean linker ATTRIBUTE_UNUSED)
{
  switch (bfd_get_mach (abfd))
    {
    case bfd_mach_sparc :
    case bfd_mach_sparc_sparclet :
    case bfd_mach_sparc_sparclite :
      break; /* nothing to do */
    case bfd_mach_sparc_v8plus :
      elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
      elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
      elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
      break;
    case bfd_mach_sparc_v8plusa :
      elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
      elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
      elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
      break;
    case bfd_mach_sparc_v8plusb :
      elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
      elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
      elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
				       | EF_SPARC_SUN_US3;
      break;
    case bfd_mach_sparc_sparclite_le :
      elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
      break;
    default :
      abort ();
      break;
    }
}

static enum elf_reloc_type_class
elf32_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
			      const asection *rel_sec ATTRIBUTE_UNUSED,
			      const Elf_Internal_Rela *rela)
{
  switch ((int) ELF32_R_TYPE (rela->r_info))
    {
    case R_SPARC_RELATIVE:
      return reloc_class_relative;
    case R_SPARC_JMP_SLOT:
      return reloc_class_plt;
    case R_SPARC_COPY:
      return reloc_class_copy;
    default:
      return reloc_class_normal;
    }
}

/* Hook called by the linker routine which adds symbols from an object
   file.  */

static bfd_boolean
elf32_sparc_add_symbol_hook (bfd * abfd,
			     struct bfd_link_info * info,
			     Elf_Internal_Sym * sym,
			     const char ** namep ATTRIBUTE_UNUSED,
			     flagword * flagsp ATTRIBUTE_UNUSED,
			     asection ** secp ATTRIBUTE_UNUSED,
			     bfd_vma * valp ATTRIBUTE_UNUSED)
{
  if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
      && (abfd->flags & DYNAMIC) == 0
      && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
    elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
  return TRUE;
}

#define TARGET_BIG_SYM	sparc_elf32_vec
#define TARGET_BIG_NAME	"elf32-sparc"
#define ELF_ARCH	bfd_arch_sparc
#define ELF_TARGET_ID	SPARC_ELF_DATA
#define ELF_MACHINE_CODE EM_SPARC
#define ELF_MACHINE_ALT1 EM_SPARC32PLUS
#define ELF_MAXPAGESIZE 0x10000
#define ELF_COMMONPAGESIZE 0x2000

#define bfd_elf32_bfd_merge_private_bfd_data \
					elf32_sparc_merge_private_bfd_data
#define elf_backend_final_write_processing \
					elf32_sparc_final_write_processing
#define elf_backend_grok_psinfo		elf32_sparc_grok_psinfo
#define elf_backend_reloc_type_class	elf32_sparc_reloc_type_class

#define elf_info_to_howto		_bfd_sparc_elf_info_to_howto
#define bfd_elf32_bfd_reloc_type_lookup	_bfd_sparc_elf_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup \
  _bfd_sparc_elf_reloc_name_lookup
#define bfd_elf32_bfd_link_hash_table_create \
					_bfd_sparc_elf_link_hash_table_create
#define bfd_elf32_bfd_relax_section	_bfd_sparc_elf_relax_section
#define bfd_elf32_new_section_hook	_bfd_sparc_elf_new_section_hook
#define elf_backend_copy_indirect_symbol \
					_bfd_sparc_elf_copy_indirect_symbol
#define elf_backend_create_dynamic_sections \
					_bfd_sparc_elf_create_dynamic_sections
#define elf_backend_check_relocs	_bfd_sparc_elf_check_relocs
#define elf_backend_adjust_dynamic_symbol \
					_bfd_sparc_elf_adjust_dynamic_symbol
#define elf_backend_omit_section_dynsym	_bfd_sparc_elf_omit_section_dynsym
#define elf_backend_size_dynamic_sections \
					_bfd_sparc_elf_size_dynamic_sections
#define elf_backend_relocate_section	_bfd_sparc_elf_relocate_section
#define elf_backend_finish_dynamic_symbol \
					_bfd_sparc_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections \
					_bfd_sparc_elf_finish_dynamic_sections
#define bfd_elf32_mkobject		_bfd_sparc_elf_mkobject
#define elf_backend_object_p		_bfd_sparc_elf_object_p
#define elf_backend_gc_mark_hook	_bfd_sparc_elf_gc_mark_hook
#define elf_backend_gc_sweep_hook       _bfd_sparc_elf_gc_sweep_hook
#define elf_backend_plt_sym_val		_bfd_sparc_elf_plt_sym_val
#define elf_backend_init_index_section	_bfd_elf_init_1_index_section

#define elf_backend_can_gc_sections 1
#define elf_backend_can_refcount 1
#define elf_backend_want_got_plt 0
#define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 1
#define elf_backend_got_header_size 4
#define elf_backend_rela_normal 1

#define elf_backend_add_symbol_hook		elf32_sparc_add_symbol_hook

#include "elf32-target.h"

/* Solaris 2.  */

#undef	TARGET_BIG_SYM
#define	TARGET_BIG_SYM				sparc_elf32_sol2_vec
#undef	TARGET_BIG_NAME
#define	TARGET_BIG_NAME				"elf32-sparc-sol2"

#undef elf32_bed
#define elf32_bed				elf32_sparc_sol2_bed

/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
   boundary.  */
#undef  elf_backend_static_tls_alignment
#define elf_backend_static_tls_alignment	8

#undef  elf_backend_strtab_flags
#define elf_backend_strtab_flags	SHF_STRINGS

static bfd_boolean
elf32_sparc_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
						 bfd *obfd ATTRIBUTE_UNUSED,
						 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
						 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
{
  /* PR 19938: FIXME: Need to add code for setting the sh_info
     and sh_link fields of Solaris specific section types.  */
  return FALSE;
}

#undef  elf_backend_copy_special_section_fields
#define elf_backend_copy_special_section_fields elf32_sparc_copy_solaris_special_section_fields

#include "elf32-target.h"

/* A wrapper around _bfd_sparc_elf_link_hash_table_create that identifies
   the target system as VxWorks.  */

static struct bfd_link_hash_table *
elf32_sparc_vxworks_link_hash_table_create (bfd *abfd)
{
  struct bfd_link_hash_table *ret;

  ret = _bfd_sparc_elf_link_hash_table_create (abfd);
  if (ret)
    {
      struct _bfd_sparc_elf_link_hash_table *htab;

      htab = (struct _bfd_sparc_elf_link_hash_table *) ret;
      htab->is_vxworks = 1;
    }
  return ret;
}

/* A final_write_processing hook that does both the SPARC- and VxWorks-
   specific handling.  */

static void
elf32_sparc_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
{
  elf32_sparc_final_write_processing (abfd, linker);
  elf_vxworks_final_write_processing (abfd, linker);
}

#undef  TARGET_BIG_SYM
#define TARGET_BIG_SYM	sparc_elf32_vxworks_vec
#undef  TARGET_BIG_NAME
#define TARGET_BIG_NAME	"elf32-sparc-vxworks"

#undef  ELF_MINPAGESIZE
#define ELF_MINPAGESIZE	0x1000

#undef bfd_elf32_bfd_link_hash_table_create
#define bfd_elf32_bfd_link_hash_table_create \
  elf32_sparc_vxworks_link_hash_table_create

#undef  elf_backend_want_got_plt
#define elf_backend_want_got_plt		1
#undef  elf_backend_plt_readonly
#define elf_backend_plt_readonly		1
#undef  elf_backend_got_header_size
#define elf_backend_got_header_size		12
#undef  elf_backend_add_symbol_hook
#define elf_backend_add_symbol_hook \
  elf_vxworks_add_symbol_hook
#undef  elf_backend_link_output_symbol_hook
#define elf_backend_link_output_symbol_hook \
  elf_vxworks_link_output_symbol_hook
#undef  elf_backend_emit_relocs
#define elf_backend_emit_relocs \
  elf_vxworks_emit_relocs
#undef  elf_backend_final_write_processing
#define elf_backend_final_write_processing \
  elf32_sparc_vxworks_final_write_processing
#undef  elf_backend_static_tls_alignment
#undef  elf_backend_strtab_flags
#undef  elf_backend_copy_special_section_fields

#undef  elf32_bed
#define elf32_bed				sparc_elf_vxworks_bed

#include "elf32-target.h"
Commit	Line	Data
	1	/* SPARC-specific support for 32-bit ELF
	2	Copyright (C) 1993-2016 Free Software Foundation, Inc.
	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	19	MA 02110-1301, USA. */
	20
	21	#include "sysdep.h"
	22	#include "bfd.h"
	23	#include "bfdlink.h"
	24	#include "libbfd.h"
	25	#include "elf-bfd.h"
	26	#include "elf/sparc.h"
	27	#include "opcode/sparc.h"
	28	#include "elfxx-sparc.h"
	29	#include "elf-vxworks.h"
	30
	31	/* Support for core dump NOTE sections. */
	32
	33	static bfd_boolean
	34	elf32_sparc_grok_psinfo (bfd abfd, Elf_Internal_Note note)
	35	{
	36	switch (note->descsz)
	37	{
	38	default:
	39	return FALSE;
	40
	41	case 260: /* Solaris prpsinfo_t. */
	42	elf_tdata (abfd)->core->program
	43	= _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
	44	elf_tdata (abfd)->core->command
	45	= _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
	46	break;
	47
	48	case 336: /* Solaris psinfo_t. */
	49	elf_tdata (abfd)->core->program
	50	= _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
	51	elf_tdata (abfd)->core->command
	52	= _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
	53	break;
	54	}
	55
	56	return TRUE;
	57	}
	58
	59	/* Functions for dealing with the e_flags field.
	60
	61	We don't define set_private_flags or copy_private_bfd_data because
	62	the only currently defined values are based on the bfd mach number,
	63	so we use the latter instead and defer setting e_flags until the
	64	file is written out. */
	65
	66	/* Merge backend specific data from an object file to the output
	67	object file when linking. */
	68
	69	static bfd_boolean
	70	elf32_sparc_merge_private_bfd_data (bfd ibfd, bfd obfd)
	71	{
	72	bfd_boolean error;
	73	unsigned long ibfd_mach;
	74	/* FIXME: This should not be static. */
	75	static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
	76
	77	if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
	78	\|\| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
	79	return TRUE;
	80
	81	error = FALSE;
	82
	83	ibfd_mach = bfd_get_mach (ibfd);
	84	if (bfd_mach_sparc_64bit_p (ibfd_mach))
	85	{
	86	error = TRUE;
	87	(*_bfd_error_handler)
	88	(_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
	89	}
	90	else if ((ibfd->flags & DYNAMIC) == 0)
	91	{
	92	if (bfd_get_mach (obfd) < ibfd_mach)
	93	bfd_set_arch_mach (obfd, bfd_arch_sparc, ibfd_mach);
	94	}
	95
	96	if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
	97	!= previous_ibfd_e_flags)
	98	&& previous_ibfd_e_flags != (unsigned long) -1)
	99	{
	100	(*_bfd_error_handler)
	101	(_("%B: linking little endian files with big endian files"), ibfd);
	102	error = TRUE;
	103	}
	104	previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
	105
	106	if (error)
	107	{
	108	bfd_set_error (bfd_error_bad_value);
	109	return FALSE;
	110	}
	111
	112	return _bfd_sparc_elf_merge_private_bfd_data (ibfd, obfd);
	113	}
	114
	115	/* The final processing done just before writing out the object file.
	116	We need to set the e_machine field appropriately. */
	117
	118	static void
	119	elf32_sparc_final_write_processing (bfd *abfd,
	120	bfd_boolean linker ATTRIBUTE_UNUSED)
	121	{
	122	switch (bfd_get_mach (abfd))
	123	{
	124	case bfd_mach_sparc :
	125	case bfd_mach_sparc_sparclet :
	126	case bfd_mach_sparc_sparclite :
	127	break; /* nothing to do */
	128	case bfd_mach_sparc_v8plus :
	129	elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
	130	elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
	131	elf_elfheader (abfd)->e_flags \|= EF_SPARC_32PLUS;
	132	break;
	133	case bfd_mach_sparc_v8plusa :
	134	elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
	135	elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
	136	elf_elfheader (abfd)->e_flags \|= EF_SPARC_32PLUS \| EF_SPARC_SUN_US1;
	137	break;
	138	case bfd_mach_sparc_v8plusb :
	139	elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
	140	elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
	141	elf_elfheader (abfd)->e_flags \|= EF_SPARC_32PLUS \| EF_SPARC_SUN_US1
	142	\| EF_SPARC_SUN_US3;
	143	break;
	144	case bfd_mach_sparc_sparclite_le :
	145	elf_elfheader (abfd)->e_flags \|= EF_SPARC_LEDATA;
	146	break;
	147	default :
	148	abort ();
	149	break;
	150	}
	151	}
	152
	153	static enum elf_reloc_type_class
	154	elf32_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
	155	const asection *rel_sec ATTRIBUTE_UNUSED,
	156	const Elf_Internal_Rela *rela)
	157	{
	158	switch ((int) ELF32_R_TYPE (rela->r_info))
	159	{
	160	case R_SPARC_RELATIVE:
	161	return reloc_class_relative;
	162	case R_SPARC_JMP_SLOT:
	163	return reloc_class_plt;
	164	case R_SPARC_COPY:
	165	return reloc_class_copy;
	166	default:
	167	return reloc_class_normal;
	168	}
	169	}
	170
	171	/* Hook called by the linker routine which adds symbols from an object
	172	file. */
	173
	174	static bfd_boolean
	175	elf32_sparc_add_symbol_hook (bfd * abfd,
	176	struct bfd_link_info * info,
	177	Elf_Internal_Sym * sym,
	178	const char ** namep ATTRIBUTE_UNUSED,
	179	flagword * flagsp ATTRIBUTE_UNUSED,
	180	asection ** secp ATTRIBUTE_UNUSED,
	181	bfd_vma * valp ATTRIBUTE_UNUSED)
	182	{
	183	if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
	184	&& (abfd->flags & DYNAMIC) == 0
	185	&& bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
	186	elf_tdata (info->output_bfd)->has_gnu_symbols \|= elf_gnu_symbol_ifunc;
	187	return TRUE;
	188	}
	189
	190	#define TARGET_BIG_SYM sparc_elf32_vec
	191	#define TARGET_BIG_NAME "elf32-sparc"
	192	#define ELF_ARCH bfd_arch_sparc
	193	#define ELF_TARGET_ID SPARC_ELF_DATA
	194	#define ELF_MACHINE_CODE EM_SPARC
	195	#define ELF_MACHINE_ALT1 EM_SPARC32PLUS
	196	#define ELF_MAXPAGESIZE 0x10000
	197	#define ELF_COMMONPAGESIZE 0x2000
	198
	199	#define bfd_elf32_bfd_merge_private_bfd_data \
	200	elf32_sparc_merge_private_bfd_data
	201	#define elf_backend_final_write_processing \
	202	elf32_sparc_final_write_processing
	203	#define elf_backend_grok_psinfo elf32_sparc_grok_psinfo
	204	#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
	205
	206	#define elf_info_to_howto _bfd_sparc_elf_info_to_howto
	207	#define bfd_elf32_bfd_reloc_type_lookup _bfd_sparc_elf_reloc_type_lookup
	208	#define bfd_elf32_bfd_reloc_name_lookup \
	209	_bfd_sparc_elf_reloc_name_lookup
	210	#define bfd_elf32_bfd_link_hash_table_create \
	211	_bfd_sparc_elf_link_hash_table_create
	212	#define bfd_elf32_bfd_relax_section _bfd_sparc_elf_relax_section
	213	#define bfd_elf32_new_section_hook _bfd_sparc_elf_new_section_hook
	214	#define elf_backend_copy_indirect_symbol \
	215	_bfd_sparc_elf_copy_indirect_symbol
	216	#define elf_backend_create_dynamic_sections \
	217	_bfd_sparc_elf_create_dynamic_sections
	218	#define elf_backend_check_relocs _bfd_sparc_elf_check_relocs
	219	#define elf_backend_adjust_dynamic_symbol \
	220	_bfd_sparc_elf_adjust_dynamic_symbol
	221	#define elf_backend_omit_section_dynsym _bfd_sparc_elf_omit_section_dynsym
	222	#define elf_backend_size_dynamic_sections \
	223	_bfd_sparc_elf_size_dynamic_sections
	224	#define elf_backend_relocate_section _bfd_sparc_elf_relocate_section
	225	#define elf_backend_finish_dynamic_symbol \
	226	_bfd_sparc_elf_finish_dynamic_symbol
	227	#define elf_backend_finish_dynamic_sections \
	228	_bfd_sparc_elf_finish_dynamic_sections
	229	#define bfd_elf32_mkobject _bfd_sparc_elf_mkobject
	230	#define elf_backend_object_p _bfd_sparc_elf_object_p
	231	#define elf_backend_gc_mark_hook _bfd_sparc_elf_gc_mark_hook
	232	#define elf_backend_gc_sweep_hook _bfd_sparc_elf_gc_sweep_hook
	233	#define elf_backend_plt_sym_val _bfd_sparc_elf_plt_sym_val
	234	#define elf_backend_init_index_section _bfd_elf_init_1_index_section
	235
	236	#define elf_backend_can_gc_sections 1
	237	#define elf_backend_can_refcount 1
	238	#define elf_backend_want_got_plt 0
	239	#define elf_backend_plt_readonly 0
	240	#define elf_backend_want_plt_sym 1
	241	#define elf_backend_got_header_size 4
	242	#define elf_backend_rela_normal 1
	243
	244	#define elf_backend_add_symbol_hook elf32_sparc_add_symbol_hook
	245
	246	#include "elf32-target.h"
	247
	248	/* Solaris 2. */
	249
	250	#undef TARGET_BIG_SYM
	251	#define TARGET_BIG_SYM sparc_elf32_sol2_vec
	252	#undef TARGET_BIG_NAME
	253	#define TARGET_BIG_NAME "elf32-sparc-sol2"
	254
	255	#undef elf32_bed
	256	#define elf32_bed elf32_sparc_sol2_bed
	257
	258	/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
	259	boundary. */
	260	#undef elf_backend_static_tls_alignment
	261	#define elf_backend_static_tls_alignment 8
	262
	263	#undef elf_backend_strtab_flags
	264	#define elf_backend_strtab_flags SHF_STRINGS
	265
	266	static bfd_boolean
	267	elf32_sparc_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
	268	bfd *obfd ATTRIBUTE_UNUSED,
	269	const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
	270	Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
	271	{
	272	/* PR 19938: FIXME: Need to add code for setting the sh_info
	273	and sh_link fields of Solaris specific section types. */
	274	return FALSE;
	275	}
	276
	277	#undef elf_backend_copy_special_section_fields
	278	#define elf_backend_copy_special_section_fields elf32_sparc_copy_solaris_special_section_fields
	279
	280	#include "elf32-target.h"
	281
	282	/* A wrapper around _bfd_sparc_elf_link_hash_table_create that identifies
	283	the target system as VxWorks. */
	284
	285	static struct bfd_link_hash_table *
	286	elf32_sparc_vxworks_link_hash_table_create (bfd *abfd)
	287	{
	288	struct bfd_link_hash_table *ret;
	289
	290	ret = _bfd_sparc_elf_link_hash_table_create (abfd);
	291	if (ret)
	292	{
	293	struct _bfd_sparc_elf_link_hash_table *htab;
	294
	295	htab = (struct _bfd_sparc_elf_link_hash_table *) ret;
	296	htab->is_vxworks = 1;
	297	}
	298	return ret;
	299	}
	300
	301	/* A final_write_processing hook that does both the SPARC- and VxWorks-
	302	specific handling. */
	303
	304	static void
	305	elf32_sparc_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
	306	{
	307	elf32_sparc_final_write_processing (abfd, linker);
	308	elf_vxworks_final_write_processing (abfd, linker);
	309	}
	310
	311	#undef TARGET_BIG_SYM
	312	#define TARGET_BIG_SYM sparc_elf32_vxworks_vec
	313	#undef TARGET_BIG_NAME
	314	#define TARGET_BIG_NAME "elf32-sparc-vxworks"
	315
	316	#undef ELF_MINPAGESIZE
	317	#define ELF_MINPAGESIZE 0x1000
	318
	319	#undef bfd_elf32_bfd_link_hash_table_create
	320	#define bfd_elf32_bfd_link_hash_table_create \
	321	elf32_sparc_vxworks_link_hash_table_create
	322
	323	#undef elf_backend_want_got_plt
	324	#define elf_backend_want_got_plt 1
	325	#undef elf_backend_plt_readonly
	326	#define elf_backend_plt_readonly 1
	327	#undef elf_backend_got_header_size
	328	#define elf_backend_got_header_size 12
	329	#undef elf_backend_add_symbol_hook
	330	#define elf_backend_add_symbol_hook \
	331	elf_vxworks_add_symbol_hook
	332	#undef elf_backend_link_output_symbol_hook
	333	#define elf_backend_link_output_symbol_hook \
	334	elf_vxworks_link_output_symbol_hook
	335	#undef elf_backend_emit_relocs
	336	#define elf_backend_emit_relocs \
	337	elf_vxworks_emit_relocs
	338	#undef elf_backend_final_write_processing
	339	#define elf_backend_final_write_processing \
	340	elf32_sparc_vxworks_final_write_processing
	341	#undef elf_backend_static_tls_alignment
	342	#undef elf_backend_strtab_flags
	343	#undef elf_backend_copy_special_section_fields
	344
	345	#undef elf32_bed
	346	#define elf32_bed sparc_elf_vxworks_bed
	347
	348	#include "elf32-target.h"