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
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,
20   MA 02110-1301, USA.  */
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.  */
29static int
30uleb128_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/"").  */
43static bfd_boolean
44is_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.  */
55static bfd_vma
56obj_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.  */
72static const char *
73vendor_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.  */
83static bfd_vma
84vendor_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.  */
112bfd_vma
113bfd_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.  */
126static bfd_byte *
127write_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.  */
144static bfd_byte *
145write_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.  */
168static void
169vendor_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.  */
199void
200bfd_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.  */
223static obj_attribute *
224elf_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.  */
261int
262bfd_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.  */
287void
288bfd_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.  */
298char *
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.  */
310void
311bfd_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
320/* Add a Tag_compatibility object attribute.  */
321void
322bfd_elf_add_obj_attr_compat (bfd *abfd, int vendor, unsigned int i,
323			     const char *s)
324{
325  obj_attribute_list *list;
326  obj_attribute_list *p;
327  obj_attribute_list **lastp;
328
329  list = (obj_attribute_list *)
330    bfd_alloc (abfd, sizeof (obj_attribute_list));
331  memset (list, 0, sizeof (obj_attribute_list));
332  list->tag = Tag_compatibility;
333  list->attr.type = 3;
334  list->attr.i = i;
335  list->attr.s = _bfd_elf_attr_strdup (abfd, s);
336
337  lastp = &elf_other_obj_attributes (abfd)[vendor];
338  for (p = *lastp; p; p = p->next)
339    {
340      int cmp;
341      if (p->tag != Tag_compatibility)
342	break;
343      cmp = strcmp(s, p->attr.s);
344      if (cmp < 0 || (cmp == 0 && i < p->attr.i))
345	break;
346      lastp = &p->next;
347    }
348  list->next = *lastp;
349  *lastp = list;
350}
351
352/* Copy the object attributes from IBFD to OBFD.  */
353void
354_bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
355{
356  obj_attribute *in_attr;
357  obj_attribute *out_attr;
358  obj_attribute_list *list;
359  int i;
360  int vendor;
361
362  for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
363    {
364      in_attr = &elf_known_obj_attributes (ibfd)[vendor][4];
365      out_attr = &elf_known_obj_attributes (obfd)[vendor][4];
366      for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
367	{
368	  out_attr->type = in_attr->type;
369	  out_attr->i = in_attr->i;
370	  if (in_attr->s && *in_attr->s)
371	    out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
372	  in_attr++;
373	  out_attr++;
374	}
375
376      for (list = elf_other_obj_attributes (ibfd)[vendor];
377	   list;
378	   list = list->next)
379	{
380	  in_attr = &list->attr;
381	  switch (in_attr->type)
382	    {
383	    case 1:
384	      bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
385	      break;
386	    case 2:
387	      bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
388					   in_attr->s);
389	      break;
390	    case 3:
391	      bfd_elf_add_obj_attr_compat (obfd, vendor, in_attr->i,
392					   in_attr->s);
393	      break;
394	    default:
395	      abort ();
396	    }
397	}
398    }
399}
400
401/* Determine whether a GNU object attribute tag takes an integer, a
402   string or both.  */
403static int
404gnu_obj_attrs_arg_type (int tag)
405{
406  /* Except for Tag_compatibility, for GNU attributes we follow the
407     same rule ARM ones > 32 follow: odd-numbered tags take strings
408     and even-numbered tags take integers.  In addition, tag & 2 is
409     nonzero for architecture-independent tags and zero for
410     architecture-dependent ones.  */
411  if (tag == Tag_compatibility)
412    return 3;
413  else
414    return (tag & 1) != 0 ? 2 : 1;
415}
416
417/* Determine what arguments an attribute tag takes.  */
418int
419_bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
420{
421  switch (vendor)
422    {
423    case OBJ_ATTR_PROC:
424      return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
425      break;
426    case OBJ_ATTR_GNU:
427      return gnu_obj_attrs_arg_type (tag);
428      break;
429    default:
430      abort ();
431    }
432}
433
434/* Parse an object attributes section.  */
435void
436_bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
437{
438  bfd_byte *contents;
439  bfd_byte *p;
440  bfd_vma len;
441  const char *std_section;
442
443  contents = bfd_malloc (hdr->sh_size);
444  if (!contents)
445    return;
446  if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
447				 hdr->sh_size))
448    {
449      free (contents);
450      return;
451    }
452  p = contents;
453  std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
454  if (*(p++) == 'A')
455    {
456      len = hdr->sh_size - 1;
457      while (len > 0)
458	{
459	  int namelen;
460	  bfd_vma section_len;
461	  int vendor;
462
463	  section_len = bfd_get_32 (abfd, p);
464	  p += 4;
465	  if (section_len > len)
466	    section_len = len;
467	  len -= section_len;
468	  namelen = strlen ((char *)p) + 1;
469	  section_len -= namelen + 4;
470	  if (std_section && strcmp ((char *)p, std_section) == 0)
471	    vendor = OBJ_ATTR_PROC;
472	  else if (strcmp ((char *)p, "gnu") == 0)
473	    vendor = OBJ_ATTR_GNU;
474	  else
475	    {
476	      /* Other vendor section.  Ignore it.  */
477	      p += namelen + section_len;
478	      continue;
479	    }
480
481	  p += namelen;
482	  while (section_len > 0)
483	    {
484	      int tag;
485	      unsigned int n;
486	      unsigned int val;
487	      bfd_vma subsection_len;
488	      bfd_byte *end;
489
490	      tag = read_unsigned_leb128 (abfd, p, &n);
491	      p += n;
492	      subsection_len = bfd_get_32 (abfd, p);
493	      p += 4;
494	      if (subsection_len > section_len)
495		subsection_len = section_len;
496	      section_len -= subsection_len;
497	      subsection_len -= n + 4;
498	      end = p + subsection_len;
499	      switch (tag)
500		{
501		case Tag_File:
502		  while (p < end)
503		    {
504		      int type;
505
506		      tag = read_unsigned_leb128 (abfd, p, &n);
507		      p += n;
508		      type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
509		      switch (type)
510			{
511			case 3:
512			  val = read_unsigned_leb128 (abfd, p, &n);
513			  p += n;
514			  bfd_elf_add_obj_attr_compat (abfd, vendor, val,
515						       (char *)p);
516			  p += strlen ((char *)p) + 1;
517			  break;
518			case 2:
519			  bfd_elf_add_obj_attr_string (abfd, vendor, tag,
520						       (char *)p);
521			  p += strlen ((char *)p) + 1;
522			  break;
523			case 1:
524			  val = read_unsigned_leb128 (abfd, p, &n);
525			  p += n;
526			  bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
527			  break;
528			default:
529			  abort ();
530			}
531		    }
532		  break;
533		case Tag_Section:
534		case Tag_Symbol:
535		  /* Don't have anywhere convenient to attach these.
536		     Fall through for now.  */
537		default:
538		  /* Ignore things we don't kow about.  */
539		  p += subsection_len;
540		  subsection_len = 0;
541		  break;
542		}
543	    }
544	}
545    }
546  free (contents);
547}
548
549/* Merge common object attributes from IBFD into OBFD.  Raise an error
550   if there are conflicting attributes.  Any processor-specific
551   attributes have already been merged.  This must be called from the
552   bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
553   target, along with any target-specific merging.  Because there are
554   no common attributes other than Tag_compatibility at present, and
555   non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
556   is not presently called for targets without their own
557   attributes.  */
558
559bfd_boolean
560_bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
561{
562  obj_attribute *in_attr;
563  obj_attribute *out_attr;
564  obj_attribute_list *in_list;
565  obj_attribute_list *out_list;
566  int vendor;
567
568  /* The only common attribute is currently Tag_compatibility,
569     accepted in both processor and "gnu" sections.  */
570  for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
571    {
572      in_list = elf_other_obj_attributes (ibfd)[vendor];
573      out_list = elf_other_obj_attributes (ibfd)[vendor];
574      while (in_list && in_list->tag == Tag_compatibility)
575	{
576	  in_attr = &in_list->attr;
577	  if (in_attr->i == 0)
578	    continue;
579	  if (in_attr->i == 1 && strcmp (in_attr->s, "gnu") != 0)
580	    {
581	      _bfd_error_handler
582		(_("ERROR: %B: Must be processed by '%s' toolchain"),
583		 ibfd, in_attr->s);
584	      return FALSE;
585	    }
586	  if (!out_list || out_list->tag != Tag_compatibility
587	      || strcmp (in_attr->s, out_list->attr.s) != 0)
588	    {
589	      /* Add this compatibility tag to the output.  */
590	      bfd_elf_add_proc_attr_compat (obfd, in_attr->i, in_attr->s);
591	      continue;
592	    }
593	  out_attr = &out_list->attr;
594	  /* Check all the input tags with the same identifier.  */
595	  for (;;)
596	    {
597	      if (out_list->tag != Tag_compatibility
598		  || in_attr->i != out_attr->i
599		  || strcmp (in_attr->s, out_attr->s) != 0)
600		{
601		  _bfd_error_handler
602		    (_("ERROR: %B: Incompatible object tag '%s':%d"),
603		     ibfd, in_attr->s, in_attr->i);
604		  return FALSE;
605		}
606	      in_list = in_list->next;
607	      if (in_list->tag != Tag_compatibility
608		  || strcmp (in_attr->s, in_list->attr.s) != 0)
609		break;
610	      in_attr = &in_list->attr;
611	      out_list = out_list->next;
612	      if (out_list)
613		out_attr = &out_list->attr;
614	    }
615
616	  /* Check the output doesn't have extra tags with this identifier.  */
617	  if (out_list && out_list->tag == Tag_compatibility
618	      && strcmp (in_attr->s, out_list->attr.s) == 0)
619	    {
620	      _bfd_error_handler
621		(_("ERROR: %B: Incompatible object tag '%s':%d"),
622		 ibfd, in_attr->s, out_list->attr.i);
623	      return FALSE;
624	    }
625	}
626    }
627
628  return TRUE;
629}
630