[thirdparty/binutils-gdb.git] / bfd / elf-s390-common.c

/* IBM S/390-specific support for ELF 32 and 64 bit functions
   Copyright (C) 2000-2015 Free Software Foundation, Inc.
   Contributed by Andreas Krebbel.

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


/* Return TRUE if H is an IFUNC symbol.  Simply checking for the
   symbol type might not be enough since it might get changed to
   STT_FUNC for pointer equality reasons.  */
static inline bfd_boolean
s390_is_ifunc_symbol_p (struct elf_link_hash_entry *h)
{
  struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
  return h->type == STT_GNU_IFUNC || eh->ifunc_resolver_address != 0;
}

/* Create sections needed by STT_GNU_IFUNC symbol.  */

static bfd_boolean
s390_elf_create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
{
  flagword flags;
  asection *s;
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
  struct elf_link_hash_table *htab = elf_hash_table (info);

  if (htab->iplt != NULL)
    return TRUE;

  flags = bed->dynamic_sec_flags;

  if (info->shared)
    {
      s = bfd_make_section_with_flags (abfd, ".rela.ifunc",
				       flags | SEC_READONLY);
      if (s == NULL
	  || ! bfd_set_section_alignment (abfd, s,
					  bed->s->log_file_align))
	return FALSE;
      htab->irelifunc = s;
    }

  /* Create .iplt, .rel[a].iplt, and .igot.plt.  */
  s = bfd_make_section_with_flags (abfd, ".iplt",
				   flags | SEC_CODE | SEC_READONLY);
  if (s == NULL
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
    return FALSE;
  htab->iplt = s;

  s = bfd_make_section_with_flags (abfd, ".rela.iplt", flags | SEC_READONLY);
  if (s == NULL
      || ! bfd_set_section_alignment (abfd, s,
				      bed->s->log_file_align))
    return FALSE;
  htab->irelplt = s;

  s = bfd_make_section_with_flags (abfd, ".igot.plt", flags);
  if (s == NULL
      || !bfd_set_section_alignment (abfd, s,
				     bed->s->log_file_align))
    return FALSE;
  htab->igotplt = s;

  return TRUE;
}


/* Allocate space in .plt, .got and associated reloc sections for
   dynamic relocs against a STT_GNU_IFUNC symbol definition.  */

static bfd_boolean
s390_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
				    struct elf_link_hash_entry *h,
				    struct elf_dyn_relocs **head)
{
  struct elf_dyn_relocs *p;
  struct elf_link_hash_table *htab;
  struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;

  htab = elf_hash_table (info);
  eh->ifunc_resolver_address = h->root.u.def.value;
  eh->ifunc_resolver_section = h->root.u.def.section;

  /* Support garbage collection against STT_GNU_IFUNC symbols.  */
  if (h->plt.refcount <= 0 && h->got.refcount <= 0)
    {
      /* When building shared library, we need to handle the case
         where it is marked with regular reference, but not non-GOT
	 reference.  It may happen if we didn't see STT_GNU_IFUNC
	 symbol at the time when checking relocations.  */
      if (info->shared
	  && !h->non_got_ref
	  && h->ref_regular)
	for (p = *head; p != NULL; p = p->next)
	  if (p->count)
	    {
	      h->non_got_ref = 1;
	      goto keep;
	    }

      h->got = htab->init_got_offset;
      h->plt = htab->init_plt_offset;
      *head = NULL;
      return TRUE;
    }

  /* Return and discard space for dynamic relocations against it if
     it is never referenced in a non-shared object.  */
  if (!h->ref_regular)
    {
      if (h->plt.refcount > 0
	  || h->got.refcount > 0)
	abort ();
      h->got = htab->init_got_offset;
      h->plt = htab->init_plt_offset;
      *head = NULL;
      return TRUE;
    }

keep:
  /* Without checking h->plt.refcount here we allocate a PLT slot.
     When setting plt.refcount in check_relocs it might not have been
     known that this will be an IFUNC symol.  */
  h->plt.offset = htab->iplt->size;
  h->needs_plt = 1;
  htab->iplt->size += PLT_ENTRY_SIZE;
  htab->igotplt->size += GOT_ENTRY_SIZE;
  htab->irelplt->size += RELA_ENTRY_SIZE;
  htab->irelplt->reloc_count++;

  /* In order to make pointer equality work with IFUNC symbols defined
     in a non-PIE executable and referenced in a shared lib, we turn
     the symbol into a STT_FUNC symbol and make the symbol value to
     point to the IPLT slot.  That way the referencing shared lib will
     always get the PLT slot address when resolving the respective
     R_390_GLOB_DAT/R_390_64 relocs on that symbol.  */
  if (info->executable && !info->shared && h->def_regular && h->ref_dynamic)
    {
      h->root.u.def.section = htab->iplt;
      h->root.u.def.value = h->plt.offset;
      h->size = PLT_ENTRY_SIZE;
      h->type = STT_FUNC;
    }

  /* We need dynamic relocation for STT_GNU_IFUNC symbol only when
     there is a non-GOT reference in a shared object.  */
  if (!info->shared || !h->non_got_ref)
    *head = NULL;

  /* Finally, allocate space.  */
  p = *head;
  if (p != NULL)
    {
      bfd_size_type count = 0;
      do
	{
	  count += p->count;
	  p = p->next;
	}
      while (p != NULL);
      htab->irelifunc->size += count * RELA_ENTRY_SIZE;
    }

  /* Decide whether the got.iplt slot can be used.  This has to be
     avoided if the values in the GOT slots could differ for pointer
     equality reasons.  */
  if (h->got.refcount <= 0
      || (info->shared
	  && (h->dynindx == -1 || h->forced_local))
      || (info->executable && info->shared)
      || htab->sgot == NULL)
    {
      /* Use .got.iplt.  */
      h->got.offset = (bfd_vma) -1;
    }
  else
    {
      h->got.offset = htab->sgot->size;
      htab->sgot->size += GOT_ENTRY_SIZE;
      if (info->shared)
	htab->srelgot->size += RELA_ENTRY_SIZE;
    }

  return TRUE;
}

static bfd_boolean
elf_s390_allocate_local_syminfo (bfd *abfd, Elf_Internal_Shdr *symtab_hdr)
{
  bfd_size_type size;

  size = symtab_hdr->sh_info;
  size *= (sizeof (bfd_signed_vma)       /* local got */
	   + sizeof (struct plt_entry)   /* local plt */
	   + sizeof(char));              /* local tls type */
  elf_local_got_refcounts (abfd) = ((bfd_signed_vma *)
				    bfd_zalloc (abfd, size));
  if (elf_local_got_refcounts (abfd) == NULL)
    return FALSE;
  elf_s390_local_plt (abfd)
    = (struct plt_entry*)(elf_local_got_refcounts (abfd)
			  + symtab_hdr->sh_info);
  elf_s390_local_got_tls_type (abfd)
    = (char *) (elf_s390_local_plt (abfd) + symtab_hdr->sh_info);

  return TRUE;
}

/* Pick ELFOSABI_GNU if IFUNC symbols are used.  */

static bfd_boolean
elf_s390_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
       || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
      && (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_any;

  return TRUE;
}

/* Whether to sort relocs output by ld -r or ld --emit-relocs, by
   r_offset.  Don't do so for code sections.  We want to keep ordering
   of GDCALL / PLT32DBL for TLS optimizations as is.  On the other
   hand, elf-eh-frame.c processing requires .eh_frame relocs to be
   sorted.  */

static bfd_boolean
elf_s390_elf_sort_relocs_p (asection *sec)
{
  return (sec->flags & SEC_CODE) == 0;
}

/* Merge object attributes from IBFD into OBFD.  Raise an error if
   there are conflicting attributes.  */
static bfd_boolean
elf_s390_merge_obj_attributes (bfd *ibfd, bfd *obfd)
{
  obj_attribute *in_attr, *in_attrs;
  obj_attribute *out_attr, *out_attrs;

  if (!elf_known_obj_attributes_proc (obfd)[0].i)
    {
      /* This is the first object.  Copy the attributes.  */
      _bfd_elf_copy_obj_attributes (ibfd, obfd);

      /* Use the Tag_null value to indicate the attributes have been
	 initialized.  */
      elf_known_obj_attributes_proc (obfd)[0].i = 1;

      return TRUE;
    }

  in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
  out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];

  /* Check for conflicting Tag_GNU_S390_ABI_Vector attributes and
     merge non-conflicting ones.  */
  in_attr = &in_attrs[Tag_GNU_S390_ABI_Vector];
  out_attr = &out_attrs[Tag_GNU_S390_ABI_Vector];

  if (in_attr->i > 2)
    _bfd_error_handler
      (_("Warning: %B uses unknown vector ABI %d"), ibfd,
       in_attr->i);
  else if (out_attr->i > 2)
    _bfd_error_handler
      (_("Warning: %B uses unknown vector ABI %d"), obfd,
       out_attr->i);
  else if (in_attr->i != out_attr->i)
    {
      out_attr->type = ATTR_TYPE_FLAG_INT_VAL;

      if (in_attr->i && out_attr->i)
	{
	  const char abi_str[3][9] = { "none", "software", "hardware" };

	  _bfd_error_handler
	    (_("Warning: %B uses vector %s ABI, %B uses %s ABI"),
	     ibfd, obfd, abi_str[in_attr->i], abi_str[out_attr->i]);
	}
      if (in_attr->i > out_attr->i)
	out_attr->i = in_attr->i;
    }

  /* Merge Tag_compatibility attributes and any common GNU ones.  */
  _bfd_elf_merge_object_attributes (ibfd, obfd);

  return TRUE;
}
Commit	Line	Data
470b557a	1	/* IBM S/390-specific support for ELF 32 and 64 bit functions
b90efa5b	2	Copyright (C) 2000-2015 Free Software Foundation, Inc.
470b557a AK	3	Contributed by Andreas Krebbel.
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
	20	02110-1301, USA. */
	21
	22
	23	/* Return TRUE if H is an IFUNC symbol. Simply checking for the
	24	symbol type might not be enough since it might get changed to
	25	STT_FUNC for pointer equality reasons. */
	26	static inline bfd_boolean
	27	s390_is_ifunc_symbol_p (struct elf_link_hash_entry *h)
	28	{
	29	struct elf_s390_link_hash_entry eh = (struct elf_s390_link_hash_entry)h;
	30	return h->type == STT_GNU_IFUNC \|\| eh->ifunc_resolver_address != 0;
	31	}
	32
	33	/* Create sections needed by STT_GNU_IFUNC symbol. */
	34
	35	static bfd_boolean
	36	s390_elf_create_ifunc_sections (bfd abfd, struct bfd_link_info info)
	37	{
	38	flagword flags;
	39	asection *s;
	40	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
	41	struct elf_link_hash_table *htab = elf_hash_table (info);
	42
	43	if (htab->iplt != NULL)
	44	return TRUE;
	45
	46	flags = bed->dynamic_sec_flags;
	47
	48	if (info->shared)
	49	{
	50	s = bfd_make_section_with_flags (abfd, ".rela.ifunc",
	51	flags \| SEC_READONLY);
	52	if (s == NULL
	53	\|\| ! bfd_set_section_alignment (abfd, s,
	54	bed->s->log_file_align))
	55	return FALSE;
	56	htab->irelifunc = s;
	57	}
	58
	59	/* Create .iplt, .rel[a].iplt, and .igot.plt. */
	60	s = bfd_make_section_with_flags (abfd, ".iplt",
	61	flags \| SEC_CODE \| SEC_READONLY);
	62	if (s == NULL
	63	\|\| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
	64	return FALSE;
	65	htab->iplt = s;
	66
67	s = bfd_make_section_with_flags (abfd, ".rela.iplt", flags \| SEC_READONLY);
68	if (s == NULL
69	\|\| ! bfd_set_section_alignment (abfd, s,
70	bed->s->log_file_align))
71	return FALSE;
72	htab->irelplt = s;
73
74	s = bfd_make_section_with_flags (abfd, ".igot.plt", flags);
75	if (s == NULL
76	\|\| !bfd_set_section_alignment (abfd, s,
77	bed->s->log_file_align))
78	return FALSE;
79	htab->igotplt = s;
80
81	return TRUE;
82	}
83
84
85	/* Allocate space in .plt, .got and associated reloc sections for
86	dynamic relocs against a STT_GNU_IFUNC symbol definition. */
87
88	static bfd_boolean
89	s390_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
90	struct elf_link_hash_entry *h,
91	struct elf_dyn_relocs **head)
92	{
93	struct elf_dyn_relocs *p;
94	struct elf_link_hash_table *htab;
95	struct elf_s390_link_hash_entry eh = (struct elf_s390_link_hash_entry)h;
96
97	htab = elf_hash_table (info);
98	eh->ifunc_resolver_address = h->root.u.def.value;
99	eh->ifunc_resolver_section = h->root.u.def.section;
100
101	/* Support garbage collection against STT_GNU_IFUNC symbols. */
102	if (h->plt.refcount <= 0 && h->got.refcount <= 0)
103	{
104	/* When building shared library, we need to handle the case
105	where it is marked with regular reference, but not non-GOT
106	reference. It may happen if we didn't see STT_GNU_IFUNC
107	symbol at the time when checking relocations. */
108	if (info->shared
109	&& !h->non_got_ref
110	&& h->ref_regular)
111	for (p = *head; p != NULL; p = p->next)
112	if (p->count)
113	{
114	h->non_got_ref = 1;
115	goto keep;
116	}
117
118	h->got = htab->init_got_offset;
119	h->plt = htab->init_plt_offset;
120	*head = NULL;
121	return TRUE;
122	}
123
124	/* Return and discard space for dynamic relocations against it if
125	it is never referenced in a non-shared object. */
126	if (!h->ref_regular)
127	{
128	if (h->plt.refcount > 0
129	\|\| h->got.refcount > 0)
130	abort ();
131	h->got = htab->init_got_offset;
132	h->plt = htab->init_plt_offset;
133	*head = NULL;
134	return TRUE;
135	}
136
137	keep:
138	/* Without checking h->plt.refcount here we allocate a PLT slot.
139	When setting plt.refcount in check_relocs it might not have been
140	known that this will be an IFUNC symol. */
141	h->plt.offset = htab->iplt->size;
142	h->needs_plt = 1;
143	htab->iplt->size += PLT_ENTRY_SIZE;
144	htab->igotplt->size += GOT_ENTRY_SIZE;
145	htab->irelplt->size += RELA_ENTRY_SIZE;
146	htab->irelplt->reloc_count++;
147
148	/* In order to make pointer equality work with IFUNC symbols defined
149	in a non-PIE executable and referenced in a shared lib, we turn
150	the symbol into a STT_FUNC symbol and make the symbol value to
151	point to the IPLT slot. That way the referencing shared lib will
152	always get the PLT slot address when resolving the respective
153	R_390_GLOB_DAT/R_390_64 relocs on that symbol. */
154	if (info->executable && !info->shared && h->def_regular && h->ref_dynamic)
155	{
156	h->root.u.def.section = htab->iplt;
157	h->root.u.def.value = h->plt.offset;
158	h->size = PLT_ENTRY_SIZE;
159	h->type = STT_FUNC;
160	}
161
162	/* We need dynamic relocation for STT_GNU_IFUNC symbol only when
163	there is a non-GOT reference in a shared object. */
164	if (!info->shared \|\| !h->non_got_ref)
165	*head = NULL;
166
167	/* Finally, allocate space. */
168	p = *head;
169	if (p != NULL)
170	{
171	bfd_size_type count = 0;
172	do
173	{
174	count += p->count;
175	p = p->next;
176	}
177	while (p != NULL);
178	htab->irelifunc->size += count * RELA_ENTRY_SIZE;
179	}
180
181	/* Decide whether the got.iplt slot can be used. This has to be
182	avoided if the values in the GOT slots could differ for pointer
183	equality reasons. */
184	if (h->got.refcount <= 0
185	\|\| (info->shared
186	&& (h->dynindx == -1 \|\| h->forced_local))
187	\|\| (info->executable && info->shared)
188	\|\| htab->sgot == NULL)
189	{
190	/* Use .got.iplt. */
191	h->got.offset = (bfd_vma) -1;
192	}
193	else
194	{
195	h->got.offset = htab->sgot->size;
196	htab->sgot->size += GOT_ENTRY_SIZE;
197	if (info->shared)
198	htab->srelgot->size += RELA_ENTRY_SIZE;
199	}
200
201	return TRUE;
202	}
203
204	static bfd_boolean
205	elf_s390_allocate_local_syminfo (bfd abfd, Elf_Internal_Shdr symtab_hdr)
206	{
207	bfd_size_type size;
208
209	size = symtab_hdr->sh_info;
210	size = (sizeof (bfd_signed_vma) / local got */
211	+ sizeof (struct plt_entry) /* local plt */
212	+ sizeof(char)); /* local tls type */
213	elf_local_got_refcounts (abfd) = ((bfd_signed_vma *)
214	bfd_zalloc (abfd, size));
215	if (elf_local_got_refcounts (abfd) == NULL)
216	return FALSE;
217	elf_s390_local_plt (abfd)
218	= (struct plt_entry*)(elf_local_got_refcounts (abfd)
219	+ symtab_hdr->sh_info);
220	elf_s390_local_got_tls_type (abfd)
221	= (char *) (elf_s390_local_plt (abfd) + symtab_hdr->sh_info);
222
223	return TRUE;
224	}
225
226	/* Pick ELFOSABI_GNU if IFUNC symbols are used. */
227
228	static bfd_boolean
229	elf_s390_add_symbol_hook (bfd *abfd,
230	struct bfd_link_info *info,
231	Elf_Internal_Sym *sym,
232	const char **namep ATTRIBUTE_UNUSED,
233	flagword *flagsp ATTRIBUTE_UNUSED,
234	asection **secp ATTRIBUTE_UNUSED,
235	bfd_vma *valp ATTRIBUTE_UNUSED)
236	{
f1885d1e AM	237	if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
	238	\|\| ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
	239	&& (abfd->flags & DYNAMIC) == 0
	240	&& bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
13a2df29	241	elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
470b557a AK	242
	243	return TRUE;
	244	}
b9005ba7 AK	245
	246	/* Whether to sort relocs output by ld -r or ld --emit-relocs, by
	247	r_offset. Don't do so for code sections. We want to keep ordering
	248	of GDCALL / PLT32DBL for TLS optimizations as is. On the other
	249	hand, elf-eh-frame.c processing requires .eh_frame relocs to be
	250	sorted. */
	251
	252	static bfd_boolean
	253	elf_s390_elf_sort_relocs_p (asection *sec)
	254	{
	255	return (sec->flags & SEC_CODE) == 0;
	256	}
643f7afb AK	257
	258	/* Merge object attributes from IBFD into OBFD. Raise an error if
	259	there are conflicting attributes. */
	260	static bfd_boolean
	261	elf_s390_merge_obj_attributes (bfd ibfd, bfd obfd)
	262	{
	263	obj_attribute in_attr, in_attrs;
	264	obj_attribute out_attr, out_attrs;
	265
	266	if (!elf_known_obj_attributes_proc (obfd)[0].i)
	267	{
	268	/* This is the first object. Copy the attributes. */
	269	_bfd_elf_copy_obj_attributes (ibfd, obfd);
	270
	271	/* Use the Tag_null value to indicate the attributes have been
	272	initialized. */
	273	elf_known_obj_attributes_proc (obfd)[0].i = 1;
	274
	275	return TRUE;
	276	}
	277
	278	in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
	279	out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
	280
	281	/* Check for conflicting Tag_GNU_S390_ABI_Vector attributes and
	282	merge non-conflicting ones. */
	283	in_attr = &in_attrs[Tag_GNU_S390_ABI_Vector];
	284	out_attr = &out_attrs[Tag_GNU_S390_ABI_Vector];
	285
	286	if (in_attr->i > 2)
	287	_bfd_error_handler
	288	(_("Warning: %B uses unknown vector ABI %d"), ibfd,
	289	in_attr->i);
	290	else if (out_attr->i > 2)
	291	_bfd_error_handler
	292	(_("Warning: %B uses unknown vector ABI %d"), obfd,
	293	out_attr->i);
	294	else if (in_attr->i != out_attr->i)
	295	{
	296	out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
	297
	298	if (in_attr->i && out_attr->i)
	299	{
	300	const char abi_str[3][9] = { "none", "software", "hardware" };
	301
	302	_bfd_error_handler
	303	(_("Warning: %B uses vector %s ABI, %B uses %s ABI"),
	304	ibfd, obfd, abi_str[in_attr->i], abi_str[out_attr->i]);
	305	}
	306	if (in_attr->i > out_attr->i)
	307	out_attr->i = in_attr->i;
	308	}
	309
	310	/* Merge Tag_compatibility attributes and any common GNU ones. */
	311	_bfd_elf_merge_object_attributes (ibfd, obfd);
	312
	313	return TRUE;
	314	}