1 /* ELF attributes support (based on ARM EABI attributes).
2 Copyright 2005, 2006, 2007
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. */
24 #include "libiberty.h"
28 /* Return the number of bytes needed by I in uleb128 format. */
30 uleb128_size (unsigned int i)
42 /* Return TRUE if the attribute has the default value (0/""). */
44 is_default_attr (obj_attribute *attr)
46 if (ATTR_TYPE_HAS_INT_VAL (attr->type) && attr->i != 0)
48 if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s)
50 if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type))
56 /* Return the size of a single attribute. */
58 obj_attr_size (int tag, obj_attribute *attr)
62 if (is_default_attr (attr))
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;
73 /* Return the vendor name for a given object attributes section. */
75 vendor_obj_attr_name (bfd *abfd, int vendor)
77 return (vendor == OBJ_ATTR_PROC
78 ? get_elf_backend_data (abfd)->obj_attrs_vendor
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. */
86 vendor_obj_attr_size (bfd *abfd, int vendor)
90 obj_attribute_list *list;
92 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
97 attr = elf_known_obj_attributes (abfd)[vendor];
99 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
100 size += obj_attr_size (i, &attr[i]);
102 for (list = elf_other_obj_attributes (abfd)[vendor];
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)
113 /* Return the size of the object attributes section. */
115 bfd_elf_obj_attr_size (bfd *abfd)
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
129 write_uleb128 (bfd_byte *p, unsigned int val)
144 /* Write attribute ATTR to butter P, and return a pointer to the following
147 write_obj_attribute (bfd_byte *p, int tag, obj_attribute *attr)
149 /* Suppress default entries. */
150 if (is_default_attr (attr))
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))
160 len = strlen (attr->s) + 1;
161 memcpy (p, attr->s, len);
168 /* Write the contents of the object attributes section (length SIZE)
169 for VENDOR to CONTENTS. */
171 vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
176 obj_attribute_list *list;
178 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
179 size_t vendor_length = strlen (vendor_name) + 1;
182 bfd_put_32 (abfd, size, p);
184 memcpy (p, vendor_name, vendor_length);
187 bfd_put_32 (abfd, size - 4 - vendor_length, p);
190 attr = elf_known_obj_attributes (abfd)[vendor];
191 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
192 p = write_obj_attribute (p, i, &attr[i]);
194 for (list = elf_other_obj_attributes (abfd)[vendor];
197 p = write_obj_attribute (p, list->tag, &list->attr);
200 /* Write the contents of the object attributes section to CONTENTS. */
202 bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
211 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
213 bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
215 vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
217 my_size += vendor_size;
224 /* Allocate/find an object attribute. */
225 static obj_attribute *
226 elf_new_obj_attr (bfd *abfd, int vendor, int tag)
229 obj_attribute_list *list;
230 obj_attribute_list *p;
231 obj_attribute_list **lastp;
234 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
236 /* Knwon tags are preallocated. */
237 attr = &elf_known_obj_attributes (abfd)[vendor][tag];
241 /* Create a new tag. */
242 list = (obj_attribute_list *)
243 bfd_alloc (abfd, sizeof (obj_attribute_list));
244 memset (list, 0, sizeof (obj_attribute_list));
246 /* Keep the tag list in order. */
247 lastp = &elf_other_obj_attributes (abfd)[vendor];
248 for (p = *lastp; p; p = p->next)
262 /* Return the value of an integer object attribute. */
264 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag)
266 obj_attribute_list *p;
268 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
270 /* Knwon tags are preallocated. */
271 return elf_known_obj_attributes (abfd)[vendor][tag].i;
275 for (p = elf_other_obj_attributes (abfd)[vendor];
288 /* Add an integer object attribute. */
290 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i)
294 attr = elf_new_obj_attr (abfd, vendor, tag);
295 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
299 /* Duplicate an object attribute string value. */
301 _bfd_elf_attr_strdup (bfd *abfd, const char * s)
306 len = strlen (s) + 1;
307 p = (char *) bfd_alloc (abfd, len);
308 return memcpy (p, s, len);
311 /* Add a string object attribute. */
313 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, int tag, const char *s)
317 attr = elf_new_obj_attr (abfd, vendor, tag);
318 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
319 attr->s = _bfd_elf_attr_strdup (abfd, s);
322 /* Add a int+string object attribute. */
324 bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, int tag,
325 unsigned int i, const char *s)
329 attr = elf_new_obj_attr (abfd, vendor, tag);
330 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
332 attr->s = _bfd_elf_attr_strdup (abfd, s);
335 /* Copy the object attributes from IBFD to OBFD. */
337 _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
339 obj_attribute *in_attr;
340 obj_attribute *out_attr;
341 obj_attribute_list *list;
345 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
347 in_attr = &elf_known_obj_attributes (ibfd)[vendor][4];
348 out_attr = &elf_known_obj_attributes (obfd)[vendor][4];
349 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
351 out_attr->type = in_attr->type;
352 out_attr->i = in_attr->i;
353 if (in_attr->s && *in_attr->s)
354 out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s);
359 for (list = elf_other_obj_attributes (ibfd)[vendor];
363 in_attr = &list->attr;
364 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
366 case ATTR_TYPE_FLAG_INT_VAL:
367 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
369 case ATTR_TYPE_FLAG_STR_VAL:
370 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
373 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
374 bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag,
375 in_attr->i, in_attr->s);
384 /* Determine whether a GNU object attribute tag takes an integer, a
387 gnu_obj_attrs_arg_type (int tag)
389 /* Except for Tag_compatibility, for GNU attributes we follow the
390 same rule ARM ones > 32 follow: odd-numbered tags take strings
391 and even-numbered tags take integers. In addition, tag & 2 is
392 nonzero for architecture-independent tags and zero for
393 architecture-dependent ones. */
394 if (tag == Tag_compatibility)
397 return (tag & 1) != 0 ? 2 : 1;
400 /* Determine what arguments an attribute tag takes. */
402 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag)
407 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
410 return gnu_obj_attrs_arg_type (tag);
417 /* Parse an object attributes section. */
419 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
424 const char *std_section;
426 contents = bfd_malloc (hdr->sh_size);
429 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
436 std_section = get_elf_backend_data (abfd)->obj_attrs_vendor;
439 len = hdr->sh_size - 1;
446 section_len = bfd_get_32 (abfd, p);
448 if (section_len > len)
451 namelen = strlen ((char *)p) + 1;
452 section_len -= namelen + 4;
453 if (std_section && strcmp ((char *)p, std_section) == 0)
454 vendor = OBJ_ATTR_PROC;
455 else if (strcmp ((char *)p, "gnu") == 0)
456 vendor = OBJ_ATTR_GNU;
459 /* Other vendor section. Ignore it. */
460 p += namelen + section_len;
465 while (section_len > 0)
470 bfd_vma subsection_len;
473 tag = read_unsigned_leb128 (abfd, p, &n);
475 subsection_len = bfd_get_32 (abfd, p);
477 if (subsection_len > section_len)
478 subsection_len = section_len;
479 section_len -= subsection_len;
480 subsection_len -= n + 4;
481 end = p + subsection_len;
489 tag = read_unsigned_leb128 (abfd, p, &n);
491 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
492 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
494 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
495 val = read_unsigned_leb128 (abfd, p, &n);
497 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
499 p += strlen ((char *)p) + 1;
501 case ATTR_TYPE_FLAG_STR_VAL:
502 bfd_elf_add_obj_attr_string (abfd, vendor, tag,
504 p += strlen ((char *)p) + 1;
506 case ATTR_TYPE_FLAG_INT_VAL:
507 val = read_unsigned_leb128 (abfd, p, &n);
509 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
518 /* Don't have anywhere convenient to attach these.
519 Fall through for now. */
521 /* Ignore things we don't kow about. */
532 /* Merge common object attributes from IBFD into OBFD. Raise an error
533 if there are conflicting attributes. Any processor-specific
534 attributes have already been merged. This must be called from the
535 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
536 target, along with any target-specific merging. Because there are
537 no common attributes other than Tag_compatibility at present, and
538 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
539 is not presently called for targets without their own
543 _bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
545 obj_attribute *in_attr;
546 obj_attribute *out_attr;
549 /* The only common attribute is currently Tag_compatibility,
550 accepted in both processor and "gnu" sections. */
551 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
553 /* Handle Tag_compatibility. The tags are only compatible if the flags
554 are identical and, if the flags are '1', the strings are identical.
555 If the flags are non-zero, then we can only use the string "gnu". */
556 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
557 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
559 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
562 (_("ERROR: %B: Must be processed by '%s' toolchain"),
567 if (in_attr->i != out_attr->i
568 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
570 _bfd_error_handler (_("ERROR: %B: Object tag '%d, %s' is "
571 "incompatible with tag '%d, %s'"),
573 in_attr->i, in_attr->s ? in_attr->s : "",
574 out_attr->i, out_attr->s ? out_attr->s : "");