https://gcc.gnu.org/g:7d2496170af17d46323445ea4832e6c098977869

commit r17-5894-g7d2496170af17d46323445ea4832e6c098977869
Author: Karl Meakin <[email protected]>
Date:   Thu Aug 6 14:10:51 2026 +0000

    aarch64: Port vabs intrinsics to pragma-based framework
    
    Port the `vabs` family of NEON intrinsics to the pragma-based framework,
    and add assembly tests for every variant.
    
    This also makes the `__builtin_aarch64_abs<mode>` builtin functions
    obsolete, so they have been deleted too.
    
    gcc/ChangeLog:
    
            * config/aarch64/aarch64-builtins.cc
            (aarch64_general_fold_builtin): Delete case to handle `abs`.
            * config/aarch64/aarch64-neon-builtins-base.cc (vabsd, vabsh,
            vabs, vabsq): New function bases.
            * config/aarch64/aarch64-neon-builtins-base.def (vabsd): (vabs):
            (vabsq): (vabsh): New function declarations.
            * config/aarch64/aarch64-simd-builtins.def: Delete `abs` builtin
            functions.
            * config/aarch64/aarch64-simd.md
            (aarch64_abs<mode><vczle><vczbe>): Replace UNSPEC_ABS with abs
            expression.
            (aarch64_abs_plus<mode>): Likewise.
            * config/aarch64/iterators.md (UNSPEC_ABS): Delete unspec.
            * config/aarch64/arm_neon.h (vabs_f32, vabs_f64, vabs_s8,
            vabs_s16, vabs_s32, vabs_s64, vabsq_f32, vabsq_f64, vabsq_s8,
            vabsq_s16, vabsq_s32, vabsq_s64, vabsd_s64, vabs_f16,
            vabsq_f16): Delete function definitions.
            * config/aarch64/arm_fp16.h (vabsh_f16): Use `__builtin_fabs`
            instead of `__builtin_aarch64_abshf` now that the latter has
            been deleted.
    
    gcc/testsuite/ChangeLog:
    
            * gcc.target/aarch64/neon/vabs.c: New test.
            * gcc.target/aarch64/neon/trapping_math.c: New tests.
            * gcc.target/aarch64/singleton_intrinsics_1.c: Mark `vabs_s64`
            test as `xfail` because of codegen regression.
            * gcc.target/aarch64/vabs_intrinsic_1.c: Fix test. The `asm
            volatile` trick for disabling constant folding stopped
            working. Replace with declaring variables `volatile`.
            * gcc.target/aarch64/fneg-abs_1.c: Add `-fno-trapping-math`
            to flags.
            * gcc.target/aarch64/sve/fneg-abs_1.c: Likewise.

Diff:
---
 gcc/config/aarch64/aarch64-builtins.cc             |   2 -
 gcc/config/aarch64/aarch64-neon-builtins-base.cc   |  19 ++++
 gcc/config/aarch64/aarch64-neon-builtins-base.def  |  11 ++
 gcc/config/aarch64/aarch64-simd-builtins.def       |   6 --
 gcc/config/aarch64/aarch64-simd.md                 |  18 +---
 gcc/config/aarch64/arm_fp16.h                      |   2 +-
 gcc/config/aarch64/arm_neon.h                      | 112 -------------------
 gcc/config/aarch64/iterators.md                    |   1 -
 gcc/testsuite/gcc.target/aarch64/fneg-abs_1.c      |   2 +-
 .../gcc.target/aarch64/neon/trapping_math.c        |  66 ++++++++++++
 gcc/testsuite/gcc.target/aarch64/neon/vabs.c       | 118 +++++++++++++++++++++
 .../gcc.target/aarch64/singleton_intrinsics_1.c    |   2 +-
 gcc/testsuite/gcc.target/aarch64/sve/fneg-abs_1.c  |   2 +-
 .../gcc.target/aarch64/vabs_intrinsic_1.c          |   9 +-
 14 files changed, 223 insertions(+), 147 deletions(-)

diff --git a/gcc/config/aarch64/aarch64-builtins.cc 
b/gcc/config/aarch64/aarch64-builtins.cc
index 765743f55073..d94d75b9afc1 100644
--- a/gcc/config/aarch64/aarch64-builtins.cc
+++ b/gcc/config/aarch64/aarch64-builtins.cc
@@ -4717,8 +4717,6 @@ aarch64_general_fold_builtin (unsigned int fcode, tree 
type,
 {
   switch (fcode)
     {
-      BUILTIN_VDQF (UNOP, abs, 2, ALL)
-       return fold_build1 (ABS_EXPR, type, args[0]);
       VAR1 (UNOP, floatv2si, 2, ALL, v2sf)
       VAR1 (UNOP, floatv4si, 2, ALL, v4sf)
       VAR1 (UNOP, floatv2di, 2, ALL, v2df)
diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.cc 
b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
index 729e3038f1c1..b8a8060b1622 100644
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.cc
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
@@ -884,6 +884,24 @@ struct gimple_reinterpret : public gimple_function_base
   }
 };
 
+struct gimple_abs : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto arg = gimple_call_arg (f.call, 0);
+    auto arg_type = TREE_TYPE (arg);
+
+    if (!FLOAT_TYPE_P (arg_type))
+      return gimple_build_assign (
+       f.lhs, build_cast (arg_type,
+                          f.force_val (fold_build1 (
+                            ABSU_EXPR, unsigned_type_for (arg_type), arg))));
+
+    auto ret = fold_build1 (ABS_EXPR, arg_type, arg);
+    return this->maybe_optimization_barrier (f, ret);
+  }
+};
+
 // Reinterpret
 NEON_FUNCTION (vreinterpret, vreinterpretq, gimple_reinterpret,)
 
@@ -902,6 +920,7 @@ NEON_FUNCTION (vadd, vaddq, vaddd, gimple_arith, 
(PLUS_EXPR, PLUS_EXPR, BIT_XOR_
 NEON_FUNCTION (vsub, vsubq, vsubd, gimple_arith, (MINUS_EXPR))
 NEON_FUNCTION (vdiv, vdivq,       gimple_arith, (RDIV_EXPR))
 NEON_FUNCTION (vneg, vnegq, vnegd, gimple_arith, (NEGATE_EXPR))
+NEON_FUNCTION (vabs, vabsq, vabsd, gimple_abs,)
 
 NEON_FUNCTION (vmul, vmulq,            gimple_arith, (MULT_EXPR))
 NEON_FUNCTION (vmul_n, vmulq_n,                gimple_arith_dup, (MULT_EXPR))
diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.def 
b/gcc/config/aarch64/aarch64-neon-builtins-base.def
index f2c0d22ee3ab..00428ed42e22 100644
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.def
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.def
@@ -101,6 +101,13 @@ DEF_NEON_FUNCTION (vneg,  all_signed, ("D0,D0"))
 DEF_NEON_FUNCTION (vnegq, all_signed, ("Q0,Q0"))
 DEF_NEON_FUNCTION (vneg,  sd_float,   ("D0,D0"))
 DEF_NEON_FUNCTION (vnegq, sd_float,   ("Q0,Q0"))
+
+// Absolute value
+DEF_NEON_FUNCTION (vabsd, d_signed,   ("s0,s0"))
+DEF_NEON_FUNCTION (vabs,  all_signed, ("D0,D0"))
+DEF_NEON_FUNCTION (vabsq, all_signed, ("Q0,Q0"))
+DEF_NEON_FUNCTION (vabs,  sd_float,   ("D0,D0"))
+DEF_NEON_FUNCTION (vabsq, sd_float,   ("Q0,Q0"))
 #undef REQUIRED_EXTENSIONS
 
 // Lanewise arithmetic (FP16)
@@ -132,6 +139,10 @@ DEF_NEON_FUNCTION (vdivq, h_float, ("Q0,Q0,Q0"))
 // Negation
 DEF_NEON_FUNCTION (vneg,  h_float, ("D0,D0"))
 DEF_NEON_FUNCTION (vnegq, h_float, ("Q0,Q0"))
+
+// Absolute value
+DEF_NEON_FUNCTION (vabs,  h_float, ("D0,D0"))
+DEF_NEON_FUNCTION (vabsq, h_float, ("Q0,Q0"))
 #undef REQUIRED_EXTENSIONS
 
 // Saturating arithmetic
diff --git a/gcc/config/aarch64/aarch64-simd-builtins.def 
b/gcc/config/aarch64/aarch64-simd-builtins.def
index 0df54066b7a9..3254f07af70a 100644
--- a/gcc/config/aarch64/aarch64-simd-builtins.def
+++ b/gcc/config/aarch64/aarch64-simd-builtins.def
@@ -668,12 +668,6 @@
   BUILTIN_VHSDF (UNOP, frecpe, 0, FP)
   BUILTIN_VHSDF_HSDF (BINOP, frecps, 0, FP)
 
-  /* Implemented by a mixture of abs2 patterns.  Note the DImode builtin is
-     only ever used for the int64x1_t intrinsic, there is no scalar version.  
*/
-  BUILTIN_VSDQ_I_DI (UNOP, abs, 0, QUIET)
-  BUILTIN_VHSDF (UNOP, abs, 2, QUIET)
-  VAR1 (UNOP, abs, 2, QUIET, hf)
-
   BUILTIN_VQ_HSF (UNOP, vec_unpacks_hi_, 10, FP)
   VAR1 (BINOP, float_truncate_hi_, 0, FP, v4sf)
   VAR1 (BINOP, float_truncate_hi_, 0, FP, v8hf)
diff --git a/gcc/config/aarch64/aarch64-simd.md 
b/gcc/config/aarch64/aarch64-simd.md
index 53c2cbf0f687..1599f1fa349e 100644
--- a/gcc/config/aarch64/aarch64-simd.md
+++ b/gcc/config/aarch64/aarch64-simd.md
@@ -974,19 +974,6 @@
   [(set_attr "type" "neon_abs<q>")]
 )
 
-;; The intrinsic version of integer ABS must not be allowed to
-;; combine with any operation with an integrated ABS step, such
-;; as SABD.
-(define_insn "aarch64_abs<mode><vczle><vczbe>"
-  [(set (match_operand:VSDQ_I_DI 0 "register_operand" "=w")
-         (unspec:VSDQ_I_DI
-           [(match_operand:VSDQ_I_DI 1 "register_operand" "w")]
-          UNSPEC_ABS))]
-  "TARGET_SIMD"
-  "abs\t%<v>0<Vmtype>, %<v>1<Vmtype>"
-  [(set_attr "type" "neon_abs<q>")]
-)
-
 ;; It's tempting to represent SABD as ABS (MINUS op1 op2).
 ;; This isn't accurate as ABS treats always its input as a signed value.
 ;; So (ABS:QI (minus:QI 64 -128)) == (ABS:QI (192 or -64 signed)) == 64.
@@ -1318,9 +1305,8 @@
 (define_insn_and_split "*aarch64_abs_plus<mode>"
   [(set (match_operand:VDQ_BHSI 0 "register_operand" "=&w")
        (plus:VDQ_BHSI
-         (unspec:VDQ_BHSI
-           [(match_operand:VDQ_BHSI 1 "register_operand" "w")]
-           UNSPEC_ABS)
+         (abs:VDQ_BHSI
+           (match_operand:VDQ_BHSI 1 "register_operand" "w"))
          (match_operand:VDQ_BHSI 2 "register_operand" "w")))]
   "TARGET_SIMD && can_create_pseudo_p ()"
   "#"
diff --git a/gcc/config/aarch64/arm_fp16.h b/gcc/config/aarch64/arm_fp16.h
index c6356fdc78bf..f67a9e199880 100644
--- a/gcc/config/aarch64/arm_fp16.h
+++ b/gcc/config/aarch64/arm_fp16.h
@@ -40,7 +40,7 @@ __extension__ extern __inline float16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vabsh_f16 (float16_t __a)
 {
-  return __builtin_aarch64_abshf (__a);
+  return __builtin_fabs (__a);
 }
 
 __extension__ extern __inline uint16_t
diff --git a/gcc/config/aarch64/arm_neon.h b/gcc/config/aarch64/arm_neon.h
index af5294f81909..fba4a2d8c093 100644
--- a/gcc/config/aarch64/arm_neon.h
+++ b/gcc/config/aarch64/arm_neon.h
@@ -4509,104 +4509,6 @@ vabdq_f64 (float64x2_t __a, float64x2_t __b)
   return __builtin_aarch64_fabdv2df (__a, __b);
 }
 
-/* vabs  */
-
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_f32 (float32x2_t __a)
-{
-  return __builtin_aarch64_absv2sf (__a);
-}
-
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_f64 (float64x1_t __a)
-{
-  return (float64x1_t) {__builtin_fabs (__a[0])};
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s8 (int8x8_t __a)
-{
-  return __builtin_aarch64_absv8qi (__a);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s16 (int16x4_t __a)
-{
-  return __builtin_aarch64_absv4hi (__a);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s32 (int32x2_t __a)
-{
-  return __builtin_aarch64_absv2si (__a);
-}
-
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s64 (int64x1_t __a)
-{
-  return (int64x1_t) {__builtin_aarch64_absdi (__a[0])};
-}
-
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_f32 (float32x4_t __a)
-{
-  return __builtin_aarch64_absv4sf (__a);
-}
-
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_f64 (float64x2_t __a)
-{
-  return __builtin_aarch64_absv2df (__a);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s8 (int8x16_t __a)
-{
-  return __builtin_aarch64_absv16qi (__a);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s16 (int16x8_t __a)
-{
-  return __builtin_aarch64_absv8hi (__a);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s32 (int32x4_t __a)
-{
-  return __builtin_aarch64_absv4si (__a);
-}
-
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s64 (int64x2_t __a)
-{
-  return __builtin_aarch64_absv2di (__a);
-}
-
-/* Try to avoid moving between integer and vector registers.
-   For why the cast to unsigned is needed check the vnegd_s64 intrinsic.
-   There is a testcase related to this issue:
-   gcc.target/aarch64/vabsd_s64.c.  */
-
-__extension__ extern __inline int64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsd_s64 (int64_t __a)
-{
-  return __a < 0 ? - (uint64_t) __a : __a;
-}
-
 /* ARMv8.1-A intrinsics.  */
 #pragma GCC push_options
 #pragma GCC target ("+nothing+rdma")
@@ -17619,20 +17521,6 @@ vuqaddd_s64 (int64_t __a, uint64_t __b)
 
 /* ARMv8.2-A FP16 one operand vector intrinsics.  */
 
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_f16 (float16x4_t __a)
-{
-  return __builtin_aarch64_absv4hf (__a);
-}
-
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_f16 (float16x8_t __a)
-{
-  return __builtin_aarch64_absv8hf (__a);
-}
-
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vceqz_f16 (float16x4_t __a)
diff --git a/gcc/config/aarch64/iterators.md b/gcc/config/aarch64/iterators.md
index ae78fbe5b5bd..dfee954a5d54 100644
--- a/gcc/config/aarch64/iterators.md
+++ b/gcc/config/aarch64/iterators.md
@@ -926,7 +926,6 @@
  [
     UNSPEC_ASHIFT_SIGNED       ; Used in aarch-simd.md.
     UNSPEC_ASHIFT_UNSIGNED     ; Used in aarch64-simd.md.
-    UNSPEC_ABS         ; Used in aarch64-simd.md.
     UNSPEC_FCVTN_FP8   ; Used in aarch64-simd.md.
     UNSPEC_FCVTN2_FP8  ; Used in aarch64-builtins.cc.
     UNSPEC_F1CVTL_FP8  ; Used in aarch64-simd.md.
diff --git a/gcc/testsuite/gcc.target/aarch64/fneg-abs_1.c 
b/gcc/testsuite/gcc.target/aarch64/fneg-abs_1.c
index 43c37e21b50e..9af313f42203 100644
--- a/gcc/testsuite/gcc.target/aarch64/fneg-abs_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/fneg-abs_1.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O3" } */
+/* { dg-options "-O3 -fno-trapping-math" } */
 /* { dg-final { check-function-bodies "**" "" "" { target lp64 } } } */
 
 #pragma GCC target "+nosve"
diff --git a/gcc/testsuite/gcc.target/aarch64/neon/trapping_math.c 
b/gcc/testsuite/gcc.target/aarch64/neon/trapping_math.c
index 0f56da59c12e..9ad49b580422 100644
--- a/gcc/testsuite/gcc.target/aarch64/neon/trapping_math.c
+++ b/gcc/testsuite/gcc.target/aarch64/neon/trapping_math.c
@@ -72,3 +72,69 @@ test_vaddq_f64 (float64x2_t a, float64x2_t b)
 {
   vaddq_f64 (a, b);
 }
+
+/*
+** test_vabs_f16:
+** fabs        v[0-9]+\.4h, v0\.4h
+** ret
+*/
+void
+test_vabs_f16 (float16x4_t a)
+{
+  vabs_f16 (a);
+}
+
+/*
+** test_vabsq_f16:
+** fabs        v[0-9]+\.8h, v0\.8h
+** ret
+*/
+void
+test_vabsq_f16 (float16x8_t a)
+{
+  vabsq_f16 (a);
+}
+
+/*
+** test_vabs_f32:
+** fabs        v[0-9]+\.2s, v0\.2s
+** ret
+*/
+void
+test_vabs_f32 (float32x2_t a)
+{
+  vabs_f32 (a);
+}
+
+/*
+** test_vabsq_f32:
+** fabs        v[0-9]+\.4s, v0\.4s
+** ret
+*/
+void
+test_vabsq_f32 (float32x4_t a)
+{
+  vabsq_f32 (a);
+}
+
+/*
+** test_vabs_f64:
+** fabs        d[0-9]+, d0
+** ret
+*/
+void
+test_vabs_f64 (float64x1_t a)
+{
+  vabs_f64 (a);
+}
+
+/*
+** test_vabsq_f64:
+** fabs        v[0-9]+\.2d, v0\.2d
+** ret
+*/
+void
+test_vabsq_f64 (float64x2_t a)
+{
+  vabsq_f64 (a);
+}
diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vabs.c 
b/gcc/testsuite/gcc.target/aarch64/neon/vabs.c
new file mode 100644
index 000000000000..5b0bf5d48510
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vabs.c
@@ -0,0 +1,118 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+/*
+** test_vabs_f32:
+** fabs        v0\.2s, v0\.2s
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_f32, float32x2_t)
+
+/*
+** test_vabs_f64:
+** fabs        d0, d0
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_f64, float64x1_t)
+
+/*
+** test_vabs_s8:
+** abs v0\.8b, v0\.8b
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_s8, int8x8_t)
+
+/*
+** test_vabs_s16:
+** abs v0\.4h, v0\.4h
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_s16, int16x4_t)
+
+/*
+** test_vabs_s32:
+** abs v0\.2s, v0\.2s
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_s32, int32x2_t)
+
+/* FIXME (Karl Meakin): Performs abs in scalar register, even though it 
requires
+   extra moves:
+fmov   x31, d0
+cmp    x31, #?0
+csneg  x31, x31, x31, ge
+fmov   d0, x31
+*/
+
+/*
+** test_vabs_s64: { xfail *-*-* }
+** abs d0, d0
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_s64, int64x1_t)
+
+/*
+** test_vabsd_s64:
+** cmp x0, #?0
+** csneg       x0, x0, x0, ge
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsd_s64, int64_t)
+
+/*
+** test_vabsq_f32:
+** fabs        v0\.4s, v0\.4s
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_f32, float32x4_t)
+
+/*
+** test_vabsq_f64:
+** fabs        v0\.2d, v0\.2d
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_f64, float64x2_t)
+
+/*
+** test_vabsq_s8:
+** abs v0\.16b, v0\.16b
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_s8, int8x16_t)
+
+/*
+** test_vabsq_s16:
+** abs v0\.8h, v0\.8h
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_s16, int16x8_t)
+
+/*
+** test_vabsq_s32:
+** abs v0\.4s, v0\.4s
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_s32, int32x4_t)
+
+/*
+** test_vabsq_s64:
+** abs v0\.2d, v0\.2d
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_s64, int64x2_t)
+
+/*
+** test_vabs_f16:
+** fabs        v0\.4h, v0\.4h
+** ret
+*/
+TEST_UNIFORM_UNARY (vabs_f16, float16x4_t)
+
+/*
+** test_vabsq_f16:
+** fabs        v0\.8h, v0\.8h
+** ret
+*/
+TEST_UNIFORM_UNARY (vabsq_f16, float16x8_t)
diff --git a/gcc/testsuite/gcc.target/aarch64/singleton_intrinsics_1.c 
b/gcc/testsuite/gcc.target/aarch64/singleton_intrinsics_1.c
index 27360150b582..062d3aca375e 100644
--- a/gcc/testsuite/gcc.target/aarch64/singleton_intrinsics_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/singleton_intrinsics_1.c
@@ -19,7 +19,7 @@ test_vadd_s64 (int64x1_t a, int64x1_t b)
   return vadd_s64 (a, b);
 }
 
-/* { dg-final { scan-assembler-times "\\tabs\\td\[0-9\]+, d\[0-9\]+" 1 } } */
+/* { dg-final { scan-assembler-times "\\tabs\\td\[0-9\]+, d\[0-9\]+" 1 { xfail 
*-*-* } } } */
 
 int64x1_t
 test_vabs_s64 (int64x1_t a)
diff --git a/gcc/testsuite/gcc.target/aarch64/sve/fneg-abs_1.c 
b/gcc/testsuite/gcc.target/aarch64/sve/fneg-abs_1.c
index 03560008fda1..67c49cabcf19 100644
--- a/gcc/testsuite/gcc.target/aarch64/sve/fneg-abs_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/sve/fneg-abs_1.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O3" } */
+/* { dg-options "-O3 -fno-trapping-math" } */
 /* { dg-final { check-function-bodies "**" "" "" { target lp64 } } } */
 
 #include <arm_neon.h>
diff --git a/gcc/testsuite/gcc.target/aarch64/vabs_intrinsic_1.c 
b/gcc/testsuite/gcc.target/aarch64/vabs_intrinsic_1.c
index b18db7ec6411..f21771bfe890 100644
--- a/gcc/testsuite/gcc.target/aarch64/vabs_intrinsic_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/vabs_intrinsic_1.c
@@ -13,8 +13,9 @@ static void                                                   
\
 test_vabs##q##_##size (ETYPE (size) * res,                     \
                        const ETYPE (size) *in1)                \
 {                                                              \
-  VTYPE (size, lanes) a = vld1##q##_s##size (res);             \
-  VTYPE (size, lanes) b = vld1##q##_s##size (in1);             \
+  /* Use volatile to prevent constant folding.  */             \
+  volatile VTYPE (size, lanes) a = vld1##q##_s##size (res);    \
+  volatile VTYPE (size, lanes) b = vld1##q##_s##size (in1);    \
   a = vabs##q##_s##size (b);                                   \
   vst1##q##_s##size (res, a);                                  \
 }
@@ -54,15 +55,11 @@ test_##size (void)                                          
\
   ETYPE (size) res2[lanes_128] = {0};                          \
   ETYPE (size) expected2[lanes_128] = EXPECTED##lanes_128;     \
                                                                \
-  /* Forcefully avoid optimization.  */                                \
-  asm volatile ("" : : : "memory");                            \
   test_vabs_##size (res1, pool1);                              \
   for (i = 0; i < lanes_64; i++)                               \
     if (res1[i] != expected1[i])                               \
       abort ();                                                        \
                                                                \
-  /* Forcefully avoid optimization.  */                                \
-  asm volatile ("" : : : "memory");                            \
   test_vabsq_##size (res2, pool2);                             \
   for (i = 0; i < lanes_128; i++)                              \
     if (res2[i] != expected2[i])                               \

Reply via email to