bfd/elf-attrs.c

   1 /* ELF attributes support (based on ARM EABI attributes).
   2    Copyright (C) 2005-2018 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   if (hdr->sh_size > bfd_get_file_size (abfd))
 442     {
 443       /* xgettext:c-format */
 444       _bfd_error_handler (_("%pB: error: attribute section '%pA' too big: %#llx"),
 445                           abfd, hdr->bfd_section, (long long) hdr->sh_size);
 446       bfd_set_error (bfd_error_invalid_operation);
 447       return;
 448     }
 449
 450   contents = (bfd_byte *) bfd_malloc (hdr->sh_size + 1);
 451   if (!contents)
 452     return;
 453   if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
 454                                  hdr->sh_size))
 455     {
 456       free (contents);
 457       return;
 458     }
 459   /* Ensure that the buffer is NUL terminated.  */
 460   contents[hdr->sh_size] = 0;
 461   p = contents;
 462   p_end = p + hdr->sh_size;
 463   std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor;
 464
 465   if (*(p++) == 'A')
 466     {
 467       len = hdr->sh_size - 1;
 468
 469       while (len > 0 && p < p_end - 4)
 470         {
 471           unsigned namelen;
 472           bfd_vma section_len;
 473           int vendor;
 474
 475           section_len = bfd_get_32 (abfd, p);
 476           p += 4;
 477           if (section_len == 0)
 478             break;
 479           if (section_len > len)
 480             section_len = len;
 481           len -= section_len;
 482           if (section_len <= 4)
 483             {
 484               _bfd_error_handler
 485                 (_("%pB: error: attribute section length too small: %" PRId64),
 486                  abfd, (int64_t) section_len);
 487               break;
 488             }
 489           section_len -= 4;
 490           namelen = strnlen ((char *) p, section_len) + 1;
 491           if (namelen == 0 || namelen >= section_len)
 492             break;
 493           section_len -= namelen;
 494           if (std_sec && strcmp ((char *) p, std_sec) == 0)
 495             vendor = OBJ_ATTR_PROC;
 496           else if (strcmp ((char *) p, "gnu") == 0)
 497             vendor = OBJ_ATTR_GNU;
 498           else
 499             {
 500               /* Other vendor section.  Ignore it.  */
 501               p += namelen + section_len;
 502               continue;
 503             }
 504
 505           p += namelen;
 506           while (section_len > 0 && p < p_end)
 507             {
 508               unsigned int tag;
 509               unsigned int n;
 510               unsigned int val;
 511               bfd_vma subsection_len;
 512               bfd_byte *end;
 513
 514               tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, p_end);
 515               p += n;
 516               if (p < p_end - 4)
 517                 subsection_len = bfd_get_32 (abfd, p);
 518               else
 519                 subsection_len = 0;
 520               p += 4;
 521               if (subsection_len == 0)
 522                 break;
 523               if (subsection_len > section_len)
 524                 subsection_len = section_len;
 525               section_len -= subsection_len;
 526               subsection_len -= n + 4;
 527               end = p + subsection_len;
 528               /* PR 17512: file: 0e8c0c90.  */
 529               if (end > p_end)
 530                 end = p_end;
 531               switch (tag)
 532                 {
 533                 case Tag_File:
 534                   while (p < end)
 535                     {
 536                       int type;
 537
 538                       tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
 539                       p += n;
 540                       type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
 541                       switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL))
 542                         {
 543                         case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL:
 544                           val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
 545                           p += n;
 546                           bfd_elf_add_obj_attr_int_string (abfd, vendor, tag,
 547                                                            val, (char *) p);
 548                           p += strlen ((char *)p) + 1;
 549                           break;
 550                         case ATTR_TYPE_FLAG_STR_VAL:
 551                           bfd_elf_add_obj_attr_string (abfd, vendor, tag,
 552                                                        (char *) p);
 553                           p += strlen ((char *)p) + 1;
 554                           break;
 555                         case ATTR_TYPE_FLAG_INT_VAL:
 556                           val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end);
 557                           p += n;
 558                           bfd_elf_add_obj_attr_int (abfd, vendor, tag, val);
 559                           break;
 560                         default:
 561                           abort ();
 562                         }
 563                     }
 564                   break;
 565                 case Tag_Section:
 566                 case Tag_Symbol:
 567                   /* Don't have anywhere convenient to attach these.
 568                      Fall through for now.  */
 569                 default:
 570                   /* Ignore things we don't kow about.  */
 571                   p += subsection_len;
 572                   subsection_len = 0;
 573                   break;
 574                 }
 575             }
 576         }
 577     }
 578   free (contents);
 579 }
 580
 581 /* Merge common object attributes from IBFD into OBFD.  Raise an error
 582    if there are conflicting attributes.  Any processor-specific
 583    attributes have already been merged.  This must be called from the
 584    bfd_elfNN_bfd_merge_private_bfd_data hook for each individual
 585    target, along with any target-specific merging.  Because there are
 586    no common attributes other than Tag_compatibility at present, and
 587    non-"gnu" Tag_compatibility is not expected in "gnu" sections, this
 588    is not presently called for targets without their own
 589    attributes.  */
 590
 591 bfd_boolean
 592 _bfd_elf_merge_object_attributes (bfd *ibfd, struct bfd_link_info *info)
 593 {
 594   bfd *obfd = info->output_bfd;
 595   obj_attribute *in_attr;
 596   obj_attribute *out_attr;
 597   int vendor;
 598
 599   /* The only common attribute is currently Tag_compatibility,
 600      accepted in both processor and "gnu" sections.  */
 601   for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++)
 602     {
 603       /* Handle Tag_compatibility.  The tags are only compatible if the flags
 604          are identical and, if the flags are '1', the strings are identical.
 605          If the flags are non-zero, then we can only use the string "gnu".  */
 606       in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility];
 607       out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility];
 608
 609       if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0)
 610         {
 611           _bfd_error_handler
 612             /* xgettext:c-format */
 613                 (_("error: %pB: object has vendor-specific contents that "
 614                    "must be processed by the '%s' toolchain"),
 615                  ibfd, in_attr->s);
 616           return FALSE;
 617         }
 618
 619       if (in_attr->i != out_attr->i
 620           || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0))
 621         {
 622           /* xgettext:c-format */
 623           _bfd_error_handler (_("error: %pB: object tag '%d, %s' is "
 624                                 "incompatible with tag '%d, %s'"),
 625                               ibfd,
 626                               in_attr->i, in_attr->s ? in_attr->s : "",
 627                               out_attr->i, out_attr->s ? out_attr->s : "");
 628           return FALSE;
 629         }
 630     }
 631
 632   return TRUE;
 633 }
 634
 635 /* Merge an unknown processor-specific attribute TAG, within the range
 636    of known attributes, from IBFD into OBFD; return TRUE if the link
 637    is OK, FALSE if it must fail.  */
 638
 639 bfd_boolean
 640 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag)
 641 {
 642   obj_attribute *in_attr;
 643   obj_attribute *out_attr;
 644   bfd *err_bfd = NULL;
 645   bfd_boolean result = TRUE;
 646
 647   in_attr = elf_known_obj_attributes_proc (ibfd);
 648   out_attr = elf_known_obj_attributes_proc (obfd);
 649
 650   if (out_attr[tag].i != 0 || out_attr[tag].s != NULL)
 651     err_bfd = obfd;
 652   else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL)
 653     err_bfd = ibfd;
 654
 655   if (err_bfd != NULL)
 656     result
 657       = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag);
 658
 659   /* Only pass on attributes that match in both inputs.  */
 660   if (in_attr[tag].i != out_attr[tag].i
 661       || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL)
 662       || (in_attr[tag].s != NULL && out_attr[tag].s != NULL
 663           && strcmp (in_attr[tag].s, out_attr[tag].s) != 0))
 664     {
 665       out_attr[tag].i = 0;
 666       out_attr[tag].s = NULL;
 667     }
 668
 669   return result;
 670 }
 671
 672 /* Merge the lists of unknown processor-specific attributes, outside
 673    the known range, from IBFD into OBFD; return TRUE if the link is
 674    OK, FALSE if it must fail.  */
 675
 676 bfd_boolean
 677 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd)
 678 {
 679   obj_attribute_list *in_list;
 680   obj_attribute_list *out_list;
 681   obj_attribute_list **out_listp;
 682   bfd_boolean result = TRUE;
 683
 684   in_list = elf_other_obj_attributes_proc (ibfd);
 685   out_listp = &elf_other_obj_attributes_proc (obfd);
 686   out_list = *out_listp;
 687
 688   for (; in_list || out_list; )
 689     {
 690       bfd *err_bfd = NULL;
 691       unsigned int err_tag = 0;
 692
 693       /* The tags for each list are in numerical order.  */
 694       /* If the tags are equal, then merge.  */
 695       if (out_list && (!in_list || in_list->tag > out_list->tag))
 696         {
 697           /* This attribute only exists in obfd.  We can't merge, and we don't
 698              know what the tag means, so delete it.  */
 699           err_bfd = obfd;
 700           err_tag = out_list->tag;
 701           *out_listp = out_list->next;
 702           out_list = *out_listp;
 703         }
 704       else if (in_list && (!out_list || in_list->tag < out_list->tag))
 705         {
 706           /* This attribute only exists in ibfd. We can't merge, and we don't
 707              know what the tag means, so ignore it.  */
 708           err_bfd = ibfd;
 709           err_tag = in_list->tag;
 710           in_list = in_list->next;
 711         }
 712       else /* The tags are equal.  */
 713         {
 714           /* As present, all attributes in the list are unknown, and
 715              therefore can't be merged meaningfully.  */
 716           err_bfd = obfd;
 717           err_tag = out_list->tag;
 718
 719           /*  Only pass on attributes that match in both inputs.  */
 720           if (in_list->attr.i != out_list->attr.i
 721               || (in_list->attr.s == NULL) != (out_list->attr.s == NULL)
 722               || (in_list->attr.s && out_list->attr.s
 723                   && strcmp (in_list->attr.s, out_list->attr.s) != 0))
 724             {
 725               /* No match.  Delete the attribute.  */
 726               *out_listp = out_list->next;
 727               out_list = *out_listp;
 728             }
 729           else
 730             {
 731               /* Matched.  Keep the attribute and move to the next.  */
 732               out_list = out_list->next;
 733               in_list = in_list->next;
 734             }
 735         }
 736
 737       if (err_bfd)
 738         result = result
 739           && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd,
 740                                                                        err_tag);
 741     }
 742
 743   return result;
 744 }