bfd/elf-attrs.c

   1 /* ELF attributes support (based on ARM EABI attributes).
   2    Copyright (C) 2005-2023 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 bool
  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
  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 *
  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
  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
 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 *
 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 *
 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
 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
 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 *
 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
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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 *
 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
 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
 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
 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
 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
 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
 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
 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 }