[PATCH v2 11/28] gas: implement parsing of object attributes v2
Matthieu Longo
matthieu.longo@arm.com
Fri May 2 10:32:43 GMT 2025
From: Richard Ball <richard.ball@arm.com>
This patch adds the parsing logic for Object Attributes v2 (OAv2), enabling
Gas to interpret and process these attributes correctly. It also updates the
AArch64 backend to utilize the new parsing capabilities, and handle the new
AArch64-specific directives.
This patch relies on the abstractions introduced in the previous patch to
store the data. Its scope is limited to parsing the new assembly directives,
checking the inputs, and storing the data into the relevant OAv2 abstractions.
Note that, for now, the new parsing capabilities are only available for AArch64.
Even if the implementation was splitted into a generic part available in
gas/config/obj-elf.c, and an AArch64-specific one in gas/config/tc-aarch64.c,
the lack of GNU generic directives to handle OAv2 prevented the capability
from being exposed to others backends.
** GNU assembler interface for aeabi subsections
OAv2 introduced two new directives for AArch64:
- .aeabi_subsection name, optionality, encoding
Create or switch the current subsection to 'name'.
Optionality values can be 'required' or 'optional'.
Encoding values are limited for now to 'ULEB128', and 'NTBS'
- .aeabi_attribute tag, value
Set 'tag' to 'value' in the current subsection.
Tag can either be an integer, or one of the defined symbols in the backend.
The usage of those directives will error if the following requirements
are breached:
- If the subsection X has been previously declared, the optionality and
encoding parameters of the current .aeabi_subsection that redeclares X
have to match with the previous declaration.
- The type of the value set via .aeabi_attribute has to align with
the current subsection.
- If the tag N has already been declared for the current subsection,
a later assignment to tag N is tolerated only if the newly set value
is equal to the former one.
** Regarding the implementation
The logic of OAv1 does not always keep separated the different data processing
steps: parsing, convertion to internal abstractions, error checking and further
processing (if any) on those abstractions, and their serialization into the
object files.
This patch takes into account the specifities of syntax for OAv1 and OAv2, but
mutualize as much as possible the common behavior so that the same methods can
be used for parsing the OAv1 and OAv2 directives.
However, the mutualization of the code is limited by a different internal model
for OAv1 and OAv2. Even if it is technically feaseable to have only one middle
-end for OAv1, OAv2 and even GNU properties, sharing the same data model to
perform the merge logic with the same code, it is a significant amount of work.
This extra work was not considered as a part of this new feature, so this patch
series will stick with the minimum of mutualization as possible.
Co-Authored-By: Matthieu Longo <matthieu.longo@arm.com>
---
bfd/elf-attrs.c | 118 +++++-
bfd/elf-attrs.h | 71 ++++
bfd/elf-bfd.h | 7 +
bfd/elfnn-aarch64.c | 6 +
bfd/elfxx-aarch64.c | 72 ++++
bfd/elfxx-aarch64.h | 2 +
bfd/elfxx-target.h | 8 +
gas/config/obj-elf.c | 5 +-
gas/config/tc-aarch64.c | 18 +-
gas/obj-attr.c | 866 ++++++++++++++++++++++++++++++++++++++++
gas/obj-attr.h | 8 +
include/elf/aarch64.h | 13 +
12 files changed, 1191 insertions(+), 3 deletions(-)
diff --git a/bfd/elf-attrs.c b/bfd/elf-attrs.c
index 7622070ff03..2a2fd25bef2 100644
--- a/bfd/elf-attrs.c
+++ b/bfd/elf-attrs.c
@@ -252,8 +252,124 @@ bfd_elf_set_obj_attr_contents (bfd *abfd, bfd_byte *buffer, bfd_vma size)
write_obj_attr_section_v1 (abfd, buffer, size);
}
+/* The first two tags in gnu-testing namespace 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_subsection_v2_unknown. */
+static const obj_attr_info known_tags_gnu_testing [] =
+{
+ {
+ .tag = {"GNUTestTag_0", .value = {
+ .val.u32 = 0,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u64 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+ {
+ .tag = {"GNUTestTag_1", .value = {
+ .val.u32 = 1,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u64 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+};
+
+static known_subsection_v2 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_tags = known_tags_gnu_testing,
+ .optional = true,
+ .encoding = OA_ENC_ULEB128,
+ .len = sizeof (known_tags_gnu_testing) / sizeof (obj_attr_info),
+ },
+ /* Note for the future: GNU subsections can be added here below. */
+};
+
+static bool
+gnu_testing_namespace (const char *subsec_name)
+{
+ return strncmp ("gnu-testing", subsec_name, 11) == 0;
+}
+
+const known_subsection_v2 *
+identify_subsection (const struct elf_backend_data *be,
+ const char *name)
+{
+ /* Check known backend subsections. */
+ const known_subsection_v2 *known_subsections = be->obj_attr_v2_known_subsections;
+ const size_t known_subsections_size = be->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;
+}
+
+static const obj_attr_info *
+identify_tag (const known_subsection_v2 *subsec, uint32_t tag)
+{
+ for (unsigned i = 0; i < subsec->len; ++i)
+ {
+ const obj_attr_info *known_tag = &subsec->known_tags[i];
+ if (known_tag->tag.value.val.u32 == tag)
+ return known_tag;
+ else if (known_tag->tag.value.val.u32 > tag)
+ break;
+ }
+ return NULL;
+}
+
+const obj_attr_info *
+known_obj_attr_v2_find_by_tag (const struct elf_backend_data *be,
+ const char *subsec_name,
+ uint32_t tag)
+{
+ const known_subsection_v2 *subsec_info =
+ identify_subsection (be, subsec_name);
+ if (subsec_info != NULL)
+ {
+ const obj_attr_info *tag_info = identify_tag (subsec_info, tag);
+ return tag_info;
+ }
+ return NULL;
+}
+
+const char *
+obj_attr_v2_tag_to_string (const struct elf_backend_data *be,
+ const char *subsec_name,
+ uint32_t tag)
+{
+ const obj_attr_info *tag_info =
+ known_obj_attr_v2_find_by_tag (be, subsec_name, tag);
+ if (tag_info != NULL)
+ return tag_info->tag.identifier;
+ return NULL;
+}
+
/* Allocate/find an object attribute. */
-static obj_attribute *
+obj_attribute *
elf_new_obj_attr (bfd *abfd, obj_attr_vendor vendor, unsigned int tag)
{
obj_attribute *attr;
diff --git a/bfd/elf-attrs.h b/bfd/elf-attrs.h
index ae3a164ae40..0ea3f12c559 100644
--- a/bfd/elf-attrs.h
+++ b/bfd/elf-attrs.h
@@ -115,3 +115,74 @@ typedef struct obj_attr_subsection_list
/* The size of the list. */
uint32_t size;
} obj_attr_subsection_list;
+
+/* Basic implementation of a variant for the possible types associated to an
+ object attribute. */
+struct variant_t;
+
+typedef struct {
+ size_t len;
+ struct variant_t *elts;
+} variant_list;
+
+typedef union {
+ const char *string;
+ uint8_t u8;
+ uint32_t u32;
+ uint64_t u64;
+ int64_t i64;
+ bool b;
+ variant_list list;
+} variant_value;
+
+typedef enum {
+ VALUE_UNDEFINED = 0,
+ VALUE_U8,
+ VALUE_U32,
+ VALUE_U64,
+ VALUE_I64,
+ VALUE_UNSIGNED_INTEGER = VALUE_U64,
+ VALUE_SIGNED_INTEGER = VALUE_I64,
+ VALUE_BOOL,
+ VALUE_STRING,
+ VALUE_LIST,
+} variant_type_info;
+
+typedef struct variant_t {
+ variant_value val;
+ variant_type_info vtype;
+} variant_t;
+
+typedef struct {
+ const char *const identifier;
+ const variant_t value;
+} symbol_t;
+
+/* Attribute information. */
+typedef struct {
+ const symbol_t tag;
+ const variant_t default_value;
+ const obj_attr_encoding_v2 encoding;
+} obj_attr_info;
+
+typedef struct
+{
+ const char *const subsec_name;
+ const obj_attr_info *known_tags;
+ const bool optional;
+ const obj_attr_encoding_v2 encoding;
+ const size_t len;
+} known_subsection_v2;
+
+struct elf_backend_data;
+
+extern const known_subsection_v2 *
+identify_subsection (const struct elf_backend_data *, const char*);
+
+extern const obj_attr_info *
+known_obj_attr_v2_find_by_tag (const struct elf_backend_data *,
+ const char*, uint32_t);
+
+extern const char *
+obj_attr_v2_tag_to_string (const struct elf_backend_data *, const char*,
+ uint32_t);
diff --git a/bfd/elf-bfd.h b/bfd/elf-bfd.h
index 591eed5598f..f91597cef46 100644
--- a/bfd/elf-bfd.h
+++ b/bfd/elf-bfd.h
@@ -1648,6 +1648,12 @@ struct elf_backend_data
/* Encode the object attributes version into the output object. */
uint8_t (*obj_attrs_version_enc) (obj_attr_version_t);
+ /* The known subsections and attributes (v2 only). */
+ const known_subsection_v2 *obj_attr_v2_known_subsections;
+
+ /* The size of the array of known subsections. */
+ const size_t obj_attr_v2_known_subsections_size;
+
/* This function determines the order in which any attributes are
written. It must be defined for input in the range
LEAST_KNOWN_OBJ_ATTRIBUTE..NUM_KNOWN_OBJ_ATTRIBUTES-1 (this range
@@ -3082,6 +3088,7 @@ extern obj_attr_version_t _bfd_obj_attrs_version_dec (uint8_t);
extern uint8_t _bfd_obj_attrs_version_enc (obj_attr_version_t);
extern bfd_vma bfd_elf_obj_attr_size (bfd *);
extern void bfd_elf_set_obj_attr_contents (bfd *, bfd_byte *, bfd_vma);
+extern obj_attribute * elf_new_obj_attr (bfd *, obj_attr_vendor, unsigned int);
extern int bfd_elf_get_obj_attr_int (bfd *, int, unsigned int);
extern obj_attribute *bfd_elf_add_obj_attr_int
(bfd *, int, unsigned int, unsigned int);
diff --git a/bfd/elfnn-aarch64.c b/bfd/elfnn-aarch64.c
index ed79e127d07..d577de18092 100644
--- a/bfd/elfnn-aarch64.c
+++ b/bfd/elfnn-aarch64.c
@@ -10783,6 +10783,12 @@ const struct elf_size_info elfNN_aarch64_size_info =
#undef elf_backend_obj_attrs_version_enc
#define elf_backend_obj_attrs_version_enc \
_bfd_aarch64_obj_attrs_version_enc
+/* Object attributes v2 specific values. */
+#undef elf_backend_obj_attr_v2_known_subsections
+#define elf_backend_obj_attr_v2_known_subsections \
+ aarch64_obj_attr_v2_known_subsections
+#undef elf_backend_obj_attr_v2_known_subsections_size
+#define elf_backend_obj_attr_v2_known_subsections_size 2
#include "elfNN-target.h"
diff --git a/bfd/elfxx-aarch64.c b/bfd/elfxx-aarch64.c
index d5f98cac27f..f55490eb771 100644
--- a/bfd/elfxx-aarch64.c
+++ b/bfd/elfxx-aarch64.c
@@ -21,6 +21,7 @@
#include "sysdep.h"
#include "bfd.h"
#include "elf-bfd.h"
+#include "elf/aarch64.h"
#include "elfxx-aarch64.h"
#include "libbfd.h"
#include <stdarg.h>
@@ -884,6 +885,77 @@ _bfd_aarch64_obj_attrs_version_enc (obj_attr_version_t version)
abort ();
}
+/* Note: this array has to be sorted. */
+static const obj_attr_info known_tags_aeabi_feature_and_bits [] =
+{
+ {
+ .tag = {"Tag_Feature_BTI", .value = {
+ .val.u32 = Tag_Feature_BTI,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u32 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+ {
+ .tag = {"Tag_Feature_PAC", .value = {
+ .val.u32 = Tag_Feature_PAC,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u32 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+ {
+ .tag = {"Tag_Feature_GCS", .value = {
+ .val.u32 = Tag_Feature_GCS,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u32 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+};
+/* This is a required subsection to use PAuthABI (which is currently
+ unsupported by GCC). A value of 0 for any the tags below means that
+ the user did not permit this entity to use the PAuthABI.
+ Note: this array has to be sorted. */
+static const obj_attr_info known_tags_aeabi_pauthabi [] =
+{
+ {
+ .tag = {"Tag_PAuth_Platform", .value = {
+ .val.u32 = Tag_PAuth_Platform,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u32 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+ {
+ .tag = {"Tag_PAuth_Schema", .value = {
+ .val.u32 = Tag_PAuth_Schema,
+ .vtype = VALUE_U32
+ }},
+ .default_value = {.val.u32 = 0, .vtype = VALUE_UNSIGNED_INTEGER},
+ .encoding = OA_ENC_ULEB128,
+ },
+};
+
+/* Note: this array is exported by the backend, and needs to be sorted. */
+const known_subsection_v2 aarch64_obj_attr_v2_known_subsections[] =
+{
+ {
+ .subsec_name = "aeabi_feature_and_bits",
+ .known_tags = known_tags_aeabi_feature_and_bits,
+ .optional = true,
+ .encoding = OA_ENC_ULEB128,
+ .len = sizeof (known_tags_aeabi_feature_and_bits) / sizeof (obj_attr_info),
+ },
+ {
+ .subsec_name = "aeabi_pauthabi",
+ .known_tags = known_tags_aeabi_pauthabi,
+ .optional = false,
+ .encoding = OA_ENC_ULEB128,
+ .len = sizeof (known_tags_aeabi_pauthabi) / sizeof (obj_attr_info),
+ },
+};
+
/* Find the first input bfd with GNU property and merge it with GPROP. If no
such input is found, add it to a new section at the last input. Update
GPROP accordingly. */
diff --git a/bfd/elfxx-aarch64.h b/bfd/elfxx-aarch64.h
index a98eef1e66b..92b60439f6d 100644
--- a/bfd/elfxx-aarch64.h
+++ b/bfd/elfxx-aarch64.h
@@ -215,6 +215,8 @@ _bfd_aarch64_obj_attrs_version_dec (uint8_t);
extern uint8_t
_bfd_aarch64_obj_attrs_version_enc (obj_attr_version_t);
+extern const known_subsection_v2 aarch64_obj_attr_v2_known_subsections[];
+
extern bfd *
_bfd_aarch64_elf_link_setup_gnu_properties (struct bfd_link_info *);
diff --git a/bfd/elfxx-target.h b/bfd/elfxx-target.h
index 738fd512169..9277edf8690 100644
--- a/bfd/elfxx-target.h
+++ b/bfd/elfxx-target.h
@@ -565,6 +565,12 @@
#ifndef elf_backend_obj_attrs_version_enc
#define elf_backend_obj_attrs_version_enc _bfd_obj_attrs_version_enc
#endif
+#ifndef elf_backend_obj_attr_v2_known_subsections
+#define elf_backend_obj_attr_v2_known_subsections NULL
+#endif
+#ifndef elf_backend_obj_attr_v2_known_subsections_size
+#define elf_backend_obj_attr_v2_known_subsections_size 0
+#endif
#ifndef elf_backend_obj_attrs_order
#define elf_backend_obj_attrs_order NULL
#endif
@@ -946,6 +952,8 @@ static const struct elf_backend_data elfNN_bed =
elf_backend_default_obj_attr_version,
elf_backend_obj_attrs_version_dec,
elf_backend_obj_attrs_version_enc,
+ elf_backend_obj_attr_v2_known_subsections,
+ elf_backend_obj_attr_v2_known_subsections_size,
elf_backend_obj_attrs_order,
elf_backend_obj_attrs_handle_unknown,
elf_backend_parse_gnu_properties,
diff --git a/gas/config/obj-elf.c b/gas/config/obj-elf.c
index 4a16ac329a8..c7fdf8971b6 100644
--- a/gas/config/obj-elf.c
+++ b/gas/config/obj-elf.c
@@ -2062,7 +2062,10 @@ obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED)
static void
obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
{
- obj_attr_v1_process_attribute (OBJ_ATTR_GNU);
+ obj_attr_version_t version = elf_obj_attr_version (stdoutput);
+ if (version < OBJ_ATTR_V2)
+ obj_attr_v1_process_attribute (OBJ_ATTR_GNU);
+ obj_attr_process_attribute (OBJ_ATTR_GNU);
}
void
diff --git a/gas/config/tc-aarch64.c b/gas/config/tc-aarch64.c
index 75aee15d0eb..649de391b26 100644
--- a/gas/config/tc-aarch64.c
+++ b/gas/config/tc-aarch64.c
@@ -2401,6 +2401,20 @@ s_tlsdescldr (int ignored ATTRIBUTE_UNUSED)
demand_empty_rest_of_line ();
}
+
+/* Parse a .aeabi_subsection directive. */
+static void
+s_aarch64_aeabi_subsection (int ignored ATTRIBUTE_UNUSED)
+{
+ obj_attr_process_subsection ();
+}
+
+/* Parse a .aeabi_attribute directive. */
+static void
+s_aarch64_aeabi_attribute (int ignored ATTRIBUTE_UNUSED)
+{
+ obj_attr_process_attribute (OBJ_ATTR_PROC);
+}
#endif /* OBJ_ELF */
#ifdef TE_PE
@@ -2481,6 +2495,8 @@ const pseudo_typeS md_pseudo_table[] = {
{"tlsdesccall", s_tlsdesccall, 0},
{"tlsdescldr", s_tlsdescldr, 0},
{"variant_pcs", s_variant_pcs, 0},
+ {"aeabi_subsection", s_aarch64_aeabi_subsection, 0},
+ {"aeabi_attribute", s_aarch64_aeabi_attribute, 0},
#endif
#if defined(OBJ_ELF) || defined(OBJ_COFF)
{"word", s_aarch64_cons, 4},
@@ -11287,4 +11303,4 @@ aarch64_elf_copy_symbol_attributes (symbolS *dest, symbolS *src)
S_SET_SIZE (dest, S_GET_SIZE (src));
}
}
-#endif
+#endif /* OBJ_ELF */
diff --git a/gas/obj-attr.c b/gas/obj-attr.c
index 1b9db3ac7b1..ac92999a81f 100644
--- a/gas/obj-attr.c
+++ b/gas/obj-attr.c
@@ -20,6 +20,7 @@
#include "as.h"
#include "obj-attr.h"
+#include "obstack.h"
#include "safe-ctype.h"
@@ -118,6 +119,871 @@ obj_attr_v1_rai_seen (obj_attr_vendor vendor, uint32_t tag)
return false;
}
+/* Expected argument tokens for object attribute directives. */
+typedef enum {
+ /* Base types. */
+ IDENTIFIER = 0x1,
+ UNSIGNED_INTEGER = 0x2,
+ SIGNED_INTEGER = 0x4,
+ STRING = 0x8,
+ LIST = 0x10,
+ LT_MASK = 0xFF,
+ /* Higher types. */
+ SUBSECTION_NAME = 0x100,
+ SUBSECTION_OPTION_1 = 0x200,
+ SUBSECTION_OPTION_2 = 0x400,
+ ATTRIBUTE_KEY = 0x800,
+ ATTRIBUTE_VALUE = 0x1000,
+ HT_MASK = 0xFF00,
+} arg_token_t;
+
+typedef variant_t arg_t;
+
+/* Free an arguments list of size N. */
+static void
+args_list_free (arg_t *args, size_t n)
+{
+ for (size_t i = 0; i < n; ++i)
+ if (args[i].vtype == VALUE_STRING)
+ free ((void *) args[i].val.string);
+ else if (args[i].vtype == VALUE_LIST)
+ args_list_free (args[i].val.list.elts, args[i].val.list.len);
+ free (args);
+}
+
+/* Extract a string literal ("[^.]+") from the input. */
+static bool
+extract_string_literal (arg_t *arg_out)
+{
+ skip_whitespace (input_line_pointer);
+
+ if (*input_line_pointer != '"')
+ {
+ as_bad ("missing '\"', expected a string literal");
+ return false;
+ }
+
+ int len;
+ char *obstack_buf = demand_copy_C_string (&len);
+ if (obstack_buf != NULL)
+ {
+ arg_out->val.string = xstrdup (obstack_buf);
+ obstack_free (¬es, obstack_buf);
+ arg_out->vtype = VALUE_STRING;
+ return true;
+ }
+
+ arg_out->val.string = NULL;
+ return false;
+}
+
+/* Extract an integer literal from the input.
+ Anything matched by O_constant is considered an integer literal (see the
+ usage of O_constant in expr.c to see all the matches. */
+static bool
+extract_integer_literal (arg_t *arg_out,
+ bool signedness_unsigned)
+{
+ expressionS exp;
+ expression (&exp);
+ if (exp.X_op != O_constant)
+ {
+ as_bad (_("invalid value, expected an integer literal"));
+ goto bad;
+ }
+
+ int64_t val = exp.X_add_number;
+ if (val < 0 && signedness_unsigned)
+ {
+ as_bad (_("invalid negative value %ld, expected an unsigned integer"),
+ val);
+ goto bad;
+ }
+ if (signedness_unsigned)
+ {
+ arg_out->val.u64 = val;
+ arg_out->vtype = VALUE_UNSIGNED_INTEGER;
+ }
+ else
+ {
+ arg_out->val.i64 = val;
+ arg_out->vtype = VALUE_SIGNED_INTEGER;
+ }
+ return true;
+
+bad:
+ ignore_rest_of_line ();
+ return false;
+}
+
+/* Extract an identifier based on the provided character matcher. */
+static bool
+extract_identifier (bool (*char_predicate) (char), arg_t *arg_out)
+{
+ const char *s = input_line_pointer;
+ unsigned int i = 0;
+ for (; char_predicate (*input_line_pointer); ++input_line_pointer)
+ i++;
+ if (i == 0)
+ {
+ as_bad (_("invalid value '%c', expected an identifier"),
+ *input_line_pointer);
+ ignore_rest_of_line ();
+ return false;
+ }
+
+ char *val = xmemdup0 (s, i);
+ arg_out->vtype = VALUE_STRING;
+ arg_out->val.string = val;
+ return true;
+}
+
+/* Resolve the identifier if it matches the given symbol. */
+static bool
+resolve_if_matching (const char *identifier,
+ const symbol_t *symbol,
+ arg_t *val_out)
+{
+ if (strcmp (symbol->identifier, identifier) != 0)
+ return false;
+
+ /* Free the identifier since we found the value. */
+ free ((void *) val_out->val.string);
+
+ switch (symbol->value.vtype)
+ {
+ case VALUE_BOOL:
+ val_out->val.u64 = symbol->value.val.b;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ break;
+ case VALUE_U8:
+ val_out->val.u64 = symbol->value.val.u8;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ break;
+ case VALUE_U32:
+ val_out->val.u64 = symbol->value.val.u32;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ break;
+ case VALUE_U64:
+ val_out->val.u64 = symbol->value.val.u64;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ break;
+ case VALUE_I64:
+ val_out->val.i64 = symbol->value.val.i64;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ break;
+ case VALUE_STRING:
+ val_out->val.string = strdup (symbol->value.val.string);
+ val_out->vtype = VALUE_STRING;
+ break;
+ default:
+ abort ();
+ }
+
+ return true;
+}
+
+/* Look up attribute keys defined in the backend (object attribute v1). */
+static bool
+obj_attr_v1_lookup_known_attr_key_symbol (const char *identifier,
+ arg_token_t token_type,
+ arg_t *val_out)
+{
+#ifndef CONVERT_SYMBOLIC_ATTRIBUTE
+#define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1
+ (void) identifier;
+#endif
+
+ gas_assert (token_type & UNSIGNED_INTEGER);
+
+ int tag = CONVERT_SYMBOLIC_ATTRIBUTE (identifier);
+ if (tag < 0)
+ return false;
+ val_out->val.u64 = tag;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+ return true;
+}
+
+/* Look up attribute keys defined in the backend (object attribute v2). */
+static bool
+obj_attr_v2_lookup_known_attr_key_symbol (const char *identifier,
+ arg_token_t token_type,
+ arg_t *val_out)
+{
+ obj_attr_subsection_v2 *subsec = elf_obj_attr_subsections (stdoutput).last_;
+ gas_assert (subsec != NULL && (token_type & UNSIGNED_INTEGER));
+
+ bool resolved = false;
+ const struct elf_backend_data *be = get_elf_backend_data (stdoutput);
+ const known_subsection_v2 *known_subsec =
+ identify_subsection (be, subsec->name);
+ if (known_subsec != NULL)
+ {
+ for (size_t i = 0; i < known_subsec->len && ! resolved; ++i)
+ resolved = resolve_if_matching (identifier,
+ &known_subsec->known_tags[i].tag,
+ val_out);
+ }
+
+ if (resolved)
+ gas_assert (val_out->vtype == VALUE_UNSIGNED_INTEGER);
+
+ return resolved;
+}
+
+/* Look up known symbols, and try to resolve the given identifier. */
+static bool
+lookup_known_symbols (const char *identifier,
+ arg_token_t token_type,
+ arg_t *val_out)
+{
+ if (identifier == NULL)
+ return false;
+
+ /* The identifier should match the value in val_out. */
+ gas_assert (val_out->val.string == identifier);
+
+ arg_token_t high_ttype = (token_type & HT_MASK);
+
+ static const symbol_t known_identifiers_subsection_optional[] = {
+ { "optional", .value = { .val.b = true, .vtype = VALUE_BOOL } },
+ { "required", .value = { .val.b = false, .vtype = VALUE_BOOL } },
+ };
+
+ static const symbol_t known_identifiers_subsection_encoding[] = {
+ { "ULEB128", .value = {
+ .val.u8 = obj_attr_encoding_v2_to_u8 (OA_ENC_ULEB128),
+ .vtype = VALUE_U8
+ }
+ },
+ { "uleb128", .value = {
+ .val.u8 = obj_attr_encoding_v2_to_u8 (OA_ENC_ULEB128),
+ .vtype = VALUE_U8
+ }
+ },
+ { "NTBS", .value = {
+ .val.u8 = obj_attr_encoding_v2_to_u8 (OA_ENC_NTBS),
+ .vtype = VALUE_U8
+ }
+ },
+ { "ntbs", .value = {
+ .val.u8 = obj_attr_encoding_v2_to_u8 (OA_ENC_NTBS),
+ .vtype = VALUE_U8
+ }
+ },
+ };
+
+ bool resolved = false;
+
+ if (high_ttype == SUBSECTION_OPTION_1 || high_ttype == SUBSECTION_OPTION_2)
+ {
+ const symbol_t *known_identifiers
+ = (high_ttype == SUBSECTION_OPTION_1)
+ ? known_identifiers_subsection_optional
+ : known_identifiers_subsection_encoding;
+ const size_t N_identifiers
+ = (high_ttype == SUBSECTION_OPTION_1)
+ ? ARRAY_SIZE (known_identifiers_subsection_optional)
+ : ARRAY_SIZE (known_identifiers_subsection_encoding);
+
+ for (size_t i = 0; i < N_identifiers && ! resolved; ++i)
+ resolved = resolve_if_matching (identifier,
+ &known_identifiers[i],
+ val_out);
+ }
+ else if (high_ttype == ATTRIBUTE_KEY)
+ {
+ obj_attr_version_t version = elf_obj_attr_version (stdoutput);
+ if (version == OBJ_ATTR_V1)
+ resolved = obj_attr_v1_lookup_known_attr_key_symbol (identifier,
+ token_type, val_out);
+ else if (version == OBJ_ATTR_V2)
+ resolved = obj_attr_v2_lookup_known_attr_key_symbol (identifier,
+ token_type, val_out);
+ else
+ abort ();
+ }
+ else
+ abort ();
+
+ return resolved;
+}
+
+/* Look up the symbol table of this compilation unit, and try to resolve the
+ given identifier. */
+static bool
+lookup_symbol_table (const char *identifier,
+ const arg_token_t expected_ttype,
+ arg_t *val_out)
+{
+ if (identifier == NULL)
+ return false;
+
+ /* Note: signed integer are unsupported for now. */
+ gas_assert (expected_ttype & UNSIGNED_INTEGER);
+ /* The identifier should match the value in val_out. */
+ gas_assert (val_out->val.string == identifier);
+
+ symbolS *symbolP = symbol_find (identifier);
+ if (symbolP == NULL)
+ return false;
+
+ if (! S_IS_DEFINED (symbolP))
+ return false;
+
+ valueT val = S_GET_VALUE (symbolP);
+
+ /* Free the identifier since we found the value. */
+ free ((void *) val_out->val.string);
+
+ val_out->val.u64 = val;
+ val_out->vtype = VALUE_UNSIGNED_INTEGER;
+
+ return true;
+}
+
+/* Return true if the next characters are suspected to represent an integer
+ literal. */
+static bool
+look_like_integer_literal (char const* const cursor)
+{
+ return ISDIGIT (*cursor)
+ || ((*cursor == '+' || *cursor == '-') && ISDIGIT (*(cursor + 1)));
+}
+
+/* Parse an argument, and set its type accordingly depending on the input
+ value, and the constraints on the expected argument. */
+static bool
+obj_attr_parse_arg (arg_token_t expected_ttype,
+ bool (*match_identifier) (char c),
+ bool resolve_identifier,
+ arg_t *arg_out)
+{
+ const arg_token_t low_ttype = (expected_ttype & LT_MASK);
+
+ /* Note: symbol look-up for string literals is not available. */
+ if (((low_ttype & STRING) && *input_line_pointer == '"')
+ || !(low_ttype & ~STRING))
+ return extract_string_literal (arg_out);
+
+ if (((low_ttype & (UNSIGNED_INTEGER | SIGNED_INTEGER))
+ && look_like_integer_literal (input_line_pointer))
+ || !(low_ttype & ~(UNSIGNED_INTEGER | SIGNED_INTEGER)))
+ return extract_integer_literal (arg_out, (low_ttype & UNSIGNED_INTEGER));
+
+ /* Try to extract an identifier. */
+ if (! extract_identifier (match_identifier, arg_out))
+ return false;
+ gas_assert (arg_out->vtype == VALUE_STRING);
+
+ /* In some cases, we don't want to resolve the identifier because it is the
+ actual value. */
+ if (! resolve_identifier)
+ return true;
+
+ /* The identifier is a symbol, let's try to resolve it by:
+ 1. using the provided list of known symbols.
+ a) backend-independent
+ b) backend-specific. */
+ if (lookup_known_symbols (arg_out->val.string, expected_ttype, arg_out))
+ return true;
+
+ /* 2. using the symbol table for this compilation unit.
+ Note: this is the last attempt before failure. */
+ if (lookup_symbol_table (arg_out->val.string, low_ttype, arg_out))
+ return true;
+
+ as_bad ("unknown identifier '%s'", arg_out->val.string);
+ free ((void *) arg_out->val.string);
+ arg_out->val.string = NULL;
+ arg_out->vtype = VALUE_UNDEFINED;
+ return false;
+}
+
+/* Trim white spaces before a parameter.
+ Error if it meets a parameter separator before a parameter. */
+static bool
+trim_whitespaces_before_param (int n)
+{
+ bool error = false;
+ do
+ {
+ skip_whitespace (input_line_pointer);
+ if (*input_line_pointer == ',')
+ {
+ error = true;
+ if (n < 0)
+ as_bad (_("unexpected comma before value"));
+ else
+ as_bad (_("unexpected comma before parameter %d"), n + 1);
+ skip_past_comma (&input_line_pointer);
+ }
+ }
+ while (is_whitespace (*input_line_pointer));
+ return !error;
+}
+
+/* Skip white spaces + parameter separator after a parameter.
+ Error if it does not meet a parameter separator after a parameter. */
+static bool
+skip_whitespaces_past_comma (int n)
+{
+ skip_whitespace (input_line_pointer);
+ if (skip_past_comma (&input_line_pointer) == -1)
+ {
+ if (n < 0)
+ as_bad (_("unexpected comma after value"));
+ else
+ as_bad (_("missing comma after parameter %d"), n + 1);
+ return false;
+ }
+ return true;
+}
+
+/* Can parse a list of arguments with variable length. */
+static bool
+obj_attr_parse_args (arg_token_t expected_ttype,
+ bool (*match_identifier) (char c),
+ bool resolve_identifier,
+ arg_t *arg_out)
+{
+ if ((expected_ttype & LIST) == 0)
+ return obj_attr_parse_arg (expected_ttype, match_identifier,
+ resolve_identifier, arg_out);
+
+ static const size_t LIST_MAX_SIZE = 2;
+ variant_t *arg_list = xcalloc (LIST_MAX_SIZE, sizeof (variant_t));
+
+ /* We don't want to support recursive lists. */
+ expected_ttype &= ~LIST;
+
+ size_t n = 0;
+ do {
+ if (! trim_whitespaces_before_param (-1))
+ goto bad;
+
+ if (! obj_attr_parse_arg (expected_ttype, match_identifier,
+ resolve_identifier, &arg_list[n]))
+ goto bad;
+
+ ++n;
+ skip_whitespace (input_line_pointer);
+ if (is_end_of_stmt (*input_line_pointer))
+ break;
+
+ if (! skip_whitespaces_past_comma (-1))
+ goto bad;
+
+ if (n >= LIST_MAX_SIZE)
+ {
+ as_bad ("too many arguments for a list (max: %lu)", LIST_MAX_SIZE);
+ goto bad;
+ }
+ } while (n < LIST_MAX_SIZE);
+
+ arg_out->vtype = VALUE_LIST;
+ arg_out->val.list.len = n;
+ arg_out->val.list.elts = arg_list;
+ return true;
+
+ bad:
+ args_list_free (arg_list, n);
+ return false;
+}
+
+static bool
+is_valid_boolean (uint64_t value)
+{
+ return value == 0 || value == 1;
+}
+
+#define is_valid_optional is_valid_boolean
+
+static bool
+is_valid_encoding (uint64_t value)
+{
+ value = obj_attr_encoding_v2_from_u8 (value);
+ return OA_ENC_UNSET < value && value <= OA_ENC_MAX;
+}
+
+static bool
+match_symbol (char c)
+{
+ return ISALNUM (c) || c == '_';
+}
+
+#define match_tag_identifier match_symbol
+
+static bool
+match_subsection_identifier (char c)
+{
+ return ISALNUM (c) || c == '_' || c == '-';
+}
+
+/* Determine the expected argument type based on the tag ID. */
+static arg_token_t
+obj_attr_v1_get_arg_type (bfd *abfd, obj_attr_vendor vendor, uint32_t tag)
+{
+ int attr_type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
+ arg_token_t arg_type;
+ if (attr_type == (ATTR_TYPE_FLAG_STR_VAL | ATTR_TYPE_FLAG_INT_VAL))
+ arg_type = LIST | UNSIGNED_INTEGER | STRING;
+ else if (attr_type == ATTR_TYPE_FLAG_STR_VAL)
+ arg_type = STRING;
+ else
+ /* Covers the remaning cases:
+ - ATTR_TYPE_FLAG_INT_VAL.
+ - ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT. */
+ arg_type = UNSIGNED_INTEGER;
+ return arg_type;
+}
+
+/* Determine the expected argument type based on the subsection encoding. */
+static arg_token_t
+obj_attr_v2_get_arg_type (obj_attr_encoding_v2 subsec_encoding)
+{
+ arg_token_t arg_type;
+ switch (subsec_encoding)
+ {
+ case OA_ENC_ULEB128:
+ arg_type = UNSIGNED_INTEGER;
+ break;
+ case OA_ENC_NTBS:
+ arg_type = STRING;
+ break;
+ case OA_ENC_UNSET:
+ abort ();
+ }
+ return arg_type;
+}
+
+/* Parse the arguments of [vendor]_attribute directive. */
+static arg_t *
+vendor_attribute_parse_args (obj_attr_vendor vendor,
+ const obj_attr_subsection_v2 *subsec,
+ unsigned int nargs, ...)
+{
+ va_list args;
+ va_start (args, nargs);
+
+ arg_t *args_out = xcalloc (nargs, sizeof (arg_t));
+
+ for (unsigned int n = 0; n < nargs; ++n)
+ {
+ if (! trim_whitespaces_before_param (n))
+ goto bad;
+
+ arg_t *arg_out = &args_out[n];
+
+ arg_token_t expected_ttype = va_arg (args, arg_token_t);
+ arg_token_t high_ttype = (expected_ttype & HT_MASK);
+ /* Make sure that we called the right parse_args(). */
+ gas_assert (high_ttype == ATTRIBUTE_KEY
+ || high_ttype == ATTRIBUTE_VALUE);
+
+ if (high_ttype == ATTRIBUTE_VALUE)
+ {
+ arg_token_t type_attr_value
+ = (subsec != NULL)
+ ? obj_attr_v2_get_arg_type (subsec->encoding)
+ : obj_attr_v1_get_arg_type (stdoutput, vendor,
+ args_out[n-1].val.u32);
+ expected_ttype |= type_attr_value;
+ }
+
+ if (! obj_attr_parse_args (expected_ttype,
+ match_tag_identifier, true,
+ arg_out))
+ {
+ if (high_ttype == ATTRIBUTE_KEY)
+ as_bad (_("could not parse attribute key"));
+ else
+ as_bad (_("could not parse attribute value"));
+ goto bad;
+ }
+
+ if (n + 1 < nargs && !skip_whitespaces_past_comma (n))
+ goto bad;
+ }
+
+ va_end (args);
+ demand_empty_rest_of_line ();
+
+ return args_out;
+
+bad:
+ args_list_free (args_out, nargs);
+ va_end (args);
+ ignore_rest_of_line ();
+ return NULL;
+}
+
+/* Record an attribute (object attribute v1 only). */
+static obj_attribute *
+obj_attr_v1_record (bfd *abfd,
+ const obj_attr_vendor vendor,
+ const uint32_t tag,
+ arg_t *parsed_arg)
+{
+ obj_attribute *attr = elf_new_obj_attr (abfd, vendor, tag);
+ if (attr != NULL)
+ {
+ int tag_type = _bfd_elf_obj_attrs_arg_type (abfd, vendor, tag);
+ if (parsed_arg->vtype == VALUE_LIST)
+ {
+ gas_assert (parsed_arg->val.list.len == 2
+ && parsed_arg->val.list.elts[0].vtype == VALUE_UNSIGNED_INTEGER
+ && parsed_arg->val.list.elts[1].vtype == VALUE_STRING);
+ attr->type = tag_type;
+ attr->i = parsed_arg->val.list.elts[0].val.u64;
+ attr->s = (char *) parsed_arg->val.list.elts[1].val.string;
+ parsed_arg->val.list.elts[1].val.string = NULL;
+ }
+ else if (parsed_arg->vtype == VALUE_STRING)
+ {
+ attr->type = tag_type;
+ attr->s = (char *) parsed_arg->val.string;
+ parsed_arg->val.string = NULL;
+ }
+ else
+ {
+ attr->type = tag_type;
+ attr->i = parsed_arg->val.u64;
+ }
+ }
+ return attr;
+}
+
+/* Parse the arguments of [vendor]_subsection directive (v2 only). */
+static arg_t *
+vendor_subsection_parse_args (unsigned int nargs, ...)
+{
+ va_list args;
+ va_start (args, nargs);
+
+ arg_t *args_out = xcalloc (nargs, sizeof (arg_t));
+
+ for (unsigned int n = 0; n < nargs; ++n)
+ {
+ if (! trim_whitespaces_before_param (n))
+ goto bad;
+
+ arg_t *arg_out = &args_out[n];
+
+ arg_token_t expected_ttype = va_arg (args, arg_token_t);
+ arg_token_t high_ttype = (expected_ttype & HT_MASK);
+ /* Make sure that we called the right parse_args(). */
+ gas_assert (high_ttype == SUBSECTION_NAME
+ || high_ttype == SUBSECTION_OPTION_1
+ || high_ttype == SUBSECTION_OPTION_2);
+
+ if (high_ttype == SUBSECTION_NAME)
+ {
+ if ( !obj_attr_parse_arg (expected_ttype,
+ match_subsection_identifier, false,
+ arg_out))
+ {
+ as_bad (_("expected <subsection_name>, <optional>, <encoding>"));
+ goto bad;
+ }
+ }
+ else if (high_ttype == SUBSECTION_OPTION_1
+ || high_ttype == SUBSECTION_OPTION_2)
+ {
+ if (! obj_attr_parse_arg (expected_ttype,
+ match_symbol, true,
+ arg_out))
+ goto bad;
+ if (high_ttype == SUBSECTION_OPTION_1
+ && ! is_valid_optional (arg_out->val.u64))
+ {
+ as_bad (("invalid value %lu, expected values for <optional> are 0"
+ " (=required) or 1 (=optional)"), arg_out->val.u64);
+ goto bad;
+ }
+ else if (high_ttype == SUBSECTION_OPTION_2
+ && ! is_valid_encoding (arg_out->val.u64))
+ {
+ as_bad (("invalid value %lu, expected values for <encoding> are 0"
+ " (=ULEB128) or 1 (=NTBS)"), arg_out->val.u64);
+ goto bad;
+ }
+ }
+ else
+ abort ();
+
+ if (n + 1 < nargs && ! skip_whitespaces_past_comma (n))
+ goto bad;
+ }
+
+ va_end (args);
+ demand_empty_rest_of_line ();
+
+ return args_out;
+
+bad:
+ args_list_free (args_out, nargs);
+ va_end (args);
+ ignore_rest_of_line ();
+ return NULL;
+}
+
+/* Record an attribute (object attribute v2 only). */
+static void
+obj_attr_v2_record (uint64_t key, arg_t *arg_val)
+{
+ /* An OAv2 cannot be recorded unless a subsection has been recorded. */
+ gas_assert (elf_obj_attr_subsections (stdoutput).last_ != NULL);
+
+ union obj_attr_value_v2 obj_attr_vals;
+ if (arg_val->vtype == VALUE_UNSIGNED_INTEGER)
+ obj_attr_vals.uint_val = arg_val->val.u64;
+ else
+ {
+ /* Move the string. */
+ obj_attr_vals.string_val = arg_val->val.string;
+ arg_val->val.string = NULL;
+ }
+
+ obj_attr_v2 *obj_attr = _bfd_elf_obj_attr_v2_init (key, obj_attr_vals);
+ gas_assert (obj_attr != NULL);
+
+ /* Go over the list of already recorded attributes and check for
+ redefinitions (which are forbidden). */
+ bool skip_recording = false;
+ obj_attr_v2 *recorded_attr = obj_attr_v2_find_by_tag
+ (elf_obj_attr_subsections (stdoutput).last_, obj_attr->tag, false);
+ if (recorded_attr != NULL)
+ {
+ if ((arg_val->vtype == VALUE_UNSIGNED_INTEGER
+ && recorded_attr->vals.uint_val != obj_attr->vals.uint_val) ||
+ (arg_val->vtype == VALUE_STRING
+ && strcmp (recorded_attr->vals.string_val, obj_attr->vals.string_val) != 0))
+ as_bad (_("attribute %u cannot be redefined"), recorded_attr->tag);
+ skip_recording = true;
+ }
+
+ if (skip_recording)
+ {
+ if (arg_val->vtype == VALUE_STRING)
+ free ((void *) obj_attr->vals.string_val);
+ free (obj_attr);
+ return;
+ }
+
+ LINKED_LIST_APPEND(obj_attr_v2) (
+ elf_obj_attr_subsections (stdoutput).last_, obj_attr);
+}
+
+/* Record a subsection (object attribute v2 only). */
+static void
+obj_attr_v2_subsection_record (const char *name,
+ bool optional,
+ obj_attr_encoding_v2 encoding)
+{
+ obj_attr_subsection_v2 *already_recorded_subsec =
+ obj_attr_subsection_v2_find_by_name
+ (elf_obj_attr_subsections (stdoutput).first_, name, false);
+
+ if (already_recorded_subsec != NULL)
+ {
+ /* Check for mismatching redefinition of the subsection, i.e. the names
+ match but the properties are different. */
+ if ((already_recorded_subsec->optional != optional)
+ || (already_recorded_subsec->encoding != encoding))
+ {
+ as_bad (_("recalled subsections must have the same parameters"));
+ return;
+ }
+ /* Move the existing subsection to the last position. */
+ LINKED_LIST_REMOVE(obj_attr_subsection_v2) (
+ &elf_obj_attr_subsections (stdoutput), already_recorded_subsec);
+ LINKED_LIST_APPEND(obj_attr_subsection_v2) (
+ &elf_obj_attr_subsections (stdoutput), already_recorded_subsec);
+ }
+ else
+ {
+ const char *vendor_name =
+ get_elf_backend_data (stdoutput)->obj_attrs_vendor;
+ obj_attr_subsection_scope_v2 scope =
+ (strncmp (name, vendor_name, strlen (vendor_name)) == 0)
+ ? OA_SUBSEC_PUBLIC
+ : OA_SUBSEC_PRIVATE;
+
+ obj_attr_subsection_v2 *new_subsection =
+ _bfd_elf_obj_attr_subsection_v2_init (name, scope, optional, encoding);
+ LINKED_LIST_APPEND(obj_attr_subsection_v2) (
+ &elf_obj_attr_subsections (stdoutput), new_subsection);
+ }
+}
+
+/* Parse an object attribute v1's attribute directive. */
+uint32_t
+obj_attr_process_attribute (obj_attr_vendor vendor)
+{
+ obj_attr_version_t version = elf_obj_attr_version (stdoutput);
+
+ obj_attr_subsection_v2 *subsec = NULL;
+ if (version >= OBJ_ATTR_V2)
+ {
+ subsec = elf_obj_attr_subsections (stdoutput).last_;
+ if (subsec == NULL)
+ {
+ as_bad (_("a subsection has to be declared before declaring attributes"));
+ ignore_rest_of_line ();
+ return 0;
+ }
+ }
+
+ const size_t N_ARGS = 2;
+ arg_t *args = vendor_attribute_parse_args (
+ vendor, subsec, N_ARGS,
+ ATTRIBUTE_KEY | IDENTIFIER | UNSIGNED_INTEGER,
+ ATTRIBUTE_VALUE);
+
+ if (args == NULL)
+ return 0;
+
+ uint32_t tag = args[0].val.u64;
+ if (version == OBJ_ATTR_V1)
+ {
+ obj_attr_v1_rai_mark_as_seen (vendor, tag);
+ obj_attr_v1_record (stdoutput, vendor, tag, &args[1]);
+ }
+ else if (version == OBJ_ATTR_V2)
+ obj_attr_v2_record (tag, &args[1]);
+ else
+ abort ();
+
+ args_list_free (args, N_ARGS);
+
+ return tag;
+}
+
+/* Parse an object attribute v2's subsection directive. */
+void
+obj_attr_process_subsection ()
+{
+ const size_t N_ARGS = 3;
+ arg_t *args = vendor_subsection_parse_args (
+ N_ARGS,
+ SUBSECTION_NAME | IDENTIFIER,
+ SUBSECTION_OPTION_1 | IDENTIFIER | UNSIGNED_INTEGER,
+ SUBSECTION_OPTION_2 | IDENTIFIER | UNSIGNED_INTEGER);
+
+ if (args == NULL)
+ return;
+
+ const char *name = NULL;
+ /* move the value to avoid double free. */
+ VALUE_SWAP (name, args[0].val.string);
+
+ obj_attr_v2_subsection_record (name, args[1].val.u64,
+ obj_attr_encoding_v2_from_u8 (args[2].val.u64));
+
+ args_list_free (args, N_ARGS);
+}
+
/* Parse an attribute directive for VENDOR.
Returns the attribute number read, or zero on error. */
diff --git a/gas/obj-attr.h b/gas/obj-attr.h
index 3578a96c31a..f630b046107 100644
--- a/gas/obj-attr.h
+++ b/gas/obj-attr.h
@@ -27,6 +27,14 @@
extern void obj_attr_v1_rai_enter (void);
extern void obj_attr_v1_rai_exit (void);
extern bool obj_attr_v1_rai_seen (obj_attr_vendor, uint32_t);
+
+/* Object attributes parsers. */
+
+/* Object attributes v1 only. */
extern uint32_t obj_attr_v1_process_attribute (obj_attr_vendor);
+/* Object attributes v1 & v2. */
+extern uint32_t obj_attr_process_attribute (obj_attr_vendor);
+/* Object attributes v2 only. */
+extern void obj_attr_process_subsection (void);
#endif /* _OBJ_ATTR_H */
diff --git a/include/elf/aarch64.h b/include/elf/aarch64.h
index e218e07fa73..c076174a7ac 100644
--- a/include/elf/aarch64.h
+++ b/include/elf/aarch64.h
@@ -57,6 +57,19 @@
#define STO_AARCH64_VARIANT_PCS 0x80 /* Symbol may follow different call
convention from the base PCS. */
+/* Tags used in aeabi_feature_and_bits subsection. */
+typedef enum Tag_Feature_XXX {
+ Tag_Feature_BTI = 0,
+ Tag_Feature_PAC = 1,
+ Tag_Feature_GCS = 2,
+} Tag_Feature_XXX;
+
+/* Tags used in aeabi_pauthabi subsection. */
+typedef enum Tag_PAuth_XXX {
+ Tag_PAuth_Platform = 1,
+ Tag_PAuth_Schema = 2,
+} Tag_PAuth_XXX;
+
/* Relocation types. */
START_RELOC_NUMBERS (elf_aarch64_reloc_type)
--
2.49.0
More information about the Binutils
mailing list