1/* ELF attributes support (based on ARM EABI attributes). 2 Copyright 2005, 2006, 2007, 2009, 2010 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "bfd.h" 24#include "libiberty.h" 25#include "libbfd.h" 26#include "elf-bfd.h" 27 28/* Return the number of bytes needed by I in uleb128 format. */ 29static int 30uleb128_size (unsigned int i) 31{ 32 int size; 33 size = 1; 34 while (i >= 0x80) 35 { 36 i >>= 7; 37 size++; 38 } 39 return size; 40} 41 42/* Return TRUE if the attribute has the default value (0/""). */ 43static bfd_boolean 44is_default_attr (obj_attribute *attr) 45{ 46 if (ATTR_TYPE_HAS_INT_VAL (attr->type) && attr->i != 0) 47 return FALSE; 48 if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s) 49 return FALSE; 50 if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type)) 51 return FALSE; 52 53 return TRUE; 54} 55 56/* Return the size of a single attribute. */ 57static bfd_vma 58obj_attr_size (int tag, obj_attribute *attr) 59{ 60 bfd_vma size; 61 62 if (is_default_attr (attr)) 63 return 0; 64 65 size = uleb128_size (tag); 66 if (ATTR_TYPE_HAS_INT_VAL (attr->type)) 67 size += uleb128_size (attr->i); 68 if (ATTR_TYPE_HAS_STR_VAL (attr->type)) 69 size += strlen ((char *)attr->s) + 1; 70 return size; 71} 72 73/* Return the vendor name for a given object attributes section. */ 74static const char * 75vendor_obj_attr_name (bfd *abfd, int vendor) 76{ 77 return (vendor == OBJ_ATTR_PROC 78 ? get_elf_backend_data (abfd)->obj_attrs_vendor 79 : "gnu"); 80} 81 82/* Return the size of the object attributes section for VENDOR 83 (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes 84 for that vendor to record and the vendor is OBJ_ATTR_GNU. */ 85static bfd_vma 86vendor_obj_attr_size (bfd *abfd, int vendor) 87{ 88 bfd_vma size; 89 obj_attribute *attr; 90 obj_attribute_list *list; 91 int i; 92 const char *vendor_name = vendor_obj_attr_name (abfd, vendor); 93 94 if (!vendor_name) 95 return 0; 96 97 attr = elf_known_obj_attributes (abfd)[vendor]; 98 size = 0; 99 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 100 size += obj_attr_size (i, &attr[i]); 101 102 for (list = elf_other_obj_attributes (abfd)[vendor]; 103 list; 104 list = list->next) 105 size += obj_attr_size (list->tag, &list->attr); 106 107 /* <size> <vendor_name> NUL 0x1 <size> */ 108 return ((size || vendor == OBJ_ATTR_PROC) 109 ? size + 10 + strlen (vendor_name) 110 : 0); 111} 112 113/* Return the size of the object attributes section. */ 114bfd_vma 115bfd_elf_obj_attr_size (bfd *abfd) 116{ 117 bfd_vma size; 118 119 size = vendor_obj_attr_size (abfd, OBJ_ATTR_PROC); 120 size += vendor_obj_attr_size (abfd, OBJ_ATTR_GNU); 121 122 /* 'A' <sections for each vendor> */ 123 return (size ? size + 1 : 0); 124} 125 126/* Write VAL in uleb128 format to P, returning a pointer to the 127 following byte. */ 128static bfd_byte * 129write_uleb128 (bfd_byte *p, unsigned int val) 130{ 131 bfd_byte c; 132 do 133 { 134 c = val & 0x7f; 135 val >>= 7; 136 if (val) 137 c |= 0x80; 138 *(p++) = c; 139 } 140 while (val); 141 return p; 142} 143 144/* Write attribute ATTR to butter P, and return a pointer to the following 145 byte. */ 146static bfd_byte * 147write_obj_attribute (bfd_byte *p, int tag, obj_attribute *attr) 148{ 149 /* Suppress default entries. */ 150 if (is_default_attr (attr)) 151 return p; 152 153 p = write_uleb128 (p, tag); 154 if (ATTR_TYPE_HAS_INT_VAL (attr->type)) 155 p = write_uleb128 (p, attr->i); 156 if (ATTR_TYPE_HAS_STR_VAL (attr->type)) 157 { 158 int len; 159 160 len = strlen (attr->s) + 1; 161 memcpy (p, attr->s, len); 162 p += len; 163 } 164 165 return p; 166} 167 168/* Write the contents of the object attributes section (length SIZE) 169 for VENDOR to CONTENTS. */ 170static void 171vendor_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size, 172 int vendor) 173{ 174 bfd_byte *p; 175 obj_attribute *attr; 176 obj_attribute_list *list; 177 int i; 178 const char *vendor_name = vendor_obj_attr_name (abfd, vendor); 179 size_t vendor_length = strlen (vendor_name) + 1; 180 181 p = contents; 182 bfd_put_32 (abfd, size, p); 183 p += 4; 184 memcpy (p, vendor_name, vendor_length); 185 p += vendor_length; 186 *(p++) = Tag_File; 187 bfd_put_32 (abfd, size - 4 - vendor_length, p); 188 p += 4; 189 190 attr = elf_known_obj_attributes (abfd)[vendor]; 191 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 192 { 193 int tag = i; 194 if (get_elf_backend_data (abfd)->obj_attrs_order) 195 tag = get_elf_backend_data (abfd)->obj_attrs_order (i); 196 p = write_obj_attribute (p, tag, &attr[tag]); 197 } 198 199 for (list = elf_other_obj_attributes (abfd)[vendor]; 200 list; 201 list = list->next) 202 p = write_obj_attribute (p, list->tag, &list->attr); 203} 204 205/* Write the contents of the object attributes section to CONTENTS. */ 206void 207bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size) 208{ 209 bfd_byte *p; 210 int vendor; 211 bfd_vma my_size; 212 213 p = contents; 214 *(p++) = 'A'; 215 my_size = 1; 216 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) 217 { 218 bfd_vma vendor_size = vendor_obj_attr_size (abfd, vendor); 219 if (vendor_size) 220 vendor_set_obj_attr_contents (abfd, p, vendor_size, vendor); 221 p += vendor_size; 222 my_size += vendor_size; 223 } 224 225 if (size != my_size) 226 abort (); 227} 228 229/* Allocate/find an object attribute. */ 230static obj_attribute * 231elf_new_obj_attr (bfd *abfd, int vendor, int tag) 232{ 233 obj_attribute *attr; 234 obj_attribute_list *list; 235 obj_attribute_list *p; 236 obj_attribute_list **lastp; 237 238 239 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES) 240 { 241 /* Known tags are preallocated. */ 242 attr = &elf_known_obj_attributes (abfd)[vendor][tag]; 243 } 244 else 245 { 246 /* Create a new tag. */ 247 list = (obj_attribute_list *) 248 bfd_alloc (abfd, sizeof (obj_attribute_list)); 249 memset (list, 0, sizeof (obj_attribute_list)); 250 list->tag = tag; 251 /* Keep the tag list in order. */ 252 lastp = &elf_other_obj_attributes (abfd)[vendor]; 253 for (p = *lastp; p; p = p->next) 254 { 255 if (tag < p->tag) 256 break; 257 lastp = &p->next; 258 } 259 list->next = *lastp; 260 *lastp = list; 261 attr = &list->attr; 262 } 263 264 return attr; 265} 266 267/* Return the value of an integer object attribute. */ 268int 269bfd_elf_get_obj_attr_int (bfd *abfd, int vendor, int tag) 270{ 271 obj_attribute_list *p; 272 273 if (tag < NUM_KNOWN_OBJ_ATTRIBUTES) 274 { 275 /* Known tags are preallocated. */ 276 return elf_known_obj_attributes (abfd)[vendor][tag].i; 277 } 278 else 279 { 280 for (p = elf_other_obj_attributes (abfd)[vendor]; 281 p; 282 p = p->next) 283 { 284 if (tag == p->tag) 285 return p->attr.i; 286 if (tag < p->tag) 287 break; 288 } 289 return 0; 290 } 291} 292 293/* Add an integer object attribute. */ 294void 295bfd_elf_add_obj_attr_int (bfd *abfd, int vendor, int tag, unsigned int i) 296{ 297 obj_attribute *attr; 298 299 attr = elf_new_obj_attr (abfd, vendor, tag); 300 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 301 attr->i = i; 302} 303 304/* Duplicate an object attribute string value. */ 305char * 306_bfd_elf_attr_strdup (bfd *abfd, const char * s) 307{ 308 char * p; 309 int len; 310 311 len = strlen (s) + 1; 312 p = (char *) bfd_alloc (abfd, len); 313 return (char *) memcpy (p, s, len); 314} 315 316/* Add a string object attribute. */ 317void 318bfd_elf_add_obj_attr_string (bfd *abfd, int vendor, int tag, const char *s) 319{ 320 obj_attribute *attr; 321 322 attr = elf_new_obj_attr (abfd, vendor, tag); 323 attr->type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 324 attr->s = _bfd_elf_attr_strdup (abfd, s); 325} 326 327/* Add a int+string object attribute. */ 328void 329bfd_elf_add_obj_attr_int_string (bfd *abfd, int vendor, 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. */ 341void 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 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) 351 { 352 in_attr 353 = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; 354 out_attr 355 = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; 356 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) 357 { 358 out_attr->type = in_attr->type; 359 out_attr->i = in_attr->i; 360 if (in_attr->s && *in_attr->s) 361 out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s); 362 in_attr++; 363 out_attr++; 364 } 365 366 for (list = elf_other_obj_attributes (ibfd)[vendor]; 367 list; 368 list = list->next) 369 { 370 in_attr = &list->attr; 371 switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) 372 { 373 case ATTR_TYPE_FLAG_INT_VAL: 374 bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i); 375 break; 376 case ATTR_TYPE_FLAG_STR_VAL: 377 bfd_elf_add_obj_attr_string (obfd, vendor, list->tag, 378 in_attr->s); 379 break; 380 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: 381 bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag, 382 in_attr->i, in_attr->s); 383 break; 384 default: 385 abort (); 386 } 387 } 388 } 389} 390 391/* Determine whether a GNU object attribute tag takes an integer, a 392 string or both. */ 393static int 394gnu_obj_attrs_arg_type (int tag) 395{ 396 /* Except for Tag_compatibility, for GNU attributes we follow the 397 same rule ARM ones > 32 follow: odd-numbered tags take strings 398 and even-numbered tags take integers. In addition, tag & 2 is 399 nonzero for architecture-independent tags and zero for 400 architecture-dependent ones. */ 401 if (tag == Tag_compatibility) 402 return 3; 403 else 404 return (tag & 1) != 0 ? 2 : 1; 405} 406 407/* Determine what arguments an attribute tag takes. */ 408int 409_bfd_elf_obj_attrs_arg_type (bfd *abfd, int vendor, int tag) 410{ 411 switch (vendor) 412 { 413 case OBJ_ATTR_PROC: 414 return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag); 415 break; 416 case OBJ_ATTR_GNU: 417 return gnu_obj_attrs_arg_type (tag); 418 break; 419 default: 420 abort (); 421 } 422} 423 424/* Parse an object attributes section. */ 425void 426_bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr) 427{ 428 bfd_byte *contents; 429 bfd_byte *p; 430 bfd_vma len; 431 const char *std_section; 432 433 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 434 if (!contents) 435 return; 436 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0, 437 hdr->sh_size)) 438 { 439 free (contents); 440 return; 441 } 442 p = contents; 443 std_section = get_elf_backend_data (abfd)->obj_attrs_vendor; 444 if (*(p++) == 'A') 445 { 446 len = hdr->sh_size - 1; 447 while (len > 0) 448 { 449 int namelen; 450 bfd_vma section_len; 451 int vendor; 452 453 section_len = bfd_get_32 (abfd, p); 454 p += 4; 455 if (section_len > len) 456 section_len = len; 457 len -= section_len; 458 namelen = strlen ((char *)p) + 1; 459 section_len -= namelen + 4; 460 if (std_section && strcmp ((char *)p, std_section) == 0) 461 vendor = OBJ_ATTR_PROC; 462 else if (strcmp ((char *)p, "gnu") == 0) 463 vendor = OBJ_ATTR_GNU; 464 else 465 { 466 /* Other vendor section. Ignore it. */ 467 p += namelen + section_len; 468 continue; 469 } 470 471 p += namelen; 472 while (section_len > 0) 473 { 474 int tag; 475 unsigned int n; 476 unsigned int val; 477 bfd_vma subsection_len; 478 bfd_byte *end; 479 480 tag = read_unsigned_leb128 (abfd, p, &n); 481 p += n; 482 subsection_len = bfd_get_32 (abfd, p); 483 p += 4; 484 if (subsection_len > section_len) 485 subsection_len = section_len; 486 section_len -= subsection_len; 487 subsection_len -= n + 4; 488 end = p + subsection_len; 489 switch (tag) 490 { 491 case Tag_File: 492 while (p < end) 493 { 494 int type; 495 496 tag = read_unsigned_leb128 (abfd, p, &n); 497 p += n; 498 type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); 499 switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) 500 { 501 case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: 502 val = read_unsigned_leb128 (abfd, p, &n); 503 p += n; 504 bfd_elf_add_obj_attr_int_string (abfd, vendor, tag, 505 val, (char *)p); 506 p += strlen ((char *)p) + 1; 507 break; 508 case ATTR_TYPE_FLAG_STR_VAL: 509 bfd_elf_add_obj_attr_string (abfd, vendor, tag, 510 (char *)p); 511 p += strlen ((char *)p) + 1; 512 break; 513 case ATTR_TYPE_FLAG_INT_VAL: 514 val = read_unsigned_leb128 (abfd, p, &n); 515 p += n; 516 bfd_elf_add_obj_attr_int (abfd, vendor, tag, val); 517 break; 518 default: 519 abort (); 520 } 521 } 522 break; 523 case Tag_Section: 524 case Tag_Symbol: 525 /* Don't have anywhere convenient to attach these. 526 Fall through for now. */ 527 default: 528 /* Ignore things we don't kow about. */ 529 p += subsection_len; 530 subsection_len = 0; 531 break; 532 } 533 } 534 } 535 } 536 free (contents); 537} 538 539/* Merge common object attributes from IBFD into OBFD. Raise an error 540 if there are conflicting attributes. Any processor-specific 541 attributes have already been merged. This must be called from the 542 bfd_elfNN_bfd_merge_private_bfd_data hook for each individual 543 target, along with any target-specific merging. Because there are 544 no common attributes other than Tag_compatibility at present, and 545 non-"gnu" Tag_compatibility is not expected in "gnu" sections, this 546 is not presently called for targets without their own 547 attributes. */ 548 549bfd_boolean 550_bfd_elf_merge_object_attributes (bfd *ibfd, bfd *obfd) 551{ 552 obj_attribute *in_attr; 553 obj_attribute *out_attr; 554 int vendor; 555 556 /* The only common attribute is currently Tag_compatibility, 557 accepted in both processor and "gnu" sections. */ 558 for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) 559 { 560 /* Handle Tag_compatibility. The tags are only compatible if the flags 561 are identical and, if the flags are '1', the strings are identical. 562 If the flags are non-zero, then we can only use the string "gnu". */ 563 in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility]; 564 out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility]; 565 566 if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0) 567 { 568 _bfd_error_handler 569 (_("error: %B: Object has vendor-specific contents that " 570 "must be processed by the '%s' toolchain"), 571 ibfd, in_attr->s); 572 return FALSE; 573 } 574 575 if (in_attr->i != out_attr->i 576 || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0)) 577 { 578 _bfd_error_handler (_("error: %B: Object tag '%d, %s' is " 579 "incompatible with tag '%d, %s'"), 580 ibfd, 581 in_attr->i, in_attr->s ? in_attr->s : "", 582 out_attr->i, out_attr->s ? out_attr->s : ""); 583 return FALSE; 584 } 585 } 586 587 return TRUE; 588} 589 590/* Merge an unknown processor-specific attribute TAG, within the range 591 of known attributes, from IBFD into OBFD; return TRUE if the link 592 is OK, FALSE if it must fail. */ 593 594bfd_boolean 595_bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag) 596{ 597 obj_attribute *in_attr; 598 obj_attribute *out_attr; 599 bfd *err_bfd = NULL; 600 bfd_boolean result = TRUE; 601 602 in_attr = elf_known_obj_attributes_proc (ibfd); 603 out_attr = elf_known_obj_attributes_proc (obfd); 604 605 if (out_attr[tag].i != 0 || out_attr[tag].s != NULL) 606 err_bfd = obfd; 607 else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL) 608 err_bfd = ibfd; 609 610 if (err_bfd != NULL) 611 result 612 = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag); 613 614 /* Only pass on attributes that match in both inputs. */ 615 if (in_attr[tag].i != out_attr[tag].i 616 || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL) 617 || (in_attr[tag].s != NULL && out_attr[tag].s != NULL 618 && strcmp (in_attr[tag].s, out_attr[tag].s) != 0)) 619 { 620 out_attr[tag].i = 0; 621 out_attr[tag].s = NULL; 622 } 623 624 return result; 625} 626 627/* Merge the lists of unknown processor-specific attributes, outside 628 the known range, from IBFD into OBFD; return TRUE if the link is 629 OK, FALSE if it must fail. */ 630 631bfd_boolean 632_bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd) 633{ 634 obj_attribute_list *in_list; 635 obj_attribute_list *out_list; 636 obj_attribute_list **out_listp; 637 bfd_boolean result = TRUE; 638 639 in_list = elf_other_obj_attributes_proc (ibfd); 640 out_listp = &elf_other_obj_attributes_proc (obfd); 641 out_list = *out_listp; 642 643 for (; in_list || out_list; ) 644 { 645 bfd *err_bfd = NULL; 646 int err_tag = 0; 647 648 /* The tags for each list are in numerical order. */ 649 /* If the tags are equal, then merge. */ 650 if (out_list && (!in_list || in_list->tag > out_list->tag)) 651 { 652 /* This attribute only exists in obfd. We can't merge, and we don't 653 know what the tag means, so delete it. */ 654 err_bfd = obfd; 655 err_tag = out_list->tag; 656 *out_listp = out_list->next; 657 out_list = *out_listp; 658 } 659 else if (in_list && (!out_list || in_list->tag < out_list->tag)) 660 { 661 /* This attribute only exists in ibfd. We can't merge, and we don't 662 know what the tag means, so ignore it. */ 663 err_bfd = ibfd; 664 err_tag = in_list->tag; 665 in_list = in_list->next; 666 } 667 else /* The tags are equal. */ 668 { 669 /* As present, all attributes in the list are unknown, and 670 therefore can't be merged meaningfully. */ 671 err_bfd = obfd; 672 err_tag = out_list->tag; 673 674 /* Only pass on attributes that match in both inputs. */ 675 if (in_list->attr.i != out_list->attr.i 676 || (in_list->attr.s == NULL) != (out_list->attr.s == NULL) 677 || (in_list->attr.s && out_list->attr.s 678 && strcmp (in_list->attr.s, out_list->attr.s) != 0)) 679 { 680 /* No match. Delete the attribute. */ 681 *out_listp = out_list->next; 682 out_list = *out_listp; 683 } 684 else 685 { 686 /* Matched. Keep the attribute and move to the next. */ 687 out_list = out_list->next; 688 in_list = in_list->next; 689 } 690 } 691 692 if (err_bfd) 693 result = result 694 && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, 695 err_tag); 696 } 697 698 return result; 699} 700