Compiler Explorer

Source code

typedef unsigned char __uint8_t;
typedef unsigned short __uint16_t;
typedef unsigned __uint32_t;
typedef unsigned long __uint64_t;
template <bool, typename, typename> using If = __fp16 *;
struct Trans_NS_hwy_float16_t {
  __fp16 native;
};
template <typename> struct Relations {
  typedef unsigned Wide;
};
template <> struct Relations<__uint32_t> {
  typedef unsigned long Wide;
};
template <> struct Relations<Trans_NS_hwy_float16_t> {
  typedef unsigned short Unsigned;
  using Wide = float;
};
template <typename T> using MakeUnsigned = Relations<T>::Unsigned;
template <typename T> using MakeWide = Relations<T>::Wide;
typedef float float32_t;
typedef __SVUint8_t svuint8_t;
typedef __SVUint16_t svuint16_t;
typedef __SVUint32_t svuint32_t;
typedef __SVUint64_t svuint64_t;
typedef __SVFloat16_t svfloat16_t;
typedef __SVFloat32_t svfloat32_t;
typedef __SVBool_t svbool_t;
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16)))
svuint8_t svreinterpret_u8_u16(svuint16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32)))
svuint8_t svreinterpret_u8_u32(svuint32_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64)))
svuint8_t svreinterpret_u8_u64(svuint64_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16)))
svuint8_t svreinterpret_u8_f16(svfloat16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32)))
svuint8_t svreinterpret_u8_f32(svfloat32_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8)))
svuint16_t svreinterpret_u16_u8(svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8)))
svuint32_t svreinterpret_u32_u8(svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8)))
svuint64_t svreinterpret_u64_u8(svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8)))
svfloat16_t svreinterpret_f16_u8(svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8)))
svfloat32_t svreinterpret_f32_u8(svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
svuint32_t sveortb_n_u32(svuint32_t, svuint32_t, __uint32_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
svuint16_t sveortb_n_u16(svuint16_t, svuint16_t, __uint16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
svbool_t svcmplt_n_u8(svbool_t, svuint8_t, __uint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
svbool_t svcmplt_f16(svbool_t, svfloat16_t, svfloat16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
svuint8_t svext_u8(svuint8_t, svuint8_t, __uint64_t);
svfloat16_t svld1_f16(svbool_t, __fp16);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
svfloat16_t svmaxnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b8))) svbool_t
svptrue_b8();
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b32))) svbool_t
svptrue_b32();
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
svuint32_t svrevh_u32_x(svbool_t, svuint32_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
svuint64_t svrevw_u64_x(svbool_t, svuint64_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
svbool_t svsel_b(svbool_t, svbool_t, svbool_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
svuint8_t svsel_u8(svbool_t, svuint8_t, svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
svfloat16_t svsel_f16(svbool_t, svfloat16_t, svfloat16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
svuint8_t svsplice_u8(svbool_t, svuint8_t, svuint8_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16))) void
svst1_f16(svbool_t, __fp16 *, svfloat16_t);
__attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
svbool_t svwhilelt_b8_u32(__uint32_t, __uint32_t);
#pragma clang attribute push
template <typename Lane, int, int kPow2> struct Simd {
  using T = Lane;
  template <typename NewT> using Rebind = Simd<NewT, 0, 0>;
  template <typename NewT> using Repartition = Simd<NewT, 0, kPow2>;
};
template <typename T, int N> struct ClampNAndPow2 {
  using type = Simd<T, N, 0>;
};
template <typename T> struct ScalableTagChecker {
  using type = ClampNAndPow2<T, 256 / sizeof(T)>::type;
};
constexpr int kLimitPow2{1};
template <typename T> using ScalableTag = ScalableTagChecker<T>::type;
template <typename, int>
using CappedTag = ClampNAndPow2<Trans_NS_hwy_float16_t, kLimitPow2>::type;
template <class D> using TFromD = D::T;
template <class T, class D> using Rebind = D::template Rebind<T>;
template <class D> using RebindToUnsigned = Rebind<MakeUnsigned<TFromD<D>>, D>;
template <class T, class D> using Repartition = D::template Repartition<T>;
template <class D>
using RepartitionToWide = Repartition<MakeWide<TFromD<D>>, D>;
#pragma clang attribute(__attribute__((target("+sve2+sve2-aes,+sve"))),        \
                        apply_to = function)
If<0, __fp16, __fp16> StoreU___trans_tmp_20;
template <class> struct DFromV_t;
template <class V> using DFromV = DFromV_t<V>::type;
template <> struct DFromV_t<svuint32_t> {
  using type = ScalableTag<__uint32_t>;
};
template <> struct DFromV_t<svfloat16_t> {
  using type = ScalableTag<Trans_NS_hwy_float16_t>;
};
template <> struct DFromV_t<svfloat32_t> {
  using type = ScalableTag<float32_t>;
};
template <int N, int kPow2>
svbool_t FirstN(Simd<__uint8_t, N, kPow2>, int count) {
  return svwhilelt_b8_u32({}, count);
}
template <int N, int kPow2>
svbool_t FirstN(Simd<Trans_NS_hwy_float16_t, N, kPow2>, int count) {
  return svwhilelt_b8_u32({}, count);
}
template <int N, int kPow2> svbool_t PTrue(Simd<__uint32_t, N, kPow2>) {
  return svptrue_b32();
}
Simd<Trans_NS_hwy_float16_t, 1, 0> MakeMask_d, ReverseKeys2_d,
    SwapAdjacentQuads_d;
template <int N, int kPow2> svuint8_t Set(Simd<__uint8_t, N, kPow2>, __uint8_t);
template <int N, int kPow2>
svuint16_t Set(Simd<__uint16_t, N, kPow2>, __uint16_t);
template <int N, int kPow2>
svuint32_t Set(Simd<__uint32_t, N, kPow2>, __uint32_t);
template <int N, int kPow2>
svuint64_t Set(Simd<__uint64_t, N, kPow2>, __uint64_t);
template <int N, int kPow2>
svfloat16_t Set(Simd<Trans_NS_hwy_float16_t, N, kPow2>, Trans_NS_hwy_float16_t);
template <int N, int kPow2>
svfloat32_t Set(Simd<float32_t, N, kPow2>, float32_t);
template <class D> using VFromD = decltype(Set(D(), TFromD<D>()));
template <class D> VFromD<D> Zero(D);
svuint8_t BitCastToByte(svuint8_t v) { return v; }
template <int N, int kPow2>
svuint8_t BitCastFromByte(Simd<__uint8_t, N, kPow2>, svuint8_t v) {
  return v;
}
svuint8_t BitCastToByte(svuint16_t v) { return svreinterpret_u8_u16(v); }
template <int N, int kPow2>
svuint16_t BitCastFromByte(Simd<__uint16_t, N, kPow2>, svuint8_t v) {
  return svreinterpret_u16_u8(v);
}
svuint8_t BitCastToByte(svuint32_t v) { return svreinterpret_u8_u32(v); }
template <int N, int kPow2>
svuint32_t BitCastFromByte(Simd<__uint32_t, N, kPow2>, svuint8_t v) {
  return svreinterpret_u32_u8(v);
}
svuint8_t BitCastToByte(svuint64_t v) { return svreinterpret_u8_u64(v); }
template <int N, int kPow2>
svuint64_t BitCastFromByte(Simd<__uint64_t, N, kPow2>, svuint8_t v) {
  return svreinterpret_u64_u8(v);
}
svuint8_t BitCastToByte(svfloat16_t v) { return svreinterpret_u8_f16(v); }
template <int N, int kPow2>
svfloat16_t BitCastFromByte(Simd<Trans_NS_hwy_float16_t, N, kPow2>,
                            svuint8_t v) {
  return svreinterpret_f16_u8(v);
}
svuint8_t BitCastToByte(svfloat32_t v) { return svreinterpret_u8_f32(v); }
template <int N, int kPow2>
svfloat32_t BitCastFromByte(Simd<float32_t, N, kPow2>, svuint8_t v) {
  return svreinterpret_f32_u8(v);
}
template <class D, class FromV> VFromD<D> BitCast(D d, FromV v) {
  svuint8_t __trans_tmp_3 = BitCastToByte(v);
  return BitCastFromByte(d, __trans_tmp_3);
}
template <class V> svbool_t Gt(V);
template <class V> V Min(V a, V b) {
  svfloat16_t __trans_tmp_36, __trans_tmp_25;
  svbool_t __trans_tmp_27;
  svbool_t __trans_tmp_24;
  svbool_t __trans_tmp_19;
  __trans_tmp_24 = svcmplt_f16(svptrue_b8(), __trans_tmp_25, b);
  __trans_tmp_27 = svcmplt_f16(svptrue_b8(), a, b);
  __trans_tmp_19 = svsel_b(__trans_tmp_24, __trans_tmp_24, __trans_tmp_27);
  __trans_tmp_36 = svsel_f16(__trans_tmp_19, a, b);
  return __trans_tmp_36;
}
svbool_t MaskFromVec(int);
template <int N, int kPow2>
svfloat16_t LoadU(Simd<Trans_NS_hwy_float16_t, N, kPow2>,
                  Trans_NS_hwy_float16_t *) {
  svbool_t __trans_tmp_35;
  int __trans_tmp_2;
  __trans_tmp_35 = FirstN(MakeMask_d, __trans_tmp_2);
  svbool_t __trans_tmp_7 = __trans_tmp_35;
  return svld1_f16(__trans_tmp_7, 0);
}
template <int N, int kPow2>
void StoreU(svfloat16_t v, Simd<Trans_NS_hwy_float16_t, N, kPow2>,
            Trans_NS_hwy_float16_t *p) {
  svbool_t __trans_tmp_38;
  int __trans_tmp_2;
  __trans_tmp_38 = FirstN(MakeMask_d, __trans_tmp_2);
  StoreU___trans_tmp_20 = &p->native;
  svst1_f16(__trans_tmp_38, StoreU___trans_tmp_20, v);
}
template <int N, int kPow2>
void BlendedStore(svfloat16_t v, svbool_t m,
                  Simd<Trans_NS_hwy_float16_t, N, kPow2>) {
  If<0, __fp16, __fp16> __trans_tmp_22;
  svst1_f16(m, __trans_tmp_22, v);
}
template <int kIndex> svuint8_t Ext(svuint8_t hi, svuint8_t lo) {
  return svext_u8(lo, hi, kIndex);
}
svuint16_t OddEven(svuint16_t odd, svuint16_t even) {
  return sveortb_n_u16(even, odd, 0);
}
svuint32_t OddEven(svuint32_t odd, svuint32_t even) {
  return sveortb_n_u32(even, odd, 0);
}
template <class V> V OddEven(V odd, V even) {
  DFromV<V> d;
  RebindToUnsigned<decltype(d)> du;
  svuint16_t __trans_tmp_50 = OddEven(BitCast(du, odd), BitCast(du, even));
  return BitCast(d, __trans_tmp_50);
}
VFromD<Simd<Trans_NS_hwy_float16_t, 1, 0>>
Reverse2(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
         VFromD<Simd<Trans_NS_hwy_float16_t, 1, 0>> v) {
  RebindToUnsigned<decltype(d)> du;
  RepartitionToWide<decltype(du)> dw;
  svbool_t __trans_tmp_12;
  svuint32_t __trans_tmp_11 = svrevh_u32_x(__trans_tmp_12, BitCast(dw, v));
  return BitCast(d, __trans_tmp_11);
}
VFromD<Simd<unsigned, 4, 0>> Reverse2(Simd<unsigned, 64, 0> d,
                                      VFromD<Simd<unsigned, 4, 0>> v) {
  RepartitionToWide<decltype(d)> dw;
  svbool_t __trans_tmp_14 = PTrue(d);
  svuint64_t __trans_tmp_13 = svrevw_u64_x(__trans_tmp_14, BitCast(dw, v));
  return BitCast(d, __trans_tmp_13);
}
Simd<char, 0, 0> CombineShiftRightBytes_d;
template <int kBytes, class V> V CombineShiftRightBytes(V hi, V lo) {
  svuint8_t __trans_tmp_33, __trans_tmp_15;
  svuint8_t __trans_tmp_32;
  Repartition<__uint8_t, decltype(CombineShiftRightBytes_d)> d8;
  svbool_t __trans_tmp_16 = FirstN(d8, kBytes);
  __trans_tmp_32 = svsplice_u8(__trans_tmp_16, hi, hi);
  auto lo_down = Ext<kBytes>(lo, lo);
  svbool_t __trans_tmp_34;
  __trans_tmp_34 = svcmplt_n_u8(svptrue_b8(), __trans_tmp_15, 0);
  __trans_tmp_33 = svsel_u8(__trans_tmp_34, lo_down, __trans_tmp_32);
  return __trans_tmp_33;
}
template <class V> V Shuffle2301(V v) {
  DFromV<V> d;
  return Reverse2(d, v);
}
template <class V> V Shuffle1032(V v) {
  DFromV<V> d;
  Repartition<__uint8_t, decltype(d)> d8;
  svuint8_t v8 = BitCast(d8, v);
  return BitCast(d, CombineShiftRightBytes<8>(v8, v8));
}
template <class D> using Vec = decltype(Zero(D()));
template <class> using Mask = decltype(MaskFromVec(0));
template <class Base> struct SharedTraits : Base {
  template <class D> Vec<D> SortPairsDistance2(D d, Vec<D> v) {
    Base base;
    Vec<D> swapped = base.SwapAdjacentPairs(d, v);
    base.Sort2(d, v, swapped);
    return base.OddEvenPairs(d, swapped, v);
  }
};
struct TraitsLane;
template <int, class V>
void Merge16x4(Simd<Trans_NS_hwy_float16_t, 1, 0>, TraitsLane, V, V &, V &, V &,
               V &, V, V &, V &, V &, V &, V &);
Simd<Trans_NS_hwy_float16_t, 1, 0> Merge16x16_d;
template <int, class Traits, class V>
__attribute((always_inline)) void Merge16x16(Traits st, V &v0, V &v2, V &v5,
                                             V &v6, V &v7, V &v9, V &va, V &vb,
                                             V &vc, V &vd, V &ve, V &vf) {
  v2 = st.SortPairsDistance4(Merge16x16_d, v2);
  v5 = st.SortPairsDistance4(Merge16x16_d, v5);
  v6 = st.SortPairsDistance4(Merge16x16_d, v6);
  v7 = st.SortPairsDistance4(Merge16x16_d, v7);
  v9 = st.SortPairsDistance4(Merge16x16_d, v9);
  va = st.SortPairsDistance4(Merge16x16_d, va);
  vb = st.SortPairsDistance4(Merge16x16_d, vb);
  vc = st.SortPairsDistance4(Merge16x16_d, vc);
  vd = st.SortPairsDistance4(Merge16x16_d, vd);
  vf = st.SortPairsDistance4(Merge16x16_d, vf);
  v0 = st.SortPairsDistance2(Merge16x16_d, v0);
  va = st.SortPairsDistance1(Merge16x16_d, va);
  vb = st.SortPairsDistance1(Merge16x16_d, vb);
  vc = st.SortPairsDistance1(Merge16x16_d, vc);
  vd = st.SortPairsDistance1(Merge16x16_d, vd);
  ve = st.SortPairsDistance1(Merge16x16_d, ve);
}
template <class V> V OddEvenKeys(V odd, V even) { return OddEven(odd, even); }
struct KeyLane {
  Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>>
  SwapAdjacentPairs(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
                    Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> v) {
    Repartition<__uint32_t, Simd<int, 1, 0>> du32;
    return BitCast(d, Shuffle2301(BitCast(du32, v)));
  }
  Vec<Simd<float, 0, 0>> SwapAdjacentPairs(Vec<Simd<float, 0, 0>> v) {
    return Shuffle1032(v);
  }
  Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>>
  OddEvenPairs(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
               Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> odd,
               Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> even) {
    RepartitionToWide<Simd<int, 1, 0>> dw;
    return BitCast(d, OddEven(BitCast(dw, odd), BitCast(dw, even)));
  }
};
struct TraitsLane : KeyLane {
  void Sort2(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
             Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> &a,
             Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> &b) {
    Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_52, a_copy = a;
    Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_45;
    __trans_tmp_45 = Min(a, b);
    a = __trans_tmp_45;
    {
      Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_53 = b;
      {
        svfloat16_t __trans_tmp_29 =
            svmaxnm_f16_x(svptrue_b8(), a_copy, __trans_tmp_53);
        __trans_tmp_52 = __trans_tmp_29;
      }
    }
    b = __trans_tmp_52;
  }
  Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>>
  SortPairsDistance1(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
                     Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> v) {
    Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_48 =
        Reverse2(ReverseKeys2_d, v);
    Sort2(d, v, __trans_tmp_48);
    return OddEvenKeys(__trans_tmp_48, v);
  }
  Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>>
  SortPairsDistance4(Simd<Trans_NS_hwy_float16_t, 1, 0> d,
                     Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> v) {
    Vec<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_42, __trans_tmp_39;
    RepartitionToWide<Simd<Trans_NS_hwy_float16_t, 1, 0>> dw;
    __trans_tmp_39 =
        BitCast(SwapAdjacentQuads_d, SwapAdjacentPairs(BitCast(dw, v)));
    Sort2(d, v, __trans_tmp_39);
    {
      VFromD<Simd<Trans_NS_hwy_float16_t, 1, 0>> __trans_tmp_51(v);
      __trans_tmp_42 = OddEven(__trans_tmp_39, __trans_tmp_51);
    }
    return __trans_tmp_42;
  }
};
void Sort2To2(SharedTraits<TraitsLane>, Trans_NS_hwy_float16_t *, int,
              Trans_NS_hwy_float16_t *);
template <int kKeysPerRow>
void Sort16Rows(SharedTraits<TraitsLane> st, Trans_NS_hwy_float16_t *keys, int,
                Trans_NS_hwy_float16_t *) {
  CappedTag<Trans_NS_hwy_float16_t, kKeysPerRow> d;
  using V = Vec<decltype(d)>;
  V v8, v9, va, vb, vc, vd, ve, vf, v2 = LoadU(d, keys), v4, v7;
  V v0 = LoadU(d, keys);
  V v3 = LoadU(d, keys + 3 * kKeysPerRow);
  V v5;
  V v6 = LoadU(d, keys);
  V kIota;
  Mask<decltype(d)> m8 = Gt(kIota);
  Mask<decltype(d)> m9 = Gt(0);
  Mask<decltype(d)> ma = Gt(0);
  Mask<decltype(d)> mb = Gt(0);
  Mask<decltype(d)> mc = Gt(0);
  Mask<decltype(d)> md = Gt(0);
  Mask<decltype(d)> me = Gt(0);
  Mask<decltype(d)> mf = Gt(0);
  Merge16x4<kKeysPerRow>(d, st, v4, v5, v7, v8, v9, va, vb, vc, vd, ve, vf);
  Merge16x16<kKeysPerRow>(st, v0, v2, v5, v6, v7, v9, va, vb, vc, vd, ve, vf);
  StoreU(v0, d, keys);
  StoreU(v2, d, keys + 2);
  StoreU(v3, d, keys + 3 * kKeysPerRow);
  StoreU(v5, d, keys + 5);
  StoreU(v6, d, keys + 6);
  StoreU(v7, d, keys + 7);
  BlendedStore(v8, m8, d);
  BlendedStore(v9, m9, d);
  BlendedStore(va, ma, d);
  BlendedStore(vb, mb, d);
  BlendedStore(vc, mc, d);
  BlendedStore(vd, md, d);
  BlendedStore(ve, me, d);
  BlendedStore(vf, mf, d);
}
decltype(&Sort2To2) BaseCase_fun = 1 ? Sort16Rows<6> : nullptr;
#pragma clang attribute pop