From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-bugzilla@gcc.gnu.org>
Received: by sourceware.org (Postfix, from userid 48)
	id 744E13858C20; Tue,  5 Sep 2023 16:24:56 +0000 (GMT)
DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 744E13858C20
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org;
	s=default; t=1693931096;
	bh=9OVzSHwN0o5u2kjYJk+rlBFQQMeMe4XhEap64winZDw=;
	h=From:To:Subject:Date:In-Reply-To:References:From;
	b=NU6FYUSdjdcvrLkNe2PwIjqctHQsjR88jlG40QJB+f6lg2TbZAI5r78aEcSbN6Zrc
	 0MMXI7spcCea6mlU+9jAd/HFzroLS18mlH3U4SvHmLZ2CVWehHnbey2z9x3SuBxSeV
	 GjNPXBHWczKyBHjDPefQaAgJY3739UQibxvGLw4s=
From: "malat at debian dot org" <gcc-bugzilla@gcc.gnu.org>
To: gcc-bugs@gcc.gnu.org
Subject: [Bug target/111231] armhf: Miscompilation at O2 level (O1 is
 working)
Date: Tue, 05 Sep 2023 16:24:56 +0000
X-Bugzilla-Reason: CC
X-Bugzilla-Type: changed
X-Bugzilla-Watch-Reason: None
X-Bugzilla-Product: gcc
X-Bugzilla-Component: target
X-Bugzilla-Version: 13.2.0
X-Bugzilla-Keywords: wrong-code
X-Bugzilla-Severity: normal
X-Bugzilla-Who: malat at debian dot org
X-Bugzilla-Status: UNCONFIRMED
X-Bugzilla-Resolution: 
X-Bugzilla-Priority: P3
X-Bugzilla-Assigned-To: unassigned at gcc dot gnu.org
X-Bugzilla-Target-Milestone: ---
X-Bugzilla-Flags: 
X-Bugzilla-Changed-Fields: 
Message-ID: <bug-111231-4-kEYT7mgRHW@http.gcc.gnu.org/bugzilla/>
In-Reply-To: <bug-111231-4@http.gcc.gnu.org/bugzilla/>
References: <bug-111231-4@http.gcc.gnu.org/bugzilla/>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Bugzilla-URL: http://gcc.gnu.org/bugzilla/
Auto-Submitted: auto-generated
MIME-Version: 1.0
List-Id: <gcc-bugs.sourceware.org>

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=3D111231

--- Comment #5 from Mathieu Malaterre <malat at debian dot org> ---
Result from cvise (+manual editing):

c++ -Wfatal-errors -Wall -Wextra -Werror -o works -O1 -march=3Darmv7-a
-mfpu=3Dneon-vfpv4 -mfloat-abi=3Dhard -mfp16-format=3Dieee step7.cc
-> exit(0)

c++ -Wfatal-errors -Wall -Wextra -Werror -o fails -O2 -march=3Darmv7-a
-mfpu=3Dneon-vfpv4 -mfloat-abi=3Dhard -mfp16-format=3Dieee step7.cc
-> exit(42)

Where:

% cat step7.cc=20
#include <inttypes.h>
#include <stddef.h>
#define HWY_MIN(a, b) a < b
template <size_t kBytes, typename From, typename To>
void CopyBytes(From from, To to) {
  __builtin_memcpy(to, from, kBytes);
}
template <typename From, typename To> void CopySameSize(From from, To to) {
  CopyBytes<sizeof(int)>(from, to);
}
struct Relations {
  using Wide =3D int16_t;
};
template <typename> using MakeWide =3D Relations::Wide;
#if 0
#else
#define HWY_LANES(T) (sizeof(T))
#endif
namespace detail {
constexpr size_t ScaleByPower(size_t N, int pow2) { return pow2 >=3D 0 ? N =
: 0; }
} // namespace detail
template <typename Lane, size_t N, int kPow2> struct Simd {
  using T =3D Lane;
  static constexpr size_t kWhole =3D N;
  static constexpr int kFrac =3D 0;
  static constexpr size_t kPrivateLanes =3D detail::ScaleByPower(kWhole, kF=
rac);
  constexpr size_t MaxBytes() { return kPrivateLanes; }
  template <typename> static constexpr size_t RepartitionLanes() {
    return sizeof(int);
  }
  template <int kNewPow2, size_t kNewMaxLanes>
  static constexpr size_t WholeN() {
    return detail::ScaleByPower(kNewMaxLanes, kNewPow2);
  }
  template <int kNewPow2, size_t kNewMaxLanes> static constexpr size_t NewN=
() {
    return WholeN<kNewPow2, kNewMaxLanes>();
  }
  template <typename> using Rebind =3D Simd;
  template <typename NewT>
  using Repartition =3D
      Simd<NewT, NewN<kPow2, RepartitionLanes<NewT>()>(), kPow2>;
};
namespace detail {
template <typename T, size_t N, int> struct ClampNAndPow2 {
  using type =3D Simd<T, HWY_MIN(N, 6), 3>;
};
template <typename T, size_t, int kPow2> struct CappedTagChecker {
  static constexpr size_t N =3D HWY_LANES(T);
  using type =3D typename ClampNAndPow2<T, N, kPow2>::type;
};
} // namespace detail
template <typename T, size_t kLimit, int kPow2 =3D 0>
using CappedTag =3D typename detail::CappedTagChecker<T, kLimit, kPow2>::ty=
pe;
template <class D> using TFromD =3D typename D::T;
#define HWY_MAX_LANES_D(D) D::kPrivateLanes
template <class D> size_t MaxLanes(D) { return HWY_MAX_LANES_D(D); }
template <class D> size_t Lanes(D) { return HWY_MAX_LANES_D(D); }
template <class T, class D> using Rebind =3D typename D::Rebind<T>;
template <class D> using RebindToUnsigned =3D Rebind<D, D>;
template <class T, class D> using Repartition =3D typename D::Repartition<T=
>;
template <class D> using RepartitionToWide =3D Repartition<MakeWide<D>, D>;
#include <cmath>
#include <cstring>
#include <memory>
namespace hwy {
template <typename T, size_t> struct Vec128 {
  T raw[16 / sizeof(T)];
};
template <class D> Vec128<TFromD<D>, HWY_MAX_LANES_D(D)> Zero(D);
template <class D> using VFromD =3D decltype(Zero(D()));
template <class D, class VFrom> VFromD<D> BitCast(D, VFrom v) {
  VFromD<D> to;
  CopySameSize(&v, &to);
  return to;
}
template <class D, typename T2> VFromD<D> Set(D d, T2 t) {
  VFromD<D> v;
  for (size_t i =3D 0; i < MaxLanes(d); ++i)
    v.raw[i] =3D t;
  return v;
}
template <typename T, size_t N> Vec128<T, N> SaturatedAdd(Vec128<T, N> b) {
  Vec128<T, N> a;
  using TW =3D T;
  for (size_t i =3D 0; i < N; ++i)
    a.raw[i] =3D HWY_MIN(TW() + b.raw[i], T());
  return a;
}
template <class D> void Store(VFromD<D> v, D d, TFromD<D> *aligned) {
  CopyBytes<d.MaxBytes()>(v.raw, aligned);
}
template <class D> using Vec =3D decltype(Zero(D()));
template <class DI16, class VU8, class VI8>
Vec<DI16> SatWidenMulPairwiseAdd(DI16 di16, VU8 a, VI8 b) {
  RebindToUnsigned<decltype(di16)> du16;
  auto a1 =3D BitCast(du16, a), b1(BitCast(di16, b));
  return SaturatedAdd(a1);
}
using AllocPtr =3D void *(void *, size_t);
using FreePtr =3D void (*)(void *, void *);
void *AllocateAlignedBytes(size_t size, AllocPtr, void *) {
        return aligned_alloc(4096, size);

}
void FreeAlignedBytes(const void *ptr, FreePtr, void *) {
        free((void*)ptr);
}
AllocPtr *AllocateAlignedItems_alloc_ptr;
template <typename T> T *AllocateAlignedItems(size_t items) {
  size_t size =3D sizeof(T);
  bool is_pow2 =3D 0;
  size_t bits(size);
  size_t bytes =3D is_pow2 ? bits : items;
  return static_cast<T *>(
      AllocateAlignedBytes(bytes, AllocateAlignedItems_alloc_ptr, 0));
}
struct AlignedFreer {
  AlignedFreer(FreePtr free_ptr, void *opaque_ptr)
      : free_(free_ptr), opaque_ptr_(opaque_ptr) {}
  template <typename T> void operator()(T aligned_pointer) {
    FreeAlignedBytes(aligned_pointer, free_, opaque_ptr_);
  }
  FreePtr free_;
  void *opaque_ptr_;
};
template <typename T>
using AlignedFreeUniquePtr =3D std::unique_ptr<T, AlignedFreer>;
FreePtr AllocateAligned_free;
template <typename T>
AlignedFreeUniquePtr<T[]> AllocateAligned(size_t items, void *opaque) {
  T *__trans_tmp_1 =3D AllocateAlignedItems<T>(items);
  return AlignedFreeUniquePtr<T[]>(__trans_tmp_1,
                                   AlignedFreer(AllocateAligned_free, opaqu=
e));
}
template <typename T> AlignedFreeUniquePtr<T[]> AllocateAligned(size_t item=
s) {
  return AllocateAligned<T>(items, nullptr);
}
void AssertArrayEqual2(void *a, void *b, size_t c, const char *, int) {
  if (memcmp(a, b, c))
    exit(42);
}
template <class n, typename o =3D TFromD<n>>
void p(n d, Vec<n> expected, Vec<n> actual, const char *ab, int ac) {
  size_t q =3D Lanes(d);
  auto r =3D AllocateAligned<o>(q), s =3D AllocateAligned<o>(q);
  Store(expected, d, r.get());
  Store(actual, d, s.get());
  AssertArrayEqual2(r.get(), s.get(), q, ab, ac);
}
#define t(d, expected, actual) p(d, expected, actual, __FILE__, __LINE__)
template <typename o, size_t u, class v> struct w {
  static void x(size_t ae, size_t af) {
    CappedTag<o, u> d;
    size_t ag =3D Lanes(d);
    if (ag < ae)
      return;
    if (af)
      v()(o(), d);
  }
};
struct y {
  template <typename b, class c> void operator()(b, c d) {
    RepartitionToWide<c> aa;
    size_t g =3D Lanes(d);
    RebindToUnsigned<decltype(d)> h;
    auto m =3D 0, j =3D Set(h, b()), k =3D Set(aa, 0);
    for (size_t i =3D 0; i < g; i++)
      t(aa, k, SatWidenMulPairwiseAdd(aa, j, m));
  }
};
template <int ah =3D 1> struct ai {
  template <typename o> void operator()(o) {
    size_t aj =3D ah;
    constexpr size_t ak HWY_LANES(o);
    size_t af =3D ak;
    w<o, ak, y>::x(aj, af);
  }
};
void l() { ai()(int8_t()); }
} // namespace hwy
int main() { hwy::l(); }=