1 /* ELF attributes support (based on ARM EABI attributes). 2 Copyright (C) 2005-2020 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_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 memset (list, 0, sizeof (obj_attribute_list)); 251 list->tag = tag; 252 /* Keep the tag list in order. */ 253 lastp = &elf_other_obj_attributes (abfd)[vendor]; 254 for (p = *lastp; p; p = p->next) 255 { 256 if (tag < p->tag) 257 break; 258 lastp = &p->next; 259 } 260 list->next = *lastp; 261 *lastp = list; 262 attr = &list->attr; 263 } 264 265 return attr; 266 } 267 268 /* Return the value of an integer object attribute. */ 269 int 270 bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, unsigned int tag) 271 { 272 obj_attribute_list *p; 273 274 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES) 275 { 276 /* Known tags are preallocated. */ 277 return elf_known_obj_attributes (abfd)[vendor][tag].i; 278 } 279 else 280 { 281 for (p = elf_other_obj_attributes (abfd)[vendor]; 282 p; 283 p = p->next) 284 { 285 if (tag == p->tag) 286 return p->attr.i; 287 if (tag < p->tag) 288 break; 289 } 290 return 0; 291 } 292 } 293 294 /* Add an integer object attribute. */ 295 void 296 bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, unsigned int tag, unsigned int i) 297 { 298 obj_attribute *attr; 299 300 attr = elf_new_obj_attr (abfd, vendor, tag); 301 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 302 attr->i = i; 303 } 304 305 /* Duplicate an object attribute string value. */ 306 char * 307 _bfd_elf_attr_strdup (bfd *abfd, const char * s) 308 { 309 char * p; 310 int len; 311 312 len = strlen (s) + 1; 313 p = (char *) bfd_alloc (abfd, len); 314 return (char *) memcpy (p, s, len); 315 } 316 317 /* Add a string object attribute. */ 318 void 319 bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, unsigned int tag, const char *s) 320 { 321 obj_attribute *attr; 322 323 attr = elf_new_obj_attr (abfd, vendor, tag); 324 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 325 attr->s = _bfd_elf_attr_strdup (abfd, s); 326 } 327 328 /* Add a int+string object attribute. */ 329 void 330 bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, 331 unsigned int tag, 332 unsigned int i, const char *s) 333 { 334 obj_attribute *attr; 335 336 attr = elf_new_obj_attr (abfd, vendor, tag); 337 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 338 attr->i = i; 339 attr->s = _bfd_elf_attr_strdup (abfd, s); 340 } 341 342 /* Copy the object attributes from IBFD to OBFD. */ 343 void 344 _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd) 345 { 346 obj_attribute *in_attr; 347 obj_attribute *out_attr; 348 obj_attribute_list *list; 349 int i; 350 int vendor; 351 352 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 353 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 354 return; 355 356 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) 357 { 358 in_attr 359 = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; 360 out_attr 361 = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; 362 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 363 { 364 out_attr->type = in_attr->type; 365 out_attr->i = in_attr->i; 366 if (in_attr->s && *in_attr->s) 367 out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s); 368 in_attr++; 369 out_attr++; 370 } 371 372 for (list = elf_other_obj_attributes (ibfd)[vendor]; 373 list; 374 list = list->next) 375 { 376 in_attr = &list->attr; 377 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) 378 { 379 case ATTR_TYPE_FLAG_INT_VAL: 380 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i); 381 break; 382 case ATTR_TYPE_FLAG_STR_VAL: 383 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag, 384 in_attr->s); 385 break; 386 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: 387 bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag, 388 in_attr->i, in_attr->s); 389 break; 390 default: 391 abort (); 392 } 393 } 394 } 395 } 396 397 /* Determine whether a GNU object attribute tag takes an integer, a 398 string or both. */ 399 static int 400 gnu_obj_attrs_arg_type (unsigned int tag) 401 { 402 /* Except for Tag_compatibility, for GNU attributes we follow the 403 same rule ARM ones > 32 follow: odd-numbered tags take strings 404 and even-numbered tags take integers. In addition, tag & 2 is 405 nonzero for architecture-independent tags and zero for 406 architecture-dependent ones. */ 407 if (tag == Tag_compatibility) 408 return 3; 409 else 410 return (tag & 1) != 0 ? 2 : 1; 411 } 412 413 /* Determine what arguments an attribute tag takes. */ 414 int 415 _bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, unsigned int tag) 416 { 417 switch (vendor) 418 { 419 case OBJ_ATTR_PROC: 420 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag); 421 break; 422 case OBJ_ATTR_GNU: 423 return gnu_obj_attrs_arg_type (tag); 424 break; 425 default: 426 abort (); 427 } 428 } 429 430 /* Parse an object attributes section. */ 431 void 432 _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr) 433 { 434 bfd_byte *contents; 435 bfd_byte *p; 436 bfd_byte *p_end; 437 bfd_vma len; 438 const char *std_sec; 439 440 /* PR 17512: file: 2844a11d. */ 441 if (hdr->sh_size == 0) 442 return; 443 if (hdr->sh_size > bfd_get_file_size (abfd)) 444 { 445 /* xgettext:c-format */ 446 _bfd_error_handler (_("%pB: error: attribute section '%pA' too big: %#llx"), 447 abfd, hdr->bfd_section, (long long) hdr->sh_size); 448 bfd_set_error (bfd_error_invalid_operation); 449 return; 450 } 451 452 contents = (bfd_byte *) bfd_malloc (hdr->sh_size + 1); 453 if (!contents) 454 return; 455 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0, 456 hdr->sh_size)) 457 { 458 free (contents); 459 return; 460 } 461 /* Ensure that the buffer is NUL terminated. */ 462 contents[hdr->sh_size] = 0; 463 p = contents; 464 p_end = p + hdr->sh_size; 465 std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor; 466 467 if (*(p++) == 'A') 468 { 469 len = hdr->sh_size - 1; 470 471 while (len > 0 && p < p_end - 4) 472 { 473 unsigned namelen; 474 bfd_vma section_len; 475 int vendor; 476 477 section_len = bfd_get_32 (abfd, p); 478 p += 4; 479 if (section_len == 0) 480 break; 481 if (section_len > len) 482 section_len = len; 483 len -= section_len; 484 if (section_len <= 4) 485 { 486 _bfd_error_handler 487 (_("%pB: error: attribute section length too small: %" PRId64), 488 abfd, (int64_t) section_len); 489 break; 490 } 491 section_len -= 4; 492 namelen = strnlen ((char *) p, section_len) + 1; 493 if (namelen == 0 || namelen >= section_len) 494 break; 495 section_len -= namelen; 496 if (std_sec && strcmp ((char *) p, std_sec) == 0) 497 vendor = OBJ_ATTR_PROC; 498 else if (strcmp ((char *) p, "gnu") == 0) 499 vendor = OBJ_ATTR_GNU; 500 else 501 { 502 /* Other vendor section. Ignore it. */ 503 p += namelen + section_len; 504 continue; 505 } 506 507 p += namelen; 508 while (section_len > 0 && p < p_end) 509 { 510 unsigned int tag; 511 unsigned int n; 512 unsigned int val; 513 bfd_vma subsection_len; 514 bfd_byte *end; 515 516 tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, p_end); 517 p += n; 518 if (p < p_end - 4) 519 subsection_len = bfd_get_32 (abfd, p); 520 else 521 subsection_len = 0; 522 p += 4; 523 if (subsection_len == 0) 524 break; 525 if (subsection_len > section_len) 526 subsection_len = section_len; 527 section_len -= subsection_len; 528 subsection_len -= n + 4; 529 end = p + subsection_len; 530 /* PR 17512: file: 0e8c0c90. */ 531 if (end > p_end) 532 end = p_end; 533 switch (tag) 534 { 535 case Tag_File: 536 while (p < end) 537 { 538 int type; 539 540 tag = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end); 541 p += n; 542 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 543 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) 544 { 545 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: 546 val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end); 547 p += n; 548 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag, 549 val, (char *) p); 550 p += strlen ((char *)p) + 1; 551 break; 552 case ATTR_TYPE_FLAG_STR_VAL: 553 bfd_elf_add_obj_attr_string (abfd, vendor, tag, 554 (char *) p); 555 p += strlen ((char *)p) + 1; 556 break; 557 case ATTR_TYPE_FLAG_INT_VAL: 558 val = _bfd_safe_read_leb128 (abfd, p, &n, FALSE, end); 559 p += n; 560 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val); 561 break; 562 default: 563 abort (); 564 } 565 } 566 break; 567 case Tag_Section: 568 case Tag_Symbol: 569 /* Don't have anywhere convenient to attach these. 570 Fall through for now. */ 571 default: 572 /* Ignore things we don't kow about. */ 573 p += subsection_len; 574 subsection_len = 0; 575 break; 576 } 577 } 578 } 579 } 580 free (contents); 581 } 582 583 /* Merge common object attributes from IBFD into OBFD. Raise an error 584 if there are conflicting attributes. Any processor-specific 585 attributes have already been merged. This must be called from the 586 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual 587 target, along with any target-specific merging. Because there are 588 no common attributes other than Tag_compatibility at present, and 589 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this 590 is not presently called for targets without their own 591 attributes. */ 592 593 bfd_boolean 594 _bfd_elf_merge_object_attributes (bfd *ibfd, struct bfd_link_info *info) 595 { 596 bfd *obfd = info->output_bfd; 597 obj_attribute *in_attr; 598 obj_attribute *out_attr; 599 int vendor; 600 601 /* The only common attribute is currently Tag_compatibility, 602 accepted in both processor and "gnu" sections. */ 603 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) 604 { 605 /* Handle Tag_compatibility. The tags are only compatible if the flags 606 are identical and, if the flags are '1', the strings are identical. 607 If the flags are non-zero, then we can only use the string "gnu". */ 608 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility]; 609 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility]; 610 611 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0) 612 { 613 _bfd_error_handler 614 /* xgettext:c-format */ 615 (_("error: %pB: object has vendor-specific contents that " 616 "must be processed by the '%s' toolchain"), 617 ibfd, in_attr->s); 618 return FALSE; 619 } 620 621 if (in_attr->i != out_attr->i 622 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0)) 623 { 624 /* xgettext:c-format */ 625 _bfd_error_handler (_("error: %pB: object tag '%d, %s' is " 626 "incompatible with tag '%d, %s'"), 627 ibfd, 628 in_attr->i, in_attr->s ? in_attr->s : "", 629 out_attr->i, out_attr->s ? out_attr->s : ""); 630 return FALSE; 631 } 632 } 633 634 return TRUE; 635 } 636 637 /* Merge an unknown processor-specific attribute TAG, within the range 638 of known attributes, from IBFD into OBFD; return TRUE if the link 639 is OK, FALSE if it must fail. */ 640 641 bfd_boolean 642 _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag) 643 { 644 obj_attribute *in_attr; 645 obj_attribute *out_attr; 646 bfd *err_bfd = NULL; 647 bfd_boolean result = TRUE; 648 649 in_attr = elf_known_obj_attributes_proc (ibfd); 650 out_attr = elf_known_obj_attributes_proc (obfd); 651 652 if (out_attr[tag].i != 0 || out_attr[tag].s != NULL) 653 err_bfd = obfd; 654 else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL) 655 err_bfd = ibfd; 656 657 if (err_bfd != NULL) 658 result 659 = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag); 660 661 /* Only pass on attributes that match in both inputs. */ 662 if (in_attr[tag].i != out_attr[tag].i 663 || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL) 664 || (in_attr[tag].s != NULL && out_attr[tag].s != NULL 665 && strcmp (in_attr[tag].s, out_attr[tag].s) != 0)) 666 { 667 out_attr[tag].i = 0; 668 out_attr[tag].s = NULL; 669 } 670 671 return result; 672 } 673 674 /* Merge the lists of unknown processor-specific attributes, outside 675 the known range, from IBFD into OBFD; return TRUE if the link is 676 OK, FALSE if it must fail. */ 677 678 bfd_boolean 679 _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd) 680 { 681 obj_attribute_list *in_list; 682 obj_attribute_list *out_list; 683 obj_attribute_list **out_listp; 684 bfd_boolean result = TRUE; 685 686 in_list = elf_other_obj_attributes_proc (ibfd); 687 out_listp = &elf_other_obj_attributes_proc (obfd); 688 out_list = *out_listp; 689 690 for (; in_list || out_list; ) 691 { 692 bfd *err_bfd = NULL; 693 unsigned int err_tag = 0; 694 695 /* The tags for each list are in numerical order. */ 696 /* If the tags are equal, then merge. */ 697 if (out_list && (!in_list || in_list->tag > out_list->tag)) 698 { 699 /* This attribute only exists in obfd. We can't merge, and we don't 700 know what the tag means, so delete it. */ 701 err_bfd = obfd; 702 err_tag = out_list->tag; 703 *out_listp = out_list->next; 704 out_list = *out_listp; 705 } 706 else if (in_list && (!out_list || in_list->tag < out_list->tag)) 707 { 708 /* This attribute only exists in ibfd. We can't merge, and we don't 709 know what the tag means, so ignore it. */ 710 err_bfd = ibfd; 711 err_tag = in_list->tag; 712 in_list = in_list->next; 713 } 714 else /* The tags are equal. */ 715 { 716 /* As present, all attributes in the list are unknown, and 717 therefore can't be merged meaningfully. */ 718 err_bfd = obfd; 719 err_tag = out_list->tag; 720 721 /* Only pass on attributes that match in both inputs. */ 722 if (in_list->attr.i != out_list->attr.i 723 || (in_list->attr.s == NULL) != (out_list->attr.s == NULL) 724 || (in_list->attr.s && out_list->attr.s 725 && strcmp (in_list->attr.s, out_list->attr.s) != 0)) 726 { 727 /* No match. Delete the attribute. */ 728 *out_listp = out_list->next; 729 out_list = *out_listp; 730 } 731 else 732 { 733 /* Matched. Keep the attribute and move to the next. */ 734 out_list = out_list->next; 735 in_list = in_list->next; 736 } 737 } 738 739 if (err_bfd) 740 result = result 741 && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, 742 err_tag); 743 } 744 745 return result; 746 } 747