1 /* ELF attributes support (based on ARM EABI attributes).
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
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.
10
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.
15
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. */
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_HAS_INT_VAL (attr->type) && attr->i != 0)
46 return FALSE;
47 if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s)
48 return FALSE;
49 if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type))
50 return FALSE;
51
52 return TRUE;
53 }
54
55 /* Return the size of a single attribute. */
56 static bfd_vma
obj_attr_size(unsigned int tag,obj_attribute * attr)57 obj_attr_size (unsigned int tag, obj_attribute *attr)
58 {
59 bfd_vma size;
60
61 if (is_default_attr (attr))
62 return 0;
63
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;
69 return size;
70 }
71
72 /* Return the vendor name for a given object attributes section. */
73 static const char *
vendor_obj_attr_name(bfd * abfd,int vendor)74 vendor_obj_attr_name (bfd *abfd, int vendor)
75 {
76 return (vendor == OBJ_ATTR_PROC
77 ? get_elf_backend_data (abfd)->obj_attrs_vendor
78 : "gnu");
79 }
80
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. */
84 static bfd_vma
vendor_obj_attr_size(bfd * abfd,int vendor)85 vendor_obj_attr_size (bfd *abfd, int vendor)
86 {
87 bfd_vma size;
88 obj_attribute *attr;
89 obj_attribute_list *list;
90 int i;
91 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
92
93 if (!vendor_name)
94 return 0;
95
96 attr = elf_known_obj_attributes (abfd)[vendor];
97 size = 0;
98 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
99 size += obj_attr_size (i, &attr[i]);
100
101 for (list = elf_other_obj_attributes (abfd)[vendor];
102 list;
103 list = list->next)
104 size += obj_attr_size (list->tag, &list->attr);
105
106 /* <size> <vendor_name> NUL 0x1 <size> */
107 return ((size || vendor == OBJ_ATTR_PROC)
108 ? size + 10 + strlen (vendor_name)
109 : 0);
110 }
111
112 /* Return the size of the object attributes section. */
113 bfd_vma
bfd_elf_obj_attr_size(bfd * abfd)114 bfd_elf_obj_attr_size (bfd *abfd)
115 {
116 bfd_vma size;
117
118 size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC);
119 size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU);
120
121 /* 'A' <sections for each vendor> */
122 return (size ? size + 1 : 0);
123 }
124
125 /* Write VAL in uleb128 format to P, returning a pointer to the
126 following byte. */
127 static bfd_byte *
write_uleb128(bfd_byte * p,unsigned int val)128 write_uleb128 (bfd_byte *p, unsigned int val)
129 {
130 bfd_byte c;
131 do
132 {
133 c = val & 0x7f;
134 val >>= 7;
135 if (val)
136 c |= 0x80;
137 *(p++) = c;
138 }
139 while (val);
140 return p;
141 }
142
143 /* Write attribute ATTR to butter P, and return a pointer to the following
144 byte. */
145 static bfd_byte *
write_obj_attribute(bfd_byte * p,unsigned int tag,obj_attribute * attr)146 write_obj_attribute (bfd_byte *p, unsigned int tag, obj_attribute *attr)
147 {
148 /* Suppress default entries. */
149 if (is_default_attr (attr))
150 return p;
151
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))
156 {
157 int len;
158
159 len = strlen (attr->s) + 1;
160 memcpy (p, attr->s, len);
161 p += len;
162 }
163
164 return p;
165 }
166
167 /* Write the contents of the object attributes section (length SIZE)
168 for VENDOR to CONTENTS. */
169 static void
vendor_set_obj_attr_contents(bfd * abfd,bfd_byte * contents,bfd_vma size,int vendor)170 vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size,
171 int vendor)
172 {
173 bfd_byte *p;
174 obj_attribute *attr;
175 obj_attribute_list *list;
176 int i;
177 const char *vendor_name = vendor_obj_attr_name (abfd, vendor);
178 size_t vendor_length = strlen (vendor_name) + 1;
179
180 p = contents;
181 bfd_put_32 (abfd, size, p);
182 p += 4;
183 memcpy (p, vendor_name, vendor_length);
184 p += vendor_length;
185 *(p++) = Tag_File;
186 bfd_put_32 (abfd, size - 4 - vendor_length, p);
187 p += 4;
188
189 attr = elf_known_obj_attributes (abfd)[vendor];
190 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
191 {
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]);
196 }
197
198 for (list = elf_other_obj_attributes (abfd)[vendor];
199 list;
200 list = list->next)
201 p = write_obj_attribute (p, list->tag, &list->attr);
202 }
203
204 /* Write the contents of the object attributes section to CONTENTS. */
205 void
bfd_elf_set_obj_attr_contents(bfd * abfd,bfd_byte * contents,bfd_vma size)206 bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
207 {
208 bfd_byte *p;
209 int vendor;
210 bfd_vma my_size;
211
212 p = contents;
213 *(p++) = 'A';
214 my_size = 1;
215 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
216 {
217 bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor);
218 if (vendor_size)
219 vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor);
220 p += vendor_size;
221 my_size += vendor_size;
222 }
223
224 if (size != my_size)
225 abort ();
226 }
227
228 /* Allocate/find an object attribute. */
229 static obj_attribute *
elf_new_obj_attr(bfd * abfd,int vendor,unsigned int tag)230 elf_new_obj_attr (bfd *abfd, int vendor, unsigned int tag)
231 {
232 obj_attribute *attr;
233 obj_attribute_list *list;
234 obj_attribute_list *p;
235 obj_attribute_list **lastp;
236
237
238 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
239 {
240 /* Known tags are preallocated. */
241 attr = &elf_known_obj_attributes (abfd)[vendor][tag];
242 }
243 else
244 {
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));
249 list->tag = tag;
250 /* Keep the tag list in order. */
251 lastp = &elf_other_obj_attributes (abfd)[vendor];
252 for (p = *lastp; p; p = p->next)
253 {
254 if (tag < p->tag)
255 break;
256 lastp = &p->next;
257 }
258 list->next = *lastp;
259 *lastp = list;
260 attr = &list->attr;
261 }
262
263 return attr;
264 }
265
266 /* Return the value of an integer object attribute. */
267 int
bfd_elf_get_obj_attr_int(bfd * abfd,int vendor,unsigned int tag)268 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, unsigned int tag)
269 {
270 obj_attribute_list *p;
271
272 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES)
273 {
274 /* Known tags are preallocated. */
275 return elf_known_obj_attributes (abfd)[vendor][tag].i;
276 }
277 else
278 {
279 for (p = elf_other_obj_attributes (abfd)[vendor];
280 p;
281 p = p->next)
282 {
283 if (tag == p->tag)
284 return p->attr.i;
285 if (tag < p->tag)
286 break;
287 }
288 return 0;
289 }
290 }
291
292 /* Add an integer object attribute. */
293 void
bfd_elf_add_obj_attr_int(bfd * abfd,int vendor,unsigned int tag,unsigned int i)294 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, unsigned int tag, unsigned int i)
295 {
296 obj_attribute *attr;
297
298 attr = elf_new_obj_attr (abfd, vendor, tag);
299 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag) | ATTR_TYPE_FLAG_EXIST;
300 attr->i = i;
301 }
302
303 /* Duplicate an object attribute string value. */
304 char *
_bfd_elf_attr_strdup(bfd * abfd,const char * s)305 _bfd_elf_attr_strdup (bfd *abfd, const char * s)
306 {
307 char * p;
308 int len;
309
310 len = strlen (s) + 1;
311 p = (char *) bfd_alloc (abfd, len);
312 return (char *) memcpy (p, s, len);
313 }
314
315 /* Add a string object attribute. */
316 void
bfd_elf_add_obj_attr_string(bfd * abfd,int vendor,unsigned int tag,const char * s)317 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, unsigned int tag, const char *s)
318 {
319 obj_attribute *attr;
320
321 attr = elf_new_obj_attr (abfd, vendor, tag);
322 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag) | ATTR_TYPE_FLAG_EXIST;
323 attr->s = _bfd_elf_attr_strdup (abfd, s);
324 }
325
326 /* Add a int+string object attribute. */
327 void
bfd_elf_add_obj_attr_int_string(bfd * abfd,int vendor,unsigned int tag,unsigned int i,const char * s)328 bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor,
329 unsigned int tag,
330 unsigned int i, const char *s)
331 {
332 obj_attribute *attr;
333
334 attr = elf_new_obj_attr (abfd, vendor, tag);
335 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag) | ATTR_TYPE_FLAG_EXIST;
336 attr->i = i;
337 attr->s = _bfd_elf_attr_strdup (abfd, s);
338 }
339
340 /* Copy the object attributes from IBFD to OBFD. */
341 void
_bfd_elf_copy_obj_attributes(bfd * ibfd,bfd * obfd)342 _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd)
343 {
344 obj_attribute *in_attr;
345 obj_attribute *out_attr;
346 obj_attribute_list *list;
347 int i;
348 int vendor;
349
350 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
351 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
352 return;
353
354 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
355 {
356 in_attr
357 = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
358 out_attr
359 = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE];
360 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
361 {
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);
366 in_attr++;
367 out_attr++;
368 }
369
370 for (list = elf_other_obj_attributes (ibfd)[vendor];
371 list;
372 list = list->next)
373 {
374 in_attr = &list->attr;
375 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
376 {
377 case ATTR_TYPE_FLAG_INT_VAL:
378 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i);
379 break;
380 case ATTR_TYPE_FLAG_STR_VAL:
381 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag,
382 in_attr->s);
383 break;
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);
387 break;
388 default:
389 abort ();
390 }
391 }
392 }
393 }
394
395 /* Determine whether a GNU object attribute tag takes an integer, a
396 string or both. */
397 static int
gnu_obj_attrs_arg_type(unsigned int tag)398 gnu_obj_attrs_arg_type (unsigned int tag)
399 {
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)
406 return 3;
407 else
408 return (tag & 1) != 0 ? 2 : 1;
409 }
410
411 /* Determine what arguments an attribute tag takes. */
412 int
_bfd_elf_obj_attrs_arg_type(bfd * abfd,int vendor,unsigned int tag)413 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, unsigned int tag)
414 {
415 switch (vendor)
416 {
417 case OBJ_ATTR_PROC:
418 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag);
419 break;
420 case OBJ_ATTR_GNU:
421 return gnu_obj_attrs_arg_type (tag);
422 break;
423 default:
424 abort ();
425 }
426 }
427
428 /* Parse an object attributes section. */
429 void
_bfd_elf_parse_attributes(bfd * abfd,Elf_Internal_Shdr * hdr)430 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
431 {
432 bfd_byte *contents;
433 bfd_byte *p;
434 bfd_byte *p_end;
435 bfd_vma len;
436 const char *std_sec;
437
438 /* PR 17512: file: 2844a11d. */
439 if (hdr->sh_size == 0)
440 return;
441 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
442 if (!contents)
443 return;
444 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
445 hdr->sh_size))
446 {
447 free (contents);
448 return;
449 }
450 p = contents;
451 p_end = p + hdr->sh_size;
452 std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor;
453
454 if (*(p++) == 'A')
455 {
456 len = hdr->sh_size - 1;
457
458 while (len > 0 && p < p_end - 4)
459 {
460 unsigned namelen;
461 bfd_vma section_len;
462 int vendor;
463
464 section_len = bfd_get_32 (abfd, p);
465 p += 4;
466 if (section_len == 0)
467 break;
468 if (section_len > len)
469 section_len = len;
470 len -= section_len;
471 section_len -= 4;
472 namelen = strnlen ((char *) p, section_len) + 1;
473 if (namelen == 0 || namelen >= section_len)
474 break;
475 section_len -= namelen;
476 if (std_sec && strcmp ((char *) p, std_sec) == 0)
477 vendor = OBJ_ATTR_PROC;
478 else if (strcmp ((char *) p, "gnu") == 0)
479 vendor = OBJ_ATTR_GNU;
480 else
481 {
482 /* Other vendor section. Ignore it. */
483 p += namelen + section_len;
484 continue;
485 }
486
487 p += namelen;
488 while (section_len > 0 && p < p_end)
489 {
490 unsigned int tag;
491 unsigned int n;
492 unsigned int val;
493 bfd_vma subsection_len;
494 bfd_byte *end;
495
496 tag = safe_read_leb128 (abfd, p, &n, FALSE, p_end);
497 p += n;
498 if (p < p_end - 4)
499 subsection_len = bfd_get_32 (abfd, p);
500 else
501 subsection_len = 0;
502 p += 4;
503 if (subsection_len == 0)
504 break;
505 if (subsection_len > section_len)
506 subsection_len = section_len;
507 section_len -= subsection_len;
508 subsection_len -= n + 4;
509 end = p + subsection_len;
510 /* PR 17512: file: 0e8c0c90. */
511 if (end > p_end)
512 end = p_end;
513 switch (tag)
514 {
515 case Tag_File:
516 while (p < end)
517 {
518 int type;
519
520 tag = safe_read_leb128 (abfd, p, &n, FALSE, end);
521 p += n;
522 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
523 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
524 {
525 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
526 val = safe_read_leb128 (abfd, p, &n, FALSE, end);
527 p += n;
528 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
529 val, (char *) p);
530 p += strlen ((char *)p) + 1;
531 break;
532 case ATTR_TYPE_FLAG_STR_VAL:
533 bfd_elf_add_obj_attr_string (abfd, vendor, tag,
534 (char *) p);
535 p += strlen ((char *)p) + 1;
536 break;
537 case ATTR_TYPE_FLAG_INT_VAL:
538 val = safe_read_leb128 (abfd, p, &n, FALSE, end);
539 p += n;
540 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
541 break;
542 default:
543 abort ();
544 }
545 }
546 break;
547 case Tag_Section:
548 case Tag_Symbol:
549 /* Don't have anywhere convenient to attach these.
550 Fall through for now. */
551 default:
552 /* Ignore things we don't kow about. */
553 p += subsection_len;
554 subsection_len = 0;
555 break;
556 }
557 }
558 }
559 }
560 free (contents);
561 }
562
563 /* Merge common object attributes from IBFD into OBFD. Raise an error
564 if there are conflicting attributes. Any processor-specific
565 attributes have already been merged. This must be called from the
566 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
567 target, along with any target-specific merging. Because there are
568 no common attributes other than Tag_compatibility at present, and
569 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
570 is not presently called for targets without their own
571 attributes. */
572
573 bfd_boolean
_bfd_elf_merge_object_attributes(bfd * ibfd,bfd * obfd)574 _bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd)
575 {
576 obj_attribute *in_attr;
577 obj_attribute *out_attr;
578 int vendor;
579
580 /* The only common attribute is currently Tag_compatibility,
581 accepted in both processor and "gnu" sections. */
582 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
583 {
584 /* Handle Tag_compatibility. The tags are only compatible if the flags
585 are identical and, if the flags are '1', the strings are identical.
586 If the flags are non-zero, then we can only use the string "gnu". */
587 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
588 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
589
590 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
591 {
592 _bfd_error_handler
593 (_("error: %B: Object has vendor-specific contents that "
594 "must be processed by the '%s' toolchain"),
595 ibfd, in_attr->s);
596 return FALSE;
597 }
598
599 if (in_attr->i != out_attr->i
600 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
601 {
602 _bfd_error_handler (_("error: %B: Object tag '%d, %s' is "
603 "incompatible with tag '%d, %s'"),
604 ibfd,
605 in_attr->i, in_attr->s ? in_attr->s : "",
606 out_attr->i, out_attr->s ? out_attr->s : "");
607 return FALSE;
608 }
609 }
610
611 return TRUE;
612 }
613
614 /* Merge an unknown processor-specific attribute TAG, within the range
615 of known attributes, from IBFD into OBFD; return TRUE if the link
616 is OK, FALSE if it must fail. */
617
618 bfd_boolean
_bfd_elf_merge_unknown_attribute_low(bfd * ibfd,bfd * obfd,int tag)619 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag)
620 {
621 obj_attribute *in_attr;
622 obj_attribute *out_attr;
623 bfd *err_bfd = NULL;
624 bfd_boolean result = TRUE;
625
626 in_attr = elf_known_obj_attributes_proc (ibfd);
627 out_attr = elf_known_obj_attributes_proc (obfd);
628
629 if (out_attr[tag].i != 0 || out_attr[tag].s != NULL)
630 err_bfd = obfd;
631 else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL)
632 err_bfd = ibfd;
633
634 if (err_bfd != NULL)
635 result
636 = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag);
637
638 /* Only pass on attributes that match in both inputs. */
639 if (in_attr[tag].i != out_attr[tag].i
640 || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL)
641 || (in_attr[tag].s != NULL && out_attr[tag].s != NULL
642 && strcmp (in_attr[tag].s, out_attr[tag].s) != 0))
643 {
644 out_attr[tag].i = 0;
645 out_attr[tag].s = NULL;
646 }
647
648 return result;
649 }
650
651 /* Merge the lists of unknown processor-specific attributes, outside
652 the known range, from IBFD into OBFD; return TRUE if the link is
653 OK, FALSE if it must fail. */
654
655 bfd_boolean
_bfd_elf_merge_unknown_attribute_list(bfd * ibfd,bfd * obfd)656 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd)
657 {
658 obj_attribute_list *in_list;
659 obj_attribute_list *out_list;
660 obj_attribute_list **out_listp;
661 bfd_boolean result = TRUE;
662
663 in_list = elf_other_obj_attributes_proc (ibfd);
664 out_listp = &elf_other_obj_attributes_proc (obfd);
665 out_list = *out_listp;
666
667 for (; in_list || out_list; )
668 {
669 bfd *err_bfd = NULL;
670 unsigned int err_tag = 0;
671
672 /* The tags for each list are in numerical order. */
673 /* If the tags are equal, then merge. */
674 if (out_list && (!in_list || in_list->tag > out_list->tag))
675 {
676 /* This attribute only exists in obfd. We can't merge, and we don't
677 know what the tag means, so delete it. */
678 err_bfd = obfd;
679 err_tag = out_list->tag;
680 *out_listp = out_list->next;
681 out_list = *out_listp;
682 }
683 else if (in_list && (!out_list || in_list->tag < out_list->tag))
684 {
685 /* This attribute only exists in ibfd. We can't merge, and we don't
686 know what the tag means, so ignore it. */
687 err_bfd = ibfd;
688 err_tag = in_list->tag;
689 in_list = in_list->next;
690 }
691 else /* The tags are equal. */
692 {
693 /* As present, all attributes in the list are unknown, and
694 therefore can't be merged meaningfully. */
695 err_bfd = obfd;
696 err_tag = out_list->tag;
697
698 /* Only pass on attributes that match in both inputs. */
699 if (in_list->attr.i != out_list->attr.i
700 || (in_list->attr.s == NULL) != (out_list->attr.s == NULL)
701 || (in_list->attr.s && out_list->attr.s
702 && strcmp (in_list->attr.s, out_list->attr.s) != 0))
703 {
704 /* No match. Delete the attribute. */
705 *out_listp = out_list->next;
706 out_list = *out_listp;
707 }
708 else
709 {
710 /* Matched. Keep the attribute and move to the next. */
711 out_list = out_list->next;
712 in_list = in_list->next;
713 }
714 }
715
716 if (err_bfd)
717 result = result
718 && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd,
719 err_tag);
720 }
721
722 return result;
723 }
724