no message

Author: Guillaume Piolat

source/inteli/avx2intrin.d

@@ -2374,8 +2374,83 @@ unittest
     assert(C.array == correctC);
 }
 
-// TODO __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) pure @safe
-// TODO __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) pure @safe
+/// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded 
+/// from addresses starting at `base_addr` and offset by each 64-bit element in `vindex` 
+/// (each index is scaled by the factor in `scale`). Return gathered elements. 
+/// `scale` should be 1, 2, 4 or 8.
+__m128i _mm256_i64gather_epi32(int scale)(const(int)* base_addr, __m256i vindex) @system
+{
+    __m128i src;
+    return _mm256_mask_i64gather_epi32!scale(src, base_addr, vindex, _mm_set1_epi32(-1));
+}
+unittest
+{
+    int[8] data = [0, 1, 2, 3, 
+                   4, 5, 6, 7]; 
+    __m256i vindex = _mm256_setr_epi64(-2, 4, 0, 2);
+    int4 A = cast(int4) _mm256_i64gather_epi32!2(&data[1], vindex);
+    int[4] correctA = [0, 3, 1, 2];
+    assert(A.array == correctA);
+}
+
+/// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded 
+/// from addresses starting at `base_addr` and offset by each 64-bit element in `vindex` 
+/// (each index is scaled by the factor in `scale`). Gathered elements are merged using 
+/// `mask` (elements are copied from `src` when the highest bit is not set in the 
+/// corresponding element). `scale` should be 1, 2, 4 or 8.
+__m128i _mm256_mask_i64gather_epi32(int scale)(__m128i src, const(int)* base_addr, __m256i vindex, __m128i mask) @system
+{
+    static assert(isValidSIBScale(scale));
+
+    static if (GDC_with_AVX2)
+    {
+        return cast(__m128i) __builtin_ia32_gatherdiv4si256(cast(int4)src, base_addr, cast(long4)vindex, cast(int4)mask, scale);
+    }
+    else static if (LDC_with_AVX2)
+    {
+        return cast(__m128i) __builtin_ia32_gatherq_d256(cast(int4)src, base_addr, cast(long4)vindex, cast(int4)mask, cast(ubyte)scale);
+    }
+    else
+    {
+        __m128i r = src;
+        long4 vindexl = cast(long4)vindex;
+        int4 srci = cast(int4)src;
+        int4 maski = cast(int4)mask;
+        for (int n = 0; n < 4; ++n)
+        {
+            long index = vindexl.array[n];
+            long offset = index * scale;
+            void* p = cast(void*)(base_addr);
+            if (maski.array[n] < 0)
+                r.ptr[n] = *cast(int*)(p + offset);
+            else
+                r.ptr[n] = srci.ptr[n];
+        }
+        return r;
+    }
+}
+unittest
+{
+    int[24] data = [0, 1, 2, 3, 
+                    4, 5, 6, 7, 
+                    8, 9, 10, 11, 
+                    12, 13, 14, 15,
+                    16, 17, 18, 19,
+                    20, 21, 22, 23];
+    __m128i src    = _mm_setr_epi32(-1, -2, -3, -4);
+    __m128i mask   = _mm_setr_epi32(-4,  4, -1, -2);
+    __m256i vindex = _mm256_setr_epi64(-4,  8, 0, 12);
+
+    int4 A = cast(int4) _mm256_mask_i64gather_epi32!1(src, &data[10], vindex, mask);
+    int4 B = cast(int4) _mm256_mask_i64gather_epi32!2(src, &data[10], vindex, mask);
+    int4 C = cast(int4) _mm256_mask_i64gather_epi32!4(src, &data[10], vindex, mask);
+    int[4] correctA = [9, -2, 10, 13];
+    int[4] correctB = [8, -2, 10, 16];
+    int[4] correctC = [6, -2, 10, 22];
+    assert(A.array == correctA);
+    assert(B.array == correctB);
+    assert(C.array == correctC);
+}
 // TODO __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) pure @safe
 // TODO __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) pure @safe
 // TODO __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) pure @safe
@@ -5534,27 +5609,4 @@ long2 __builtin_ia32_gatherq_q(long2, const void*, long2, long2, byte);
 pragma(LDC_intrinsic, "llvm.x86.avx2.gather.q.q.256")
 long4 __builtin_ia32_gatherq_q256(long4, const void*, long4, long4, byte);
 
-pragma(LDC_intrinsic, "llvm.x86.avx2.maskstore.d")
-void __builtin_ia32_maskstored(void*, int4, int4);
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.maskstore.d.256")
-void __builtin_ia32_maskstored256(void*, int8, int8);
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.maskstore.q")
-void __builtin_ia32_maskstoreq(void*, long2, long2);
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.maskstore.q.256")
-void __builtin_ia32_maskstoreq256(void*, long4, long4);
-
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.permd")
-int8 __builtin_ia32_permvarsi256(int8, int8) pure @safe;
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.permps")
-float8 __builtin_ia32_permvarsf256(float8, int8) pure @safe;
-
-
-pragma(LDC_intrinsic, "llvm.x86.avx2.pmovmskb")
-int __builtin_ia32_pmovmskb256(byte32) pure @safe;
-
 +/