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

/* IBM S/390-specific support for ELF 32 and 64 bit functions
   Copyright (C) 2000-2016 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 (bfd_link_pic (info))
    {
      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 *p;
  struct elf_link_hash_table *htab;
  struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
  struct elf_dyn_relocs **head = &eh->dyn_relocs;

  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 (bfd_link_pic (info)
	  && !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 (bfd_link_pde (info)
      && 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 (!bfd_link_pic (info) || !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
      || (bfd_link_pic (info)
	  && (h->dynindx == -1 || h->forced_local))
      || bfd_link_pie (info)
      || 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 (bfd_link_pic (info))
	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
      && (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;
}

/* 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, struct bfd_link_info *info)
{
  bfd *obfd = info->output_bfd;
  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, info);

  return TRUE;
}
Commit	Line	Data
470b557a	1	/* IBM S/390-specific support for ELF 32 and 64 bit functions
6f2750fe	2	Copyright (C) 2000-2016 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
0e1862bb	48	if (bfd_link_pic (info))
470b557a AK	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,
61643fba	90	struct elf_link_hash_entry *h)
470b557a AK	91	{
	92	struct elf_dyn_relocs *p;
	93	struct elf_link_hash_table *htab;
	94	struct elf_s390_link_hash_entry eh = (struct elf_s390_link_hash_entry)h;
61643fba	95	struct elf_dyn_relocs **head = &eh->dyn_relocs;
470b557a AK	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. */
0e1862bb	108	if (bfd_link_pic (info)
470b557a AK	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. */
3cbc1e5e	154	if (bfd_link_pde (info)
0e1862bb L	155	&& h->def_regular
0e1862bb L	156	&& h->ref_dynamic)
470b557a AK	157	{
	158	h->root.u.def.section = htab->iplt;
	159	h->root.u.def.value = h->plt.offset;
	160	h->size = PLT_ENTRY_SIZE;
	161	h->type = STT_FUNC;
	162	}
	163
	164	/* We need dynamic relocation for STT_GNU_IFUNC symbol only when
	165	there is a non-GOT reference in a shared object. */
0e1862bb	166	if (!bfd_link_pic (info) \|\| !h->non_got_ref)
470b557a AK	167	*head = NULL;
	168
	169	/* Finally, allocate space. */
	170	p = *head;
	171	if (p != NULL)
	172	{
	173	bfd_size_type count = 0;
	174	do
	175	{
	176	count += p->count;
	177	p = p->next;
	178	}
	179	while (p != NULL);
	180	htab->irelifunc->size += count * RELA_ENTRY_SIZE;
	181	}
	182
	183	/* Decide whether the got.iplt slot can be used. This has to be
	184	avoided if the values in the GOT slots could differ for pointer
	185	equality reasons. */
	186	if (h->got.refcount <= 0
0e1862bb	187	\|\| (bfd_link_pic (info)
470b557a	188	&& (h->dynindx == -1 \|\| h->forced_local))
3cbc1e5e	189	\|\| bfd_link_pie (info)
470b557a AK	190	\|\| htab->sgot == NULL)
	191	{
	192	/* Use .got.iplt. */
	193	h->got.offset = (bfd_vma) -1;
	194	}
	195	else
	196	{
	197	h->got.offset = htab->sgot->size;
	198	htab->sgot->size += GOT_ENTRY_SIZE;
0e1862bb	199	if (bfd_link_pic (info))
470b557a AK	200	htab->srelgot->size += RELA_ENTRY_SIZE;
	201	}
	202
	203	return TRUE;
	204	}
	205
	206	static bfd_boolean
	207	elf_s390_allocate_local_syminfo (bfd abfd, Elf_Internal_Shdr symtab_hdr)
	208	{
	209	bfd_size_type size;
	210
	211	size = symtab_hdr->sh_info;
	212	size = (sizeof (bfd_signed_vma) / local got */
	213	+ sizeof (struct plt_entry) /* local plt */
	214	+ sizeof(char)); /* local tls type */
	215	elf_local_got_refcounts (abfd) = ((bfd_signed_vma *)
	216	bfd_zalloc (abfd, size));
	217	if (elf_local_got_refcounts (abfd) == NULL)
	218	return FALSE;
	219	elf_s390_local_plt (abfd)
	220	= (struct plt_entry*)(elf_local_got_refcounts (abfd)
	221	+ symtab_hdr->sh_info);
	222	elf_s390_local_got_tls_type (abfd)
	223	= (char *) (elf_s390_local_plt (abfd) + symtab_hdr->sh_info);
	224
	225	return TRUE;
	226	}
	227
	228	/* Pick ELFOSABI_GNU if IFUNC symbols are used. */
	229
	230	static bfd_boolean
	231	elf_s390_add_symbol_hook (bfd *abfd,
	232	struct bfd_link_info *info,
	233	Elf_Internal_Sym *sym,
	234	const char **namep ATTRIBUTE_UNUSED,
	235	flagword *flagsp ATTRIBUTE_UNUSED,
	236	asection **secp ATTRIBUTE_UNUSED,
	237	bfd_vma *valp ATTRIBUTE_UNUSED)
	238	{
a43942db	239	if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
f1885d1e AM	240	&& (abfd->flags & DYNAMIC) == 0
f1885d1e AM	241	&& bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
a43942db	242	elf_tdata (info->output_bfd)->has_gnu_symbols \|= elf_gnu_symbol_ifunc;
470b557a AK	243
	244	return TRUE;
	245	}
b9005ba7 AK	246
	247	/* Whether to sort relocs output by ld -r or ld --emit-relocs, by
	248	r_offset. Don't do so for code sections. We want to keep ordering
	249	of GDCALL / PLT32DBL for TLS optimizations as is. On the other
	250	hand, elf-eh-frame.c processing requires .eh_frame relocs to be
	251	sorted. */
	252
	253	static bfd_boolean
	254	elf_s390_elf_sort_relocs_p (asection *sec)
	255	{
	256	return (sec->flags & SEC_CODE) == 0;
	257	}
643f7afb AK	258
	259	/* Merge object attributes from IBFD into OBFD. Raise an error if
	260	there are conflicting attributes. */
	261	static bfd_boolean
50e03d47	262	elf_s390_merge_obj_attributes (bfd ibfd, struct bfd_link_info info)
643f7afb	263	{
50e03d47	264	bfd *obfd = info->output_bfd;
643f7afb AK	265	obj_attribute in_attr, in_attrs;
	266	obj_attribute out_attr, out_attrs;
	267
	268	if (!elf_known_obj_attributes_proc (obfd)[0].i)
	269	{
	270	/* This is the first object. Copy the attributes. */
	271	_bfd_elf_copy_obj_attributes (ibfd, obfd);
	272
	273	/* Use the Tag_null value to indicate the attributes have been
	274	initialized. */
	275	elf_known_obj_attributes_proc (obfd)[0].i = 1;
	276
	277	return TRUE;
	278	}
	279
	280	in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
	281	out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
	282
	283	/* Check for conflicting Tag_GNU_S390_ABI_Vector attributes and
	284	merge non-conflicting ones. */
	285	in_attr = &in_attrs[Tag_GNU_S390_ABI_Vector];
	286	out_attr = &out_attrs[Tag_GNU_S390_ABI_Vector];
	287
	288	if (in_attr->i > 2)
	289	_bfd_error_handler
	290	(_("Warning: %B uses unknown vector ABI %d"), ibfd,
	291	in_attr->i);
	292	else if (out_attr->i > 2)
	293	_bfd_error_handler
	294	(_("Warning: %B uses unknown vector ABI %d"), obfd,
	295	out_attr->i);
	296	else if (in_attr->i != out_attr->i)
	297	{
	298	out_attr->type = ATTR_TYPE_FLAG_INT_VAL;
	299
	300	if (in_attr->i && out_attr->i)
	301	{
	302	const char abi_str[3][9] = { "none", "software", "hardware" };
	303
	304	_bfd_error_handler
	305	(_("Warning: %B uses vector %s ABI, %B uses %s ABI"),
	306	ibfd, obfd, abi_str[in_attr->i], abi_str[out_attr->i]);
	307	}
	308	if (in_attr->i > out_attr->i)
	309	out_attr->i = in_attr->i;
	310	}
	311
	312	/* Merge Tag_compatibility attributes and any common GNU ones. */
50e03d47	313	_bfd_elf_merge_object_attributes (ibfd, info);
643f7afb AK	314
	315	return TRUE;
	316	}