https://gcc.gnu.org/g:67c0ac1c6b624698d30c1e2c430201699b6beac1

commit r17-5888-g67c0ac1c6b624698d30c1e2c430201699b6beac1
Author: Karl Meakin <[email protected]>
Date:   Wed Jul 29 19:10:01 2026 +0000

    aarch64: Fix vadd behaviour on overflow
    
    Fix the behaviour of the `vadd` family of intrinsics on signed integer
    overflow. Previously, they followed the standard C semantics where
    signed overflow was undefined behaviour; but the ACLE requires signed
    overflow to have wraparound semantics. Fix by casting to unsigned before
    performing the addition.
    
    Also add tests for some floating point addition intrinsics that were
    missed.
    
    gcc/ChangeLog:
    
            * config/aarch64/aarch64-neon-builtins-base.cc (gimple_arith):
            New struct.
            (vaddd, vadd, vaddq): Use `gimple_arith` rather than
            `gimple_expr`.
            * config/aarch64/aarch64-neon-builtins-base.def: Reorder
            definitions and add comments.
    
    gcc/testsuite/ChangeLog:
    
            * gcc.target/aarch64/neon/vadd.c: Add tests for `vadd_f16`,
            `vadd_f32`, `vadd_f64`.

Diff:
---
 gcc/config/aarch64/aarch64-neon-builtins-base.cc  | 68 ++++++++++++++++++++++-
 gcc/config/aarch64/aarch64-neon-builtins-base.def |  6 +-
 gcc/testsuite/gcc.target/aarch64/neon/vadd.c      | 23 +++++++-
 3 files changed, 92 insertions(+), 5 deletions(-)

diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.cc 
b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
index b00aed7c7d77..0bdef25c8668 100644
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.cc
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
@@ -221,6 +221,70 @@ public:
   }
 };
 
+/* Like gimple_expr above, but converts signed inputs to unsigned first, to
+   avoid undefined behaviour on overflow.  */
+class gimple_arith : public gimple_function_base
+{
+  tree_code m_int_code;
+  tree_code m_float_code;
+  tree_code m_poly_code;
+
+public:
+  constexpr gimple_arith (tree_code code)
+    : m_int_code (code), m_float_code (code), m_poly_code (code)
+  {}
+
+  constexpr gimple_arith (tree_code int_code, tree_code float_code,
+                         tree_code poly_code)
+    : m_int_code (int_code), m_float_code (float_code), m_poly_code (poly_code)
+  {}
+
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto nargs = gimple_call_num_args (f.call);
+    auto arg0 = nargs >= 1 ? gimple_call_arg (f.call, 0) : nullptr;
+    auto arg1 = nargs >= 2 ? gimple_call_arg (f.call, 1) : nullptr;
+    auto build = [&] (auto code, auto type) {
+      auto ret = nargs == 1 ? fold_build1 (code, type, arg0)
+                           : fold_build2 (code, type, arg0, arg1);
+      return f.force_val (ret);
+    };
+
+    tree ret;
+    auto type_class = f.type_suffix (0).tclass;
+    switch (type_class)
+      {
+      case TYPE_signed:
+       {
+         auto signed_type = TREE_TYPE (arg0);
+         auto unsigned_type = unsigned_type_for (signed_type);
+         auto to_unsigned = [&] (auto arg) {
+           return arg ? f.force_val (build_cast (unsigned_type, arg))
+                      : nullptr;
+         };
+         arg0 = to_unsigned (arg0);
+         arg1 = to_unsigned (arg1);
+         ret = build (m_int_code, unsigned_type);
+         ret = build_cast (signed_type, f.force_val (ret));
+         break;
+       }
+      case TYPE_unsigned:
+       ret = build (m_int_code, TREE_TYPE (arg0));
+       break;
+      case TYPE_float:
+       ret = build (m_float_code, TREE_TYPE (arg0));
+       break;
+      case TYPE_poly:
+       ret = build (m_poly_code, TREE_TYPE (arg0));
+       break;
+      default:
+       gcc_unreachable ();
+      }
+
+    return gimple_build_assign (f.lhs, ret);
+  }
+};
+
 struct gimple_create : public gimple_function_base
 {
   gimple *fold (gimple_folder &f) const override
@@ -778,9 +842,7 @@ NEON_FUNCTION (vdupb_lane, vdupb_laneq, vduph_lane,   
vduph_laneq,
               vdups_lane, vdups_laneq, vdupd_lane,   vdupd_laneq, 
gimple_get_lane,)
 
 // Lanewise arithmetic
-NEON_FUNCTION (vaddd, gimple_expr, (PLUS_EXPR))
-NEON_FUNCTION (vadd,  gimple_expr, (PLUS_EXPR, PLUS_EXPR, BIT_XOR_EXPR))
-NEON_FUNCTION (vaddq, gimple_expr, (PLUS_EXPR, PLUS_EXPR, BIT_XOR_EXPR))
+NEON_FUNCTION (vadd, vaddq, vaddd, gimple_arith, (PLUS_EXPR, PLUS_EXPR, 
BIT_XOR_EXPR))
 
 // Saturating arithmetic
 NEON_FUNCTION (vqaddb, vqaddh, vqadds, vqaddd, vqadd, vqaddq, gimple_ifn, 
(IFN_SAT_ADD))
diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.def 
b/gcc/config/aarch64/aarch64-neon-builtins-base.def
index df33c37c34fc..d7a6657e3f0c 100644
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.def
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.def
@@ -63,15 +63,19 @@ DEF_NEON_FUNCTION (vcopyq_laneq, neon_copy_lane,
 
 // Lanewise arithmetic
 #define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
+// Addition
 DEF_NEON_FUNCTION (vaddd, d_integer,        ("s0,s0,s0"))
 DEF_NEON_FUNCTION (vadd,  all_arith_no_fp16, ("D0,D0,D0"))
-DEF_NEON_FUNCTION (vadd,  bhd_poly,         ("D0,D0,D0"))
 DEF_NEON_FUNCTION (vaddq, all_arith_no_fp16, ("Q0,Q0,Q0"))
+
+// Polynomial "addition" (really xor)
+DEF_NEON_FUNCTION (vadd,  bhd_poly,         ("D0,D0,D0"))
 DEF_NEON_FUNCTION (vaddq, bhdq_poly,        ("Q0,Q0,Q0"))
 #undef REQUIRED_EXTENSIONS
 
 // Lanewise arithmetic (FP16)
 #define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD | 
AARCH64_FL_F16)
+// Addition
 DEF_NEON_FUNCTION (vadd,  h_float, ("D0,D0,D0"))
 DEF_NEON_FUNCTION (vaddq, h_float, ("Q0,Q0,Q0"))
 #undef REQUIRED_EXTENSIONS
diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vadd.c 
b/gcc/testsuite/gcc.target/aarch64/neon/vadd.c
index e622718685db..e1bfec03ba07 100644
--- a/gcc/testsuite/gcc.target/aarch64/neon/vadd.c
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vadd.c
@@ -38,6 +38,13 @@ TEST_UNIFORM_BINARY (vadd_u16, uint16x4_t)
 */
 TEST_UNIFORM_BINARY (vadd_s16, int16x4_t)
 
+/*
+** test_vadd_f16:
+** fadd        v0\.4h, (v0\.4h, v1\.4h|v1\.4h, v0\.4h)
+** ret
+*/
+TEST_UNIFORM_BINARY (vadd_f16, float16x4_t)
+
 /*
 ** test_vadd_p16:
 ** eor v0\.8b, (v0\.8b, v1\.8b|v1\.8b, v0\.8b)
@@ -59,6 +66,13 @@ TEST_UNIFORM_BINARY (vadd_u32, uint32x2_t)
 */
 TEST_UNIFORM_BINARY (vadd_s32, int32x2_t)
 
+/*
+** test_vadd_f32:
+** fadd        v0\.2s, (v0\.2s, v1\.2s|v1\.2s, v0\.2s)
+** ret
+*/
+TEST_UNIFORM_BINARY (vadd_f32, float32x2_t)
+
 /*
 ** test_vadd_u64:
 ** add d0, (d0, d1|d1, d0)
@@ -73,6 +87,13 @@ TEST_UNIFORM_BINARY (vadd_u64, uint64x1_t)
 */
 TEST_UNIFORM_BINARY (vadd_s64, int64x1_t)
 
+/*
+** test_vadd_f64:
+** fadd        d0, (d0, d1|d1, d0)
+** ret
+*/
+TEST_UNIFORM_BINARY (vadd_f64, float64x1_t)
+
 /*
 ** test_vadd_p64:
 ** eor v0\.8b, (v0\.8b, v1\.8b|v1\.8b, v0\.8b)
@@ -179,7 +200,7 @@ TEST_UNIFORM_BINARY (vaddq_f64, float64x2_t)
 TEST_UNIFORM_BINARY (vaddq_p64, poly64x2_t)
 
 /* `poly128_t` is a scalar type, like `__uint128_t`, so it is passed in two GPR
-    registers.  *
+    registers.  */
 /*
 ** test_vaddq_p128:
 ** eor x[0-9], x[0-9]+, x[0-9]+

Reply via email to