1 /* ELF attributes support (based on ARM EABI attributes).
2 Copyright (C) 2005-2018 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "libiberty.h"
27 /* Return the number of bytes needed by I in uleb128 format. */
29 uleb128_size (unsigned int i)
41 /* Return TRUE if the attribute has the default value (0/""). */
43 is_default_attr (obj_attribute *attr)
45 if (ATTR_TYPE_HAS_INT_VAL (attr->type) && attr->i != 0)
47 if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s)
49 if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type))
55 /* Return the size of a single attribute. */
57 obj_attr_size (unsigned int tag, obj_attribute *attr)
61 if (is_default_attr (attr))
64 size = uleb128_size (tag);
65 if (ATTR_TYPE_HAS_INT_VAL (attr->type))
66 size += uleb128_size (attr->i);
67 if (ATTR_TYPE_HAS_STR_VAL (attr->type))
68 size += strlen ((char *)attr->s) + 1;
72 /* Return the vendor name for a given object attributes section. */
74 vendor_obj_attr_name (bfd *abfd, int vendor)
76 return (vendor == OBJ_ATTR_PROC
77 ? get_elf_backend_data (abfd)->obj_attrs_vendor
81 /* Return the size of the object attributes section for VENDOR
82 (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes
83 for that vendor to record and the vendor is OBJ_ATTR_GNU. */
85 vendor_obj_attr_size (bfd *abfd, int vendor)
89 obj_attribute_list *list;
91 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
96 attr = elf_known_obj_attributes (abfd)[vendor];
98 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
99 size += obj_attr_size (i, &attr[i]);
101 for (list = elf_other_obj_attributes (abfd)[vendor];
104 size += obj_attr_size (list->tag, &list->attr);
106 /* <size> <vendor_name> NUL 0x1 <size> */
107 return ((size || vendor == OBJ_ATTR_PROC)
108 ? size + 10 + strlen (vendor_name)
112 /* Return the size of the object attributes section. */
114 bfd_elf_obj_attr_size (bfd *abfd)
118 size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
119 size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);
121 /* 'A' <sections for each vendor> */
122 return (size ? size + 1 : 0);
125 /* Write VAL in uleb128 format to P, returning a pointer to the
128 write_uleb128 (bfd_byte *p, unsigned int val)
143 /* Write attribute ATTR to butter P, and return a pointer to the following
146 write_obj_attribute (bfd_byte *p, unsigned int tag, obj_attribute *attr)
148 /* Suppress default entries. */
149 if (is_default_attr (attr))
152 p = write_uleb128 (p, tag);
153 if (ATTR_TYPE_HAS_INT_VAL (attr->type))
154 p = write_uleb128 (p, attr->i);
155 if (ATTR_TYPE_HAS_STR_VAL (attr->type))
159 len = strlen (attr->s) + 1;
160 memcpy (p, attr->s, len);
167 /* Write the contents of the object attributes section (length SIZE)
168 for VENDOR to CONTENTS. */
170 vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
175 obj_attribute_list *list;
177 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
178 size_t vendor_length = strlen (vendor_name) + 1;
181 bfd_put_32 (abfd, size, p);
183 memcpy (p, vendor_name, vendor_length);
186 bfd_put_32 (abfd, size - 4 - vendor_length, p);
189 attr = elf_known_obj_attributes (abfd)[vendor];
190 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
192 unsigned int tag = i;
193 if (get_elf_backend_data (abfd)->obj_attrs_order)
194 tag = get_elf_backend_data (abfd)->obj_attrs_order (i);
195 p = write_obj_attribute (p, tag, &attr[tag]);
198 for (list = elf_other_obj_attributes (abfd)[vendor];
201 p = write_obj_attribute (p, list->tag, &list->attr);
204 /* Write the contents of the object attributes section to CONTENTS. */
206 bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
215 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
217 bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
219 vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
221 my_size += vendor_size;
228 /* Allocate/find an object attribute. */
229 static obj_attribute *
230 elf_new_obj_attr (bfd *abfd, int vendor, unsigned int tag)
233 obj_attribute_list *list;
234 obj_attribute_list *p;
235 obj_attribute_list **lastp;
238 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
240 /* Known tags are preallocated. */
241 attr = &elf_known_obj_attributes (abfd)[vendor][tag];
245 /* Create a new tag. */
246 list = (obj_attribute_list *)
247 bfd_alloc (abfd, sizeof (obj_attribute_list));
248 memset (list, 0, sizeof (obj_attribute_list));
250 /* Keep the tag list in order. */
251 lastp = &elf_other_obj_attributes (abfd)[vendor];
252 for (p = *lastp; p; p = p->next)
266 /* Return the value of an integer object attribute. */
268 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, unsigned int tag)
270 obj_attribute_list *p;
272 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
274 /* Known tags are preallocated. */
275 return elf_known_obj_attributes (abfd)[vendor][tag].i;
279 for (p = elf_other_obj_attributes (abfd)[vendor];
292 /* Add an integer object attribute. */
294 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, unsigned int tag, unsigned int i)
298 attr = elf_new_obj_attr (abfd, vendor, tag);
299 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
303 /* Duplicate an object attribute string value. */
305 _bfd_elf_attr_strdup (bfd *abfd, const char * s)
310 len = strlen (s) + 1;
311 p = (char *) bfd_alloc (abfd, len);
312 return (char *) memcpy (p, s, len);
315 /* Add a string object attribute. */
317 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, unsigned int tag, const char *s)
321 attr = elf_new_obj_attr (abfd, vendor, tag);
322 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
323 attr->s = _bfd_elf_attr_strdup (abfd, s);
326 /* Add a int+string object attribute. */
328 bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor,
330 unsigned int i, const char *s)
334 attr = elf_new_obj_attr (abfd, vendor, tag);
335 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
337 attr->s = _bfd_elf_attr_strdup (abfd, s);
340 /* Copy the object attributes from IBFD to OBFD. */
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;
350 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
351 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
354 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
357 = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
359 = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
360 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
362 out_attr->type = in_attr->type;
363 out_attr->i = in_attr->i;
364 if (in_attr->s && *in_attr->s)
365 out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
370 for (list = elf_other_obj_attributes (ibfd)[vendor];
374 in_attr = &list->attr;
375 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
377 case ATTR_TYPE_FLAG_INT_VAL:
378 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
380 case ATTR_TYPE_FLAG_STR_VAL:
381 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
384 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
385 bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag,
386 in_attr->i, in_attr->s);
395 /* Determine whether a GNU object attribute tag takes an integer, a
398 gnu_obj_attrs_arg_type (unsigned int tag)
400 /* Except for Tag_compatibility, for GNU attributes we follow the
401 same rule ARM ones > 32 follow: odd-numbered tags take strings
402 and even-numbered tags take integers. In addition, tag & 2 is
403 nonzero for architecture-independent tags and zero for
404 architecture-dependent ones. */
405 if (tag == Tag_compatibility)
408 return (tag & 1) != 0 ? 2 : 1;
411 /* Determine what arguments an attribute tag takes. */
413 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, unsigned int tag)
418 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
421 return gnu_obj_attrs_arg_type (tag);
428 /* Parse an object attributes section. */
430 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
438 /* PR 17512: file: 2844a11d. */
439 if (hdr->sh_size == 0)
441 if (hdr->sh_size > bfd_get_file_size (abfd))
443 /* xgettext:c-format */
444 _bfd_error_handler (_("%pB: error: attribute section '%pA' too big: %#llx"),
445 abfd, hdr->bfd_section, (long long) hdr->sh_size);
446 bfd_set_error (bfd_error_invalid_operation);
450 contents = (bfd_byte *) bfd_malloc (hdr->sh_size + 1);
453 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
459 /* Ensure that the buffer is NUL terminated. */
460 contents[hdr->sh_size] = 0;
462 p_end = p + hdr->sh_size;
463 std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor;
467 len = hdr->sh_size - 1;
469 while (len > 0 && p < p_end - 4)
475 section_len = bfd_get_32 (abfd, p);
477 if (section_len == 0)
479 if (section_len > len)
482 if (section_len <= 4)
485 (_("%pB: error: attribute section length too small: %" PRId64),
486 abfd, (int64_t) section_len);
490 namelen = strnlen ((char *) p, section_len) + 1;
491 if (namelen == 0 || namelen >= section_len)
493 section_len -= namelen;
494 if (std_sec && strcmp ((char *) p, std_sec) == 0)
495 vendor = OBJ_ATTR_PROC;
496 else if (strcmp ((char *) p, "gnu") == 0)
497 vendor = OBJ_ATTR_GNU;
500 /* Other vendor section. Ignore it. */
501 p += namelen + section_len;
506 while (section_len > 0 && p < p_end)
511 bfd_vma subsection_len;
514 tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, p_end);
517 subsection_len = bfd_get_32 (abfd, p);
521 if (subsection_len == 0)
523 if (subsection_len > section_len)
524 subsection_len = section_len;
525 section_len -= subsection_len;
526 subsection_len -= n + 4;
527 end = p + subsection_len;
528 /* PR 17512: file: 0e8c0c90. */
538 tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
540 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
541 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
543 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
544 val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
546 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
548 p += strlen ((char *)p) + 1;
550 case ATTR_TYPE_FLAG_STR_VAL:
551 bfd_elf_add_obj_attr_string (abfd, vendor, tag,
553 p += strlen ((char *)p) + 1;
555 case ATTR_TYPE_FLAG_INT_VAL:
556 val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
558 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
567 /* Don't have anywhere convenient to attach these.
568 Fall through for now. */
570 /* Ignore things we don't kow about. */
581 /* Merge common object attributes from IBFD into OBFD. Raise an error
582 if there are conflicting attributes. Any processor-specific
583 attributes have already been merged. This must be called from the
584 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
585 target, along with any target-specific merging. Because there are
586 no common attributes other than Tag_compatibility at present, and
587 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
588 is not presently called for targets without their own
592 _bfd_elf_merge_object_attributes (bfd *ibfd, struct bfd_link_info *info)
594 bfd *obfd = info->output_bfd;
595 obj_attribute *in_attr;
596 obj_attribute *out_attr;
599 /* The only common attribute is currently Tag_compatibility,
600 accepted in both processor and "gnu" sections. */
601 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
603 /* Handle Tag_compatibility. The tags are only compatible if the flags
604 are identical and, if the flags are '1', the strings are identical.
605 If the flags are non-zero, then we can only use the string "gnu". */
606 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
607 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
609 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
612 /* xgettext:c-format */
613 (_("error: %pB: object has vendor-specific contents that "
614 "must be processed by the '%s' toolchain"),
619 if (in_attr->i != out_attr->i
620 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
622 /* xgettext:c-format */
623 _bfd_error_handler (_("error: %pB: object tag '%d, %s' is "
624 "incompatible with tag '%d, %s'"),
626 in_attr->i, in_attr->s ? in_attr->s : "",
627 out_attr->i, out_attr->s ? out_attr->s : "");
635 /* Merge an unknown processor-specific attribute TAG, within the range
636 of known attributes, from IBFD into OBFD; return TRUE if the link
637 is OK, FALSE if it must fail. */
640 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag)
642 obj_attribute *in_attr;
643 obj_attribute *out_attr;
645 bfd_boolean result = TRUE;
647 in_attr = elf_known_obj_attributes_proc (ibfd);
648 out_attr = elf_known_obj_attributes_proc (obfd);
650 if (out_attr[tag].i != 0 || out_attr[tag].s != NULL)
652 else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL)
657 = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag);
659 /* Only pass on attributes that match in both inputs. */
660 if (in_attr[tag].i != out_attr[tag].i
661 || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL)
662 || (in_attr[tag].s != NULL && out_attr[tag].s != NULL
663 && strcmp (in_attr[tag].s, out_attr[tag].s) != 0))
666 out_attr[tag].s = NULL;
672 /* Merge the lists of unknown processor-specific attributes, outside
673 the known range, from IBFD into OBFD; return TRUE if the link is
674 OK, FALSE if it must fail. */
677 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd)
679 obj_attribute_list *in_list;
680 obj_attribute_list *out_list;
681 obj_attribute_list **out_listp;
682 bfd_boolean result = TRUE;
684 in_list = elf_other_obj_attributes_proc (ibfd);
685 out_listp = &elf_other_obj_attributes_proc (obfd);
686 out_list = *out_listp;
688 for (; in_list || out_list; )
691 unsigned int err_tag = 0;
693 /* The tags for each list are in numerical order. */
694 /* If the tags are equal, then merge. */
695 if (out_list && (!in_list || in_list->tag > out_list->tag))
697 /* This attribute only exists in obfd. We can't merge, and we don't
698 know what the tag means, so delete it. */
700 err_tag = out_list->tag;
701 *out_listp = out_list->next;
702 out_list = *out_listp;
704 else if (in_list && (!out_list || in_list->tag < out_list->tag))
706 /* This attribute only exists in ibfd. We can't merge, and we don't
707 know what the tag means, so ignore it. */
709 err_tag = in_list->tag;
710 in_list = in_list->next;
712 else /* The tags are equal. */
714 /* As present, all attributes in the list are unknown, and
715 therefore can't be merged meaningfully. */
717 err_tag = out_list->tag;
719 /* Only pass on attributes that match in both inputs. */
720 if (in_list->attr.i != out_list->attr.i
721 || (in_list->attr.s == NULL) != (out_list->attr.s == NULL)
722 || (in_list->attr.s && out_list->attr.s
723 && strcmp (in_list->attr.s, out_list->attr.s) != 0))
725 /* No match. Delete the attribute. */
726 *out_listp = out_list->next;
727 out_list = *out_listp;
731 /* Matched. Keep the attribute and move to the next. */
732 out_list = out_list->next;
733 in_list = in_list->next;
739 && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd,