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