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