/* ELF attributes support (based on ARM EABI attributes). Copyright (C) 2005-2026 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ /* Design note regarding the merge of Object Attributes v2 during linkage Entry point: _bfd_elf_link_setup_object_attributes The linker is an "advanced" consumer of OAv2. After parsing, it deduplicates them, merges them, detects any compatibility issues, and finally translates them to GNU properties. ** Overall design The OAv2 processing pipeline follows a map-reduce pattern. Obviously, the actual processing in GNU ld is not multi-threaded, and the operations are not necessarily executed directly one after another. * Phase 1, map: successive per-file operations applied on the list of compatible input objects. 1. Parsing of the OAv2 section's data (also used by objcopy). 2. Translation of relevant GNU properties to OAv2. This is required for the backward-compatibility with input objects only marked using GNU properties. 3. Sorting of the subsections and object attributes. Further operations rely on the ordering to perform some optimization in the processing of the data. 4. Deduplication of subsections and object attributes, and detection of any conflict between duplicated subsections or tags. 5. Translation of relevant OAv2 to GNU properties for a forward -compatibility with the GNU properties merge. 6. Marking of unknown subsections to skip them during the merge (in phase 2), and to prune them before the output object's serialization (in phase 3). * Phase 2, reduce: OAv2 in input objects are merged together. 1. Gathering of "frozen" values (=coming from the command-line arguments) into a virtual read-only list of subsections and attributes. 2. Merging of OAv2 from an input file and the frozen input. 3. Merging of the results of step 2 together. Since the OAv2 merge is commutative and associative, it can be implemented as a reduce. However, GNU ld implements it as an accumulate because it does not support multithreading. Notes: the two merge phases also perform a marking of unsupported / invalid subsections and attributes. This marking can be used for debugging, and also more practically to drop unsupported optional subsections from the output. * Phase 3, finalization of the output. 1. Pruning of the unknown / unsupported / invalid subsections and attributes. 2. Serialization of OAv2 data (also used by objcopy). Notes: - There is no translation of the merged OAv2 to GNU properties at this stage, as the GNU properties merge process has already all the needed information (translated in step 5 of stage 1) to produce the GNU properties. - The GNU properties are currently required as the runtime linker does not understand OAv2 yet. - Phase 3 should also include a compatibility check between the final merge result of the current link unit and input shared objects. I opted for postponing this compatibility check, and GNU properties merge will take care of it as it already does. The Object Ottributes merge process must handle both optional and required subsections. It also treats the first merge of the frozen set specially, as the OAv2 list in the input BFD serves as the accumulator for subsequent merges. ** Optional subsections Optional subsections are processed as if merging two ordered sets — by iterating linearly through both, checking whether an element of a given ordinality is present in the opposite set, and adding it to the accumulator. The added diffuculty with subsections and attributes lies in the fact that missing elements have default values, and these must be merged with existing ones to produce the final value to be stored. ** Required subsections Required subsections are processed slightly differently from the optional subsections, as they cannot be pruned since they are mandatory, hence an error will be raised by the linker if it is not recognized. For now, the subsection for PAuth ABI is the only one use case, and no merge is applied on the values. The values simply need to match. This implementation choice might be challenged in the future if required subsections can have the same diversity as optional subsections. If the case arises, the refactoring to handle this new behavior should consist in adding a new merge policy MERGE-EQUAL, or something similar. Some "if required" should be added in the optional subsections merge logic to error on any missing elements, or mismatch, and messages should also be rephrased to point out that the error is for a required subsection. ** Important note regarding support for testing In order to test this generic logic, AArch64's use cases are not offering enough coverage, so a "GNU testing namespace" which corresponds to the name of the subsection was introduced. It follows the following pattern: gnu_testing__MERGE_ with: - : an arbitrary name for your testing subsection. - : the name of the merging policy to apply on the values in the subsection. The currently supported merge policy are: * _MERGE_AND: bitwise AND applied on numerical values. * _MERGE_OR: bitwise OR applied on numerical values. * _MERGE_ADD: concatenates strings together with a '+' in-between. Note: "_MERGE_ADD" does not make really sense, and will very likely never be used for a real merge. Its only purpose is to test the correct handling of merges with strings. Any subsection name matching neither names supported by the backend, nor following the pattern corresponding GNU testing namespace will be considered unknown and its status set to obj_attr_subsection_v2_unknown. This will have for consequence the pruning of this subsection. Additionally, the first two tags in gnu_testing namespace, GNUTestTag_0 and GNUTestTag_1, are known, and so have a name and can be initialized to the default value ('0' or NULL) depending on the encoding specified on the subsection. Any tags above 1 will be considered unknown, so will be default -initialized in the same way but its status will be set to obj_attr_v2_unknown. This behavior of the testing tags allows to test the pruning of unknown attributes. */ #include "sysdep.h" #include "bfd.h" #include "doubly-linked-list.h" #include "libiberty.h" #include "libbfd.h" #include "elf-bfd.h" /* Decode the encoded version number corresponding to the Object Attribute version. Return the version on success, UNSUPPORTED on failure. */ obj_attr_version_t _bfd_obj_attrs_version_dec (uint8_t encoded_version) { if (encoded_version == 'A') return OBJ_ATTR_V1; return OBJ_ATTR_VERSION_UNSUPPORTED; } /* Encode the Object Attribute version into a byte. */ uint8_t _bfd_obj_attrs_version_enc (obj_attr_version_t version) { if (version == OBJ_ATTR_V1) return 'A'; abort (); } /* Return the number of bytes needed by I in uleb128 format. */ static uint32_t uleb128_size (uint32_t i) { uint32_t size = 1; while (i >= 0x80) { i >>= 7; size++; } return size; } /* Return TRUE if the attribute has the default value (0/""). */ static bool is_default_attr (obj_attribute *attr) { if (ATTR_TYPE_HAS_ERROR (attr->type)) return true; if (ATTR_TYPE_HAS_INT_VAL (attr->type) && attr->i != 0) return false; if (ATTR_TYPE_HAS_STR_VAL (attr->type) && attr->s && *attr->s) return false; if (ATTR_TYPE_HAS_NO_DEFAULT (attr->type)) return false; return true; } /* Return the vendor name for a given object attributes section. */ static const char * obj_attr_v1_vendor_name (bfd *abfd, int vendor) { return (vendor == OBJ_ATTR_PROC ? get_elf_backend_data (abfd)->obj_attrs_vendor : "gnu"); } /* Return the size of a single attribute. */ static bfd_vma obj_attr_v1_size (unsigned int tag, obj_attribute *attr) { bfd_vma size; if (is_default_attr (attr)) return 0; size = uleb128_size (tag); if (ATTR_TYPE_HAS_INT_VAL (attr->type)) size += uleb128_size (attr->i); if (ATTR_TYPE_HAS_STR_VAL (attr->type)) size += strlen ((char *)attr->s) + 1; return size; } /* Return the size of the object attributes section for VENDOR (OBJ_ATTR_PROC or OBJ_ATTR_GNU), or 0 if there are no attributes for that vendor to record and the vendor is OBJ_ATTR_GNU. */ static bfd_vma vendor_obj_attrs_v1_size (bfd *abfd, int vendor) { bfd_vma size; obj_attribute *attr; obj_attribute_list *list; int i; const char *vendor_name = obj_attr_v1_vendor_name (abfd, vendor); if (!vendor_name) return 0; attr = elf_known_obj_attributes (abfd)[vendor]; size = 0; for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) size += obj_attr_v1_size (i, &attr[i]); for (list = elf_other_obj_attributes (abfd)[vendor]; list; list = list->next) size += obj_attr_v1_size (list->tag, &list->attr); /* NUL 0x1 */ return (size ? size + 10 + strlen (vendor_name) : 0); } static bfd_vma oav1_section_size (bfd *abfd) { bfd_vma size = 0; size = vendor_obj_attrs_v1_size (abfd, OBJ_ATTR_PROC); size += vendor_obj_attrs_v1_size (abfd, OBJ_ATTR_GNU); if (size > 0) size += sizeof (uint8_t); /* */ return size; } /* Return the size of a single attribute. */ static bfd_vma oav2_attr_size (const obj_attr_v2_t *attr, obj_attr_encoding_v2_t type) { bfd_vma size = uleb128_size (attr->tag); switch (type) { case OA_ENC_ULEB128: size += uleb128_size (attr->val.uint); break; case OA_ENC_NTBS: size += strlen (attr->val.string) + 1; /* +1 for '\0'. */ break; default: abort (); } return size; } /* Return the size of a subsection. */ static bfd_vma oav2_subsection_size (const obj_attr_subsection_v2_t *subsec) { bfd_vma size = sizeof (uint32_t); /* */ size += strlen (subsec->name) + 1; /* so +1 for '\0'. */ size += 2 * sizeof (uint8_t); /* */ /* * */ for (const obj_attr_v2_t *attr = subsec->first; attr != NULL; attr = attr->next) size += oav2_attr_size (attr, subsec->encoding); return size; } /* Return the size of a object attributes section. */ static bfd_vma oav2_section_size (bfd *abfd) { const obj_attr_subsection_v2_t *subsec = elf_obj_attr_subsections (abfd).first; if (subsec == NULL) return 0; bfd_vma size = sizeof (uint8_t); /* */ for (; subsec != NULL; subsec = subsec->next) size += oav2_subsection_size (subsec); return size; } /* Return the size of the object attributes section. */ bfd_vma bfd_elf_obj_attr_size (bfd *abfd) { obj_attr_version_t version = elf_obj_attr_version (abfd); switch (version) { case OBJ_ATTR_V1: return oav1_section_size (abfd); case OBJ_ATTR_V2: return oav2_section_size (abfd); case OBJ_ATTR_VERSION_NONE: return 0; default: abort (); } } /* Write VAL in uleb128 format to P, returning a pointer to the following byte. */ static bfd_byte * write_uleb128 (bfd_byte *p, uint32_t val) { bfd_byte c; do { c = val & 0x7f; val >>= 7; if (val) c |= 0x80; *(p++) = c; } while (val); return p; } /* Write attribute ATTR to butter P, and return a pointer to the following byte. */ static bfd_byte * write_obj_attr_v1 (bfd_byte *p, unsigned int tag, obj_attribute *attr) { /* Suppress default entries. */ if (is_default_attr (attr)) return p; p = write_uleb128 (p, tag); if (ATTR_TYPE_HAS_INT_VAL (attr->type)) p = write_uleb128 (p, attr->i); if (ATTR_TYPE_HAS_STR_VAL (attr->type)) { int len; len = strlen (attr->s) + 1; memcpy (p, attr->s, len); p += len; } return p; } /* Write the contents of the object attributes section (length SIZE) for VENDOR to CONTENTS. */ static void write_vendor_obj_attrs_v1 (bfd *abfd, bfd_byte *contents, bfd_vma size, int vendor) { bfd_byte *p; obj_attribute *attr; obj_attribute_list *list; int i; const char *vendor_name = obj_attr_v1_vendor_name (abfd, vendor); size_t vendor_length = strlen (vendor_name) + 1; p = contents; bfd_put_32 (abfd, size, p); p += 4; memcpy (p, vendor_name, vendor_length); p += vendor_length; *(p++) = Tag_File; bfd_put_32 (abfd, size - 4 - vendor_length, p); p += 4; attr = elf_known_obj_attributes (abfd)[vendor]; for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) { unsigned int tag = i; if (get_elf_backend_data (abfd)->obj_attrs_order) tag = get_elf_backend_data (abfd)->obj_attrs_order (i); p = write_obj_attr_v1 (p, tag, &attr[tag]); } for (list = elf_other_obj_attributes (abfd)[vendor]; list; list = list->next) p = write_obj_attr_v1 (p, list->tag, &list->attr); } static void oav1_write_section (bfd *abfd, bfd_byte *buffer, bfd_vma size) { /* This function should only be called for object attributes version 1. */ BFD_ASSERT (elf_obj_attr_version (abfd) == OBJ_ATTR_V1); bfd_byte *p = buffer; const struct elf_backend_data *be = get_elf_backend_data (abfd); /* */ *(p++) = be->obj_attrs_version_enc (elf_obj_attr_version (abfd)); for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor) { bfd_vma vendor_size = vendor_obj_attrs_v1_size (abfd, vendor); if (vendor_size > 0) write_vendor_obj_attrs_v1 (abfd, p, vendor_size, vendor); p += vendor_size; } /* We didn't overrun the buffer. */ BFD_ASSERT (p <= buffer + size); } static bfd_byte * oav2_write_attr (bfd_byte *p, const obj_attr_v2_t *attr, obj_attr_encoding_v2_t type) { p = write_uleb128 (p, attr->tag); switch (type) { case OA_ENC_ULEB128: p = write_uleb128 (p, attr->val.uint); break; case OA_ENC_NTBS: /* +1 for '\0'. */ p = (bfd_byte *) stpcpy ((char *) p, attr->val.string) + 1; break; default: abort (); } return p; } static bfd_byte * oav2_write_subsection (bfd *abfd, const obj_attr_subsection_v2_t *subsec, bfd_byte *p) { /* */ bfd_vma subsec_size = oav2_subsection_size (subsec); bfd_put_32 (abfd, subsec_size, p); p += sizeof (uint32_t); /* */ size_t vendor_name_size = strlen (subsec->name) + 1; /* +1 for '\0'. */ memcpy (p, subsec->name, vendor_name_size); p += vendor_name_size; /* -- -- */ /* */ bfd_put_8 (abfd, subsec->optional, p); ++p; /* */ bfd_put_8 (abfd, obj_attr_encoding_v2_to_u8 (subsec->encoding), p); ++p; /* * */ for (const obj_attr_v2_t *attr = subsec->first; attr != NULL; attr = attr->next) p = oav2_write_attr (p, attr, subsec->encoding); return p; } static bfd_vma oav2_write_section (bfd *abfd, bfd_byte *buffer, bfd_vma size) { /* This function should only be called for object attributes version 2. */ BFD_ASSERT (elf_obj_attr_version (abfd) == OBJ_ATTR_V2); bfd_vma section_size = oav2_section_size (abfd); if (section_size == 0) return 0; bfd_byte *p = buffer; const struct elf_backend_data *be = get_elf_backend_data (abfd); /* */ *(p++) = be->obj_attrs_version_enc (elf_obj_attr_version (abfd)); /* [ ]* */ for (const obj_attr_subsection_v2_t *subsec = elf_obj_attr_subsections (abfd).first; subsec != NULL; subsec = subsec->next) p = oav2_write_subsection (abfd, subsec, p); /* We didn't overrun the buffer. */ BFD_ASSERT (p <= buffer + size); /* We wrote as many data as it was computed by vendor_section_obj_attr_using_subsections_size(). */ BFD_ASSERT (section_size == (bfd_vma) (p - buffer)); return section_size; } static void oav2_sort_subsections (obj_attr_subsection_list_t *plist) { for (obj_attr_subsection_v2_t *subsec = plist->first; subsec != NULL; subsec = subsec->next) LINKED_LIST_MERGE_SORT (obj_attr_v2_t) (subsec, _bfd_elf_obj_attr_v2_cmp); LINKED_LIST_MERGE_SORT (obj_attr_subsection_v2_t) (plist, _bfd_elf_obj_attr_subsection_v2_cmp); } /* Write the contents of the object attributes section to CONTENTS. */ void bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *buffer, bfd_vma size) { if (! abfd->is_linker_output && elf_obj_attr_version (abfd) == OBJ_ATTR_V2) /* Before dumping the data, sort subsections in alphabetical order, and attributes according to their tag in numerical order. This is useful for diagnostic tools so that they dump the same output even if the subsections or their attributes were not declared in the same order in different files. This sorting is only performed in the case of the assembler. In the case of the linker, the subsections and attributes are already sorted by the merge process. */ oav2_sort_subsections (&elf_obj_attr_subsections (abfd)); obj_attr_version_t version = elf_obj_attr_version (abfd); switch (version) { case OBJ_ATTR_V1: oav1_write_section (abfd, buffer, size); break; case OBJ_ATTR_V2: oav2_write_section (abfd, buffer, size); break; default: abort (); } } /* The first two tags in gnu-testing namespace are known (from the perspective of GNU ld), and so have a name and can be initialized to the default value ('0' or NULL) depending on the encoding specified on the subsection. Any tags above 1 will be considered unknown, so will be default initialized in the same way but its status will be set to obj_attr_subsection_v2_unknown. If the tag is unknown, ld can drop it if it is inside an optional subsection, whereas ld will raise an error in a required subsection. Note: the array below has to be sorted by the tag's integer value. */ static const obj_attr_info_t known_attrs_gnu_testing[] = { { .tag = {"GNUTestTag_0", 0} }, { .tag = {"GNUTestTag_1", 1} }, }; /* List of known GNU subsections. Note: this array has to be sorted using the same criteria as in _bfd_elf_obj_attr_subsection_v2_cmp(). */ static const known_subsection_v2_t obj_attr_v2_known_gnu_subsections[] = { { /* Note: the currently set values for the subsection name, its optionality, and encoding are irrelevant for a testing subsection. These values are unused. This entry is only a placeholder for list of known GNU testing tags. */ .subsec_name = NULL, .known_attrs = known_attrs_gnu_testing, .optional = true, .encoding = OA_ENC_ULEB128, .len = ARRAY_SIZE (known_attrs_gnu_testing), }, /* Note for the future: GNU subsections can be added here below. */ }; /* Return True if the given subsection name is part of the reserved testing namespace, i.e. SUBSEC_NAME begins with "gnu-testing". */ static bool gnu_testing_namespace (const char *subsec_name) { return strncmp ("gnu_testing_", subsec_name, 12) == 0; } /* Identify the scope of a subsection from its name. Note: the code below needs to be kept in sync with the code of elf_parse_attrs_subsection_v2() in binutils/readelf.c. */ obj_attr_subsection_scope_v2_t bfd_elf_obj_attr_subsection_v2_scope (const bfd *abfd, const char *subsec_name) { const char *vendor_name = get_elf_backend_data (abfd)->obj_attrs_vendor; obj_attr_subsection_scope_v2_t scope = OA_SUBSEC_PRIVATE; size_t vendor_name_len = strlen (vendor_name); if ((strncmp (subsec_name, vendor_name, vendor_name_len) == 0 && subsec_name[vendor_name_len] == '_') || (strncmp (subsec_name, "gnu_", 4) == 0 && !gnu_testing_namespace (subsec_name))) scope = OA_SUBSEC_PUBLIC; return scope; } /* Search for a subsection matching NAME in the list of subsections known from bfd (generic or backend-specific). Return the subsection information if it is found, or NULL otherwise. */ const known_subsection_v2_t * bfd_obj_attr_v2_identify_subsection (const struct elf_backend_data *bed, const char *name) { /* Check known backend subsections. */ const known_subsection_v2_t *known_subsections = bed->obj_attr_v2_known_subsections; const size_t known_subsections_size = bed->obj_attr_v2_known_subsections_size; for (unsigned i = 0; i < known_subsections_size; ++i) { int cmp = strcmp (known_subsections[i].subsec_name, name); if (cmp == 0) return &known_subsections[i]; else if (cmp > 0) break; } /* Check known GNU subsections. */ /* Note for the future: search known GNU subsections here. Don't forget to skip the first entry (placeholder for GNU testing subsection). */ /* Check whether this subsection is a GNU testing subsection. */ if (gnu_testing_namespace (name)) return &obj_attr_v2_known_gnu_subsections[0]; return NULL; } /* Search for the attribute information associated to TAG in the list of known tags registered in the known subsection SUBSEC. Return the tag information if it is found, NULL otherwise. */ static const obj_attr_info_t * identify_tag (const known_subsection_v2_t *subsec, obj_attr_tag_t tag) { for (unsigned i = 0; i < subsec->len; ++i) { const obj_attr_info_t *known_attr = &subsec->known_attrs[i]; if (known_attr->tag.value == tag) return known_attr; else if (known_attr->tag.value > tag) break; } return NULL; } /* Return the attribute information associated to the pair SUBSEC, TAG if it exists, NULL otherwise. */ const obj_attr_info_t * _bfd_obj_attr_v2_find_known_by_tag (const struct elf_backend_data *bed, const char *subsec_name, obj_attr_tag_t tag) { const known_subsection_v2_t *subsec_info = bfd_obj_attr_v2_identify_subsection (bed, subsec_name); if (subsec_info != NULL) return identify_tag (subsec_info, tag); return NULL; } /* To-string function for the pair . Returns the attribute information associated to TAG if it is found, or "Tag_unknown_" otherwise. */ const char * _bfd_obj_attr_v2_tag_to_string (const struct elf_backend_data *bed, const char *subsec_name, obj_attr_tag_t tag) { const obj_attr_info_t *attr_info = _bfd_obj_attr_v2_find_known_by_tag (bed, subsec_name, tag); if (attr_info != NULL) return xstrdup (attr_info->tag.name); return xasprintf ("Tag_unknown_%"PRIu64, tag); } /* To-string function for the subsection parameter "comprehension". */ const char * bfd_oav2_comprehension_to_string (bool comprehension) { return comprehension ? "optional" : "required"; } /* To-string function for the subsection parameter "encoding". */ const char * bfd_oav2_encoding_to_string (obj_attr_encoding_v2_t encoding) { return (encoding == OA_ENC_ULEB128) ? "ULEB128" : "NTBS"; } /* Return True if the given BFD is an ELF object with the target backend machine code, non-dynamic (i.e. not a shared library), non-executable, not a plugin or created by the linker. False otherwise. */ static bool oav2_relevant_elf_object (const struct bfd_link_info *info, const bfd *const abfd) { const struct elf_backend_data *output_bed = get_elf_backend_data (info->output_bfd); unsigned int elfclass = output_bed->s->elfclass; int elf_machine_code = output_bed->elf_machine_code; return ((abfd->flags & (DYNAMIC | EXEC_P | BFD_PLUGIN | BFD_LINKER_CREATED)) == 0 && bfd_get_flavour (abfd) == bfd_target_elf_flavour && elf_machine_code == get_elf_backend_data (abfd)->elf_machine_code && elfclass == get_elf_backend_data (abfd)->s->elfclass); } /* Structure storing the result of a search in the list of input BFDs. */ typedef struct { /* A pointer to a BFD. This BFD can either point to a file having object attributes, or a candidate file which does not have any. */ bfd *pbfd; /* A boolean indicating whether the file actually contains object attributes. */ bool has_object_attributes; /* A pointer to the section containing the object attributes, if any were found. */ asection *sec; } bfd_search_result_t; /* Checks whether a BFD contains object attributes, and if so search for the relevant section storing them. The name and type of the section have to match with what the backend expects, i.e. elf_backend_obj_attrs_section and elf_backend_obj_attrs_section_type, otherwise the object attributes section won't be recognized as such, and will be skipped. Return True if an object attribute section is found, False otherwise. */ static bool input_bfd_has_object_attributes (const struct bfd_link_info *info, bfd *abfd, bfd_search_result_t *res) { /* The file may contain object attributes. Save this candidate. */ res->pbfd = abfd; if (elf_obj_attr_subsections (abfd).size == 0) return false; res->has_object_attributes = true; uint32_t sec_type = get_elf_backend_data (abfd)->obj_attrs_section_type; const char *sec_name = get_elf_backend_data (abfd)->obj_attrs_section; res->sec = bfd_get_section_by_name (abfd, sec_name); if (res->sec != NULL) { if (elf_section_type (res->sec) != sec_type) { info->callbacks->minfo (_("%X%pB: warning: ignoring section '%s' with unexpected type %#x\n"), abfd, sec_name, elf_section_type (res->sec)); res->sec = NULL; } } return (res->sec != NULL); } /* Search for the first input object file containing object attributes. If no such object is found, the result structure's PBFD points to the last object file that could have contained object attributes. The result structure's HAS_OBJECT_ATTRIBUTES allows to distinguish the cases when PBFD contains or does not contain object attributes. If no candidate file is found, PBFD will stay NULL. */ static bfd_search_result_t bfd_linear_find_first_with_obj_attrs (const struct bfd_link_info *info) { bfd_search_result_t res = { .has_object_attributes = false }; for (bfd *abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) { if (oav2_relevant_elf_object (info, abfd) && abfd->section_count != 0 && input_bfd_has_object_attributes (info, abfd, &res)) break; } return res; } /* Create a object attributes section for the given bfd input. */ static asection * create_object_attributes_section (struct bfd_link_info *info, bfd *abfd) { asection *sec; const char *sec_name = get_elf_backend_data (abfd)->obj_attrs_section; sec = bfd_make_section_with_flags (abfd, sec_name, (SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA)); if (sec == NULL) info->callbacks->fatal (_("%P: failed to create %s section\n"), sec_name); if (!bfd_set_section_alignment (sec, 2)) info->callbacks->fatal (_("%pA: failed to align section\n"), sec); elf_section_type (sec) = get_elf_backend_data (abfd)->obj_attrs_section_type; bfd_set_section_size (sec, bfd_elf_obj_attr_size (abfd)); return sec; } /* Translate GNU properties that have object attributes v2 equivalents. */ static void oav2_translate_gnu_props_to_obj_attrs (const bfd *abfd) { const struct elf_backend_data *be = get_elf_backend_data (abfd); if (be->translate_gnu_props_to_obj_attrs == NULL) return; for (const elf_property_list *p = elf_properties (abfd); p != NULL; p = p->next) be->translate_gnu_props_to_obj_attrs (abfd, p); } /* Translate object attributes v2 that have GNU properties equivalents. */ static void oav2_translate_obj_attrs_to_gnu_props (bfd *abfd) { const struct elf_backend_data *be = get_elf_backend_data (abfd); if (be->translate_obj_attrs_to_gnu_props == NULL) return; for (const obj_attr_subsection_v2_t *subsec = elf_obj_attr_subsections (abfd).first; subsec != NULL; subsec = subsec->next) be->translate_obj_attrs_to_gnu_props (abfd, subsec); } /* Compact duplicated tag declarations in a subsection. Return True on success, False if any issue is found during the compaction, i.e. conflicting values for the same tag. */ static bool oav2_compact_tags (const bfd *abfd, obj_attr_subsection_v2_t *subsec) { bool success = true; for (obj_attr_v2_t *a = subsec->first; a != NULL && a->next != NULL;) { if (a->tag != a->next->tag) { a = a->next; continue; } /* For NTBS encoding, ensure that the string value of the attributes is not NULL. Note: a string attribute can only be NULL if it was created during the merge process. Since tag compaction occurs before merging begins, this assertion guarantees that the function is never called in a context where the assumption does not hold. */ BFD_ASSERT (subsec->encoding == OA_ENC_ULEB128 || (a->val.string != NULL && a->next->val.string != NULL)); /* Values of a tag are the same, we remove the duplicate. */ if ((subsec->encoding == OA_ENC_ULEB128 && a->val.uint == a->next->val.uint) || (subsec->encoding == OA_ENC_NTBS && strcmp (a->val.string, a->next->val.string) == 0)) { obj_attr_v2_t *dup_attr = a->next; LINKED_LIST_REMOVE (obj_attr_v2_t) (subsec, dup_attr); _bfd_elf_obj_attr_v2_free (dup_attr, subsec->encoding); continue; } /* The values of a tag are different, there are various options: - the tag values can be merged. This requires a knowledge of a tag merge policy, sometimes generic, sometimes only known from the target backend. Since no such complex case exists for now, it is not implemented. - values for a given tag have to be the same in the same subsection, or it raises an error. This will be the default handling for now. */ success = false; const char *tag_s = _bfd_obj_attr_v2_tag_to_string (get_elf_backend_data (abfd), subsec->name, a->tag); if (subsec->encoding == OA_ENC_ULEB128) _bfd_error_handler (_("%pB: error: found duplicated attributes '%s' with conflicting " "values (%#x vs %#x) in subsection %s"), abfd, tag_s, a->val.uint, a->next->val.uint, subsec->name); else /* (subsec->encoding == OA_ENC_NTBS) */ _bfd_error_handler (_("%pB: error: found duplicated attributes '%s' with conflicting " "values ('%s' vs '%s') in subsection %s"), abfd, tag_s, a->val.string, a->next->val.string, subsec->name); free ((char *) tag_s); /* We skip the tag, and continue the compaction of tags to find further issues (if any). */ a = a->next; } return success; } /* Merge two subsections together (object attributes v2 only). The result is stored into subsec1. subsec2 is destroyed. Return true if the merge was successful, false otherwise. Note: subsec1 and subsec2 are expected to be sorted before the call to this function. */ static bool oav2_subsection_destructive_merge (const bfd *abfd, obj_attr_subsection_v2_t *subsec1, obj_attr_subsection_v2_t *subsec2) { BFD_ASSERT (subsec1->encoding == subsec2->encoding && subsec1->optional == subsec2->optional); bool success = true; success &= oav2_compact_tags (abfd, subsec1); success &= oav2_compact_tags (abfd, subsec2); obj_attr_v2_t *a1 = subsec1->first; obj_attr_v2_t *a2 = subsec2->first; while (a1 != NULL && a2 != NULL) { if (a1->tag < a2->tag) {} /* Nothing to do, a1 is already in subsec1. */ else if (a1->tag > a2->tag) { /* a2 is missing in subsec1, add it. */ obj_attr_v2_t *previous = LINKED_LIST_REMOVE (obj_attr_v2_t) (subsec2, a2); LINKED_LIST_INSERT_BEFORE (obj_attr_v2_t) (subsec1, a2, a1); a2 = previous; } else { const char *tag_s = NULL; if (subsec1->encoding == OA_ENC_ULEB128 && a1->val.uint != a2->val.uint) { success = false; tag_s = _bfd_obj_attr_v2_tag_to_string (get_elf_backend_data (abfd), subsec1->name, a1->tag); _bfd_error_handler (_("%pB: error: found 2 subsections with the same name '%s' " "and found conflicting values (%#x vs %#x) for object " "attribute '%s'"), abfd, subsec1->name, a1->val.uint, a2->val.uint, tag_s); } else if (subsec1->encoding == OA_ENC_NTBS && strcmp (a1->val.string, a2->val.string) != 0) { success = false; tag_s = _bfd_obj_attr_v2_tag_to_string (get_elf_backend_data (abfd), subsec1->name, a1->tag); _bfd_error_handler (_("%pB: error: found 2 subsections with the same name '%s' " "and found conflicting values ('%s' vs '%s') for object " "attribute '%s"), abfd, subsec1->name, a1->val.string, a2->val.string, tag_s); } free ((char *) tag_s); } a1 = a1->next; a2 = a2->next; } for (; a2 != NULL; a2 = a2->next) { /* a2 is missing in subsec1, add it. */ obj_attr_v2_t *previous = LINKED_LIST_REMOVE (obj_attr_v2_t) (subsec2, a2); LINKED_LIST_INSERT_BEFORE (obj_attr_v2_t) (subsec1, a2, a1); a2 = previous; } /* If a1 != NULL, we don't care since it is already in subsec1. */ /* Destroy subsec2 before exiting. */ _bfd_elf_obj_attr_subsection_v2_free (subsec2); return success; } /* Merge duplicated subsections and object attributes inside a same object file. After a call to this function, the subsections and object attributes are sorted. Note: this function allows to handle in a best effort exotic objects produced by a non-GNU assembler. Duplicated subsections could come from the same section, or different ones. Indeed, the deserializer deserializes the content of a section if its type matches the object attributes type specified by the backend, regardless of the section name. The behavior for such cases is not specified by the Object Attributes specification, and are a question of implementation. Non-GNU linkers might have a different behavior with such exotic objects. */ static bool oav2_file_scope_merge_subsections (const bfd *abfd) { obj_attr_subsection_list_t *subsecs = &elf_obj_attr_subsections (abfd); /* Sort all the subsections and object attributes as they might not have been inserted in the right order. From now on, the subsections and attributes will be assumed to be always sorted. Any additive mutation will need to preserve the order. */ oav2_sort_subsections (subsecs); bool success = true; obj_attr_subsection_v2_t *subsec = subsecs->first; while (subsec != NULL && subsec->next != NULL) { obj_attr_subsection_v2_t *dup_subsec = bfd_obj_attr_subsection_v2_find_by_name (subsec->next, subsec->name, false); if (dup_subsec != NULL) { LINKED_LIST_REMOVE (obj_attr_subsection_v2_t) (subsecs, dup_subsec); success &= oav2_subsection_destructive_merge (abfd, subsec, dup_subsec); } else subsec = subsec->next; } return success; } /* If an Object Attribute subsection inside ABFD cannot be identified neither as a GNU subsection or a backend-specific one, set the status of this subsection to UNKNOWN. The unknown subsection will be skipped during the merge process, and will be pruned from the output. */ static void oav2_subsections_mark_unknown (const bfd *abfd) { const struct elf_backend_data *bed = get_elf_backend_data (abfd); for (obj_attr_subsection_v2_t *subsec = elf_obj_attr_subsections (abfd).first; subsec != NULL; subsec = subsec->next) { if (bfd_obj_attr_v2_identify_subsection (bed, subsec->name) == NULL) subsec->status = obj_attr_subsection_v2_unknown; } } /* Initialize the given ATTR with its default value coming from the known tag registry. */ static void oav2_attr_overwrite_with_default (const struct bfd_link_info *info, const obj_attr_subsection_v2_t *subsec, obj_attr_v2_t *attr) { const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd); const obj_attr_info_t *attr_info = _bfd_obj_attr_v2_find_known_by_tag (bed, subsec->name, attr->tag); if (attr_info == NULL) { attr->status = obj_attr_v2_unknown; if (subsec->encoding == OA_ENC_ULEB128) attr->val.uint = 0; else attr->val.string = NULL; return; } if (bed->obj_attr_v2_default_value != NULL && bed->obj_attr_v2_default_value (info, attr_info, subsec, attr)) {} else if (subsec->encoding == OA_ENC_NTBS) { if (attr->val.string != NULL) { free ((void *) attr->val.string); attr->val.string = NULL; } if (attr_info->default_value.string != NULL) attr->val.string = xstrdup (attr_info->default_value.string); } else attr->val.uint = attr_info->default_value.uint; } /* Create a new attribute with the same key (=tag) as ATTR, and initialized with its default value from the known tag registry. */ static obj_attr_v2_t * oav2_attr_default (const struct bfd_link_info *info, const obj_attr_subsection_v2_t *subsec, const obj_attr_v2_t *attr) { obj_attr_v2_t *new_attr = _bfd_elf_obj_attr_v2_copy (attr, subsec->encoding); oav2_attr_overwrite_with_default (info, subsec, new_attr); return new_attr; } /* The currently supported merge policy in the testing GNU namespace. - bitwise AND: apply bitwise AND. - bitwise OR: apply bitwise OR. - String-ADD: concatenates strings together with a '+' in-between. Note: Such policies should only be used for testing. */ typedef enum { SUBSECTION_TESTING_MERGE_UNSUPPORTED = 0, SUBSECTION_TESTING_MERGE_AND_POLICY = 1, SUBSECTION_TESTING_MERGE_OR_POLICY = 2, SUBSECTION_TESTING_MERGE_ADD_POLICY = 3, } gnu_testing_merge_policy; /* Determine which merge policy will be applied to SUBSEC. The GNU policy are detected from the name of the subsection. It should follow the following pattern: "gnu_testing_XXXXXX_MERGE_". Return one of the known merge policy if recognised, UNSUPPORTED otherwise. */ static gnu_testing_merge_policy gnu_testing_merge_subsection (const char *subsec_name) { if (! gnu_testing_namespace (subsec_name)) return SUBSECTION_TESTING_MERGE_UNSUPPORTED; size_t subsec_name_len = strlen (subsec_name); if (strcmp ("_MERGE_AND", subsec_name + subsec_name_len - 10) == 0) return SUBSECTION_TESTING_MERGE_AND_POLICY; else if (strcmp ("_MERGE_OR", subsec_name + subsec_name_len - 9) == 0) return SUBSECTION_TESTING_MERGE_OR_POLICY; else if (strcmp ("_MERGE_ADD", subsec_name + subsec_name_len - 10) == 0) return SUBSECTION_TESTING_MERGE_ADD_POLICY; else return SUBSECTION_TESTING_MERGE_UNSUPPORTED; } /* Merge policy Integer-AND: apply bitwise AND between REF and RHS. */ obj_attr_v2_merge_result_t _bfd_obj_attr_v2_merge_AND (const struct bfd_link_info *info ATTRIBUTE_UNUSED, const bfd *abfd ATTRIBUTE_UNUSED, const obj_attr_subsection_v2_t *subsec, const obj_attr_v2_t *ref, const obj_attr_v2_t *rhs, const obj_attr_v2_t *frozen ATTRIBUTE_UNUSED) { BFD_ASSERT (subsec->encoding == OA_ENC_ULEB128); obj_attr_v2_merge_result_t res; res.val.uint = (ref->val.uint & rhs->val.uint); res.merge = (res.val.uint != ref->val.uint); res.reason = (!res.merge ? OAv2_MERGE_SAME_VALUE_AS_REF : OAv2_MERGE_OK); return res; } /* Merge policy Integer-OR: apply bitwise OR between REF and RHS. */ static obj_attr_v2_merge_result_t obj_attr_v2_merge_OR (const struct bfd_link_info *info ATTRIBUTE_UNUSED, const bfd *abfd ATTRIBUTE_UNUSED, const obj_attr_subsection_v2_t *subsec, const obj_attr_v2_t *ref, const obj_attr_v2_t *rhs, const obj_attr_v2_t *frozen ATTRIBUTE_UNUSED) { BFD_ASSERT (subsec->encoding == OA_ENC_ULEB128); obj_attr_v2_merge_result_t res; res.val.uint = (ref->val.uint | rhs->val.uint); res.merge = (res.val.uint != ref->val.uint); res.reason = (!res.merge ? OAv2_MERGE_SAME_VALUE_AS_REF : OAv2_MERGE_OK); return res; } /* Merge policy String-ADD: concatenates strings from REF and RHS together adding a '+' character in-between. */ static obj_attr_v2_merge_result_t obj_attr_v2_merge_ADD (const struct bfd_link_info *info ATTRIBUTE_UNUSED, const bfd *abfd ATTRIBUTE_UNUSED, const obj_attr_subsection_v2_t *subsec, const obj_attr_v2_t *ref, const obj_attr_v2_t *rhs, const obj_attr_v2_t *frozen ATTRIBUTE_UNUSED) { BFD_ASSERT (subsec->encoding == OA_ENC_NTBS); obj_attr_v2_merge_result_t res = { .merge = false, .val.string = NULL, .reason = OAv2_MERGE_OK, }; /* Note: FROZEN is unused for this "concatenating" merge because it is either passed as RHS when coming from oav2_subsections_merge_frozen(), or passed as FROZEN when coming from oav2_subsections_merge() and was already merged. */ /* REF and RHS have both a value. Concatenate RHS to REF. */ if (ref->val.string && rhs->val.string) { res.merge = true; size_t ref_s_size = strlen (ref->val.string); size_t rhs_s_size = strlen (rhs->val.string); char *buffer = xmalloc (ref_s_size + 1 + rhs_s_size + 1); res.val.string = buffer; memcpy (buffer, ref->val.string, ref_s_size); buffer += ref_s_size; *buffer = '+'; ++buffer; memcpy (buffer, rhs->val.string, rhs_s_size + 1); } /* REF has a value, but RHS does not. Nothing to do. */ else if (ref->val.string) res.reason = OAv2_MERGE_SAME_VALUE_AS_REF; /* No previous value in REF. RHS is the new value. */ else if (rhs->val.string) { /* This case could be optimized to avoid the dynamic allocation by moving the value from RHS to RES, but then, we need to distinguish the case when RHS and FROZEN are the same, and in this case, the value should not be moved but copied. The little benefit is not worth the added complexity. */ res.merge = true; res.val.string = xstrdup (rhs->val.string); } return res; } /* Return the merge result between attributes LHS, RHS and FROZEN. Note: FROZEN_IS_RHS indicates that FROZEN is in RHS's position. This happens when this function is called from oav2_subsections_merge_frozen(). When this boolean is true, arguments are swapped to get the correct diagnostic messages in case of issues. */ static obj_attr_v2_merge_result_t oav2_attr_merge (const struct bfd_link_info *info, const bfd *abfd, const obj_attr_subsection_v2_t *subsec, const obj_attr_v2_t *lhs, const obj_attr_v2_t *rhs, const obj_attr_v2_t *frozen, bool frozen_is_rhs) { obj_attr_v2_merge_result_t res = { .merge = false, .val.uint = 0, .reason = OAv2_MERGE_OK, }; gnu_testing_merge_policy policy; if (get_elf_backend_data (abfd)->obj_attr_v2_tag_merge != NULL) { /* If FROZEN is RHS (i.e. called from oav2_subsections_merge_frozen()), it means that the merged value of LHS (the REF) and FROZEN is going to be merged by the caller into LHS. However, since diagnostic messages always point to RHS, we need to swap LHS and RHS, so that ABFD is not associated wrongly to FROZEN. */ if (frozen_is_rhs) { const obj_attr_v2_t *tmp = lhs; lhs = rhs; rhs = tmp; } res = get_elf_backend_data (abfd)->obj_attr_v2_tag_merge (info, abfd, subsec, lhs, rhs, frozen); if (res.merge || res.reason == OAv2_MERGE_SAME_VALUE_AS_REF) return res; } /* Note for the future: the merge of generic object attributes should be added here, between the architecture-specific merge, and the reserved GNU testing namespace. */ /* GNU testing merge policies are looked up last. */ if ((res.reason == OAv2_MERGE_UNSUPPORTED || res.reason == OAv2_MERGE_OK) && (policy = gnu_testing_merge_subsection (subsec->name)) != SUBSECTION_TESTING_MERGE_UNSUPPORTED) { /* Only the first two attributes can be merged, others won't and will be discarded. */ if (lhs->tag <= 1) { if (policy == SUBSECTION_TESTING_MERGE_AND_POLICY) res = _bfd_obj_attr_v2_merge_AND (info, abfd, subsec, lhs, rhs, frozen); else if (policy == SUBSECTION_TESTING_MERGE_OR_POLICY) res = obj_attr_v2_merge_OR (info, abfd, subsec, lhs, rhs, frozen); else if (policy == SUBSECTION_TESTING_MERGE_ADD_POLICY) res = obj_attr_v2_merge_ADD (info, abfd, subsec, lhs, rhs, frozen); return res; } } /* Nothing matched, thus the merge of this tag is unsupported. */ res.reason = OAv2_MERGE_UNSUPPORTED; return res; } /* Append a new default-initialized attribute with the same key as AREF to the given subsection. */ static void oav2_subsection_append_attr_default (const struct bfd_link_info *info, obj_attr_subsection_v2_t *s_abfd_missing, const obj_attr_v2_t *a_ref) { obj_attr_v2_t *new_attr = oav2_attr_default (info, s_abfd_missing, a_ref); LINKED_LIST_APPEND (obj_attr_v2_t) (s_abfd_missing, new_attr); } /* Return a new default-initialized subsection with the same parameters as SUBSEC. */ static obj_attr_subsection_v2_t * oav2_subsection_default_new (const struct bfd_link_info *info, const obj_attr_subsection_v2_t *subsec) { obj_attr_subsection_v2_t *new_subsec = bfd_elf_obj_attr_subsection_v2_init (xstrdup (subsec->name), subsec->scope, subsec->optional, subsec->encoding); for (const obj_attr_v2_t *attr = subsec->first; attr != NULL; attr = attr->next) oav2_subsection_append_attr_default (info, new_subsec, attr); return new_subsec; } /* Report missing required attribute with key TAG in subsection SREF. */ static void report_missing_required_obj_attr (const struct bfd_link_info *info, const bfd *abfd, const obj_attr_subsection_v2_t *s_ref, const obj_attr_tag_t tag) { const struct elf_backend_data *bed = get_elf_backend_data (abfd); const char *tag_s = _bfd_obj_attr_v2_tag_to_string (bed, s_ref->name, tag); info->callbacks->einfo ( _("%X%pB: error: missing required object attribute '%s' in subsection '%s'\n"), abfd, tag_s, s_ref->name); free ((char *) tag_s); } /* Report required attribute A_ABFD mismatching with A_REF. */ static void report_mismatching_required_obj_attr (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, const obj_attr_subsection_v2_t *s_ref, const obj_attr_v2_t *a_ref, const obj_attr_v2_t *a_abfd) { const struct elf_backend_data *bed = get_elf_backend_data (abfd); const char *tag_s = _bfd_obj_attr_v2_tag_to_string (bed, s_ref->name, a_ref->tag); if (s_ref->encoding == OA_ENC_ULEB128) { info->callbacks->einfo ( _("%X%pB: error: mismatching value for required object attribute '%s' " "in subsection '%s': %#x\n"), abfd, tag_s, s_ref->name, a_abfd->val.uint); info->callbacks->info ( _("%pB: info: conflicting value '%#x' lives here\n"), ref_bfd, a_ref->val.uint); } else { info->callbacks->einfo ( _("%X%pB: error: mismatching value for required object attribute '%s' " "in subsection '%s': \"%s\"\n"), abfd, tag_s, s_ref->name, a_abfd->val.string); info->callbacks->info ( _("%pB: info: conflicting value \"%s\" lives here\n"), ref_bfd, a_ref->val.string); } free ((char *) tag_s); } /* Attempt a perfect match between subsections S_REF and S_ABFD, and reports errors for any mismatch. Return S_REF if the subsections match, NULL otherwise.*/ static obj_attr_subsection_v2_t * oav2_subsection_perfect_match (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, obj_attr_subsection_v2_t *s_ref, const obj_attr_subsection_v2_t *s_abfd) { bool success = true; const obj_attr_v2_t *a_ref = s_ref->first; const obj_attr_v2_t *a_abfd = s_abfd->first; while (a_ref != NULL && a_abfd != NULL) { if (a_ref->tag < a_abfd->tag) { success = false; report_missing_required_obj_attr (info, abfd, s_ref, a_ref->tag); a_ref = a_ref->next; } else if (a_ref->tag > a_abfd->tag) { success = false; report_missing_required_obj_attr (info, ref_bfd, s_ref, a_abfd->tag); a_abfd = a_abfd->next; } else { if (s_ref->encoding == OA_ENC_ULEB128) { if (a_ref->val.uint != a_abfd->val.uint) { success = false; report_mismatching_required_obj_attr (info, ref_bfd, abfd, s_ref, a_ref, a_abfd); } } else if (s_ref->encoding == OA_ENC_NTBS) { if (strcmp (a_ref->val.string, a_abfd->val.string) != 0) { success = false; report_mismatching_required_obj_attr (info, ref_bfd, abfd, s_ref, a_ref, a_abfd); } } a_ref = a_ref->next; a_abfd = a_abfd->next; } } for (; a_abfd != NULL; a_abfd = a_abfd->next) { success = false; report_missing_required_obj_attr (info, ref_bfd, s_ref, a_abfd->tag); } for (; a_ref != NULL; a_ref = a_ref->next) { success = false; report_missing_required_obj_attr (info, abfd, s_ref, a_ref->tag); } return success ? s_ref : NULL; } /* Search for the attribute with TAG into a list of attributes. The attributes list is assumed to be sorted. Return the pointer to the attribute with TAG if found, NULL otherwise. */ static obj_attr_v2_t * oav2_search_by_tag (obj_attr_v2_t *attr_first, obj_attr_tag_t tag) { for (obj_attr_v2_t *attr = attr_first; attr != NULL; attr = attr->next) { if (attr->tag == tag) return attr; else if (attr->tag > tag) break; } return NULL; } /* Merge optional subsection S_ABFD into S_REF. S_FROZEN is used to report any issue with the selected configuration, and to force the merge value to a specific value if needed. */ static obj_attr_subsection_v2_t * handle_optional_subsection_merge (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, obj_attr_subsection_v2_t *s_ref, const obj_attr_subsection_v2_t *s_abfd, const obj_attr_subsection_v2_t *s_frozen) { (void) info; /* REF_BFD and ABFD are the same only when the call originated from oav2_subsections_merge_frozen(), when FROZEN is merged into ABFD (the future REF_BFD). See detailed explanation in oav2_attr_merge(). */ bool frozen_is_abfd = (ref_bfd == abfd); obj_attr_v2_t *a_ref = s_ref->first; const obj_attr_v2_t *a_abfd = s_abfd->first; obj_attr_v2_t *a_frozen_first = (s_frozen != NULL) ? s_frozen->first : NULL; while (a_ref != NULL && a_abfd != NULL) { uint32_t searched_frozen_tag = (a_ref->tag < a_abfd->tag ? a_ref->tag : a_abfd->tag); obj_attr_v2_t *a_frozen = oav2_search_by_tag (a_frozen_first, searched_frozen_tag); if (a_frozen != NULL) a_frozen_first = a_frozen; if (a_ref->tag < a_abfd->tag) { obj_attr_v2_t *a_default = oav2_attr_default (info, s_abfd, a_ref); obj_attr_v2_merge_result_t res = oav2_attr_merge (info, abfd, s_ref, a_ref, a_default, a_frozen, frozen_is_abfd); _bfd_elf_obj_attr_v2_free (a_default, s_ref->encoding); if (res.merge) a_ref->val = res.val; else if (res.reason == OAv2_MERGE_UNSUPPORTED) a_ref->status = obj_attr_v2_unknown; a_ref = a_ref->next; } else if (a_ref->tag > a_abfd->tag) { obj_attr_v2_t *a_default = oav2_attr_default (info, s_ref, a_abfd); obj_attr_v2_merge_result_t res = oav2_attr_merge (info, abfd, s_ref, a_default, a_abfd, a_frozen, frozen_is_abfd); if (res.merge || res.reason == OAv2_MERGE_SAME_VALUE_AS_REF) { a_default->val = res.val; LINKED_LIST_INSERT_BEFORE (obj_attr_v2_t) (s_ref, a_default, a_ref); } else _bfd_elf_obj_attr_v2_free (a_default, s_ref->encoding); a_abfd = a_abfd->next; } else { obj_attr_v2_merge_result_t res = oav2_attr_merge (info, abfd, s_ref, a_ref, a_abfd, a_frozen, frozen_is_abfd); if (res.merge) a_ref->val = res.val; else if (res.reason == OAv2_MERGE_UNSUPPORTED) a_ref->status = obj_attr_v2_unknown; a_ref = a_ref->next; a_abfd = a_abfd->next; } } for (; a_abfd != NULL; a_abfd = a_abfd->next) { obj_attr_v2_t *a_default = oav2_attr_default (info, s_ref, a_abfd); obj_attr_v2_merge_result_t res = oav2_attr_merge (info, abfd, s_ref, a_default, a_abfd, NULL, false); if (res.merge || res.reason == OAv2_MERGE_SAME_VALUE_AS_REF) { a_default->val = res.val; LINKED_LIST_APPEND (obj_attr_v2_t) (s_ref, a_default); } else _bfd_elf_obj_attr_v2_free (a_default, s_ref->encoding); } for (; a_ref != NULL; a_ref = a_ref->next) { obj_attr_v2_t *a_frozen = oav2_search_by_tag (a_frozen_first, a_ref->tag); if (a_frozen != NULL) a_frozen_first = a_frozen; obj_attr_v2_t *a_default = oav2_attr_default (info, s_abfd, a_ref); obj_attr_v2_merge_result_t res = oav2_attr_merge (info, abfd, s_ref, a_ref, a_default, a_frozen, frozen_is_abfd); _bfd_elf_obj_attr_v2_free (a_default, s_ref->encoding); if (res.merge) a_ref->val = res.val; else if (res.reason == OAv2_MERGE_UNSUPPORTED) a_ref->status = obj_attr_v2_unknown; } return s_ref; } /* Merge case 1: S_ABFD and S_REF exists, so merge S_ABFD into S_REF. */ static obj_attr_subsection_v2_t * handle_subsection_merge (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, obj_attr_subsection_v2_t *s_ref, const obj_attr_subsection_v2_t *s_abfd, const obj_attr_subsection_v2_t *s_frozen) { if (! s_ref->optional) return oav2_subsection_perfect_match (info, ref_bfd, abfd, s_ref, s_abfd); return handle_optional_subsection_merge (info, ref_bfd, abfd, s_ref, s_abfd, s_frozen); } /* Merge case 2: S_ABFD does not exist, but S_REF does. 1. Create a new default-initialized S_ABFD. 2. Merge S_ABFD into S_REF. */ static bool handle_subsection_missing (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, obj_attr_subsection_v2_t *s_ref, const obj_attr_subsection_v2_t *s_frozen) { if (! s_ref->optional) { info->callbacks->einfo (_("%X%pB: error: missing required object attributes subsection %s\n"), abfd, s_ref->name); return false; } /* Compute default values of the missing attributes in ABFD, but present in REF, and merge ABFD's generated subsection with the one of REF. */ obj_attr_subsection_v2_t *s_abfd = oav2_subsection_default_new (info, s_ref); const obj_attr_subsection_v2_t *merged = handle_subsection_merge (info, ref_bfd, abfd, s_ref, s_abfd, s_frozen); _bfd_elf_obj_attr_subsection_v2_free (s_abfd); return merged != NULL; } /* Merge case 3: S_ABFD does not have a S_REF equivalent. 1. Create a new default-initialized S_REF subsection. 2. Merge S_ABFD into S_REF. 3. Insert S_REF into REF before S_REF_NEXT. */ static bool handle_subsection_additional (const struct bfd_link_info *info, const bfd *ref_bfd, const bfd *abfd, obj_attr_subsection_v2_t *s_ref_next, const obj_attr_subsection_v2_t *s_abfd, const obj_attr_subsection_v2_t *s_frozen) { if (! s_abfd->optional) { info->callbacks->einfo (_("%X%pB: error: missing required object attributes subsection %s\n"), ref_bfd, s_abfd->name); return false; } /* Compute default values of the missing attributes in REF, but present in ABFD, and merge REF's generated subsection with the one of ABFD. */ obj_attr_subsection_v2_t *s_ref = oav2_subsection_default_new (info, s_abfd); obj_attr_subsection_v2_t *s_merged = handle_subsection_merge (info, ref_bfd, abfd, s_ref, s_abfd, s_frozen); if (s_merged != NULL) { LINKED_LIST_INSERT_BEFORE (obj_attr_subsection_v2_t) (&elf_obj_attr_subsections (ref_bfd), s_merged, s_ref_next); } else /* An issue occurred during the merge. s_ref won't be saved so it needs to be freed. */ _bfd_elf_obj_attr_subsection_v2_free (s_ref); return (s_merged != NULL); } /* Check whether a subsection is known, and if so, whether the current properties of the subsection match the expected ones. Return True if the subsection is known, AND all the properties of the subsection match the expected. False otherwise. */ static bool oav2_subsection_match_known (const struct bfd_link_info *info, const bfd *abfd, const obj_attr_subsection_v2_t *subsec) { const known_subsection_v2_t *subsec_info = bfd_obj_attr_v2_identify_subsection (get_elf_backend_data (abfd), subsec->name); if (subsec_info == NULL) return false; bool match = true; if (subsec_info->encoding != subsec->encoding) { info->callbacks->einfo (_("%X%pB: error: <%s> property of subsection '%s' was " "incorrectly set. Got '%s', expected '%s'\n"), abfd, "encoding", subsec->name, bfd_oav2_encoding_to_string (subsec->encoding), bfd_oav2_encoding_to_string (subsec_info->encoding)); match = false; } if (subsec_info->optional != subsec->optional) { info->callbacks->einfo (_("%X%pB: error: <%s> property of subsection '%s' was " "incorrectly set. Got '%s', expected '%s'\n"), abfd, "comprehension", subsec->name, bfd_oav2_comprehension_to_string (subsec->optional), bfd_oav2_comprehension_to_string (subsec_info->optional)); match = false; } return match; } /* Check whether the properties of the subsections S1 and S2 match. Return True if the properties match, False otherwise. */ static bool oav2_subsection_generic_params_match (const struct bfd_link_info *info, const bfd *f1, const bfd *f2, const obj_attr_subsection_v2_t *s1, const obj_attr_subsection_v2_t *s2) { bool match = (s1->encoding == s2->encoding && s1->optional == s2->optional); if (! match) { if (f1 != NULL) { info->callbacks->einfo ( _("%X%pB: error: mismatching properties of subsection '%s'\n"), f2, s1->name); info->callbacks->info ( _("%pB: info: conflicting properties (%s, %s) live here\n"), f1, bfd_oav2_comprehension_to_string (s1->optional), bfd_oav2_encoding_to_string (s1->encoding)); info->callbacks->info ( _("info: (%s, %s) VS (%s, %s)\n"), bfd_oav2_comprehension_to_string (s2->optional), bfd_oav2_encoding_to_string (s2->encoding), bfd_oav2_comprehension_to_string (s1->optional), bfd_oav2_encoding_to_string (s1->encoding)); } else { info->callbacks->einfo ( _("%X%pB: error: corrupted properties in subsection '%s'\n"), f2, s1->name); info->callbacks->info ( _("info: (%s, %s) VS (%s, %s)\n"), bfd_oav2_comprehension_to_string (s2->optional), bfd_oav2_encoding_to_string (s2->encoding), bfd_oav2_comprehension_to_string (s1->optional), bfd_oav2_encoding_to_string (s1->encoding)); } } return match; } /* Check for mismatch between the parameters of subsections S1 and S2. Return True if the parameters mismatch, False otherwise. Note: F1 can be null when comparing FROZEN and the first object file used to store the merge result. If an error is reported, it means that one of the definition of S1 or S2 is corrupted. Most likely S2 because it is a user input, or S1 if it is a programmation error of FROZEN. In the second case, please raise a bug to binutils bug tracker. */ static bool oav2_subsection_mismatching_params (const struct bfd_link_info *info, const bfd *f1, const bfd *f2, const obj_attr_subsection_v2_t *s1, const obj_attr_subsection_v2_t *s2) { if (gnu_testing_namespace (s2->name)) return ! oav2_subsection_generic_params_match (info, f1, f2, s1, s2); /* Check whether the subsection is known, and if so, match against the expected properties. Note: this piece of code must be guarded against gnu-testing subsections, as oav2_subsection_match_known() looks up at the known subsections. Since the "fictive" entry for gnu-testing known subsection has random values for its encoding and optionality, it won't be able to detect mismatching parameters correctly. */ return ! oav2_subsection_match_known (info, f2, s2); } /* Merge object attributes from FROZEN into the object file ABFD. Note: this function is called only once before starting the merge process between the object files. ABFD corresponds to the future REF_BFD, and is used to store the result of the merge. ABFD is also an input file, so any mismatch against FROZEN should be raised before the values of ABFD be modified. */ static bool oav2_subsections_merge_frozen (const struct bfd_link_info *info, const bfd *abfd, const obj_attr_subsection_list_t *frozen_cfg) { const obj_attr_subsection_v2_t *s_frozen = frozen_cfg->first; if (s_frozen == NULL) return true; bool success = true; /* Note: all the handle_subsection_* functions call oav2_attr_merge() down the stack. Passing ABFD as REF_BFD allows to detect that this function is the caller. Then a special behavior in oav2_attr_merge() is triggered for this specific use case, so that we can obtain the right diagnostics. */ obj_attr_subsection_v2_t *s_abfd = elf_obj_attr_subsections (abfd).first; while (s_frozen != NULL && s_abfd != NULL) { int cmp = strcmp (s_abfd->name, s_frozen->name); if (cmp < 0) /* ABFD has a subsection that FROZEN doesn't have. */ { /* No need to try to merge anything here. */ s_abfd = s_abfd->next; } else if (cmp > 0) /* FROZEN has a subsection that ABFD doesn't have. */ { success &= handle_subsection_additional (info, abfd, abfd, s_abfd, s_frozen, s_frozen); s_frozen = s_frozen->next; } else /* Both ABFD and frozen have the subsection. */ { bool mismatch = oav2_subsection_mismatching_params (info, NULL, abfd, s_frozen, s_abfd); success &= ! mismatch; if (mismatch) /* FROZEN cannot be corrupted as it is generated from the command line arguments. If it is corrupted, it is a bug. */ s_abfd->status = obj_attr_subsection_v2_corrupted; else success &= (handle_subsection_merge (info, abfd, abfd, s_abfd, s_frozen, s_frozen) != NULL); s_abfd = s_abfd->next; s_frozen = s_frozen->next; } } /* No need to go through the remaining sections of ABFD, only mismatches against FROZEN are interesting. */ for (; s_frozen != NULL; s_frozen = s_frozen->next) success &= handle_subsection_additional (info, abfd, abfd, elf_obj_attr_subsections (abfd).last, s_frozen, s_frozen); return success; } /* Merge object attributes from object file ABFD and FROZEN_CFG into REF_BFD. */ static bool oav2_subsections_merge (const struct bfd_link_info *info, const bfd *ref_bfd, bfd *abfd, const obj_attr_subsection_list_t *frozen_cfg) { bool success = true; obj_attr_subsection_list_t *abfd_subsecs = &elf_obj_attr_subsections (abfd); obj_attr_subsection_list_t *ref_subsecs = &elf_obj_attr_subsections (ref_bfd); obj_attr_subsection_v2_t *s_frozen_first = frozen_cfg->first; obj_attr_subsection_v2_t *s_abfd = abfd_subsecs->first; obj_attr_subsection_v2_t *s_ref = ref_subsecs->first; while (s_abfd != NULL && s_ref != NULL) { int cmp = strcmp (s_ref->name, s_abfd->name); if (cmp < 0) /* REF has a subsection that ABFD doesn't have. */ { if (s_ref->status != obj_attr_subsection_v2_ok) { s_ref = s_ref->next; continue; } obj_attr_subsection_v2_t *s_frozen = bfd_obj_attr_subsection_v2_find_by_name (s_frozen_first, s_ref->name, true); /* Mismatching between REF and FROZEN already done in oav2_subsections_merge_frozen. */ success &= handle_subsection_missing (info, ref_bfd, abfd, s_ref, s_frozen); if (s_frozen != NULL) s_frozen_first = s_frozen->next; s_ref = s_ref->next; } else if (cmp > 0) /* ABFD has a subsection that REF doesn't have. */ { if (s_abfd->status != obj_attr_subsection_v2_ok) { s_abfd = s_abfd->next; continue; } obj_attr_subsection_v2_t *s_frozen = bfd_obj_attr_subsection_v2_find_by_name (s_frozen_first, s_abfd->name, true); if (s_frozen != NULL) { /* Check any mismatch against ABFD and FROZEN. */ bool mismatch = oav2_subsection_mismatching_params (info, NULL, abfd, s_frozen, s_abfd); success &= ! mismatch; if (mismatch) s_abfd->status = obj_attr_subsection_v2_corrupted; else success &= handle_subsection_additional (info, ref_bfd, abfd, s_ref, s_abfd, s_frozen); } else success &= handle_subsection_additional (info, ref_bfd, abfd, s_ref, s_abfd, NULL); if (s_frozen != NULL) s_frozen_first = s_frozen->next; s_abfd = s_abfd->next; } else /* Both REF and ABFD have the subsection. */ { if (s_ref->status != obj_attr_subsection_v2_ok) { s_ref = s_ref->next; s_abfd = s_abfd->next; continue; } obj_attr_subsection_v2_t *s_frozen = bfd_obj_attr_subsection_v2_find_by_name (s_frozen_first, s_ref->name, true); bool mismatch = oav2_subsection_mismatching_params (info, ref_bfd, abfd, s_ref, s_abfd); success &= ! mismatch; if (mismatch) s_abfd->status = obj_attr_subsection_v2_corrupted; else success &= (handle_subsection_merge (info, ref_bfd, abfd, s_ref, s_abfd, s_frozen) != NULL); if (s_frozen != NULL) s_frozen_first = s_frozen->next; s_ref = s_ref->next; s_abfd = s_abfd->next; } } for (; s_abfd != NULL; s_abfd = s_abfd->next) { if (s_abfd->status != obj_attr_subsection_v2_ok) continue; obj_attr_subsection_v2_t *s_frozen = bfd_obj_attr_subsection_v2_find_by_name (s_frozen_first, s_abfd->name, true); if (s_frozen != NULL) { bool mismatch = oav2_subsection_mismatching_params (info, NULL, abfd, s_frozen, s_abfd); success &= ! mismatch; if (mismatch) s_abfd->status = obj_attr_subsection_v2_corrupted; else success &= handle_subsection_additional (info, ref_bfd, abfd, ref_subsecs->last, s_abfd, s_frozen); } else success &= handle_subsection_additional (info, ref_bfd, abfd, ref_subsecs->last, s_abfd, NULL); } for (; s_ref != NULL; s_ref = s_ref->next) { if (s_ref->status != obj_attr_subsection_v2_ok) continue; obj_attr_subsection_v2_t *s_frozen = bfd_obj_attr_subsection_v2_find_by_name (s_frozen_first, s_ref->name, true); /* No need to check for matching parameters here as frozen has already been checked against ref. */ success &= handle_subsection_missing (info, ref_bfd, abfd, s_ref, s_frozen); } return success; } /* Wrapper for the high-level logic of merging a single file. It handles both of the following cases: - ABFD (future REF_BFD) merged against FROZEN. - ABFD (input) and FROZEN_CFG merged into REF_BFD. If has_obj_attrs_after_translation is non-NULL, the caller is responsible for the distinction between the cases where attributes are already present, or where attributes were added as a result of a translation of GNU properties. The first step translates existing GNU properties to object attributes. Next, any duplicates entries in the input are merged, and the resulting object attributes are written back into GNU properties so that the GNU properties merge process can correctly diagnose potential issues. Before merging, unknown subsections and attributes are marked so they can be skipped during processing. Return True on success, False on failure. */ static bool oav2_merge_one (const struct bfd_link_info *info, bfd *ref_bfd, bfd *abfd, const obj_attr_subsection_list_t *frozen_cfg, bool *has_obj_attrs_after_translation) { /* ABFD is an input file that may contain GNU properties, object attributes, or both. Before merging object attributes, we must first translate any GNU properties into their equivalent object attributes (if such equivalents exist) since they may not already be present. */ oav2_translate_gnu_props_to_obj_attrs (abfd); if (has_obj_attrs_after_translation && elf_obj_attr_subsections (abfd).size > 0) *has_obj_attrs_after_translation = true; /* Merge duplicates subsections and attributes. */ if (! oav2_file_scope_merge_subsections (abfd)) return false; /* ABFD is an input file that may contain GNU properties, object attributes, or both. Before merging GNU properties, we must first translate any object attributes into their equivalent GNU properties (if such equivalents exist) since they may not already be present. */ oav2_translate_obj_attrs_to_gnu_props (abfd); /* Note: object attributes are always merged before GNU properties. Ideally, there would be a single internal representation, with an abstraction level flexible enough to capture both GNU properties and object attributes without loss. In such a design, merge order would be irrelevant, and translation would occur only at the I/O boundaries during deserialization of GNU properties and object attributes. */ /* Mark unknown subsections and attributes to skip them during the merge. */ oav2_subsections_mark_unknown (abfd); if (ref_bfd == NULL) /* When REF_BFD is null, it means that ABFD is the future REF_BFD, and will be accumulating the merge result. It means that we will lose information from ABFD beyond this stage, so we need to emit warnings / errors (if any) when merging ABFD against FROZEN. */ return oav2_subsections_merge_frozen (info, abfd, frozen_cfg); /* Common merge case. */ return oav2_subsections_merge (info, ref_bfd, abfd, frozen_cfg); } /* Merge all the object attributes in INPUT_BFDS (REF_BFD excluded) into REF_BFD. Return True on success, False otherwise. */ static bool oav2_merge_all (const struct bfd_link_info *info, bfd *ref_bfd, bfd *input_bfds, obj_attr_subsection_list_t *frozen_cfg) { bool success = true; for (bfd *abfd = input_bfds; abfd != NULL; abfd = abfd->link.next) { if (abfd != ref_bfd && oav2_relevant_elf_object (info, abfd)) success &= oav2_merge_one (info, ref_bfd, abfd, frozen_cfg, NULL); } return success; } /* Prune the given attribute, and return the next one in the list. */ static obj_attr_v2_t * oav2_attr_delete (obj_attr_subsection_v2_t *subsec, obj_attr_v2_t *attr) { obj_attr_v2_t *next = attr->next; LINKED_LIST_REMOVE (obj_attr_v2_t) (subsec, attr); _bfd_elf_obj_attr_v2_free (attr, subsec->encoding); return next; } /* Prune the given subsection, and return the next one in the list. */ static obj_attr_subsection_v2_t * oav2_subsec_delete (obj_attr_subsection_list_t *plist, obj_attr_subsection_v2_t *subsec) { obj_attr_subsection_v2_t *next = subsec->next; LINKED_LIST_REMOVE (obj_attr_subsection_v2_t) (plist, subsec); _bfd_elf_obj_attr_subsection_v2_free (subsec); return next; } /* Prune any attributes with a status different from obj_attr_v2_ok in the given subsection. */ static void oav2_attrs_prune_nok (const struct bfd_link_info *info, obj_attr_subsection_v2_t *subsec) { const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd); for (obj_attr_v2_t *attr = subsec->first; attr != NULL;) { if (attr->status != obj_attr_v2_ok) { const char *tag_s = _bfd_obj_attr_v2_tag_to_string (bed, subsec->name, attr->tag); info->callbacks->minfo (_("Removed attribute '%s' from '%s'\n"), tag_s, subsec->name); free ((char *) tag_s); attr = oav2_attr_delete (subsec, attr); } else attr = attr->next; } } /* Prune any subsection with a status different from obj_attr_subsection_v2_ok in the given list of subsections. */ static void oav2_subsecs_prune_nok (const struct bfd_link_info *info, obj_attr_subsection_list_t *plist) { for (obj_attr_subsection_v2_t *subsec = plist->first; subsec != NULL;) { if (subsec->status == obj_attr_subsection_v2_ok) oav2_attrs_prune_nok (info, subsec); if (subsec->size == 0 || subsec->status != obj_attr_subsection_v2_ok) { info->callbacks->minfo (_("Removed subsection '%s'\n"), subsec->name); subsec = oav2_subsec_delete (plist, subsec); } else subsec = subsec->next; } } /* Prune any subsection or attribute with a status different from OK. */ static bool oav2_prune_nok_attrs (const struct bfd_link_info *info, bfd *abfd) { obj_attr_subsection_list_t *plist = &elf_obj_attr_subsections (abfd); oav2_subsecs_prune_nok (info, plist); return (plist->size != 0); } /* Set up object attributes coming from configuration, and merge them with the ones from the input object files. Return a pointer to the input object file containing the merge result on success, NULL otherwise. */ bfd * _bfd_elf_link_setup_object_attributes (struct bfd_link_info *info) { obj_attr_subsection_list_t *frozen_cfg = &elf_obj_attr_subsections (info->output_bfd); bfd_search_result_t res = bfd_linear_find_first_with_obj_attrs (info); /* If res.pbfd is NULL, it means that it didn't find any ELF object files. */ if (res.pbfd == NULL) return NULL; /* Sort the frozen subsections and attributes in case that they were not inserted in the correct order. */ oav2_sort_subsections (frozen_cfg); /* Merge object attributes sections. */ info->callbacks->minfo ("\n"); info->callbacks->minfo (_("Merging object attributes\n")); info->callbacks->minfo ("\n"); bool success = oav2_merge_one (info, NULL, res.pbfd, frozen_cfg, &res.has_object_attributes); /* No frozen object attributes and no object file, so nothing to do. */ if (!res.has_object_attributes && frozen_cfg->size == 0) return NULL; /* If frozen object attributes were set by some command-line options, we still need to emit warnings / errors if incompatibilities exist. */ /* Set the object attribute version for the output object to the recommended value by the backend. */ elf_obj_attr_version (info->output_bfd) = get_elf_backend_data (info->output_bfd)->default_obj_attr_version; if (res.sec == NULL) { /* This input object has no object attribute section matching the name and type specified by the backend, i.e. elf_backend_obj_attrs_section and elf_backend_obj_attrs_section_type. One of the two following cases is possible: 1. No object attribute were found in this file, so the object attribute version was never set by the deserializer. 2. The deserializer might have found attributes in another section with the correct type but the wrong name. The object attribute version should have been set correctly in this case. Whatever of those two cases, we set the object attribute version to the backend's recommended value, and create a new section with the expected name and type. */ elf_obj_attr_version (res.pbfd) = get_elf_backend_data (res.pbfd)->default_obj_attr_version; res.sec = create_object_attributes_section (info, res.pbfd); } /* Merge all the input object files againt res.pbfd and frozen_cfg, and accumulate the merge result in res.pbfd. */ success &= oav2_merge_all (info, res.pbfd, info->input_bfds, frozen_cfg); if (! success) return NULL; /* Prune all subsections and attributes with a status different from OK. */ if (! oav2_prune_nok_attrs (info, res.pbfd)) return NULL; BFD_ASSERT (elf_obj_attr_subsections (res.pbfd).size > 0); /* Shallow-copy the object attributes into output_bfd. */ elf_obj_attr_subsections (info->output_bfd) = elf_obj_attr_subsections (res.pbfd); /* Note: the object attributes section in the output object is copied from the input object which was used for the merge (res.pbfd). No need to create it here. However, so that the section is copied to the output object, the size must be different from 0. For now, we will set this size to 1. The real size will be set later. */ res.sec->size = 1; return res.pbfd; } /* Allocate/find an object attribute. */ obj_attribute * bfd_elf_new_obj_attr (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag) { obj_attribute *attr; obj_attribute_list *list; obj_attribute_list *p; obj_attribute_list **lastp; if (tag < NUM_KNOWN_OBJ_ATTRIBUTES) { /* Known tags are preallocated. */ attr = &elf_known_obj_attributes (abfd)[vendor][tag]; } else { /* Create a new tag. */ list = (obj_attribute_list *) bfd_alloc (abfd, sizeof (obj_attribute_list)); if (list == NULL) return NULL; memset (list, 0, sizeof (obj_attribute_list)); list->tag = tag; /* Keep the tag list in order. */ lastp = &elf_other_obj_attributes (abfd)[vendor]; for (p = *lastp; p; p = p->next) { if (tag < p->tag) break; lastp = &p->next; } list->next = *lastp; *lastp = list; attr = &list->attr; } return attr; } /* Return the value of an integer object attribute. */ int bfd_elf_get_obj_attr_int (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag) { obj_attribute_list *p; if (tag < NUM_KNOWN_OBJ_ATTRIBUTES) { /* Known tags are preallocated. */ return elf_known_obj_attributes (abfd)[vendor][tag].i; } else { for (p = elf_other_obj_attributes (abfd)[vendor]; p; p = p->next) { if (tag == p->tag) return p->attr.i; if (tag < p->tag) break; } return 0; } } /* Add an integer object attribute. */ obj_attribute * bfd_elf_add_obj_attr_int (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag, unsigned int value) { obj_attribute *attr; attr = bfd_elf_new_obj_attr (abfd, vendor, tag); if (attr != NULL) { attr->type = bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); attr->i = value; } return attr; } /* Duplicate an object attribute string value. */ static char * elf_attr_strdup (bfd *abfd, const char *s, const char *end) { char *p; size_t len; if (end) len = strnlen (s, end - s); else len = strlen (s); p = (char *) bfd_alloc (abfd, len + 1); if (p != NULL) { memcpy (p, s, len); p[len] = 0; } return p; } char * _bfd_elf_attr_strdup (bfd *abfd, const char *s) { return elf_attr_strdup (abfd, s, NULL); } /* Add a string object attribute. */ static obj_attribute * elf_add_obj_attr_string (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag, const char *s, const char *end) { obj_attribute *attr; attr = bfd_elf_new_obj_attr (abfd, vendor, tag); if (attr != NULL) { attr->type = bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); attr->s = elf_attr_strdup (abfd, s, end); if (attr->s == NULL) return NULL; } return attr; } obj_attribute * bfd_elf_add_obj_attr_string (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag, const char *s) { return elf_add_obj_attr_string (abfd, vendor, tag, s, NULL); } /* Add a int+string object attribute. */ static obj_attribute * elf_add_obj_attr_int_string (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag, unsigned int i, const char *s, const char *end) { obj_attribute *attr; attr = bfd_elf_new_obj_attr (abfd, vendor, tag); if (attr != NULL) { attr->type = bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); attr->i = i; attr->s = elf_attr_strdup (abfd, s, end); if (attr->s == NULL) return NULL; } return attr; } obj_attribute * bfd_elf_add_obj_attr_int_string (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag, unsigned int i, const char *s) { return elf_add_obj_attr_int_string (abfd, vendor, tag, i, s, NULL); } /* Copy object attributes v1 from IBFD to OBFD. */ static void oav1_copy_attributes (bfd *ibfd, bfd *obfd) { obj_attribute *in_attr; obj_attribute *out_attr; obj_attribute_list *list; int i; obj_attr_vendor_t vendor; for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) { in_attr = &elf_known_obj_attributes (ibfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; out_attr = &elf_known_obj_attributes (obfd)[vendor][LEAST_KNOWN_OBJ_ATTRIBUTE]; for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++) { out_attr->type = in_attr->type; out_attr->i = in_attr->i; if (in_attr->s && *in_attr->s) { out_attr->s = _bfd_elf_attr_strdup (obfd, in_attr->s); if (out_attr->s == NULL) bfd_perror (_("error adding attribute")); } in_attr++; out_attr++; } for (list = elf_other_obj_attributes (ibfd)[vendor]; list; list = list->next) { bool ok = false; in_attr = &list->attr; switch (in_attr->type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) { case ATTR_TYPE_FLAG_INT_VAL: ok = bfd_elf_add_obj_attr_int (obfd, vendor, list->tag, in_attr->i); break; case ATTR_TYPE_FLAG_STR_VAL: ok = bfd_elf_add_obj_attr_string (obfd, vendor, list->tag, in_attr->s); break; case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: ok = bfd_elf_add_obj_attr_int_string (obfd, vendor, list->tag, in_attr->i, in_attr->s); break; default: abort (); } if (!ok) bfd_perror (_("error adding attribute")); } } } static obj_attr_subsection_v2_t * oav2_obj_attr_subsection_v2_copy (const obj_attr_subsection_v2_t *); /* Copy object attributes v2 from IBFD to OBFD. */ static void oav2_copy_attributes (bfd *ibfd, bfd *obfd) { const obj_attr_subsection_list_t *in_attr_subsecs = &elf_obj_attr_subsections (ibfd); obj_attr_subsection_list_t *out_attr_subsecs = &elf_obj_attr_subsections (obfd); for (const obj_attr_subsection_v2_t *isubsec = in_attr_subsecs->first; isubsec != NULL; isubsec = isubsec->next) { obj_attr_subsection_v2_t *osubsec = oav2_obj_attr_subsection_v2_copy (isubsec); LINKED_LIST_APPEND (obj_attr_subsection_v2_t) (out_attr_subsecs, osubsec); } } /* Copy the object attributes from IBFD to OBFD. */ void _bfd_elf_copy_obj_attributes (bfd *ibfd, bfd *obfd) { if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) return; obj_attr_version_t version = elf_obj_attr_version (ibfd); elf_obj_attr_version (obfd) = version; switch (version) { case OBJ_ATTR_VERSION_NONE: break; case OBJ_ATTR_V1: oav1_copy_attributes (ibfd, obfd); break; case OBJ_ATTR_V2: oav2_copy_attributes (ibfd, obfd); break; default: abort (); } } /* Determine whether a GNU object attribute tag takes an integer, a string or both. */ static int gnu_obj_attrs_arg_type (obj_attr_tag_t tag) { /* Except for Tag_compatibility, for GNU attributes we follow the same rule ARM ones > 32 follow: odd-numbered tags take strings and even-numbered tags take integers. In addition, tag & 2 is nonzero for architecture-independent tags and zero for architecture-dependent ones. */ if (tag == Tag_compatibility) return 3; else return (tag & 1) != 0 ? 2 : 1; } /* Determine what arguments an attribute tag takes. */ int bfd_elf_obj_attrs_arg_type (bfd *abfd, obj_attr_vendor_t vendor, obj_attr_tag_t tag) { /* This function should only be called for object attributes version 1. */ BFD_ASSERT (elf_obj_attr_version (abfd) == OBJ_ATTR_V1); switch (vendor) { case OBJ_ATTR_PROC: return get_elf_backend_data (abfd)->obj_attrs_arg_type (tag); break; case OBJ_ATTR_GNU: return gnu_obj_attrs_arg_type (tag); break; default: abort (); } } static void oav1_parse_section (bfd *abfd, bfd_byte *p, bfd_byte *p_end) { const char *std_sec = get_elf_backend_data (abfd)->obj_attrs_vendor; while (p_end - p >= 4) { size_t len = p_end - p; size_t namelen; size_t section_len; int vendor; section_len = bfd_get_32 (abfd, p); p += 4; if (section_len == 0) break; if (section_len > len) section_len = len; if (section_len <= 4) { _bfd_error_handler (_("%pB: error: attribute section length too small: %ld"), abfd, (long) section_len); break; } section_len -= 4; namelen = strnlen ((char *) p, section_len) + 1; if (namelen >= section_len) break; if (std_sec && strcmp ((char *) p, std_sec) == 0) vendor = OBJ_ATTR_PROC; else if (strcmp ((char *) p, "gnu") == 0) vendor = OBJ_ATTR_GNU; else { /* Other vendor section. Ignore it. */ p += section_len; continue; } p += namelen; section_len -= namelen; while (section_len > 0) { unsigned int tag; unsigned int val; size_t subsection_len; bfd_byte *end, *orig_p; orig_p = p; tag = _bfd_safe_read_leb128 (abfd, &p, false, p_end); if (p_end - p >= 4) { subsection_len = bfd_get_32 (abfd, p); p += 4; } else { p = p_end; break; } if (subsection_len > section_len) subsection_len = section_len; section_len -= subsection_len; end = orig_p + subsection_len; if (end < p) break; switch (tag) { case Tag_File: while (p < end) { int type; bool ok = false; tag = _bfd_safe_read_leb128 (abfd, &p, false, end); type = bfd_elf_obj_attrs_arg_type (abfd, vendor, tag); switch (type & (ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL)) { case ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL: val = _bfd_safe_read_leb128 (abfd, &p, false, end); ok = elf_add_obj_attr_int_string (abfd, vendor, tag, val, (char *) p, (char *) end); p += strnlen ((char *) p, end - p); if (p < end) p++; break; case ATTR_TYPE_FLAG_STR_VAL: ok = elf_add_obj_attr_string (abfd, vendor, tag, (char *) p, (char *) end); p += strnlen ((char *) p, end - p); if (p < end) p++; break; case ATTR_TYPE_FLAG_INT_VAL: val = _bfd_safe_read_leb128 (abfd, &p, false, end); ok = bfd_elf_add_obj_attr_int (abfd, vendor, tag, val); break; default: abort (); } if (!ok) bfd_perror (_("error adding attribute")); } break; case Tag_Section: case Tag_Symbol: /* Don't have anywhere convenient to attach these. Fall through for now. */ default: /* Ignore things we don't know about. */ p = end; break; } } } } #define READ_ULEB128(abfd, var, cursor, end, total_read) \ do \ { \ bfd_byte *begin = (cursor); \ (var) = _bfd_safe_read_leb128 (abfd, &(cursor), false, end); \ (total_read) += (cursor) - begin; \ } \ while (0) static int read_ntbs (bfd *abfd, const bfd_byte *cursor, const bfd_byte *end, char **s) { *s = NULL; const size_t MAX_STR_LEN = end - cursor; /* Including \0. */ const size_t s_len = strnlen ((const char *) cursor, MAX_STR_LEN); if (s_len == MAX_STR_LEN) { bfd_set_error (bfd_error_malformed_archive); _bfd_error_handler (_("%pB: error: NTBS value seems corrupted " "(missing '\\0')"), abfd); return -1; } *s = xmemdup (cursor, s_len + 1, s_len + 1); return s_len + 1; } /* Parse an object attribute (v2 only). */ static ssize_t oav2_parse_attr (bfd *abfd, bfd_byte *cursor, const bfd_byte *end, obj_attr_encoding_v2_t attr_type, obj_attr_v2_t **attr) { *attr = NULL; ssize_t total_read = 0; obj_attr_tag_t attr_tag; READ_ULEB128 (abfd, attr_tag, cursor, end, total_read); union obj_attr_value_v2 attr_val; switch (attr_type) { case OA_ENC_NTBS: { int read = read_ntbs (abfd, cursor, end, (char **) &attr_val.string); if (read <= 0) return -1; total_read += read; } break; case OA_ENC_ULEB128: READ_ULEB128 (abfd, attr_val.uint, cursor, end, total_read); break; default: abort (); } *attr = bfd_elf_obj_attr_v2_init (attr_tag, attr_val); return total_read; } /* Parse a subsection (object attributes v2 only). */ static ssize_t oav2_parse_subsection (bfd *abfd, bfd_byte *cursor, const uint64_t max_read, obj_attr_subsection_v2_t **subsec) { *subsec = NULL; ssize_t total_read = 0; char *subsection_name = NULL; const uint32_t F_SUBSECTION_LEN = sizeof(uint32_t); const uint32_t F_SUBSECTION_COMPREHENSION = sizeof(uint8_t); const uint32_t F_SUBSECTION_ENCODING = sizeof(uint8_t); /* The minimum subsection length is 7: 4 bytes for the length itself, and 1 byte for an empty NUL-terminated string, 1 byte for the comprehension, 1 byte for the encoding, and no vendor-data. */ const uint32_t F_MIN_SUBSECTION_DATA_LEN = F_SUBSECTION_LEN + 1 /* for '\0' */ + F_SUBSECTION_COMPREHENSION + F_SUBSECTION_ENCODING; /* Similar to the issues reported in PR 17531, we need to check all the sizes and offsets as we parse the section. */ if (max_read < F_MIN_SUBSECTION_DATA_LEN) { _bfd_error_handler (_("%pB: error: attributes subsection ends " "prematurely"), abfd); goto error; } const unsigned int subsection_len = bfd_get_32 (abfd, cursor); const bfd_byte *const end = cursor + subsection_len; total_read += F_SUBSECTION_LEN; cursor += F_SUBSECTION_LEN; if (subsection_len > max_read) { _bfd_error_handler (_("%pB: error: bad subsection length (%u > max=%" PRIu64 ")"), abfd, subsection_len, max_read); goto error; } else if (subsection_len < F_MIN_SUBSECTION_DATA_LEN) { _bfd_error_handler (_("%pB: error: subsection length of %u is too small"), abfd, subsection_len); goto error; } const size_t max_subsection_name_len = subsection_len - F_SUBSECTION_LEN - F_SUBSECTION_COMPREHENSION - F_SUBSECTION_ENCODING; const bfd_byte *subsection_name_end = memchr (cursor, '\0', max_subsection_name_len); if (subsection_name_end == NULL) { _bfd_error_handler (_("%pB: error: subsection name seems corrupted " "(missing '\\0')"), abfd); goto error; } else /* Move the end pointer after '\0'. */ ++subsection_name_end; /* Note: if the length of the subsection name is 0 (i.e. the string is '\0'), it is still considered a valid name, even if it is not particularly useful. */ /* Note: at this stage, 1. the length of the subsection name is validated, as the presence of '\0' at the end of the string, so no risk of buffer overrun. 2. the data for comprehension and encoding can also safely be read. */ { /* Note: read_ntbs() assigns a dynamically allocated string to subsection_name. Either the string has to be freed in case of errors, or its ownership must be transferred. */ int read = read_ntbs (abfd, cursor, subsection_name_end, &subsection_name); total_read += read; cursor += read; } uint8_t comprehension_raw = bfd_get_8 (abfd, cursor); ++cursor; ++total_read; /* Comprehension is supposed to be a boolean, so any value greater than 1 is considered invalid. */ if (comprehension_raw > 1) { _bfd_error_handler (_("%pB: error: '%s' seems corrupted, got %u but only " "0 ('%s') or 1 ('%s') are valid values"), abfd, "comprehension", comprehension_raw, "required", "optional"); goto error; } uint8_t value_encoding_raw = bfd_get_8 (abfd, cursor); ++cursor; ++total_read; /* Encoding cannot be greater than OA_ENC_MAX, otherwise it means that either there is a new encoding that was introduced in the spec, and this implementation in binutils is older, and not aware of it so does not support it; or the stored value for encoding is garbage. */ enum obj_attr_encoding_v2 value_encoding = obj_attr_encoding_v2_from_u8 (value_encoding_raw); if (value_encoding > OA_ENC_MAX) { _bfd_error_handler (_("%pB: error: attribute type seems corrupted, got" " %u but only 0 (ULEB128) or 1 (NTBS) are " "valid types"), abfd, value_encoding); goto error; } obj_attr_subsection_scope_v2_t scope = bfd_elf_obj_attr_subsection_v2_scope (abfd, subsection_name); /* Note: ownership of 'subsection_name' is transfered to the callee when initializing the subsection. That is why we skip free() at the end. */ *subsec = bfd_elf_obj_attr_subsection_v2_init (subsection_name, scope, comprehension_raw, value_encoding); /* A subsection can be empty, so 'cursor' can be equal to 'end' here. */ bool err = false; while (!err && cursor < end) { obj_attr_v2_t *attr; ssize_t read = oav2_parse_attr (abfd, cursor, end, value_encoding, &attr); if (attr != NULL) LINKED_LIST_APPEND (obj_attr_v2_t) (*subsec, attr); total_read += read; err |= (read < 0); cursor += read; } if (err) { _bfd_elf_obj_attr_subsection_v2_free (*subsec); *subsec = NULL; return -1; } BFD_ASSERT (cursor == end); return total_read; error: bfd_set_error (bfd_error_malformed_archive); if (subsection_name) free (subsection_name); return -1; } /* Parse the list of subsections (object attributes v2 only). */ static void oav2_parse_section (bfd *abfd, const Elf_Internal_Shdr *hdr, bfd_byte *cursor) { obj_attr_subsection_list_t *subsecs = &elf_obj_attr_subsections (abfd); ssize_t read = 0; for (uint64_t remaining = hdr->sh_size - 1; /* Already read 'A'. */ remaining > 0; remaining -= read, cursor += read) { obj_attr_subsection_v2_t *subsec = NULL; read = oav2_parse_subsection (abfd, cursor, remaining, &subsec); if (read < 0) { _bfd_error_handler (_("%pB: error: could not parse subsection at offset %" PRIx64), abfd, hdr->sh_size - remaining); bfd_set_error (bfd_error_wrong_format); break; } else LINKED_LIST_APPEND (obj_attr_subsection_v2_t) (subsecs, subsec); } } /* Parse an object attributes section. Note: The parsing setup is common between object attributes v1 and v2. */ void _bfd_elf_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr) { elf_obj_attr_version (abfd) = OBJ_ATTR_VERSION_NONE; /* PR 17512: file: 2844a11d. */ if (hdr->sh_size == 0) return; ufile_ptr filesize = bfd_get_file_size (abfd); if (filesize != 0 && hdr->sh_size > filesize) { _bfd_error_handler (_("%pB: error: attribute section '%pA' too big: %" PRIu64), abfd, hdr->bfd_section, (uint64_t) hdr->sh_size); bfd_set_error (bfd_error_invalid_operation); return; } bfd_byte *data = (bfd_byte *) bfd_malloc (hdr->sh_size); if (!data) return; if (!bfd_get_section_contents (abfd, hdr->bfd_section, data, 0, hdr->sh_size)) goto free_data; unsigned char *cursor = data; /* The first character is the version of the attributes. */ obj_attr_version_t version = get_elf_backend_data (abfd)->obj_attrs_version_dec (*cursor); if (version == OBJ_ATTR_VERSION_UNSUPPORTED || version > OBJ_ATTR_VERSION_MAX) { _bfd_error_handler (_("%pB: error: unknown attributes version '%c'(%d)\n"), abfd, *cursor, *cursor); bfd_set_error (bfd_error_wrong_format); goto free_data; } ++cursor; elf_obj_attr_version (abfd) = version; switch (version) { case OBJ_ATTR_V1: oav1_parse_section (abfd, cursor, data + hdr->sh_size); break; case OBJ_ATTR_V2: oav2_parse_section (abfd, hdr, cursor); break; default: abort (); } free_data: free (data); } /* Merge common object attributes from IBFD into OBFD. Raise an error if there are conflicting attributes. Any processor-specific attributes have already been merged. This must be called from the bfd_elfNN_bfd_merge_private_bfd_data hook for each individual target, along with any target-specific merging. Because there are no common attributes other than Tag_compatibility at present, and non-"gnu" Tag_compatibility is not expected in "gnu" sections, this is not presently called for targets without their own attributes. */ bool _bfd_elf_merge_object_attributes (bfd *ibfd, struct bfd_link_info *info) { bfd *obfd = info->output_bfd; obj_attribute *in_attr; obj_attribute *out_attr; int vendor; /* Set the object attribute version for the output object to the recommended value by the backend. */ elf_obj_attr_version (obfd) = get_elf_backend_data (obfd)->default_obj_attr_version; /* The only common attribute is currently Tag_compatibility, accepted in both processor and "gnu" sections. */ for (vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; vendor++) { /* Handle Tag_compatibility. The tags are only compatible if the flags are identical and, if the flags are '1', the strings are identical. If the flags are non-zero, then we can only use the string "gnu". */ in_attr = &elf_known_obj_attributes (ibfd)[vendor][Tag_compatibility]; out_attr = &elf_known_obj_attributes (obfd)[vendor][Tag_compatibility]; if (in_attr->i > 0 && strcmp (in_attr->s, "gnu") != 0) { _bfd_error_handler /* xgettext:c-format */ (_("error: %pB: object has vendor-specific contents that " "must be processed by the '%s' toolchain"), ibfd, in_attr->s); return false; } if (in_attr->i != out_attr->i || (in_attr->i != 0 && strcmp (in_attr->s, out_attr->s) != 0)) { /* xgettext:c-format */ _bfd_error_handler (_("error: %pB: object tag '%d, %s' is " "incompatible with tag '%d, %s'"), ibfd, in_attr->i, in_attr->s ? in_attr->s : "", out_attr->i, out_attr->s ? out_attr->s : ""); return false; } } return true; } /* Merge an unknown processor-specific attribute TAG, within the range of known attributes, from IBFD into OBFD; return TRUE if the link is OK, FALSE if it must fail. */ bool _bfd_elf_merge_unknown_attribute_low (bfd *ibfd, bfd *obfd, int tag) { obj_attribute *in_attr; obj_attribute *out_attr; bfd *err_bfd = NULL; bool result = true; in_attr = elf_known_obj_attributes_proc (ibfd); out_attr = elf_known_obj_attributes_proc (obfd); if (out_attr[tag].i != 0 || out_attr[tag].s != NULL) err_bfd = obfd; else if (in_attr[tag].i != 0 || in_attr[tag].s != NULL) err_bfd = ibfd; if (err_bfd != NULL) result = get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, tag); /* Only pass on attributes that match in both inputs. */ if (in_attr[tag].i != out_attr[tag].i || (in_attr[tag].s == NULL) != (out_attr[tag].s == NULL) || (in_attr[tag].s != NULL && out_attr[tag].s != NULL && strcmp (in_attr[tag].s, out_attr[tag].s) != 0)) { out_attr[tag].i = 0; out_attr[tag].s = NULL; } return result; } /* Merge the lists of unknown processor-specific attributes, outside the known range, from IBFD into OBFD; return TRUE if the link is OK, FALSE if it must fail. */ bool _bfd_elf_merge_unknown_attribute_list (bfd *ibfd, bfd *obfd) { obj_attribute_list *in_list; obj_attribute_list *out_list; obj_attribute_list **out_listp; bool result = true; in_list = elf_other_obj_attributes_proc (ibfd); out_listp = &elf_other_obj_attributes_proc (obfd); out_list = *out_listp; for (; in_list || out_list; ) { bfd *err_bfd = NULL; unsigned int err_tag = 0; /* The tags for each list are in numerical order. */ /* If the tags are equal, then merge. */ if (out_list && (!in_list || in_list->tag > out_list->tag)) { /* This attribute only exists in obfd. We can't merge, and we don't know what the tag means, so delete it. */ err_bfd = obfd; err_tag = out_list->tag; *out_listp = out_list->next; out_list = *out_listp; } else if (in_list && (!out_list || in_list->tag < out_list->tag)) { /* This attribute only exists in ibfd. We can't merge, and we don't know what the tag means, so ignore it. */ err_bfd = ibfd; err_tag = in_list->tag; in_list = in_list->next; } else /* The tags are equal. */ { /* As present, all attributes in the list are unknown, and therefore can't be merged meaningfully. */ err_bfd = obfd; err_tag = out_list->tag; /* Only pass on attributes that match in both inputs. */ if (in_list->attr.i != out_list->attr.i || (in_list->attr.s == NULL) != (out_list->attr.s == NULL) || (in_list->attr.s && out_list->attr.s && strcmp (in_list->attr.s, out_list->attr.s) != 0)) { /* No match. Delete the attribute. */ *out_listp = out_list->next; out_list = *out_listp; } else { /* Matched. Keep the attribute and move to the next. */ out_list = out_list->next; in_list = in_list->next; } } if (err_bfd) result = result && get_elf_backend_data (err_bfd)->obj_attrs_handle_unknown (err_bfd, err_tag); } return result; } /* Create a new object attribute with key TAG and value VAL. Return a pointer to it. */ obj_attr_v2_t * bfd_elf_obj_attr_v2_init (obj_attr_tag_t tag, union obj_attr_value_v2 val) { obj_attr_v2_t *attr = XCNEW (obj_attr_v2_t); attr->tag = tag; attr->val = val; attr->status = obj_attr_v2_ok; return attr; } /* Free memory allocated by the object attribute ATTR. */ void _bfd_elf_obj_attr_v2_free (obj_attr_v2_t *attr, obj_attr_encoding_v2_t encoding) { if (encoding == OA_ENC_NTBS) /* Note: this field never holds a string literal. */ free ((char *) attr->val.string); free (attr); } /* Copy an object attribute OTHER, and return a pointer to the copy. */ obj_attr_v2_t * _bfd_elf_obj_attr_v2_copy (const obj_attr_v2_t *other, obj_attr_encoding_v2_t encoding) { union obj_attr_value_v2 val; if (encoding == OA_ENC_NTBS) val.string = (other->val.string != NULL ? xstrdup (other->val.string) : NULL); else if (encoding == OA_ENC_ULEB128) val.uint = other->val.uint; else abort (); obj_attr_v2_t *copy = bfd_elf_obj_attr_v2_init (other->tag, val); copy->status = other->status; return copy; } /* Compare two object attributes based on their TAG value only (partial ordering), and return an integer indicating the result of the comparison, as follows: - 0, if A1 and A2 are equal. - a negative value if A1 is less than A2. - a positive value if A1 is greater than A2. */ int _bfd_elf_obj_attr_v2_cmp (const obj_attr_v2_t *a1, const obj_attr_v2_t *a2) { if (a1->tag < a2->tag) return -1; if (a1->tag > a2->tag) return 1; return 0; } /* Return an object attribute in SUBSEC matching TAG or NULL if one is not found. SORTED specifies whether the given list is ordered by tag number. This allows an early return if we find a higher numbered tag. */ obj_attr_v2_t * bfd_obj_attr_v2_find_by_tag (const obj_attr_subsection_v2_t *subsec, obj_attr_tag_t tag, bool sorted) { for (obj_attr_v2_t *attr = subsec->first; attr != NULL; attr = attr->next) { if (attr->tag == tag) return attr; if (sorted && attr->tag > tag) break; } return NULL; } /* Sort the object attributes inside a subsection. Note: since a subsection is a list of attributes, the sorting algorithm is implemented with a merge sort. See more details in libiberty/doubly-linked-list.h */ LINKED_LIST_MUTATIVE_OPS_DECL (obj_attr_subsection_v2_t, obj_attr_v2_t, /* extern */) LINKED_LIST_MERGE_SORT_DECL (obj_attr_subsection_v2_t, obj_attr_v2_t, /* extern */) /* Public API wrapper for LINKED_LIST_APPEND (obj_attr_v2_t). */ void bfd_obj_attr_subsection_v2_append (obj_attr_subsection_v2_t *subsec, obj_attr_v2_t *attr) { LINKED_LIST_APPEND (obj_attr_v2_t) (subsec, attr); } /* Create a new object attribute subsection with the following properties: - NAME: the name of the subsection. Note: this parameter never holds a string literal, so the value has to be freeable. - SCOPE: the scope of the subsection (public or private). - OPTIONAL: whether this subsection is optional (true) or required (false). - ENCODING: the expected encoding for the attributes values (ULEB128 or NTBS). Return a pointer to it. */ obj_attr_subsection_v2_t * bfd_elf_obj_attr_subsection_v2_init (const char *name, obj_attr_subsection_scope_v2_t scope, bool optional, obj_attr_encoding_v2_t encoding) { obj_attr_subsection_v2_t *subsection = XCNEW (obj_attr_subsection_v2_t); subsection->name = name; subsection->scope = scope; subsection->optional = optional; subsection->encoding = encoding; subsection->status = obj_attr_subsection_v2_ok; return subsection; } /* Free memory allocated by the object attribute subsection SUBSEC. */ void _bfd_elf_obj_attr_subsection_v2_free (obj_attr_subsection_v2_t *subsec) { obj_attr_v2_t *attr = subsec->first; while (attr != NULL) { obj_attr_v2_t *a = attr; attr = attr->next; _bfd_elf_obj_attr_v2_free (a, subsec->encoding); } /* Note: this field never holds a string literal. */ free ((char *) subsec->name); free (subsec); } /* Deep copy an object attribute subsection OTHER, and return a pointer to the copy. */ static obj_attr_subsection_v2_t * oav2_obj_attr_subsection_v2_copy (const obj_attr_subsection_v2_t *other) { obj_attr_subsection_v2_t *new_subsec = bfd_elf_obj_attr_subsection_v2_init (xstrdup (other->name), other->scope, other->optional, other->encoding); new_subsec->status = other->status; for (obj_attr_v2_t *attr = other->first; attr != NULL; attr = attr->next) { obj_attr_v2_t *new_attr = _bfd_elf_obj_attr_v2_copy (attr, other->encoding); LINKED_LIST_APPEND (obj_attr_v2_t) (new_subsec, new_attr); } return new_subsec; } /* Compare two object attribute subsections based on all their properties. This operator can be used to obtain a total order in a collection. Return an integer indicating the result of the comparison, as follows: - 0, if S1 and S2 are equal. - a negative value if S1 is less than S2. - a positive value if S1 is greater than S2. NB: the scope is computed from the name, so is not used for the comparison. */ int _bfd_elf_obj_attr_subsection_v2_cmp (const obj_attr_subsection_v2_t *s1, const obj_attr_subsection_v2_t *s2) { int res = strcmp (s1->name, s2->name); if (res != 0) return res; /* Note: The comparison of the encoding and optionality of subsections is entirely arbitrary. The numeric values could be completely flipped around without any effect. Likewise, assigning higher priority to optionality than to encoding is artificial. The desired properties for this comparison operator are reflexivity, transitivity, antisymmetry, and totality, in order to achieve a total ordering when sorting a collection of subsections. If the nature of this ordering were to change in the future, it would have no functional impact (but e.g. testsuite expectations might still need adjusting) on the final merged result in the output file. Only the order of the serialized subsections would differ, which does not affect the interpretation of the object attributes. Similarly, the ordering of subsections and attributes in an input file does not affect the merge process in ld. The merge process never assumes any particular ordering from the input files, it always sorts the subsections and attributes before merging. This means that using an older version of gas with a newer ld is safe, and vice versa as long as no new features are used that the older ld doesn't know of. In conclusion, the (arbitrary) criteria used to sort subsections during the merge process are entirely internal to ld and have no effect on the merge result. */ if (!s1->optional && s2->optional) return -1; else if (s1->optional && !s2->optional) return 1; if (s1->encoding < s2->encoding) return -1; else if (s1->encoding > s2->encoding) return 1; return 0; } /* Return a subsection in the list FIRST matching NAME, or NULL if one is not found. SORTED specifies whether the given list is ordered by name. This allows an early return if we find a alphabetically-higher name. */ obj_attr_subsection_v2_t * bfd_obj_attr_subsection_v2_find_by_name (obj_attr_subsection_v2_t *first, const char *name, bool sorted) { for (obj_attr_subsection_v2_t *s = first; s != NULL; s = s->next) { int cmp = strcmp (s->name, name); if (cmp == 0) return s; else if (sorted && cmp > 0) break; } return NULL; } /* Sort the subsections in a vendor section. Note: since a section is a list of subsections, the sorting algorithm is implemented with a merge sort. See more details in libiberty/doubly-linked-list.h */ LINKED_LIST_MUTATIVE_OPS_DECL (obj_attr_subsection_list_t, obj_attr_subsection_v2_t, /* extern */) LINKED_LIST_MERGE_SORT_DECL (obj_attr_subsection_list_t, obj_attr_subsection_v2_t, /* extern */) /* Public API wrapper for LINKED_LIST_APPEND (obj_attr_subsection_v2_t). */ void bfd_obj_attr_subsection_v2_list_append (obj_attr_subsection_list_t *l, obj_attr_subsection_v2_t *subsec) { LINKED_LIST_APPEND (obj_attr_subsection_v2_t) (l, subsec); } /* Public API wrapper for LINKED_LIST_REMOVE (obj_attr_subsection_v2_t). */ obj_attr_subsection_v2_t * bfd_obj_attr_subsection_v2_list_remove (obj_attr_subsection_list_t *l, obj_attr_subsection_v2_t *subsec) { return LINKED_LIST_REMOVE (obj_attr_subsection_v2_t) (l, subsec); } /* Serialize the object attributes in ABFD into the vendor section of OUTPUT_BFD. */ bool _bfd_elf_write_section_object_attributes (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED) { asection *sec = elf_obj_object_attributes (abfd); if (sec == NULL) return true; bfd_byte *contents = (bfd_byte *) bfd_malloc (sec->size); if (contents == NULL) return false; /* Bail out and fail. */ bfd_elf_set_obj_attr_contents (abfd, contents, sec->size); bfd_set_section_contents (abfd, sec, contents, 0, sec->size); free (contents); return true; }