Like in the previous patch, Peter has suggested not changing the instruction
names if dense math registers are supported.  If so, this patch likely will be
dropped.

Add a new test to see if we changed the name of the MMA instructions if
-mcpu=future.

gcc/testsuite/

        * gcc.target/powerpc/dm-double-test.c: New test.
        * lib/target-supports.exp (check_effective_target_ppc_dmr_ok): New
        target test.
---
 .../gcc.target/powerpc/dm-double-test.c       | 194 ++++++++++++++++++
 gcc/testsuite/lib/target-supports.exp         |  23 +++
 2 files changed, 217 insertions(+)
 create mode 100644 gcc/testsuite/gcc.target/powerpc/dm-double-test.c

diff --git a/gcc/testsuite/gcc.target/powerpc/dm-double-test.c 
b/gcc/testsuite/gcc.target/powerpc/dm-double-test.c
new file mode 100644
index 00000000000..66c19779585
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/dm-double-test.c
@@ -0,0 +1,194 @@
+/* Test derived from mma-double-1.c, modified for dense math.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target powerpc_dense_math_ok } */
+/* { dg-options "-mdejagnu-cpu=future -O2" } */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <altivec.h>
+
+typedef unsigned char vec_t __attribute__ ((vector_size (16)));
+typedef double v4sf_t __attribute__ ((vector_size (16)));
+#define SAVE_ACC(ACC, ldc, J)  \
+         __builtin_mma_disassemble_acc (result, ACC); \
+         rowC = (v4sf_t *) &CO[0*ldc+J]; \
+          rowC[0] += result[0]; \
+          rowC = (v4sf_t *) &CO[1*ldc+J]; \
+          rowC[0] += result[1]; \
+          rowC = (v4sf_t *) &CO[2*ldc+J]; \
+          rowC[0] += result[2]; \
+          rowC = (v4sf_t *) &CO[3*ldc+J]; \
+         rowC[0] += result[3];
+
+void
+DM (int m, int n, int k, double *A, double *B, double *C)
+{
+  __vector_quad acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7;
+  v4sf_t result[4];
+  v4sf_t *rowC;
+  for (int l = 0; l < n; l += 4)
+    {
+      double *CO;
+      double *AO;
+      AO = A;
+      CO = C;
+      C += m * 4;
+      for (int j = 0; j < m; j += 16)
+       {
+         double *BO = B;
+         __builtin_mma_xxsetaccz (&acc0);
+         __builtin_mma_xxsetaccz (&acc1);
+         __builtin_mma_xxsetaccz (&acc2);
+         __builtin_mma_xxsetaccz (&acc3);
+         __builtin_mma_xxsetaccz (&acc4);
+         __builtin_mma_xxsetaccz (&acc5);
+         __builtin_mma_xxsetaccz (&acc6);
+         __builtin_mma_xxsetaccz (&acc7);
+         unsigned long i;
+
+         for (i = 0; i < k; i++)
+           {
+             vec_t *rowA = (vec_t *) & AO[i * 16];
+             __vector_pair rowB;
+             vec_t *rb = (vec_t *) & BO[i * 4];
+             __builtin_mma_assemble_pair (&rowB, rb[1], rb[0]);
+             __builtin_mma_xvf64gerpp (&acc0, rowB, rowA[0]);
+             __builtin_mma_xvf64gerpp (&acc1, rowB, rowA[1]);
+             __builtin_mma_xvf64gerpp (&acc2, rowB, rowA[2]);
+             __builtin_mma_xvf64gerpp (&acc3, rowB, rowA[3]);
+             __builtin_mma_xvf64gerpp (&acc4, rowB, rowA[4]);
+             __builtin_mma_xvf64gerpp (&acc5, rowB, rowA[5]);
+             __builtin_mma_xvf64gerpp (&acc6, rowB, rowA[6]);
+             __builtin_mma_xvf64gerpp (&acc7, rowB, rowA[7]);
+           }
+         SAVE_ACC (&acc0, m, 0);
+         SAVE_ACC (&acc2, m, 4);
+         SAVE_ACC (&acc1, m, 2);
+         SAVE_ACC (&acc3, m, 6);
+         SAVE_ACC (&acc4, m, 8);
+         SAVE_ACC (&acc6, m, 12);
+         SAVE_ACC (&acc5, m, 10);
+         SAVE_ACC (&acc7, m, 14);
+         AO += k * 16;
+         BO += k * 4;
+         CO += 16;
+       }
+      B += k * 4;
+    }
+}
+
+void
+init (double *matrix, int row, int column)
+{
+  for (int j = 0; j < column; j++)
+    {
+      for (int i = 0; i < row; i++)
+       {
+         matrix[j * row + i] = (i * 16 + 2 + j) / 0.123;
+       }
+    }
+}
+
+void
+init0 (double *matrix, double *matrix1, int row, int column)
+{
+  for (int j = 0; j < column; j++)
+    for (int i = 0; i < row; i++)
+      matrix[j * row + i] = matrix1[j * row + i] = 0;
+}
+
+
+void
+print (const char *name, const double *matrix, int row, int column)
+{
+  printf ("Matrix %s has %d rows and %d columns:\n", name, row, column);
+  for (int i = 0; i < row; i++)
+    {
+      for (int j = 0; j < column; j++)
+       {
+         printf ("%f ", matrix[j * row + i]);
+       }
+      printf ("\n");
+    }
+  printf ("\n");
+}
+
+int
+main (int argc, char *argv[])
+{
+  int rowsA, colsB, common;
+  int i, j, k;
+  int ret = 0;
+
+  for (int t = 16; t <= 128; t += 16)
+    {
+      for (int t1 = 4; t1 <= 16; t1 += 4)
+       {
+         rowsA = t;
+         colsB = t1;
+         common = 1;
+         /* printf ("Running test for rows = %d,cols = %d\n", t, t1); */
+         double A[rowsA * common];
+         double B[common * colsB];
+         double C[rowsA * colsB];
+         double D[rowsA * colsB];
+
+
+         init (A, rowsA, common);
+         init (B, common, colsB);
+         init0 (C, D, rowsA, colsB);
+         DM (rowsA, colsB, common, A, B, C);
+
+         for (i = 0; i < colsB; i++)
+           {
+             for (j = 0; j < rowsA; j++)
+               {
+                 D[i * rowsA + j] = 0;
+                 for (k = 0; k < common; k++)
+                   {
+                     D[i * rowsA + j] +=
+                       A[k * rowsA + j] * B[k + common * i];
+                   }
+               }
+           }
+         for (i = 0; i < colsB; i++)
+           {
+             for (j = 0; j < rowsA; j++)
+               {
+                 for (k = 0; k < common; k++)
+                   {
+                     if (D[i * rowsA + j] != C[i * rowsA + j])
+                       {
+                         printf ("Error %d,%d,%d\n",i,j,k);
+                         ret++;
+                       }
+                   }
+               }
+           }
+         if (ret)
+           {
+             print ("A", A, rowsA, common);
+             print ("B", B, common, colsB);
+             print ("C", C, rowsA, colsB);
+             print ("D", D, rowsA, colsB);
+           }
+       }
+    }
+  
+#ifdef VERBOSE
+  if (ret)
+    printf ("DM double test fail: %d errors\n",ret);
+  else
+    printf ("DM double test success: 0 DM errors\n");
+#else
+  if (ret)
+    abort();
+#endif
+      
+  return ret;
+}
+
+/* { dg-final { scan-assembler {\mdmsetdmrz\M}      } } */
+/* { dg-final { scan-assembler {\mdmxvf64gerpp\M}   } } */
+/* { dg-final { scan-assembler {\mdmxxextfdmr512\M} } } */
+
diff --git a/gcc/testsuite/lib/target-supports.exp 
b/gcc/testsuite/lib/target-supports.exp
index fd58682cae3..a94cae9f6b7 100644
--- a/gcc/testsuite/lib/target-supports.exp
+++ b/gcc/testsuite/lib/target-supports.exp
@@ -7402,6 +7402,29 @@ proc check_effective_target_power10_ok { } {
     }
 }
 
+# Return 1 if this is a PowerPC target supporting -mcpu=future which enables
+# the dense math operations.
+proc check_effective_target_powerpc_dense_math_ok { } {
+    if { ([istarget powerpc*-*-*]) } {
+       return [check_no_compiler_messages powerpc_dense_math_ok object {
+           __vector_quad vq;
+           int main (void) {
+               #ifndef __DENSE_MATH__
+               #error "target does not have dense math support."
+               #else
+               /* Make sure we have dense math support.  */
+                 __vector_quad dmr;
+                 __asm__ ("dmsetaccz %A0" : "=wD" (dmr));
+                 vq = dmr;
+               #endif
+               return 0;
+           }
+       } "-mcpu=future"]
+    } else {
+       return 0;
+    }
+}
+
 # Return 1 if this is a PowerPC target supporting -mfloat128 via either
 # software emulation on power7/power8 systems or hardware support on power9.
 
-- 
2.47.0


-- 
Michael Meissner, IBM
PO Box 98, Ayer, Massachusetts, USA, 01432
email: meiss...@linux.ibm.com

Reply via email to