Richard Ball <[email protected]> writes:
> When using LTO, handling the pragma for sme before the pragma
> for the neon-sve-bridge caused the following error on svset_neonq,
> in the neon-sve-bridge.c test.
>
> error: ACLE function '0' can only be called when SME streaming mode is
> enabled.
>
> This has been resolved by changing the pragma handlers to accept two modes.
> One where they add functions normally and a second in which
> registered_functions
> is filled with a placeholder value.
>
> By using this, the ordering of the functions can be maintained.
>
> No regressions on aarch64-none-elf.
OK, thanks.
Richard
> gcc/ChangeLog:
>
> * config/aarch64/aarch64-c.cc (aarch64_pragma_aarch64):
> Add functions_nulls parameter to pragma_handlers.
> * config/aarch64/aarch64-protos.h: Likewise.
> * config/aarch64/aarch64-sve-builtins.h
> (enum handle_pragma_index): Add enum to count
> number of pragmas to be handled.
> * config/aarch64/aarch64-sve-builtins.cc
> (GTY): Add global variable for initial indexes
> and change overload_names to an array.
> (function_builder::function_builder):
> Add pragma handler information.
> (function_builder::add_function):
> Add code for overwriting previous
> registered_functions entries.
> (add_unique_function):
> Use an array to register overload_names
> for both pragma handler modes.
> (add_overloaded_function): Likewise.
> (init_builtins):
> Add functions_nulls parameter to pragma_handlers.
> (handle_arm_sve_h):
> Initialize pragma handler information.
> (handle_arm_neon_sve_bridge_h): Likewise.
> (handle_arm_sme_h): Likewise.
>
> diff --git a/gcc/config/aarch64/aarch64-c.cc b/gcc/config/aarch64/aarch64-c.cc
> index
> b5a6917d06db41a845681ed6f13f2800c70ede10..fe1a20e4e546a68e5f7eddff3bbb0d3e831fbd9b
> 100644
> --- a/gcc/config/aarch64/aarch64-c.cc
> +++ b/gcc/config/aarch64/aarch64-c.cc
> @@ -344,15 +344,15 @@ aarch64_pragma_aarch64 (cpp_reader *)
>
> const char *name = TREE_STRING_POINTER (x);
> if (strcmp (name, "arm_sve.h") == 0)
> - aarch64_sve::handle_arm_sve_h ();
> + aarch64_sve::handle_arm_sve_h (false);
> else if (strcmp (name, "arm_sme.h") == 0)
> - aarch64_sve::handle_arm_sme_h ();
> + aarch64_sve::handle_arm_sme_h (false);
> else if (strcmp (name, "arm_neon.h") == 0)
> handle_arm_neon_h ();
> else if (strcmp (name, "arm_acle.h") == 0)
> handle_arm_acle_h ();
> else if (strcmp (name, "arm_neon_sve_bridge.h") == 0)
> - aarch64_sve::handle_arm_neon_sve_bridge_h ();
> + aarch64_sve::handle_arm_neon_sve_bridge_h (false);
> else
> error ("unknown %<#pragma GCC aarch64%> option %qs", name);
> }
> diff --git a/gcc/config/aarch64/aarch64-protos.h
> b/gcc/config/aarch64/aarch64-protos.h
> index
> bd719b992a545630f9ad6a73753fad55c6ac5d7e..42639e9efcf1e0f9362f759ae63a31b8eeb0d581
> 100644
> --- a/gcc/config/aarch64/aarch64-protos.h
> +++ b/gcc/config/aarch64/aarch64-protos.h
> @@ -1014,9 +1014,9 @@ bool aarch64_general_check_builtin_call (location_t,
> vec<location_t>,
>
> namespace aarch64_sve {
> void init_builtins ();
> - void handle_arm_sve_h ();
> - void handle_arm_sme_h ();
> - void handle_arm_neon_sve_bridge_h ();
> + void handle_arm_sve_h (bool);
> + void handle_arm_sme_h (bool);
> + void handle_arm_neon_sve_bridge_h (bool);
> tree builtin_decl (unsigned, bool);
> bool builtin_type_p (const_tree);
> bool builtin_type_p (const_tree, unsigned int *, unsigned int *);
> diff --git a/gcc/config/aarch64/aarch64-sve-builtins.h
> b/gcc/config/aarch64/aarch64-sve-builtins.h
> index
> e66729ed63532811b3b16ab57ae11cb10518caca..3e0d2b8560c538d201c97fba3591ddf9893d664a
> 100644
> --- a/gcc/config/aarch64/aarch64-sve-builtins.h
> +++ b/gcc/config/aarch64/aarch64-sve-builtins.h
> @@ -123,6 +123,15 @@ enum units_index
> UNITS_vectors
> };
>
> +/* Enumerates the pragma handlers. */
> +enum handle_pragma_index
> +{
> + arm_sve_handle,
> + arm_sme_handle,
> + arm_neon_sve_handle,
> + NUM_PRAGMA_HANDLERS
> +};
> +
> /* Describes the various uses of a governing predicate. */
> enum predication_index
> {
> @@ -419,7 +428,7 @@ class registered_function;
> class function_builder
> {
> public:
> - function_builder ();
> + function_builder (handle_pragma_index, bool);
> ~function_builder ();
>
> void add_unique_function (const function_instance &, tree,
> @@ -453,6 +462,12 @@ private:
>
> /* Used for building up function names. */
> obstack m_string_obstack;
> +
> + /* Used to store the index for the current function. */
> + unsigned int m_function_index;
> +
> + /* Stores the mode of the current pragma handler. */
> + bool m_function_nulls;
> };
>
> /* A base class for handling calls to built-in functions. */
> diff --git a/gcc/config/aarch64/aarch64-sve-builtins.cc
> b/gcc/config/aarch64/aarch64-sve-builtins.cc
> index
> 11f5c5c500c8331094933cb1c1205a1360eca79b..924bfeb3e23bb1bbed79d36adf33286b87b52f85
> 100644
> --- a/gcc/config/aarch64/aarch64-sve-builtins.cc
> +++ b/gcc/config/aarch64/aarch64-sve-builtins.cc
> @@ -933,14 +933,19 @@ tree acle_svprfop;
> /* The list of all registered function decls, indexed by code. */
> static GTY(()) vec<registered_function *, va_gc> *registered_functions;
>
> +/* Stores the starting function index for each pragma handler. */
> +static unsigned int initial_indexes[NUM_PRAGMA_HANDLERS];
> +
> /* All registered function decls, hashed on the function_instance
> that they implement. This is used for looking up implementations of
> overloaded functions. */
> static hash_table<registered_function_hasher> *function_table;
>
> -/* Maps all overloaded function names that we've registered so far to
> - their associated function_instances. The map keys are IDENTIFIER_NODEs.
> */
> -static GTY(()) hash_map<tree, registered_function *> *overload_names;
> +/* Index 0 maps all overloaded function names that we've registered so far to
> + their associated function_instances. Index 1 does the same for functions
> + that we've skipped over without registering. In both cases, the map keys
> + are IDENTIFIER_NODEs. */
> +static GTY(()) hash_map<tree, registered_function *> *overload_names[2];
>
> /* True if we've already complained about attempts to use functions
> when the required extension is disabled. */
> @@ -1332,10 +1337,21 @@ sve_switcher::~sve_switcher ()
> maximum_field_alignment = m_old_maximum_field_alignment;
> }
>
> -function_builder::function_builder ()
> +function_builder::function_builder (handle_pragma_index pragma_index,
> + bool function_nulls)
> {
> m_overload_type = build_function_type (void_type_node, void_list_node);
> m_direct_overloads = lang_GNU_CXX ();
> +
> + if (initial_indexes[pragma_index] == 0)
> + {
> + unsigned int index = vec_safe_length (registered_functions);
> + initial_indexes[pragma_index] = index;
> + }
> +
> + m_function_index = initial_indexes[pragma_index];
> + m_function_nulls = function_nulls;
> +
> gcc_obstack_init (&m_string_obstack);
> }
>
> @@ -1499,9 +1515,8 @@ function_builder::add_function (const function_instance
> &instance,
> bool overloaded_p,
> bool placeholder_p)
> {
> - unsigned int code = vec_safe_length (registered_functions);
> - code = (code << AARCH64_BUILTIN_SHIFT) | AARCH64_BUILTIN_SVE;
> -
> + unsigned int length = vec_safe_length (registered_functions);
> + unsigned int code = (m_function_index << AARCH64_BUILTIN_SHIFT) |
> AARCH64_BUILTIN_SVE;
> /* We need to be able to generate placeholders to enusre that we have a
> consistent numbering scheme for function codes between the C and C++
> frontends, so that everything ties up in LTO.
> @@ -1515,7 +1530,7 @@ function_builder::add_function (const function_instance
> &instance,
> nodes and remove the target hook. For now, however, we need to appease
> the
> validation and return a non-NULL, non-error_mark_node node, so we
> arbitrarily choose integer_zero_node. */
> - tree decl = placeholder_p
> + tree decl = placeholder_p || m_function_nulls
> ? integer_zero_node
> : simulate_builtin_function_decl (input_location, name, fntype,
> code, NULL, attrs);
> @@ -1525,7 +1540,11 @@ function_builder::add_function (const
> function_instance &instance,
> rfn.decl = decl;
> rfn.required_extensions = required_extensions;
> rfn.overloaded_p = overloaded_p;
> - vec_safe_push (registered_functions, &rfn);
> + if (m_function_index >= length)
> + vec_safe_push (registered_functions, &rfn);
> + else
> + (*registered_functions)[m_function_index] = &rfn;
> + m_function_index++;
>
> return rfn;
> }
> @@ -1554,11 +1573,14 @@ add_unique_function (const function_instance
> &instance,
> required_extensions, false, false);
>
> /* Enter the function into the hash table. */
> - hashval_t hash = instance.hash ();
> - registered_function **rfn_slot
> - = function_table->find_slot_with_hash (instance, hash, INSERT);
> - gcc_assert (!*rfn_slot);
> - *rfn_slot = &rfn;
> + if (!m_function_nulls)
> + {
> + hashval_t hash = instance.hash ();
> + registered_function **rfn_slot
> + = function_table->find_slot_with_hash (instance, hash, INSERT);
> + gcc_assert (!*rfn_slot);
> + *rfn_slot = &rfn;
> + }
>
> /* Also add the function under its overloaded alias, if we want
> a separate decl for each instance of an overloaded function. */
> @@ -1589,12 +1611,13 @@ function_builder::
> add_overloaded_function (const function_instance &instance,
> aarch64_feature_flags required_extensions)
> {
> - if (!overload_names)
> - overload_names = hash_map<tree, registered_function *>::create_ggc ();
> + auto &name_map = overload_names[m_function_nulls];
> + if (!name_map)
> + name_map = hash_map<tree, registered_function *>::create_ggc ();
>
> char *name = get_name (instance, true);
> tree id = get_identifier (name);
> - if (registered_function **map_value = overload_names->get (id))
> + if (registered_function **map_value = name_map->get (id))
> gcc_assert ((*map_value)->instance == instance
> && ((*map_value)->required_extensions
> & ~required_extensions) == 0);
> @@ -1603,7 +1626,7 @@ add_overloaded_function (const function_instance
> &instance,
> registered_function &rfn
> = add_function (instance, name, m_overload_type, NULL_TREE,
> required_extensions, true, m_direct_overloads);
> - overload_names->put (id, &rfn);
> + name_map->put (id, &rfn);
> }
> obstack_free (&m_string_obstack, name);
> }
> @@ -4510,9 +4533,9 @@ init_builtins ()
> register_builtin_types ();
> if (in_lto_p)
> {
> - handle_arm_sve_h ();
> - handle_arm_sme_h ();
> - handle_arm_neon_sve_bridge_h ();
> + handle_arm_sve_h (false);
> + handle_arm_sme_h (false);
> + handle_arm_neon_sve_bridge_h (false);
> }
> }
>
> @@ -4614,7 +4637,7 @@ register_svprfop ()
>
> /* Implement #pragma GCC aarch64 "arm_sve.h". */
> void
> -handle_arm_sve_h ()
> +handle_arm_sve_h (bool function_nulls_p)
> {
> if (function_table)
> {
> @@ -4641,17 +4664,20 @@ handle_arm_sve_h ()
>
> /* Define the functions. */
> function_table = new hash_table<registered_function_hasher> (1023);
> - function_builder builder;
> + function_builder builder (arm_sve_handle, function_nulls_p);
> for (unsigned int i = 0; i < ARRAY_SIZE (function_groups); ++i)
> builder.register_function_group (function_groups[i]);
> }
>
> /* Implement #pragma GCC aarch64 "arm_neon_sve_bridge.h". */
> void
> -handle_arm_neon_sve_bridge_h ()
> +handle_arm_neon_sve_bridge_h (bool function_nulls_p)
> {
> + if (initial_indexes[arm_sme_handle] == 0)
> + handle_arm_sme_h (true);
> +
> /* Define the functions. */
> - function_builder builder;
> + function_builder builder (arm_neon_sve_handle, function_nulls_p);
> for (unsigned int i = 0; i < ARRAY_SIZE (neon_sve_function_groups); ++i)
> builder.register_function_group (neon_sve_function_groups[i]);
> }
> @@ -4668,7 +4694,7 @@ builtin_decl (unsigned int code, bool)
>
> /* Implement #pragma GCC aarch64 "arm_sme.h". */
> void
> -handle_arm_sme_h ()
> +handle_arm_sme_h (bool function_nulls_p)
> {
> if (!function_table)
> {
> @@ -4677,17 +4703,9 @@ handle_arm_sme_h ()
> return;
> }
>
> - static bool initialized_p;
> - if (initialized_p)
> - {
> - error ("duplicate definition of %qs", "arm_sme.h");
> - return;
> - }
> - initialized_p = true;
> -
> sme_switcher sme;
>
> - function_builder builder;
> + function_builder builder (arm_sme_handle, function_nulls_p);
> for (unsigned int i = 0; i < ARRAY_SIZE (sme_function_groups); ++i)
> builder.register_function_group (sme_function_groups[i]);
> }
