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

/* ELF attributes support (based on ARM EABI attributes).
   Copyright 2005, 2006, 2007
   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 "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"

/* Return the number of bytes needed by I in uleb128 format.  */
static int
uleb128_size (unsigned int i)
{
  int size;
  size = 1;
  while (i >= 0x80)
    {
      i >>= 7;
      size++;
    }
  return size;
}

/* Return TRUE if the attribute has the default value (0/"").  */
static bfd_boolean
is_default_attr (obj_attribute *attr)
{
  if ((attr->type & 1) && attr->i != 0)
    return FALSE;
  if ((attr->type & 2) && attr->s && *attr->s)
    return FALSE;

  return TRUE;
}

/* Return the size of a single attribute.  */
static bfd_vma
obj_attr_size (int tag, obj_attribute *attr)
{
  bfd_vma size;

  if (is_default_attr (attr))
    return 0;

  size = uleb128_size (tag);
  if (attr->type & 1)
    size += uleb128_size (attr->i);
  if (attr->type & 2)
    size += strlen ((char *)attr->s) + 1;
  return size;
}

/* Return the vendor name for a given object attributes section.  */
static const char *
vendor_obj_attr_name (bfd *abfd, int vendor)
{
  return (vendor == OBJ_ATTR_PROC
	  ? get_elf_backend_data (abfd)->obj_attrs_vendor
	  : "gnu");
}

/* Return the size of the object attributes section for VENDOR
   (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes
   for that vendor to record and the vendor is OBJ_ATTR_GNU.  */
static bfd_vma
vendor_obj_attr_size (bfd *abfd, int vendor)
{
  bfd_vma size;
  obj_attribute *attr;
  obj_attribute_list *list;
  int i;
  const char *vendor_name = vendor_obj_attr_name (abfd, vendor);

  if (!vendor_name)
    return 0;

  attr = elf_known_obj_attributes (abfd)[vendor];
  size = 0;
  for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
    size += obj_attr_size (i, &attr[i]);

  for (list = elf_other_obj_attributes (abfd)[vendor];
       list;
       list = list->next)
    size += obj_attr_size (list->tag, &list->attr);

  /* <size> <vendor_name> NUL 0x1 <size> */
  return ((size || vendor == OBJ_ATTR_PROC)
	  ? size + 10 + strlen (vendor_name)
	  : 0);
}

/* Return the size of the object attributes section.  */
bfd_vma
bfd_elf_obj_attr_size (bfd *abfd)
{
  bfd_vma size;

  size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
  size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);

  /* 'A' <sections for each vendor> */
  return (size ? size + 1 : 0);
}

/* Write VAL in uleb128 format to P, returning a pointer to the
   following byte.  */
static bfd_byte *
write_uleb128 (bfd_byte *p, unsigned int val)
{
  bfd_byte c;
  do
    {
      c = val & 0x7f;
      val >>= 7;
      if (val)
	c |= 0x80;
      *(p++) = c;
    }
  while (val);
  return p;
}

/* Write attribute ATTR to butter P, and return a pointer to the following
   byte.  */
static bfd_byte *
write_obj_attribute (bfd_byte *p, int tag, obj_attribute *attr)
{
  /* Suppress default entries.  */
  if (is_default_attr (attr))
    return p;

  p = write_uleb128 (p, tag);
  if (attr->type & 1)
    p = write_uleb128 (p, attr->i);
  if (attr->type & 2)
    {
      int len;

      len = strlen (attr->s) + 1;
      memcpy (p, attr->s, len);
      p += len;
    }

  return p;
}

/* Write the contents of the object attributes section (length SIZE)
   for VENDOR to CONTENTS.  */
static void
vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
			      int vendor)
{
  bfd_byte *p;
  obj_attribute *attr;
  obj_attribute_list *list;
  int i;
  const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
  size_t vendor_length = strlen (vendor_name) + 1;

  p = contents;
  bfd_put_32 (abfd, size, p);
  p += 4;
  memcpy (p, vendor_name, vendor_length);
  p += vendor_length;
  *(p++) = Tag_File;
  bfd_put_32 (abfd, size - 4 - vendor_length, p);
  p += 4;

  attr = elf_known_obj_attributes (abfd)[vendor];
  for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
    p = write_obj_attribute (p, i, &attr[i]);

  for (list = elf_other_obj_attributes (abfd)[vendor];
       list;
       list = list->next)
    p = write_obj_attribute (p, list->tag, &list->attr);
}

/* Write the contents of the object attributes section to CONTENTS.  */
void
bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
{
  bfd_byte *p;
  int vendor;
  bfd_vma my_size;

  p = contents;
  *(p++) = 'A';
  my_size = 1;
  for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
    {
      bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
      if (vendor_size)
	vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
      p += vendor_size;
      my_size += vendor_size;
    }

  if (size != my_size)
    abort ();
}

/* Allocate/find an object attribute.  */
static obj_attribute *
elf_new_obj_attr (bfd *abfd, int vendor, int tag)
{
  obj_attribute *attr;
  obj_attribute_list *list;
  obj_attribute_list *p;
  obj_attribute_list **lastp;


  if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
    {
      /* Knwon tags are preallocated.  */
      attr = &elf_known_obj_attributes (abfd)[vendor][tag];
    }
  else
    {
      /* Create a new tag.  */
      list = (obj_attribute_list *)
	bfd_alloc (abfd, sizeof (obj_attribute_list));
      memset (list, 0, sizeof (obj_attribute_list));
      list->tag = tag;
      /* Keep the tag list in order.  */
      lastp = &elf_other_obj_attributes (abfd)[vendor];
      for (p = *lastp; p; p = p->next)
	{
	  if (tag < p->tag)
	    break;
	  lastp = &p->next;
	}
      list->next = *lastp;
      *lastp = list;
      attr = &list->attr;
    }

  return attr;
}

/* Return the value of an integer object attribute.  */
int
bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag)
{
  obj_attribute_list *p;

  if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
    {
      /* Knwon tags are preallocated.  */
      return elf_known_obj_attributes (abfd)[vendor][tag].i;
    }
  else
    {
      for (p = elf_other_obj_attributes (abfd)[vendor];
	   p;
	   p = p->next)
	{
	  if (tag == p->tag)
	    return p->attr.i;
	  if (tag < p->tag)
	    break;
	}
      return 0;
    }
}

/* Add an integer object attribute.  */
void
bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i)
{
  obj_attribute *attr;

  attr = elf_new_obj_attr (abfd, vendor, tag);
  attr->type = 1;
  attr->i = i;
}

/* Duplicate an object attribute string value.  */
char *
_bfd_elf_attr_strdup (bfd *abfd, const char * s)
{
  char * p;
  int len;
  
  len = strlen (s) + 1;
  p = (char *) bfd_alloc (abfd, len);
  return memcpy (p, s, len);
}

/* Add a string object attribute.  */
void
bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, int tag, const char *s)
{
  obj_attribute *attr;

  attr = elf_new_obj_attr (abfd, vendor, tag);
  attr->type = 2;
  attr->s = _bfd_elf_attr_strdup (abfd, s);
}

/* Add a int+string object attribute.  */
void
bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, int tag,
				 unsigned int i, const char *s)
{
  obj_attribute *attr;

  attr = elf_new_obj_attr (abfd, vendor, tag);
  attr->type = 3;
  attr->i = i;
  attr->s = _bfd_elf_attr_strdup (abfd, s);
}

/* Copy the object attributes from IBFD to OBFD.  */
void
_bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
{
  obj_attribute *in_attr;
  obj_attribute *out_attr;
  obj_attribute_list *list;
  int i;
  int vendor;

  for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
    {
      in_attr = &elf_known_obj_attributes (ibfd)[vendor][4];
      out_attr = &elf_known_obj_attributes (obfd)[vendor][4];
      for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
	{
	  out_attr->type = in_attr->type;
	  out_attr->i = in_attr->i;
	  if (in_attr->s && *in_attr->s)
	    out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
	  in_attr++;
	  out_attr++;
	}

      for (list = elf_other_obj_attributes (ibfd)[vendor];
	   list;
	   list = list->next)
	{
	  in_attr = &list->attr;
	  switch (in_attr->type)
	    {
	    case 1:
	      bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
	      break;
	    case 2:
	      bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
					   in_attr->s);
	      break;
	    case 3:
	      bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag,
					       in_attr->i, in_attr->s);
	      break;
	    default:
	      abort ();
	    }
	}
    }
}

/* Determine whether a GNU object attribute tag takes an integer, a
   string or both.  */
static int
gnu_obj_attrs_arg_type (int tag)
{
  /* Except for Tag_compatibility, for GNU attributes we follow the
     same rule ARM ones > 32 follow: odd-numbered tags take strings
     and even-numbered tags take integers.  In addition, tag & 2 is
     nonzero for architecture-independent tags and zero for
     architecture-dependent ones.  */
  if (tag == Tag_compatibility)
    return 3;
  else
    return (tag & 1) != 0 ? 2 : 1;
}

/* Determine what arguments an attribute tag takes.  */
int
_bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
{
  switch (vendor)
    {
    case OBJ_ATTR_PROC:
      return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
      break;
    case OBJ_ATTR_GNU:
      return gnu_obj_attrs_arg_type (tag);
      break;
    default:
      abort ();
    }
}

/* Parse an object attributes section.  */
void
_bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
{
  bfd_byte *contents;
  bfd_byte *p;
  bfd_vma len;
  const char *std_section;

  contents = bfd_malloc (hdr->sh_size);
  if (!contents)
    return;
  if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
				 hdr->sh_size))
    {
      free (contents);
      return;
    }
  p = contents;
  std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
  if (*(p++) == 'A')
    {
      len = hdr->sh_size - 1;
      while (len > 0)
	{
	  int namelen;
	  bfd_vma section_len;
	  int vendor;

	  section_len = bfd_get_32 (abfd, p);
	  p += 4;
	  if (section_len > len)
	    section_len = len;
	  len -= section_len;
	  namelen = strlen ((char *)p) + 1;
	  section_len -= namelen + 4;
	  if (std_section && strcmp ((char *)p, std_section) == 0)
	    vendor = OBJ_ATTR_PROC;
	  else if (strcmp ((char *)p, "gnu") == 0)
	    vendor = OBJ_ATTR_GNU;
	  else
	    {
	      /* Other vendor section.  Ignore it.  */
	      p += namelen + section_len;
	      continue;
	    }

	  p += namelen;
	  while (section_len > 0)
	    {
	      int tag;
	      unsigned int n;
	      unsigned int val;
	      bfd_vma subsection_len;
	      bfd_byte *end;

	      tag = read_unsigned_leb128 (abfd, p, &n);
	      p += n;
	      subsection_len = bfd_get_32 (abfd, p);
	      p += 4;
	      if (subsection_len > section_len)
		subsection_len = section_len;
	      section_len -= subsection_len;
	      subsection_len -= n + 4;
	      end = p + subsection_len;
	      switch (tag)
		{
		case Tag_File:
		  while (p < end)
		    {
		      int type;

		      tag = read_unsigned_leb128 (abfd, p, &n);
		      p += n;
		      type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
		      switch (type)
			{
			case 3:
			  val = read_unsigned_leb128 (abfd, p, &n);
			  p += n;
			  bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
							   val, (char *)p);
			  p += strlen ((char *)p) + 1;
			  break;
			case 2:
			  bfd_elf_add_obj_attr_string (abfd, vendor, tag,
						       (char *)p);
			  p += strlen ((char *)p) + 1;
			  break;
			case 1:
			  val = read_unsigned_leb128 (abfd, p, &n);
			  p += n;
			  bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
			  break;
			default:
			  abort ();
			}
		    }
		  break;
		case Tag_Section:
		case Tag_Symbol:
		  /* Don't have anywhere convenient to attach these.
		     Fall through for now.  */
		default:
		  /* Ignore things we don't kow about.  */
		  p += subsection_len;
		  subsection_len = 0;
		  break;
		}
	    }
	}
    }
  free (contents);
}

/* Merge common object attributes from IBFD into OBFD.  Raise an error
   if there are conflicting attributes.  Any processor-specific
   attributes have already been merged.  This must be called from the
   bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
   target, along with any target-specific merging.  Because there are
   no common attributes other than Tag_compatibility at present, and
   non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
   is not presently called for targets without their own
   attributes.  */

bfd_boolean
_bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
{
  obj_attribute *in_attr;
  obj_attribute *out_attr;
  int vendor;

  /* The only common attribute is currently Tag_compatibility,
     accepted in both processor and "gnu" sections.  */
  for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
    {
      /* Handle Tag_compatibility.  The tags are only compatible if the flags
	 are identical and, if the flags are '1', the strings are identical.
	 If the flags are non-zero, then we can only use the string "gnu".  */
      in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
      out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];

      if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
	{
	  _bfd_error_handler
		(_("ERROR: %B: Must be processed by '%s' toolchain"),
		 ibfd, in_attr->s);
	  return FALSE;
	}

      if (in_attr->i != out_attr->i
	  || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
	{
	  _bfd_error_handler (_("ERROR: %B: Object tag '%d, %s' is "
				"incompatible with tag '%d, %s'"),
			      ibfd,
			      in_attr->i, in_attr->s ? in_attr->s : "",
			      out_attr->i, out_attr->s ? out_attr->s : "");
	  return FALSE;
	}
    }

  return TRUE;
}
Commit	Line	Data
104d59d1 JM	1	/* ELF attributes support (based on ARM EABI attributes).
	2	Copyright 2005, 2006, 2007
	3	Free Software Foundation, Inc.
	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
cd123cb7	9	the Free Software Foundation; either version 3 of the License, or
104d59d1 JM	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
cd123cb7 NC	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
cd123cb7 NC	20	MA 02110-1301, USA. */
104d59d1 JM	21
	22	#include "sysdep.h"
	23	#include "bfd.h"
	24	#include "libiberty.h"
	25	#include "libbfd.h"
	26	#include "elf-bfd.h"
	27
	28	/* Return the number of bytes needed by I in uleb128 format. */
	29	static int
	30	uleb128_size (unsigned int i)
	31	{
	32	int size;
	33	size = 1;
	34	while (i >= 0x80)
	35	{
	36	i >>= 7;
	37	size++;
	38	}
	39	return size;
	40	}
	41
	42	/* Return TRUE if the attribute has the default value (0/""). */
	43	static bfd_boolean
	44	is_default_attr (obj_attribute *attr)
	45	{
	46	if ((attr->type & 1) && attr->i != 0)
	47	return FALSE;
	48	if ((attr->type & 2) && attr->s && *attr->s)
	49	return FALSE;
	50
	51	return TRUE;
	52	}
	53
	54	/* Return the size of a single attribute. */
	55	static bfd_vma
	56	obj_attr_size (int tag, obj_attribute *attr)
	57	{
	58	bfd_vma size;
	59
	60	if (is_default_attr (attr))
	61	return 0;
	62
	63	size = uleb128_size (tag);
	64	if (attr->type & 1)
	65	size += uleb128_size (attr->i);
	66	if (attr->type & 2)
	67	size += strlen ((char *)attr->s) + 1;
	68	return size;
	69	}
	70
	71	/* Return the vendor name for a given object attributes section. */
	72	static const char *
	73	vendor_obj_attr_name (bfd *abfd, int vendor)
	74	{
	75	return (vendor == OBJ_ATTR_PROC
	76	? get_elf_backend_data (abfd)->obj_attrs_vendor
	77	: "gnu");
	78	}
	79
	80	/* Return the size of the object attributes section for VENDOR
	81	(OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes
	82	for that vendor to record and the vendor is OBJ_ATTR_GNU. */
	83	static bfd_vma
	84	vendor_obj_attr_size (bfd *abfd, int vendor)
85	{
86	bfd_vma size;
87	obj_attribute *attr;
88	obj_attribute_list *list;
89	int i;
90	const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
91
92	if (!vendor_name)
93	return 0;
94
95	attr = elf_known_obj_attributes (abfd)[vendor];
96	size = 0;
97	for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
98	size += obj_attr_size (i, &attr[i]);
99
100	for (list = elf_other_obj_attributes (abfd)[vendor];
101	list;
102	list = list->next)
103	size += obj_attr_size (list->tag, &list->attr);
104
105	/* <size> <vendor_name> NUL 0x1 <size> */
106	return ((size \|\| vendor == OBJ_ATTR_PROC)
107	? size + 10 + strlen (vendor_name)
108	: 0);
109	}
110
111	/* Return the size of the object attributes section. */
112	bfd_vma
113	bfd_elf_obj_attr_size (bfd *abfd)
114	{
115	bfd_vma size;
116
117	size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
118	size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);
119
120	/* 'A' <sections for each vendor> */
121	return (size ? size + 1 : 0);
122	}
123
124	/* Write VAL in uleb128 format to P, returning a pointer to the
125	following byte. */
126	static bfd_byte *
127	write_uleb128 (bfd_byte *p, unsigned int val)
128	{
129	bfd_byte c;
130	do
131	{
132	c = val & 0x7f;
133	val >>= 7;
134	if (val)
135	c \|= 0x80;
136	*(p++) = c;
137	}
138	while (val);
139	return p;
140	}
141
142	/* Write attribute ATTR to butter P, and return a pointer to the following
143	byte. */
144	static bfd_byte *
145	write_obj_attribute (bfd_byte p, int tag, obj_attribute attr)
146	{
147	/* Suppress default entries. */
148	if (is_default_attr (attr))
149	return p;
150
151	p = write_uleb128 (p, tag);
152	if (attr->type & 1)
153	p = write_uleb128 (p, attr->i);
154	if (attr->type & 2)
155	{
156	int len;
157
158	len = strlen (attr->s) + 1;
159	memcpy (p, attr->s, len);
160	p += len;
161	}
162
163	return p;
164	}
165
166	/* Write the contents of the object attributes section (length SIZE)
167	for VENDOR to CONTENTS. */
168	static void
169	vendor_set_obj_attr_contents (bfd abfd, bfd_byte contents, bfd_vma size,
170	int vendor)
171	{
172	bfd_byte *p;
173	obj_attribute *attr;
174	obj_attribute_list *list;
175	int i;
176	const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
177	size_t vendor_length = strlen (vendor_name) + 1;
178
179	p = contents;
180	bfd_put_32 (abfd, size, p);
181	p += 4;
182	memcpy (p, vendor_name, vendor_length);
183	p += vendor_length;
184	*(p++) = Tag_File;
185	bfd_put_32 (abfd, size - 4 - vendor_length, p);
186	p += 4;
187
188	attr = elf_known_obj_attributes (abfd)[vendor];
189	for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
190	p = write_obj_attribute (p, i, &attr[i]);
191
192	for (list = elf_other_obj_attributes (abfd)[vendor];
193	list;
194	list = list->next)
195	p = write_obj_attribute (p, list->tag, &list->attr);
196	}
197
198	/* Write the contents of the object attributes section to CONTENTS. */
199	void
200	bfd_elf_set_obj_attr_contents (bfd abfd, bfd_byte contents, bfd_vma size)
201	{
202	bfd_byte *p;
203	int vendor;
204	bfd_vma my_size;
205
206	p = contents;
207	*(p++) = 'A';
208	my_size = 1;
209	for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
210	{
211	bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
212	if (vendor_size)
213	vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
214	p += vendor_size;
215	my_size += vendor_size;
216	}
217
218	if (size != my_size)
219	abort ();
220	}
221
222	/* Allocate/find an object attribute. */
223	static obj_attribute *
224	elf_new_obj_attr (bfd *abfd, int vendor, int tag)
225	{
226	obj_attribute *attr;
227	obj_attribute_list *list;
228	obj_attribute_list *p;
229	obj_attribute_list **lastp;
230
231
232	if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
233	{
234	/* Knwon tags are preallocated. */
235	attr = &elf_known_obj_attributes (abfd)[vendor][tag];
236	}
237	else
238	{
239	/* Create a new tag. */
240	list = (obj_attribute_list *)
241	bfd_alloc (abfd, sizeof (obj_attribute_list));
242	memset (list, 0, sizeof (obj_attribute_list));
243	list->tag = tag;
244	/* Keep the tag list in order. */
245	lastp = &elf_other_obj_attributes (abfd)[vendor];
246	for (p = *lastp; p; p = p->next)
247	{
248	if (tag < p->tag)
249	break;
250	lastp = &p->next;
251	}
252	list->next = *lastp;
253	*lastp = list;
254	attr = &list->attr;
255	}
256
257	return attr;
258	}
259
260	/* Return the value of an integer object attribute. */
261	int
262	bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag)
263	{
264	obj_attribute_list *p;
265
266	if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
267	{
268	/* Knwon tags are preallocated. */
269	return elf_known_obj_attributes (abfd)[vendor][tag].i;
270	}
271	else
272	{
273	for (p = elf_other_obj_attributes (abfd)[vendor];
274	p;
275	p = p->next)
276	{
277	if (tag == p->tag)
278	return p->attr.i;
279	if (tag < p->tag)
280	break;
281	}
282	return 0;
283	}
284	}
285
286	/* Add an integer object attribute. */
287	void
288	bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i)
289	{
290	obj_attribute *attr;
291
292	attr = elf_new_obj_attr (abfd, vendor, tag);
293	attr->type = 1;
294	attr->i = i;
295	}
296
297	/* Duplicate an object attribute string value. */
298	char *
299	_bfd_elf_attr_strdup (bfd abfd, const char s)
300	{
301	char * p;
302	int len;
303
304	len = strlen (s) + 1;
305	p = (char *) bfd_alloc (abfd, len);
306	return memcpy (p, s, len);
307	}
308
309	/* Add a string object attribute. */
310	void
311	bfd_elf_add_obj_attr_string (bfd abfd, int vendor, int tag, const char s)
312	{
313	obj_attribute *attr;
314
315	attr = elf_new_obj_attr (abfd, vendor, tag);
316	attr->type = 2;
317	attr->s = _bfd_elf_attr_strdup (abfd, s);
318	}
319
7b86a9fa	320	/* Add a int+string object attribute. */
104d59d1	321	void
7b86a9fa AS	322	bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, int tag,
7b86a9fa AS	323	unsigned int i, const char *s)
104d59d1	324	{
7b86a9fa	325	obj_attribute *attr;
104d59d1	326
7b86a9fa AS	327	attr = elf_new_obj_attr (abfd, vendor, tag);
	328	attr->type = 3;
	329	attr->i = i;
	330	attr->s = _bfd_elf_attr_strdup (abfd, s);
104d59d1 JM	331	}
	332
	333	/* Copy the object attributes from IBFD to OBFD. */
	334	void
	335	_bfd_elf_copy_obj_attributes (bfd ibfd, bfd obfd)
	336	{
	337	obj_attribute *in_attr;
	338	obj_attribute *out_attr;
	339	obj_attribute_list *list;
	340	int i;
	341	int vendor;
	342
	343	for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
	344	{
	345	in_attr = &elf_known_obj_attributes (ibfd)[vendor][4];
	346	out_attr = &elf_known_obj_attributes (obfd)[vendor][4];
	347	for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
	348	{
	349	out_attr->type = in_attr->type;
	350	out_attr->i = in_attr->i;
	351	if (in_attr->s && *in_attr->s)
	352	out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
	353	in_attr++;
	354	out_attr++;
	355	}
	356
	357	for (list = elf_other_obj_attributes (ibfd)[vendor];
	358	list;
	359	list = list->next)
	360	{
	361	in_attr = &list->attr;
	362	switch (in_attr->type)
	363	{
	364	case 1:
	365	bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
	366	break;
	367	case 2:
	368	bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
	369	in_attr->s);
	370	break;
	371	case 3:
7b86a9fa AS	372	bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag,
7b86a9fa AS	373	in_attr->i, in_attr->s);
104d59d1 JM	374	break;
	375	default:
	376	abort ();
	377	}
	378	}
	379	}
	380	}
	381
	382	/* Determine whether a GNU object attribute tag takes an integer, a
	383	string or both. */
	384	static int
	385	gnu_obj_attrs_arg_type (int tag)
	386	{
	387	/* Except for Tag_compatibility, for GNU attributes we follow the
	388	same rule ARM ones > 32 follow: odd-numbered tags take strings
	389	and even-numbered tags take integers. In addition, tag & 2 is
	390	nonzero for architecture-independent tags and zero for
	391	architecture-dependent ones. */
	392	if (tag == Tag_compatibility)
	393	return 3;
	394	else
	395	return (tag & 1) != 0 ? 2 : 1;
	396	}
	397
	398	/* Determine what arguments an attribute tag takes. */
	399	int
	400	_bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
	401	{
	402	switch (vendor)
	403	{
	404	case OBJ_ATTR_PROC:
	405	return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
	406	break;
	407	case OBJ_ATTR_GNU:
	408	return gnu_obj_attrs_arg_type (tag);
	409	break;
	410	default:
	411	abort ();
	412	}
	413	}
	414
	415	/* Parse an object attributes section. */
	416	void
	417	_bfd_elf_parse_attributes (bfd abfd, Elf_Internal_Shdr hdr)
	418	{
	419	bfd_byte *contents;
	420	bfd_byte *p;
	421	bfd_vma len;
	422	const char *std_section;
	423
	424	contents = bfd_malloc (hdr->sh_size);
	425	if (!contents)
	426	return;
	427	if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
	428	hdr->sh_size))
	429	{
	430	free (contents);
	431	return;
	432	}
	433	p = contents;
	434	std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
	435	if (*(p++) == 'A')
	436	{
	437	len = hdr->sh_size - 1;
438	while (len > 0)
439	{
440	int namelen;
441	bfd_vma section_len;
442	int vendor;
443
444	section_len = bfd_get_32 (abfd, p);
445	p += 4;
446	if (section_len > len)
447	section_len = len;
448	len -= section_len;
449	namelen = strlen ((char *)p) + 1;
450	section_len -= namelen + 4;
451	if (std_section && strcmp ((char *)p, std_section) == 0)
452	vendor = OBJ_ATTR_PROC;
453	else if (strcmp ((char *)p, "gnu") == 0)
454	vendor = OBJ_ATTR_GNU;
455	else
456	{
457	/* Other vendor section. Ignore it. */
458	p += namelen + section_len;
459	continue;
460	}
461
462	p += namelen;
463	while (section_len > 0)
464	{
465	int tag;
466	unsigned int n;
467	unsigned int val;
468	bfd_vma subsection_len;
469	bfd_byte *end;
470
471	tag = read_unsigned_leb128 (abfd, p, &n);
472	p += n;
473	subsection_len = bfd_get_32 (abfd, p);
474	p += 4;
475	if (subsection_len > section_len)
476	subsection_len = section_len;
477	section_len -= subsection_len;
478	subsection_len -= n + 4;
479	end = p + subsection_len;
480	switch (tag)
481	{
482	case Tag_File:
483	while (p < end)
484	{
485	int type;
486
487	tag = read_unsigned_leb128 (abfd, p, &n);
488	p += n;
489	type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
490	switch (type)
491	{
492	case 3:
493	val = read_unsigned_leb128 (abfd, p, &n);
494	p += n;
7b86a9fa AS	495	bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
7b86a9fa AS	496	val, (char *)p);
104d59d1 JM	497	p += strlen ((char *)p) + 1;
	498	break;
	499	case 2:
	500	bfd_elf_add_obj_attr_string (abfd, vendor, tag,
	501	(char *)p);
	502	p += strlen ((char *)p) + 1;
	503	break;
	504	case 1:
	505	val = read_unsigned_leb128 (abfd, p, &n);
	506	p += n;
	507	bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
	508	break;
	509	default:
	510	abort ();
	511	}
	512	}
	513	break;
	514	case Tag_Section:
	515	case Tag_Symbol:
	516	/* Don't have anywhere convenient to attach these.
	517	Fall through for now. */
	518	default:
	519	/* Ignore things we don't kow about. */
	520	p += subsection_len;
	521	subsection_len = 0;
	522	break;
	523	}
	524	}
	525	}
	526	}
	527	free (contents);
	528	}
	529
	530	/* Merge common object attributes from IBFD into OBFD. Raise an error
	531	if there are conflicting attributes. Any processor-specific
	532	attributes have already been merged. This must be called from the
	533	bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
	534	target, along with any target-specific merging. Because there are
	535	no common attributes other than Tag_compatibility at present, and
	536	non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
	537	is not presently called for targets without their own
	538	attributes. */
	539
	540	bfd_boolean
	541	_bfd_elf_merge_object_attributes (bfd ibfd, bfd obfd)
	542	{
	543	obj_attribute *in_attr;
	544	obj_attribute *out_attr;
104d59d1 JM	545	int vendor;
	546
	547	/* The only common attribute is currently Tag_compatibility,
	548	accepted in both processor and "gnu" sections. */
	549	for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
	550	{
7b86a9fa AS	551	/* Handle Tag_compatibility. The tags are only compatible if the flags
	552	are identical and, if the flags are '1', the strings are identical.
	553	If the flags are non-zero, then we can only use the string "gnu". */
	554	in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
	555	out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
	556
	557	if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
104d59d1	558	{
7b86a9fa	559	_bfd_error_handler
104d59d1 JM	560	(_("ERROR: %B: Must be processed by '%s' toolchain"),
104d59d1 JM	561	ibfd, in_attr->s);
7b86a9fa AS	562	return FALSE;
7b86a9fa AS	563	}
104d59d1	564
7b86a9fa AS	565	if (in_attr->i != out_attr->i
	566	\|\| (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
	567	{
	568	_bfd_error_handler (_("ERROR: %B: Object tag '%d, %s' is "
	569	"incompatible with tag '%d, %s'"),
	570	ibfd,
	571	in_attr->i, in_attr->s ? in_attr->s : "",
	572	out_attr->i, out_attr->s ? out_attr->s : "");
	573	return FALSE;
104d59d1 JM	574	}
	575	}
	576
	577	return TRUE;
	578	}