diff mbox series

[rs6000] Add missing vec_expte, vec_loge, vec_re

Message ID 1525882069.8281.2.camel@us.ibm.com
State New
Headers show
Series [rs6000] Add missing vec_expte, vec_loge, vec_re | expand

Commit Message

Carl Love May 9, 2018, 4:07 p.m. UTC 
GCC Maintainers:

The following patch adds tests for the vec_expte, vec_loge,  and vec_re
builtins.

The patch for the test case was tested on

    powerpc64le-unknown-linux-gnu (Power 8 LE)
    powerpc64-unknown-linux-gnu (Power 8 BE)
    powerpc64le-unknown-linux-gnu (Power 9 LE).

 Please let me know if the patch looks OK for GCC mainline.

                         Carl Love
---------------------------------------------------------

gcc/testsuite/ChangeLog:

2018-05-09 Carl Love  <cel@us.ibm.com>
	* gcc.target/powerpc/builtins-8-runnable.c: New builtin test file.
---
 .../gcc.target/powerpc/builtins-8-runnable.c       | 98 ++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 gcc/testsuite/gcc.target/powerpc/builtins-8-runnable.c

Comments

Segher Boessenkool May 9, 2018, 6:19 p.m. UTC | #1 
Hi!

On Wed, May 09, 2018 at 09:07:49AM -0700, Carl Love wrote:
> 2018-05-09 Carl Love  <cel@us.ibm.com>
> 	* gcc.target/powerpc/builtins-8-runnable.c: New builtin test file.

> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/powerpc/builtins-8-runnable.c
> @@ -0,0 +1,98 @@
> +/* { dg-do run { target { powerpc*-*-* && { lp64 && p8vector_hw } } } } */
> +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
> +/* { dg-options "-mcpu=power8 -O2" } */

Does this need lp64?  It's not obvious to me why.

Okay for trunk.  Thanks!


Segher
diff mbox series

Patch

diff --git a/gcc/testsuite/gcc.target/powerpc/builtins-8-runnable.c b/gcc/testsuite/gcc.target/powerpc/builtins-8-runnable.c
new file mode 100644
index 0000000..82b886f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/builtins-8-runnable.c
@@ -0,0 +1,98 @@ 
+/* { dg-do run { target { powerpc*-*-* && { lp64 && p8vector_hw } } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8 -O2" } */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <math.h>
+#include <altivec.h>
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+void abort (void);
+
+int main()
+  {
+    int i;
+    vector float f_arg1;
+    vector double d_arg1;
+   
+    vector float vec_f_expected1, vec_f_result1, vec_f_error;
+    vector double vec_d_expected1, vec_d_result1, vec_d_error;
+  
+    /* vec_expte: float args, result */
+    f_arg1 = (vector float){1.0, 2.0, 3.0, 4.0};
+    vec_f_expected1 = (vector float){2.0, 4.0, 8.0, 16.0};
+
+    vec_f_result1 = vec_expte (f_arg1);
+
+    for (i = 0; i < 4; i++)
+      {
+        if (vec_f_expected1[i] != vec_f_result1[i])
+#ifdef DEBUG
+           printf("ERROR vec_expte (f) result[%d]=%f != expected[%d]=%f\n",
+		  i, vec_f_result1[i],  i, vec_f_expected1[i]);
+#else
+        abort();
+#endif
+      }
+
+    /* vec_loge: float args, result */
+    f_arg1 = (vector float){4.0, 8.0, 16.0, 64};
+    vec_f_expected1 = (vector float){2.0, 3.0, 4.0, 6.0};
+
+    vec_f_result1 = vec_loge (f_arg1);
+
+    for (i = 0; i < 4; i++)
+      {
+        if (vec_f_expected1[i] != vec_f_result1[i])
+#ifdef DEBUG
+	  printf("ERROR vec_loge (f) result[%d]=%f != expected[%d]=%f\n",
+		 i, vec_f_result1[i],  i, vec_f_expected1[i]);
+#else
+          abort();
+#endif
+    }
+
+    /* vec_re: float args, result  (calculate approximate reciprocal)  */
+    f_arg1 = (vector float){1.0, 5.0, 4.0, 8.0};
+    vec_f_expected1 = (vector float){1.0, 0.2, 0.25, 0.125};
+    vec_f_error = (vector float){1.0, 0.2, 0.25, 0.125};
+
+    vec_f_result1 = vec_re (f_arg1);
+  
+    for (i = 0; i < 4; i++)
+      {
+        vec_f_error[i] = fabs(vec_f_expected1[i] - vec_f_result1[i]);
+  
+        if (vec_f_error[i] >=  0.0001)
+#ifdef DEBUG
+           printf("ERROR vec_re (f) result[%d]=%f != expected[%d]=%f\n",
+		  i, vec_f_result1[i],  i, vec_f_expected1[i]);
+#else
+	abort();
+#endif
+      }
+
+    /* vec_re: double args, result  (calculate approximate reciprocal)  */
+    d_arg1 = (vector double){1.0, 8.0};
+    vec_d_expected1 = (vector double){1.0, 0.125};
+    vec_d_error = (vector double){1.0, 0.125};
+
+    vec_d_result1 = vec_re (d_arg1);
+  
+    for (i = 0; i < 2; i++)
+      {
+         vec_d_error[i] = fabs(vec_d_expected1[i] - vec_d_result1[i]);
+  
+         if (vec_d_error[i] >=  0.0001)
+#ifdef DEBUG
+           printf("ERROR vec_re (d) result[%d]=%f != expected[%d]=%f\n",
+		  i, vec_d_result1[i],  i, vec_d_expected1[i]);
+#else
+          abort();
+#endif
+      }
+  }