/* 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_<XXXXXX>_MERGE_<POLICY>

   with:

     - <XXXXXX>: an arbitrary name for your testing subsection.

     - <POLICY>: 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);

  /* <size> <vendor_name> NUL 0x1 <size> */

  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); /* <format-version: uint8>  */

  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); /* <subsection-length: uint32>  */

  size += strlen (subsec->name) + 1; /* <subsection-name: NTBS>  so +1 for '\0'.  */

  size += 2 * sizeof (uint8_t); /* <optional: uint8> <encoding: uint8>  */

  /* <attribute>*  */

  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); /* <format-version: uint8>  */

  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);

  /* <format-version: uint8>  */

  *(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)

{

  /* <subsection-length: uint32>  */

  bfd_vma subsec_size = oav2_subsection_size (subsec);

  bfd_put_32 (abfd, subsec_size, p);

  p += sizeof (uint32_t);

  /* <vendor-name: NTBS>  */

  size_t vendor_name_size = strlen (subsec->name) + 1; /* +1 for '\0'.  */

  memcpy (p, subsec->name, vendor_name_size);

  p += vendor_name_size;

  /* -- <vendor-data: bytes> --  */

  /* <optional: uint8>  */

  bfd_put_8 (abfd, subsec->optional, p);

  ++p;

  /* <encoding: uint8>  */

  bfd_put_8 (abfd, obj_attr_encoding_v2_to_u8 (subsec->encoding), p);

  ++p;

  /* <attribute>*  */

  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);

  /* <format-version: uint8>  */

  *(p++) = be->obj_attrs_version_enc (elf_obj_attr_version (abfd));

  /* [ <subsection-length: uint32> <vendor-name: NTBS> <vendor-data: bytes> ]*  */

  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 <SUBSEC, TAG>.

   Returns the attribute information associated to TAG if it is found,

   or "Tag_unknown_<N>" 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);