builtins: Fix up expand_builtin_int_roundingfn_2 [PR105211]

The expansion of __builtin_iround{,f,l} etc. builtins in some cases
emits calls to a different fallback builtin.  To locate the right builtin
it uses mathfn_built_in_1 with the type of the first argument.
If its TYPE_MAIN_VARIANT is {float,double,long_double}_type_node, all is
fine, but on the following testcase, because GIMPLE considers scalar
float conversions between types with the same mode as useless,
TYPE_MAIN_VARIANT of the arg's type is float32_type_node and because there
isn't __builtin_lroundf32 returns NULL and we ICE.

This patch will first try the type of the first argument of the builtin's
prototype (so that say on sizeof(double)==sizeof(long double) target it honors
whether it was a *l or non-*l call; though even that can't be 100% trusted,
user could incorrectly prototype it) and as fallback the type argument.
If neither works, doesn't fallback.

2022-04-11  Jakub Jelinek  <jakub@redhat.com>

	PR rtl-optimization/105211
	* builtins.cc (expand_builtin_int_roundingfn_2): If mathfn_built_in_1
	fails for TREE_TYPE (arg), retry it with
	TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl))) and if even that
	fails, emit call normally.

	* gcc.dg/pr105211.c: New test.

diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index 4c6c293..5b085e3 100644 (file)
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -2967,16 +2967,28 @@ expand_builtin_int_roundingfn_2 (tree exp, rtx target)
         BUILT_IN_IROUND and if __builtin_iround is called directly, emit
         a call to lround in the hope that the target provides at least some
         C99 functions.  This should result in the best user experience for
-        not full C99 targets.  */
-      tree fallback_fndecl = mathfn_built_in_1
-       (TREE_TYPE (arg), as_combined_fn (fallback_fn), 0);
-
-      exp = build_call_nofold_loc (EXPR_LOCATION (exp),
-                                  fallback_fndecl, 1, arg);
+        not full C99 targets.
+        As scalar float conversions with same mode are useless in GIMPLE,
+        we can end up e.g. with _Float32 argument passed to float builtin,
+        try to get the type from the builtin prototype first.  */
+      tree fallback_fndecl = NULL_TREE;
+      if (tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
+        fallback_fndecl
+          = mathfn_built_in_1 (TREE_VALUE (argtypes),
+                              as_combined_fn (fallback_fn), 0);
+      if (fallback_fndecl == NULL_TREE)
+       fallback_fndecl
+         = mathfn_built_in_1 (TREE_TYPE (arg),
+                              as_combined_fn (fallback_fn), 0);
+      if (fallback_fndecl)
+       {
+         exp = build_call_nofold_loc (EXPR_LOCATION (exp),
+                                      fallback_fndecl, 1, arg);
 
-      target = expand_call (exp, NULL_RTX, target == const0_rtx);
-      target = maybe_emit_group_store (target, TREE_TYPE (exp));
-      return convert_to_mode (mode, target, 0);
+         target = expand_call (exp, NULL_RTX, target == const0_rtx);
+         target = maybe_emit_group_store (target, TREE_TYPE (exp));
+         return convert_to_mode (mode, target, 0);
+       }
     }
 
   return expand_call (exp, target, target == const0_rtx);

diff --git a/gcc/testsuite/gcc.dg/pr105211.c b/gcc/testsuite/gcc.dg/pr105211.c
new file mode 100644 (file)
index 0000000..9bafe6f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr105211.c
@@ -0,0 +1,11 @@
+/* PR rtl-optimization/105211 */
+/* { dg-do compile } */
+/* { dg-options "-Os -ffast-math" } */
+/* { dg-add-options float32 } */
+/* { dg-require-effective-target float32 } */
+
+short
+foo (_Float32 f)
+{
+  return __builtin_roundf (f);
+}