Update year range in copyright notice of all files.
[external/binutils.git] / bfd / elf-attrs.c
1 /* ELF attributes support (based on ARM EABI attributes).
2    Copyright (C) 2005-2017 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
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
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
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 *
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
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
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 *
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 *
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
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
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 *
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
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
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);
300   attr->i = i;
301 }
302
303 /* Duplicate an object attribute string value.  */
304 char *
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
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);
323   attr->s = _bfd_elf_attr_strdup (abfd, s);
324 }
325
326 /* Add a int+string object attribute.  */
327 void
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);
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
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
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
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
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
574 _bfd_elf_merge_object_attributes (bfd *ibfd, struct bfd_link_info *info)
575 {
576   bfd *obfd = info->output_bfd;
577   obj_attribute *in_attr;
578   obj_attribute *out_attr;
579   int vendor;
580
581   /* The only common attribute is currently Tag_compatibility,
582      accepted in both processor and "gnu" sections.  */
583   for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
584     {
585       /* Handle Tag_compatibility.  The tags are only compatible if the flags
586          are identical and, if the flags are '1', the strings are identical.
587          If the flags are non-zero, then we can only use the string "gnu".  */
588       in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
589       out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
590
591       if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
592         {
593           _bfd_error_handler
594             /* xgettext:c-format */
595                 (_("error: %B: Object has vendor-specific contents that "
596                    "must be processed by the '%s' toolchain"),
597                  ibfd, in_attr->s);
598           return FALSE;
599         }
600
601       if (in_attr->i != out_attr->i
602           || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
603         {
604           /* xgettext:c-format */
605           _bfd_error_handler (_("error: %B: Object tag '%d, %s' is "
606                                 "incompatible with tag '%d, %s'"),
607                               ibfd,
608                               in_attr->i, in_attr->s ? in_attr->s : "",
609                               out_attr->i, out_attr->s ? out_attr->s : "");
610           return FALSE;
611         }
612     }
613
614   return TRUE;
615 }
616
617 /* Merge an unknown processor-specific attribute TAG, within the range
618    of known attributes, from IBFD into OBFD; return TRUE if the link
619    is OK, FALSE if it must fail.  */
620
621 bfd_boolean
622 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag)
623 {
624   obj_attribute *in_attr;
625   obj_attribute *out_attr;
626   bfd *err_bfd = NULL;
627   bfd_boolean result = TRUE;
628
629   in_attr = elf_known_obj_attributes_proc (ibfd);
630   out_attr = elf_known_obj_attributes_proc (obfd);
631
632   if (out_attr[tag].i != 0 || out_attr[tag].s != NULL)
633     err_bfd = obfd;
634   else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL)
635     err_bfd = ibfd;
636
637   if (err_bfd != NULL)
638     result
639       = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag);
640
641   /* Only pass on attributes that match in both inputs.  */
642   if (in_attr[tag].i != out_attr[tag].i
643       || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL)
644       || (in_attr[tag].s != NULL && out_attr[tag].s != NULL
645           && strcmp (in_attr[tag].s, out_attr[tag].s) != 0))
646     {
647       out_attr[tag].i = 0;
648       out_attr[tag].s = NULL;
649     }
650
651   return result;
652 }
653
654 /* Merge the lists of unknown processor-specific attributes, outside
655    the known range, from IBFD into OBFD; return TRUE if the link is
656    OK, FALSE if it must fail.  */
657
658 bfd_boolean
659 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd)
660 {
661   obj_attribute_list *in_list;
662   obj_attribute_list *out_list;
663   obj_attribute_list **out_listp;
664   bfd_boolean result = TRUE;
665
666   in_list = elf_other_obj_attributes_proc (ibfd);
667   out_listp = &elf_other_obj_attributes_proc (obfd);
668   out_list = *out_listp;
669
670   for (; in_list || out_list; )
671     {
672       bfd *err_bfd = NULL;
673       unsigned int err_tag = 0;
674
675       /* The tags for each list are in numerical order.  */
676       /* If the tags are equal, then merge.  */
677       if (out_list && (!in_list || in_list->tag > out_list->tag))
678         {
679           /* This attribute only exists in obfd.  We can't merge, and we don't
680              know what the tag means, so delete it.  */
681           err_bfd = obfd;
682           err_tag = out_list->tag;
683           *out_listp = out_list->next;
684           out_list = *out_listp;
685         }
686       else if (in_list && (!out_list || in_list->tag < out_list->tag))
687         {
688           /* This attribute only exists in ibfd. We can't merge, and we don't
689              know what the tag means, so ignore it.  */
690           err_bfd = ibfd;
691           err_tag = in_list->tag;
692           in_list = in_list->next;
693         }
694       else /* The tags are equal.  */
695         {
696           /* As present, all attributes in the list are unknown, and
697              therefore can't be merged meaningfully.  */
698           err_bfd = obfd;
699           err_tag = out_list->tag;
700
701           /*  Only pass on attributes that match in both inputs.  */
702           if (in_list->attr.i != out_list->attr.i
703               || (in_list->attr.s == NULL) != (out_list->attr.s == NULL)
704               || (in_list->attr.s && out_list->attr.s
705                   && strcmp (in_list->attr.s, out_list->attr.s) != 0))
706             {
707               /* No match.  Delete the attribute.  */
708               *out_listp = out_list->next;
709               out_list = *out_listp;
710             }
711           else
712             {
713               /* Matched.  Keep the attribute and move to the next.  */
714               out_list = out_list->next;
715               in_list = in_list->next;
716             }
717         }
718
719       if (err_bfd)
720         result = result
721           && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd,
722                                                                        err_tag);
723     }
724
725   return result;
726 }