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