daily update
[binutils.git] / bfd / elf-attrs.c
blob569e846cc5474605fdcc5b941d1ecd994e8ca605
1 /* ELF attributes support (based on ARM EABI attributes).
2 Copyright 2005, 2006, 2007, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libiberty.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
28 /* Return the number of bytes needed by I in uleb128 format. */
29 static int
30 uleb128_size (unsigned int i)
32 int size;
33 size = 1;
34 while (i >= 0x80)
36 i >>= 7;
37 size++;
39 return size;
42 /* Return TRUE if the attribute has the default value (0/""). */
43 static bfd_boolean
44 is_default_attr (obj_attribute *attr)
46 if (ATTR_TYPE_HAS_INT_VAL (attr->type) && attr->i != 0)
47 return FALSE;
48 if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s)
49 return FALSE;
50 if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type))
51 return FALSE;
53 return TRUE;
56 /* Return the size of a single attribute. */
57 static bfd_vma
58 obj_attr_size (int tag, obj_attribute *attr)
60 bfd_vma size;
62 if (is_default_attr (attr))
63 return 0;
65 size = uleb128_size (tag);
66 if (ATTR_TYPE_HAS_INT_VAL (attr->type))
67 size += uleb128_size (attr->i);
68 if (ATTR_TYPE_HAS_STR_VAL (attr->type))
69 size += strlen ((char *)attr->s) + 1;
70 return size;
73 /* Return the vendor name for a given object attributes section. */
74 static const char *
75 vendor_obj_attr_name (bfd *abfd, int vendor)
77 return (vendor == OBJ_ATTR_PROC
78 ? get_elf_backend_data (abfd)->obj_attrs_vendor
79 : "gnu");
82 /* Return the size of the object attributes section for VENDOR
83 (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes
84 for that vendor to record and the vendor is OBJ_ATTR_GNU. */
85 static bfd_vma
86 vendor_obj_attr_size (bfd *abfd, int vendor)
88 bfd_vma size;
89 obj_attribute *attr;
90 obj_attribute_list *list;
91 int i;
92 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
94 if (!vendor_name)
95 return 0;
97 attr = elf_known_obj_attributes (abfd)[vendor];
98 size = 0;
99 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
100 size += obj_attr_size (i, &attr[i]);
102 for (list = elf_other_obj_attributes (abfd)[vendor];
103 list;
104 list = list->next)
105 size += obj_attr_size (list->tag, &list->attr);
107 /* <size> <vendor_name> NUL 0x1 <size> */
108 return ((size || vendor == OBJ_ATTR_PROC)
109 ? size + 10 + strlen (vendor_name)
110 : 0);
113 /* Return the size of the object attributes section. */
114 bfd_vma
115 bfd_elf_obj_attr_size (bfd *abfd)
117 bfd_vma size;
119 size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
120 size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);
122 /* 'A' <sections for each vendor> */
123 return (size ? size + 1 : 0);
126 /* Write VAL in uleb128 format to P, returning a pointer to the
127 following byte. */
128 static bfd_byte *
129 write_uleb128 (bfd_byte *p, unsigned int val)
131 bfd_byte c;
134 c = val & 0x7f;
135 val >>= 7;
136 if (val)
137 c |= 0x80;
138 *(p++) = c;
140 while (val);
141 return p;
144 /* Write attribute ATTR to butter P, and return a pointer to the following
145 byte. */
146 static bfd_byte *
147 write_obj_attribute (bfd_byte *p, int tag, obj_attribute *attr)
149 /* Suppress default entries. */
150 if (is_default_attr (attr))
151 return p;
153 p = write_uleb128 (p, tag);
154 if (ATTR_TYPE_HAS_INT_VAL (attr->type))
155 p = write_uleb128 (p, attr->i);
156 if (ATTR_TYPE_HAS_STR_VAL (attr->type))
158 int len;
160 len = strlen (attr->s) + 1;
161 memcpy (p, attr->s, len);
162 p += len;
165 return p;
168 /* Write the contents of the object attributes section (length SIZE)
169 for VENDOR to CONTENTS. */
170 static void
171 vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
172 int vendor)
174 bfd_byte *p;
175 obj_attribute *attr;
176 obj_attribute_list *list;
177 int i;
178 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
179 size_t vendor_length = strlen (vendor_name) + 1;
181 p = contents;
182 bfd_put_32 (abfd, size, p);
183 p += 4;
184 memcpy (p, vendor_name, vendor_length);
185 p += vendor_length;
186 *(p++) = Tag_File;
187 bfd_put_32 (abfd, size - 4 - vendor_length, p);
188 p += 4;
190 attr = elf_known_obj_attributes (abfd)[vendor];
191 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
193 int tag = i;
194 if (get_elf_backend_data (abfd)->obj_attrs_order)
195 tag = get_elf_backend_data (abfd)->obj_attrs_order (i);
196 p = write_obj_attribute (p, tag, &attr[tag]);
199 for (list = elf_other_obj_attributes (abfd)[vendor];
200 list;
201 list = list->next)
202 p = write_obj_attribute (p, list->tag, &list->attr);
205 /* Write the contents of the object attributes section to CONTENTS. */
206 void
207 bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
209 bfd_byte *p;
210 int vendor;
211 bfd_vma my_size;
213 p = contents;
214 *(p++) = 'A';
215 my_size = 1;
216 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
218 bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
219 if (vendor_size)
220 vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
221 p += vendor_size;
222 my_size += vendor_size;
225 if (size != my_size)
226 abort ();
229 /* Allocate/find an object attribute. */
230 static obj_attribute *
231 elf_new_obj_attr (bfd *abfd, int vendor, int tag)
233 obj_attribute *attr;
234 obj_attribute_list *list;
235 obj_attribute_list *p;
236 obj_attribute_list **lastp;
239 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
241 /* Known tags are preallocated. */
242 attr = &elf_known_obj_attributes (abfd)[vendor][tag];
244 else
246 /* Create a new tag. */
247 list = (obj_attribute_list *)
248 bfd_alloc (abfd, sizeof (obj_attribute_list));
249 memset (list, 0, sizeof (obj_attribute_list));
250 list->tag = tag;
251 /* Keep the tag list in order. */
252 lastp = &elf_other_obj_attributes (abfd)[vendor];
253 for (p = *lastp; p; p = p->next)
255 if (tag < p->tag)
256 break;
257 lastp = &p->next;
259 list->next = *lastp;
260 *lastp = list;
261 attr = &list->attr;
264 return attr;
267 /* Return the value of an integer object attribute. */
269 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag)
271 obj_attribute_list *p;
273 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
275 /* Known tags are preallocated. */
276 return elf_known_obj_attributes (abfd)[vendor][tag].i;
278 else
280 for (p = elf_other_obj_attributes (abfd)[vendor];
282 p = p->next)
284 if (tag == p->tag)
285 return p->attr.i;
286 if (tag < p->tag)
287 break;
289 return 0;
293 /* Add an integer object attribute. */
294 void
295 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i)
297 obj_attribute *attr;
299 attr = elf_new_obj_attr (abfd, vendor, tag);
300 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
301 attr->i = i;
304 /* Duplicate an object attribute string value. */
305 char *
306 _bfd_elf_attr_strdup (bfd *abfd, const char * s)
308 char * p;
309 int len;
311 len = strlen (s) + 1;
312 p = (char *) bfd_alloc (abfd, len);
313 return (char *) memcpy (p, s, len);
316 /* Add a string object attribute. */
317 void
318 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, int tag, const char *s)
320 obj_attribute *attr;
322 attr = elf_new_obj_attr (abfd, vendor, tag);
323 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
324 attr->s = _bfd_elf_attr_strdup (abfd, s);
327 /* Add a int+string object attribute. */
328 void
329 bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, int tag,
330 unsigned int i, const char *s)
332 obj_attribute *attr;
334 attr = elf_new_obj_attr (abfd, vendor, tag);
335 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
336 attr->i = i;
337 attr->s = _bfd_elf_attr_strdup (abfd, s);
340 /* Copy the object attributes from IBFD to OBFD. */
341 void
342 _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
344 obj_attribute *in_attr;
345 obj_attribute *out_attr;
346 obj_attribute_list *list;
347 int i;
348 int vendor;
350 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
352 in_attr
353 = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
354 out_attr
355 = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
356 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
358 out_attr->type = in_attr->type;
359 out_attr->i = in_attr->i;
360 if (in_attr->s && *in_attr->s)
361 out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
362 in_attr++;
363 out_attr++;
366 for (list = elf_other_obj_attributes (ibfd)[vendor];
367 list;
368 list = list->next)
370 in_attr = &list->attr;
371 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
373 case ATTR_TYPE_FLAG_INT_VAL:
374 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
375 break;
376 case ATTR_TYPE_FLAG_STR_VAL:
377 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
378 in_attr->s);
379 break;
380 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
381 bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag,
382 in_attr->i, in_attr->s);
383 break;
384 default:
385 abort ();
391 /* Determine whether a GNU object attribute tag takes an integer, a
392 string or both. */
393 static int
394 gnu_obj_attrs_arg_type (int tag)
396 /* Except for Tag_compatibility, for GNU attributes we follow the
397 same rule ARM ones > 32 follow: odd-numbered tags take strings
398 and even-numbered tags take integers. In addition, tag & 2 is
399 nonzero for architecture-independent tags and zero for
400 architecture-dependent ones. */
401 if (tag == Tag_compatibility)
402 return 3;
403 else
404 return (tag & 1) != 0 ? 2 : 1;
407 /* Determine what arguments an attribute tag takes. */
409 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
411 switch (vendor)
413 case OBJ_ATTR_PROC:
414 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
415 break;
416 case OBJ_ATTR_GNU:
417 return gnu_obj_attrs_arg_type (tag);
418 break;
419 default:
420 abort ();
424 /* Parse an object attributes section. */
425 void
426 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
428 bfd_byte *contents;
429 bfd_byte *p;
430 bfd_vma len;
431 const char *std_section;
433 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
434 if (!contents)
435 return;
436 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
437 hdr->sh_size))
439 free (contents);
440 return;
442 p = contents;
443 std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
444 if (*(p++) == 'A')
446 len = hdr->sh_size - 1;
447 while (len > 0)
449 int namelen;
450 bfd_vma section_len;
451 int vendor;
453 section_len = bfd_get_32 (abfd, p);
454 p += 4;
455 if (section_len > len)
456 section_len = len;
457 len -= section_len;
458 namelen = strlen ((char *)p) + 1;
459 section_len -= namelen + 4;
460 if (std_section && strcmp ((char *)p, std_section) == 0)
461 vendor = OBJ_ATTR_PROC;
462 else if (strcmp ((char *)p, "gnu") == 0)
463 vendor = OBJ_ATTR_GNU;
464 else
466 /* Other vendor section. Ignore it. */
467 p += namelen + section_len;
468 continue;
471 p += namelen;
472 while (section_len > 0)
474 int tag;
475 unsigned int n;
476 unsigned int val;
477 bfd_vma subsection_len;
478 bfd_byte *end;
480 tag = read_unsigned_leb128 (abfd, p, &n);
481 p += n;
482 subsection_len = bfd_get_32 (abfd, p);
483 p += 4;
484 if (subsection_len > section_len)
485 subsection_len = section_len;
486 section_len -= subsection_len;
487 subsection_len -= n + 4;
488 end = p + subsection_len;
489 switch (tag)
491 case Tag_File:
492 while (p < end)
494 int type;
496 tag = read_unsigned_leb128 (abfd, p, &n);
497 p += n;
498 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
499 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
501 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
502 val = read_unsigned_leb128 (abfd, p, &n);
503 p += n;
504 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
505 val, (char *)p);
506 p += strlen ((char *)p) + 1;
507 break;
508 case ATTR_TYPE_FLAG_STR_VAL:
509 bfd_elf_add_obj_attr_string (abfd, vendor, tag,
510 (char *)p);
511 p += strlen ((char *)p) + 1;
512 break;
513 case ATTR_TYPE_FLAG_INT_VAL:
514 val = read_unsigned_leb128 (abfd, p, &n);
515 p += n;
516 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
517 break;
518 default:
519 abort ();
522 break;
523 case Tag_Section:
524 case Tag_Symbol:
525 /* Don't have anywhere convenient to attach these.
526 Fall through for now. */
527 default:
528 /* Ignore things we don't kow about. */
529 p += subsection_len;
530 subsection_len = 0;
531 break;
536 free (contents);
539 /* Merge common object attributes from IBFD into OBFD. Raise an error
540 if there are conflicting attributes. Any processor-specific
541 attributes have already been merged. This must be called from the
542 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
543 target, along with any target-specific merging. Because there are
544 no common attributes other than Tag_compatibility at present, and
545 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
546 is not presently called for targets without their own
547 attributes. */
549 bfd_boolean
550 _bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
552 obj_attribute *in_attr;
553 obj_attribute *out_attr;
554 int vendor;
556 /* The only common attribute is currently Tag_compatibility,
557 accepted in both processor and "gnu" sections. */
558 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
560 /* Handle Tag_compatibility. The tags are only compatible if the flags
561 are identical and, if the flags are '1', the strings are identical.
562 If the flags are non-zero, then we can only use the string "gnu". */
563 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
564 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
566 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
568 _bfd_error_handler
569 (_("error: %B: Object has vendor-specific contents that "
570 "must be processed by the '%s' toolchain"),
571 ibfd, in_attr->s);
572 return FALSE;
575 if (in_attr->i != out_attr->i
576 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
578 _bfd_error_handler (_("error: %B: Object tag '%d, %s' is "
579 "incompatible with tag '%d, %s'"),
580 ibfd,
581 in_attr->i, in_attr->s ? in_attr->s : "",
582 out_attr->i, out_attr->s ? out_attr->s : "");
583 return FALSE;
587 return TRUE;
590 /* Merge an unknown processor-specific attribute TAG, within the range
591 of known attributes, from IBFD into OBFD; return TRUE if the link
592 is OK, FALSE if it must fail. */
594 bfd_boolean
595 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag)
597 obj_attribute *in_attr;
598 obj_attribute *out_attr;
599 bfd *err_bfd = NULL;
600 bfd_boolean result = TRUE;
602 in_attr = elf_known_obj_attributes_proc (ibfd);
603 out_attr = elf_known_obj_attributes_proc (obfd);
605 if (out_attr[tag].i != 0 || out_attr[tag].s != NULL)
606 err_bfd = obfd;
607 else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL)
608 err_bfd = ibfd;
610 if (err_bfd != NULL)
611 result
612 = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag);
614 /* Only pass on attributes that match in both inputs. */
615 if (in_attr[tag].i != out_attr[tag].i
616 || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL)
617 || (in_attr[tag].s != NULL && out_attr[tag].s != NULL
618 && strcmp (in_attr[tag].s, out_attr[tag].s) != 0))
620 out_attr[tag].i = 0;
621 out_attr[tag].s = NULL;
624 return result;
627 /* Merge the lists of unknown processor-specific attributes, outside
628 the known range, from IBFD into OBFD; return TRUE if the link is
629 OK, FALSE if it must fail. */
631 bfd_boolean
632 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd)
634 obj_attribute_list *in_list;
635 obj_attribute_list *out_list;
636 obj_attribute_list **out_listp;
637 bfd_boolean result = TRUE;
639 in_list = elf_other_obj_attributes_proc (ibfd);
640 out_listp = &elf_other_obj_attributes_proc (obfd);
641 out_list = *out_listp;
643 for (; in_list || out_list; )
645 bfd *err_bfd = NULL;
646 int err_tag = 0;
648 /* The tags for each list are in numerical order. */
649 /* If the tags are equal, then merge. */
650 if (out_list && (!in_list || in_list->tag > out_list->tag))
652 /* This attribute only exists in obfd. We can't merge, and we don't
653 know what the tag means, so delete it. */
654 err_bfd = obfd;
655 err_tag = out_list->tag;
656 *out_listp = out_list->next;
657 out_list = *out_listp;
659 else if (in_list && (!out_list || in_list->tag < out_list->tag))
661 /* This attribute only exists in ibfd. We can't merge, and we don't
662 know what the tag means, so ignore it. */
663 err_bfd = ibfd;
664 err_tag = in_list->tag;
665 in_list = in_list->next;
667 else /* The tags are equal. */
669 /* As present, all attributes in the list are unknown, and
670 therefore can't be merged meaningfully. */
671 err_bfd = obfd;
672 err_tag = out_list->tag;
674 /* Only pass on attributes that match in both inputs. */
675 if (in_list->attr.i != out_list->attr.i
676 || (in_list->attr.s == NULL) != (out_list->attr.s == NULL)
677 || (in_list->attr.s && out_list->attr.s
678 && strcmp (in_list->attr.s, out_list->attr.s) != 0))
680 /* No match. Delete the attribute. */
681 *out_listp = out_list->next;
682 out_list = *out_listp;
684 else
686 /* Matched. Keep the attribute and move to the next. */
687 out_list = out_list->next;
688 in_list = in_list->next;
692 if (err_bfd)
693 result = result
694 && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd,
695 err_tag);
698 return result;