[2/6] arm: [MVE intrinsics] Add support for void and load/store pointers as argument types.
Checks
Commit Message
This patch adds support for '_', 'al' and 'as' for void, load pointer
and store pointer argument/return value types in intrinsic signatures.
It also adds a mew memory_scalar_type() helper to function_instance,
which is used by 'al' and 'as'.
2023-11-16 Christophe Lyon <christophe.lyon@linaro.org>
gcc/
* config/arm/arm-mve-builtins-shapes.cc (build_const_pointer):
New.
(parse_type): Add support for '_', 'al' and 'as'.
* config/arm/arm-mve-builtins.h (function_instance): Add
memory_scalar_type.
(function_base): Likewise.
---
gcc/config/arm/arm-mve-builtins-shapes.cc | 25 +++++++++++++++++++++++
gcc/config/arm/arm-mve-builtins.h | 17 +++++++++++++++
2 files changed, 42 insertions(+)
@@ -39,6 +39,13 @@
namespace arm_mve {
+/* Return a representation of "const T *". */
+static tree
+build_const_pointer (tree t)
+{
+ return build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
+}
+
/* If INSTANCE has a predicate, add it to the list of argument types
in ARGUMENT_TYPES. RETURN_TYPE is the type returned by the
function. */
@@ -140,6 +147,9 @@ parse_element_type (const function_instance &instance, const char *&format)
/* Read and return a type from FORMAT for function INSTANCE. Advance
FORMAT beyond the type string. The format is:
+ _ - void
+ al - array pointer for loads
+ as - array pointer for stores
p - predicates with type mve_pred16_t
s<elt> - a scalar type with the given element suffix
t<elt> - a vector or tuple type with given element suffix [*1]
@@ -156,6 +166,21 @@ parse_type (const function_instance &instance, const char *&format)
{
int ch = *format++;
+
+ if (ch == '_')
+ return void_type_node;
+
+ if (ch == 'a')
+ {
+ ch = *format++;
+ if (ch == 'l')
+ return build_const_pointer (instance.memory_scalar_type ());
+ if (ch == 's') {
+ return build_pointer_type (instance.memory_scalar_type ());
+ }
+ gcc_unreachable ();
+ }
+
if (ch == 'p')
return get_mve_pred16_t ();
@@ -277,6 +277,7 @@ public:
bool could_trap_p () const;
unsigned int vectors_per_tuple () const;
+ tree memory_scalar_type () const;
const mode_suffix_info &mode_suffix () const;
@@ -519,6 +520,14 @@ public:
of vectors in the tuples, otherwise return 1. */
virtual unsigned int vectors_per_tuple () const { return 1; }
+ /* If the function addresses memory, return the type of a single
+ scalar memory element. */
+ virtual tree
+ memory_scalar_type (const function_instance &) const
+ {
+ gcc_unreachable ();
+ }
+
/* Try to fold the given gimple call. Return the new gimple statement
on success, otherwise return null. */
virtual gimple *fold (gimple_folder &) const { return NULL; }
@@ -644,6 +653,14 @@ function_instance::vectors_per_tuple () const
return base->vectors_per_tuple ();
}
+/* If the function addresses memory, return the type of a single
+ scalar memory element. */
+inline tree
+function_instance::memory_scalar_type () const
+{
+ return base->memory_scalar_type (*this);
+}
+
/* Return information about the function's mode suffix. */
inline const mode_suffix_info &
function_instance::mode_suffix () const