Merge remote-tracking branch 'remotes/amarkovic/tags/mips-queue-mar-05-2019' into staging

MIPS queue for March 5th, 2019

# gpg: Signature made Tue 05 Mar 2019 16:06:34 GMT
# gpg:                using RSA key D4972A8967F75A65
# gpg: Good signature from "Aleksandar Markovic <amarkovic@wavecomp.com>" [unknown]
# gpg: WARNING: This key is not certified with a trusted signature!
# gpg:          There is no indication that the signature belongs to the owner.
# Primary key fingerprint: 8526 FBF1 5DA3 811F 4A01  DD75 D497 2A89 67F7 5A65

* remotes/amarkovic/tags/mips-queue-mar-05-2019:
  target/mips: Add tests for integer add MSA instruction group
  tests/tcg: target/mips: Add tests for MSA pack instructions
  tests/tcg: target/mips: Add tests for MIPS64R6 int multiply instructions
  tests/tcg: target/mips: Add tests for MIPS64R6 shift instructions
  tests/tcg: target/mips: Add tests for MIPS64R6 bit count instructions
  tests/tcg: target/mips: Add tests for MIPS64R6 bit swap instructions
  tests/tcg: target/mips: Add tests for MIPS64R6 logic instructions
  tests/tcg: target/mips: Add wrappers for some MIPS64R6 instructions
  tests/tcg: target/mips: Extend functionality of MSA wrapper macros
  tests/tcg: target/mips: Fix test utilities for 128-bit tests
  tests/tcg: target/mips: Add test utilities for 64-bit tests
  tests/tcg: target/mips: Add test utilities for 32-bit tests
  tests/tcg: target/mips: Add wrappers for various MSA instructions
  disas: nanoMIPS: Add graphical description of pool organization
  disas: nanoMIPS: Correct comments to handlers of some DSP instructions
Signed-off-by: NPeter Maydell <peter.maydell@linaro.org>

tests/tcg/mips/include/test_inputs.h

@@ -28,7 +28,7 @@
 #define PATTERN_INPUTS_COUNT          64
 #define PATTERN_INPUTS_SHORT_COUNT     8
 
-uint64_t b128_pattern[PATTERN_INPUTS_COUNT][2] = {
+static const uint64_t b128_pattern[PATTERN_INPUTS_COUNT][2] = {
     { 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL, },   /*   0 */
     { 0x0000000000000000ULL, 0x0000000000000000ULL, },
     { 0xAAAAAAAAAAAAAAAAULL, 0xAAAAAAAAAAAAAAAAULL, },
@@ -99,7 +99,7 @@ uint64_t b128_pattern[PATTERN_INPUTS_COUNT][2] = {
 #define RANDOM_INPUTS_COUNT           16
 #define RANDOM_INPUTS_SHORT_COUNT      4
 
-uint64_t b128_random[RANDOM_INPUTS_COUNT][2] = {
+static const uint64_t b128_random[RANDOM_INPUTS_COUNT][2] = {
     { 0x886AE6CC28625540ULL, 0x4B670B5EFE7BB00CULL, },   /*   0 */
     { 0xFBBE00634D93C708ULL, 0x12F7BB1A153F52FCULL, },
     { 0xAC5AAEAAB9CF8B80ULL, 0x27D8C6FFAB2B2514ULL, },

tests/tcg/mips/include/test_inputs_32.h

+/*
+ *  Header file for pattern and random test inputs
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Aleksandar Markovic <amarkovic@wavecomp.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TEST_INPUTS_32_H
+#define TEST_INPUTS_32_H
+
+#include <stdint.h>
+
+
+#define PATTERN_INPUTS_32_COUNT          64
+#define PATTERN_INPUTS_32_SHORT_COUNT     8
+
+static const uint32_t b32_pattern[PATTERN_INPUTS_32_COUNT] = {
+    0xFFFFFFFF,                                          /*   0 */
+    0x00000000,
+    0xAAAAAAAA,
+    0x55555555,
+    0xCCCCCCCC,
+    0x33333333,
+    0xE38E38E3,
+    0x1C71C71C,
+    0xF0F0F0F0,                                          /*   8 */
+    0x0F0F0F0F,
+    0xF83E0F83,
+    0x07C1F07C,
+    0xFC0FC0FC,
+    0x03F03F03,
+    0xFE03F80F,
+    0x01FC07F0,
+    0xFF00FF00,                                          /*  16 */
+    0x00FF00FF,
+    0xFF803FE0,
+    0x007FC01F,
+    0xFFC00FFC,
+    0x003FF003,
+    0xFFE003FF,
+    0x001FFC00,
+    0xFFF000FF,                                          /*  24 */
+    0x000FFF00,
+    0xFFF8003F,
+    0x0007FFC0,
+    0xFFFC000F,
+    0x0003FFF0,
+    0xFFFE0003,
+    0x0001FFFC,
+    0xFFFF0000,                                          /*  32 */
+    0x0000FFFF,
+    0xFFFF8000,
+    0x00007FFF,
+    0xFFFFC000,
+    0x00003FFF,
+    0xFFFFE000,
+    0x00001FFF,
+    0xFFFFF000,                                          /*  40 */
+    0x00000FFF,
+    0xFFFFF800,
+    0x000007FF,
+    0xFFFFFC00,
+    0x000003FF,
+    0xFFFFFE00,
+    0x000001FF,
+    0xFFFFFF00,                                          /*  48 */
+    0x000000FF,
+    0xFFFFFF80,
+    0x0000007F,
+    0xFFFFFFC0,
+    0x0000003F,
+    0xFFFFFFE0,
+    0x0000001F,
+    0xFFFFFFF0,                                          /*  56 */
+    0x0000000F,
+    0xFFFFFFF8,
+    0x00000007,
+    0xFFFFFFFC,
+    0x00000003,
+    0xFFFFFFFE,
+    0x00000001,
+};
+
+
+#define RANDOM_INPUTS_32_COUNT           16
+#define RANDOM_INPUTS_32_SHORT_COUNT      4
+
+static const uint32_t b32_random[RANDOM_INPUTS_32_COUNT] = {
+    0x886AE6CC,                                          /*   0 */
+    0xFBBE0063,
+    0xAC5AAEAA,
+    0x704F164D,
+    0xB9926B7C,
+    0xD027BE89,
+    0xB83B5806,
+    0xFC8F23F0,
+    0x201E09CD,                                          /*   8 */
+    0xA57CD913,
+    0xA2E8F6F5,
+    0xA89CF2F1,
+    0xE61438E9,
+    0x944A35FD,
+    0x46304263,
+    0x8B5AA7A2,
+};
+
+
+#endif

tests/tcg/mips/include/test_inputs_64.h

+/*
+ *  Header file for pattern and random test inputs
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Aleksandar Markovic <amarkovic@wavecomp.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TEST_INPUTS_64_H
+#define TEST_INPUTS_64_H
+
+#include <stdint.h>
+
+
+#define PATTERN_INPUTS_64_COUNT          64
+#define PATTERN_INPUTS_64_SHORT_COUNT     8
+
+static const uint64_t b64_pattern[PATTERN_INPUTS_64_COUNT] = {
+    0xFFFFFFFFFFFFFFFFULL,                               /*   0 */
+    0x0000000000000000ULL,
+    0xAAAAAAAAAAAAAAAAULL,
+    0x5555555555555555ULL,
+    0xCCCCCCCCCCCCCCCCULL,
+    0x3333333333333333ULL,
+    0xE38E38E38E38E38EULL,
+    0x1C71C71C71C71C71ULL,
+    0xF0F0F0F0F0F0F0F0ULL,                               /*   8 */
+    0x0F0F0F0F0F0F0F0FULL,
+    0xF83E0F83E0F83E0FULL,
+    0x07C1F07C1F07C1F0ULL,
+    0xFC0FC0FC0FC0FC0FULL,
+    0x03F03F03F03F03F0ULL,
+    0xFE03F80FE03F80FEULL,
+    0x01FC07F01FC07F01ULL,
+    0xFF00FF00FF00FF00ULL,                               /*  16 */
+    0x00FF00FF00FF00FFULL,
+    0xFF803FE00FF803FEULL,
+    0x007FC01FF007FC01ULL,
+    0xFFC00FFC00FFC00FULL,
+    0x003FF003FF003FF0ULL,
+    0xFFE003FF800FFE00ULL,
+    0x001FFC007FF001FFULL,
+    0xFFF000FFF000FFF0ULL,                               /*  24 */
+    0x000FFF000FFF000FULL,
+    0xFFF8003FFE000FFFULL,
+    0x0007FFC001FFF000ULL,
+    0xFFFC000FFFC000FFULL,
+    0x0003FFF0003FFF00ULL,
+    0xFFFE0003FFF8000FULL,
+    0x0001FFFC0007FFF0ULL,
+    0xFFFF0000FFFF0000ULL,                               /*  32 */
+    0x0000FFFF0000FFFFULL,
+    0xFFFF80003FFFE000ULL,
+    0x00007FFFC0001FFFULL,
+    0xFFFFC0000FFFFC00ULL,
+    0x00003FFFF00003FFULL,
+    0xFFFFE00003FFFF80ULL,
+    0x00001FFFFC00007FULL,
+    0xFFFFF00000FFFFF0ULL,                               /*  40 */
+    0x00000FFFFF00000FULL,
+    0xFFFFF800003FFFFEULL,
+    0x000007FFFFC00001ULL,
+    0xFFFFFC00000FFFFFULL,
+    0x000003FFFFF00000ULL,
+    0xFFFFFE000003FFFFULL,
+    0x000001FFFFFC0000ULL,
+    0xFFFFFF000000FFFFULL,                               /*  48 */
+    0x000000FFFFFF0000ULL,
+    0xFFFFFF8000003FFFULL,
+    0x0000007FFFFFC000ULL,
+    0xFFFFFFC000000FFFULL,
+    0x0000003FFFFFF000ULL,
+    0xFFFFFFE0000003FFULL,
+    0x0000001FFFFFFC00ULL,
+    0xFFFFFFF0000000FFULL,                               /*  56 */
+    0x0000000FFFFFFF00ULL,
+    0xFFFFFFF80000003FULL,
+    0x00000007FFFFFFC0ULL,
+    0xFFFFFFFC0000000FULL,
+    0x00000003FFFFFFF0ULL,
+    0xFFFFFFFE00000003ULL,
+    0x00000001FFFFFFFCULL,
+};
+
+static const uint64_t b64_pattern_se[PATTERN_INPUTS_64_COUNT] = {
+    0xFFFFFFFFFFFFFFFFULL,                               /*   0 */
+    0x0000000000000000ULL,
+    0xFFFFFFFFAAAAAAAAULL,
+    0x0000000055555555ULL,
+    0xFFFFFFFFCCCCCCCCULL,
+    0x0000000033333333ULL,
+    0xFFFFFFFFE38E38E3ULL,
+    0x000000001C71C71CULL,
+    0xFFFFFFFFF0F0F0F0ULL,                               /*   8 */
+    0x000000000F0F0F0FULL,
+    0xFFFFFFFFF83E0F83ULL,
+    0x0000000007C1F07CULL,
+    0xFFFFFFFFFC0FC0FCULL,
+    0x0000000003F03F03ULL,
+    0xFFFFFFFFFE03F80FULL,
+    0x0000000001FC07F0ULL,
+    0xFFFFFFFFFF00FF00ULL,                               /*  16 */
+    0x0000000000FF00FFULL,
+    0xFFFFFFFFFF803FE0ULL,
+    0x00000000007FC01FULL,
+    0xFFFFFFFFFFC00FFCULL,
+    0x00000000003FF003ULL,
+    0xFFFFFFFFFFE003FFULL,
+    0x00000000001FFC00ULL,
+    0xFFFFFFFFFFF000FFULL,                               /*  24 */
+    0x00000000000FFF00ULL,
+    0xFFFFFFFFFFF8003FULL,
+    0x000000000007FFC0ULL,
+    0xFFFFFFFFFFFC000FULL,
+    0x000000000003FFF0ULL,
+    0xFFFFFFFFFFFE0003ULL,
+    0x000000000001FFFCULL,
+    0xFFFFFFFFFFFF0000ULL,                               /*  32 */
+    0x000000000000FFFFULL,
+    0xFFFFFFFFFFFF8000ULL,
+    0x0000000000007FFFULL,
+    0xFFFFFFFFFFFFC000ULL,
+    0x0000000000003FFFULL,
+    0xFFFFFFFFFFFFE000ULL,
+    0x0000000000001FFFULL,
+    0xFFFFFFFFFFFFF000ULL,                               /*  40 */
+    0x0000000000000FFFULL,
+    0xFFFFFFFFFFFFF800ULL,
+    0x00000000000007FFULL,
+    0xFFFFFFFFFFFFFC00ULL,
+    0x00000000000003FFULL,
+    0xFFFFFFFFFFFFFE00ULL,
+    0x00000000000001FFULL,
+    0xFFFFFFFFFFFFFF00ULL,                               /*  48 */
+    0x00000000000000FFULL,
+    0xFFFFFFFFFFFFFF80ULL,
+    0x000000000000007FULL,
+    0xFFFFFFFFFFFFFFC0ULL,
+    0x000000000000003FULL,
+    0xFFFFFFFFFFFFFFE0ULL,
+    0x000000000000001FULL,
+    0xFFFFFFFFFFFFFFF0ULL,                               /*  56 */
+    0x000000000000000FULL,
+    0xFFFFFFFFFFFFFFF8ULL,
+    0x0000000000000007ULL,
+    0xFFFFFFFFFFFFFFFCULL,
+    0x0000000000000003ULL,
+    0xFFFFFFFFFFFFFFFEULL,
+    0x0000000000000001ULL,
+};
+
+
+#define RANDOM_INPUTS_64_COUNT           16
+#define RANDOM_INPUTS_64_SHORT_COUNT      4
+
+static const uint64_t b64_random[RANDOM_INPUTS_64_COUNT] = {
+    0x886AE6CC28625540ULL,                               /*   0 */
+    0xFBBE00634D93C708ULL,
+    0xAC5AAEAAB9CF8B80ULL,
+    0x704F164D5E31E24EULL,
+    0xB9926B7C7DAF4258ULL,
+    0xD027BE89FF0A2EF9ULL,
+    0xB83B580665CABC4AULL,
+    0xFC8F23F09AA6B782ULL,
+    0x201E09CD56AEE649ULL,                               /*   8 */
+    0xA57CD91365D9E5D7ULL,
+    0xA2E8F6F5C9CBC61BULL,
+    0xA89CF2F131A864AEULL,
+    0xE61438E9A652EA0AULL,
+    0x944A35FD192361A8ULL,
+    0x4630426322BEF79CULL,
+    0x8B5AA7A2F259DEADULL,
+};
+
+static const uint64_t b64_random_se[RANDOM_INPUTS_64_COUNT] = {
+    0xFFFFFFFF886AE6CCULL,                               /*   0 */
+    0xFFFFFFFFFBBE0063ULL,
+    0xFFFFFFFFAC5AAEAAULL,
+    0x00000000704F164DULL,
+    0xFFFFFFFFB9926B7CULL,
+    0xFFFFFFFFD027BE89ULL,
+    0xFFFFFFFFB83B5806ULL,
+    0xFFFFFFFFFC8F23F0ULL,
+    0x00000000201E09CDULL,                               /*   8 */
+    0xFFFFFFFFA57CD913ULL,
+    0xFFFFFFFFA2E8F6F5ULL,
+    0xFFFFFFFFA89CF2F1ULL,
+    0xFFFFFFFFE61438E9ULL,
+    0xFFFFFFFF944A35FDULL,
+    0x0000000046304263ULL,
+    0xFFFFFFFF8B5AA7A2ULL,
+};
+
+
+#endif

tests/tcg/mips/include/test_utils.h

@@ -27,14 +27,14 @@
 #include <inttypes.h>
 #include <string.h>
 
-#define PRINT_RESULTS 1
+#define PRINT_RESULTS 0
 
 
-static inline int32_t check_results(char *instruction_name,
-                                    uint32_t test_count,
-                                    double elapsed_time,
-                                    uint64_t *b128_result,
-                                    uint64_t *b128_expect)
+static inline int32_t check_results(const char *instruction_name,
+                                    const uint32_t test_count,
+                                    const double elapsed_time,
+                                    const uint64_t *b128_result,
+                                    const uint64_t *b128_expect)
 {
 #if PRINT_RESULTS
     uint32_t ii;
@@ -58,7 +58,8 @@ static inline int32_t check_results(char *instruction_name,
 
     printf("%s:   ", instruction_name);
     for (i = 0; i < test_count; i++) {
-        if (b128_result[i] == b128_expect[i]) {
+        if ((b128_result[2 * i] == b128_expect[2 * i]) &&
+            (b128_result[2 * i + 1] == b128_expect[2 * i + 1])) {
             pass_count++;
         } else {
             fail_count++;

tests/tcg/mips/include/test_utils_32.h

+/*
+ *  Header file for test utilities
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Aleksandar Markovic <amarkovic@wavecomp.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TEST_UTILS_32_H
+#define TEST_UTILS_32_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <string.h>
+
+#define PRINT_RESULTS 0
+
+
+static inline int32_t check_results_32(const char *instruction_name,
+                                       const uint32_t test_count,
+                                       const double elapsed_time,
+                                       const uint32_t *b32_result,
+                                       const uint32_t *b32_expect)
+{
+#if PRINT_RESULTS
+    uint32_t ii;
+    printf("\n");
+    for (ii = 0; ii < test_count; ii++) {
+        uint64_t a;
+        memcpy(&a, (b32_result + ii), 8);
+        if (ii % 8 != 0) {
+            printf("        0x%08lxULL,\n", a);
+        } else {
+            printf("        0x%08lxULL,                   /* %3d  */\n",
+                   a, ii);
+        }
+    }
+    printf("\n");
+#endif
+    uint32_t i;
+    uint32_t pass_count = 0;
+    uint32_t fail_count = 0;
+
+    printf("%s:   ", instruction_name);
+    for (i = 0; i < test_count; i++) {
+        if (b32_result[i] == b32_expect[i]) {
+            pass_count++;
+        } else {
+            fail_count++;
+        }
+    }
+
+    printf("PASS: %3d   FAIL: %3d   elapsed time: %5.2f ms\n",
+           pass_count, fail_count, elapsed_time);
+
+    if (fail_count > 0) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+
+#endif

tests/tcg/mips/include/test_utils_64.h

+/*
+ *  Header file for test utilities
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Aleksandar Markovic <amarkovic@wavecomp.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef TEST_UTILS_64_H
+#define TEST_UTILS_64_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <string.h>
+
+#define PRINT_RESULTS 0
+
+
+static inline int32_t check_results_64(const char *instruction_name,
+                                       const uint32_t test_count,
+                                       const double elapsed_time,
+                                       const uint64_t *b64_result,
+                                       const uint64_t *b64_expect)
+{
+#if PRINT_RESULTS
+    uint32_t ii;
+    printf("\n");
+    for (ii = 0; ii < test_count; ii++) {
+        uint64_t a;
+        memcpy(&a, (b64_result + ii), 8);
+        if (ii % 8 != 0) {
+            printf("        0x%016llxULL,\n", a);
+        } else {
+            printf("        0x%016llxULL,                    /* %3d  */\n",
+                   a, ii);
+        }
+    }
+    printf("\n");
+#endif
+    uint32_t i;
+    uint32_t pass_count = 0;
+    uint32_t fail_count = 0;
+
+    printf("%s:   ", instruction_name);
+    for (i = 0; i < test_count; i++) {
+        if (b64_result[i] == b64_expect[i]) {
+            pass_count++;
+        } else {
+            fail_count++;
+        }
+    }
+
+    printf("PASS: %3d   FAIL: %3d   elapsed time: %5.2f ms\n",
+           pass_count, fail_count, elapsed_time);
+
+    if (fail_count > 0) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+
+#endif

tests/tcg/mips/include/wrappers_mips64r6.h

+/*
+ *  Header file for wrappers around MIPS64R6 instructions assembler
+ *  invocations
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Aleksandar Markovic <amarkovic@wavecomp.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef WRAPPERS_MIPS64R6_H
+#define WRAPPERS_MIPS64R6_H
+
+
+#define DO_MIPS64R6__RD__RS(suffix, mnemonic)                          \
+static inline void do_mips64r6_##suffix(const void *input,             \
+                                        void *output)                  \
+{                                                                      \
+   __asm__ volatile (                                                  \
+      "ld $t1, 0(%0)\n\t"                                              \
+      #mnemonic " $t0, $t1\n\t"                                        \
+      "sd $t0, 0(%1)\n\t"                                              \
+      :                                                                \
+      : "r" (input), "r" (output)                                      \
+      : "t0", "t1", "memory"                                           \
+   );                                                                  \
+}
+
+DO_MIPS64R6__RD__RS(CLO, clo)
+DO_MIPS64R6__RD__RS(CLZ, clz)
+DO_MIPS64R6__RD__RS(DCLO, dclo)
+DO_MIPS64R6__RD__RS(DCLZ, dclz)
+
+DO_MIPS64R6__RD__RS(BITSWAP, bitswap)
+DO_MIPS64R6__RD__RS(DBITSWAP, dbitswap)
+
+
+#define DO_MIPS64R6__RD__RS_RT(suffix, mnemonic)                       \
+static inline void do_mips64r6_##suffix(const void *input1,            \
+                                        const void *input2,            \
+                                        void *output)                  \
+{                                                                      \
+   __asm__ volatile (                                                  \
+      "ld $t1, 0(%0)\n\t"                                              \
+      "ld $t2, 0(%1)\n\t"                                              \
+      #mnemonic " $t0, $t1, $t2\n\t"                                   \
+      "sd $t0, 0(%2)\n\t"                                              \
+      :                                                                \
+      : "r" (input1), "r" (input2), "r" (output)                       \
+      : "t0", "t1", "memory"                                           \
+   );                                                                  \
+}
+
+DO_MIPS64R6__RD__RS_RT(SLLV, sllv)
+DO_MIPS64R6__RD__RS_RT(SRLV, srlv)
+DO_MIPS64R6__RD__RS_RT(SRAV, srav)
+DO_MIPS64R6__RD__RS_RT(DSLLV, dsllv)
+DO_MIPS64R6__RD__RS_RT(DSRLV, dsrlv)
+DO_MIPS64R6__RD__RS_RT(DSRAV, dsrav)
+
+DO_MIPS64R6__RD__RS_RT(MUL, mul)
+DO_MIPS64R6__RD__RS_RT(MUH, muh)
+DO_MIPS64R6__RD__RS_RT(MULU, mulu)
+DO_MIPS64R6__RD__RS_RT(MUHU, muhu)
+DO_MIPS64R6__RD__RS_RT(DMUL, dmul)
+DO_MIPS64R6__RD__RS_RT(DMUH, dmuh)
+DO_MIPS64R6__RD__RS_RT(DMULU, dmulu)
+DO_MIPS64R6__RD__RS_RT(DMUHU, dmuhu)
+
+
+#endif

tests/tcg/mips/include/wrappers_msa.h

@@ -38,6 +38,21 @@ static inline void do_msa_##suffix(void *input, void *output)          \
    );                                                                  \
 }
 
+#define DO_MSA__WD__WD(suffix, mnemonic)                               \
+static inline void do_msa_##suffix(void *input, void *output)          \
+{                                                                      \
+   __asm__ volatile (                                                  \
+      "move $t0, %0\n\t"                                               \
+      "ld.d $w11, 0($t0)\n\t"                                          \
+      #mnemonic " $w10, $w10\n\t"                                      \
+      "move $t0, %1\n\t"                                               \
+      "st.d $w10, 0($t0)\n\t"                                          \
+      :                                                                \
+      : "r" (input), "r" (output)                                      \
+      : "t0", "memory"                                                 \
+   );                                                                  \
+}
+
 DO_MSA__WD__WS(NLOC_B, nloc.b)
 DO_MSA__WD__WS(NLOC_H, nloc.h)
 DO_MSA__WD__WS(NLOC_W, nloc.w)
@@ -72,6 +87,42 @@ static inline void do_msa_##suffix(void *input1, void *input2,         \
    );                                                                  \
 }
 
+#define DO_MSA__WD__WD_WT(suffix, mnemonic)                            \
+static inline void do_msa_##suffix(void *input1, void *input2,         \
+                                   void *output)                       \
+{                                                                      \
+   __asm__ volatile (                                                  \
+      "move $t0, %0\n\t"                                               \
+      "ld.d $w11, 0($t0)\n\t"                                          \
+      "move $t0, %1\n\t"                                               \
+      "ld.d $w12, 0($t0)\n\t"                                          \
+      #mnemonic " $w10, $w10, $w12\n\t"                                \
+      "move $t0, %2\n\t"                                               \
+      "st.d $w10, 0($t0)\n\t"                                          \
+      :                                                                \
+      : "r" (input1), "r" (input2), "r" (output)                       \
+      : "t0", "memory"                                                 \
+   );                                                                  \
+}
+
+#define DO_MSA__WD__WS_WD(suffix, mnemonic)                            \
+static inline void do_msa_##suffix(void *input1, void *input2,         \
+                                   void *output)                       \
+{                                                                      \
+   __asm__ volatile (                                                  \
+      "move $t0, %0\n\t"                                               \
+      "ld.d $w11, 0($t0)\n\t"                                          \
+      "move $t0, %1\n\t"                                               \
+      "ld.d $w12, 0($t0)\n\t"                                          \
+      #mnemonic " $w10, $w11, $w10\n\t"                                \
+      "move $t0, %2\n\t"                                               \
+      "st.d $w10, 0($t0)\n\t"                                          \
+      :                                                                \
+      : "r" (input1), "r" (input2), "r" (output)                       \
+      : "t0", "memory"                                                 \
+   );                                                                  \
+}
+
 DO_MSA__WD__WS_WT(ILVEV_B, ilvev.b)
 DO_MSA__WD__WS_WT(ILVEV_H, ilvev.h)
 DO_MSA__WD__WS_WT(ILVEV_W, ilvev.w)
@@ -152,5 +203,75 @@ DO_MSA__WD__WS_WT(MIN_U_H, min_u.h)
 DO_MSA__WD__WS_WT(MIN_U_W, min_u.w)
 DO_MSA__WD__WS_WT(MIN_U_D, min_u.d)
 
+DO_MSA__WD__WS_WT(BCLR_B, bclr.b)
+DO_MSA__WD__WS_WT(BCLR_H, bclr.h)
+DO_MSA__WD__WS_WT(BCLR_W, bclr.w)
+DO_MSA__WD__WS_WT(BCLR_D, bclr.d)
+
+DO_MSA__WD__WS_WT(BSET_B, bset.b)
+DO_MSA__WD__WS_WT(BSET_H, bset.h)
+DO_MSA__WD__WS_WT(BSET_W, bset.w)
+DO_MSA__WD__WS_WT(BSET_D, bset.d)
+
+DO_MSA__WD__WS_WT(BNEG_B, bneg.b)
+DO_MSA__WD__WS_WT(BNEG_H, bneg.h)
+DO_MSA__WD__WS_WT(BNEG_W, bneg.w)
+DO_MSA__WD__WS_WT(BNEG_D, bneg.d)
+
+DO_MSA__WD__WS_WT(PCKEV_B, pckev.b)
+DO_MSA__WD__WS_WT(PCKEV_H, pckev.h)
+DO_MSA__WD__WS_WT(PCKEV_W, pckev.w)
+DO_MSA__WD__WS_WT(PCKEV_D, pckev.d)
+
+DO_MSA__WD__WS_WT(PCKOD_B, pckod.b)
+DO_MSA__WD__WS_WT(PCKOD_H, pckod.h)
+DO_MSA__WD__WS_WT(PCKOD_W, pckod.w)
+DO_MSA__WD__WS_WT(PCKOD_D, pckod.d)
+
+DO_MSA__WD__WS_WT(VSHF_B, vshf.b)
+DO_MSA__WD__WS_WT(VSHF_H, vshf.h)
+DO_MSA__WD__WS_WT(VSHF_W, vshf.w)
+DO_MSA__WD__WS_WT(VSHF_D, vshf.d)
+
+DO_MSA__WD__WS_WT(SLL_B, sll.b)
+DO_MSA__WD__WS_WT(SLL_H, sll.h)
+DO_MSA__WD__WS_WT(SLL_W, sll.w)
+DO_MSA__WD__WS_WT(SLL_D, sll.d)
+
+DO_MSA__WD__WS_WT(SRA_B, sra.b)
+DO_MSA__WD__WS_WT(SRA_H, sra.h)
+DO_MSA__WD__WS_WT(SRA_W, sra.w)
+DO_MSA__WD__WS_WT(SRA_D, sra.d)
+
+DO_MSA__WD__WS_WT(SRAR_B, srar.b)
+DO_MSA__WD__WS_WT(SRAR_H, srar.h)
+DO_MSA__WD__WS_WT(SRAR_W, srar.w)
+DO_MSA__WD__WS_WT(SRAR_D, srar.d)
+
+DO_MSA__WD__WS_WT(SRL_B, srl.b)
+DO_MSA__WD__WS_WT(SRL_H, srl.h)
+DO_MSA__WD__WS_WT(SRL_W, srl.w)
+DO_MSA__WD__WS_WT(SRL_D, srl.d)
+
+DO_MSA__WD__WS_WT(SRLR_B, srlr.b)
+DO_MSA__WD__WS_WT(SRLR_H, srlr.h)
+DO_MSA__WD__WS_WT(SRLR_W, srlr.w)
+DO_MSA__WD__WS_WT(SRLR_D, srlr.d)
+
+DO_MSA__WD__WS_WT(BMNZ_V, bmnz.v)
+DO_MSA__WD__WS_WT(BMZ_V, bmz.v)
+
+DO_MSA__WD__WS_WT(FMAX_W, fmax.w)
+DO_MSA__WD__WS_WT(FMAX_D, fmax.d)
+
+DO_MSA__WD__WS_WT(FMAX_A_W, fmax_a.w)
+DO_MSA__WD__WS_WT(FMAX_A_D, fmax_a.d)
+
+DO_MSA__WD__WS_WT(FMIN_W, fmin.w)
+DO_MSA__WD__WS_WT(FMIN_D, fmin.d)
+
+DO_MSA__WD__WS_WT(FMIN_A_W, fmin_a.w)
+DO_MSA__WD__WS_WT(FMIN_A_D, fmin_a.d)
+
 
 #endif

tests/tcg/mips/user/ase/msa/int-add/test_msa_add_a_b.c

+/*
+ *  Test program for MSA instruction ADD_A.B
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADD_A.B";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0202020202020202ULL, 0x0202020202020202ULL, },    /*   0  */
+        { 0x0101010101010101ULL, 0x0101010101010101ULL, },
+        { 0x5757575757575757ULL, 0x5757575757575757ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0x3535353535353535ULL, 0x3535353535353535ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x1e73391e73391e73ULL, 0x391e73391e73391eULL, },
+        { 0x1d723a1d723a1d72ULL, 0x3a1d723a1d723a1dULL, },
+        { 0x0101010101010101ULL, 0x0101010101010101ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1d72381d72381d72ULL, 0x381d72381d72381dULL, },
+        { 0x1c71391c71391c71ULL, 0x391c71391c71391cULL, },
+        { 0x5757575757575757ULL, 0x5757575757575757ULL, },    /*  16  */
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0xacacacacacacacacULL, 0xacacacacacacacacULL, },
+        { 0xababababababababULL, 0xababababababababULL, },
+        { 0x8a8a8a8a8a8a8a8aULL, 0x8a8a8a8a8a8a8a8aULL, },
+        { 0x8989898989898989ULL, 0x8989898989898989ULL, },
+        { 0x73c88e73c88e73c8ULL, 0x8e73c88e73c88e73ULL, },
+        { 0x72c78f72c78f72c7ULL, 0x8f72c78f72c78f72ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xababababababababULL, 0xababababababababULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8989898989898989ULL, 0x8989898989898989ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x72c78d72c78d72c7ULL, 0x8d72c78d72c78d72ULL, },
+        { 0x71c68e71c68e71c6ULL, 0x8e71c68e71c68e71ULL, },
+        { 0x3535353535353535ULL, 0x3535353535353535ULL, },    /*  32  */
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x8a8a8a8a8a8a8a8aULL, 0x8a8a8a8a8a8a8a8aULL, },
+        { 0x8989898989898989ULL, 0x8989898989898989ULL, },
+        { 0x6868686868686868ULL, 0x6868686868686868ULL, },
+        { 0x6767676767676767ULL, 0x6767676767676767ULL, },
+        { 0x51a66c51a66c51a6ULL, 0x6c51a66c51a66c51ULL, },
+        { 0x50a56d50a56d50a5ULL, 0x6d50a56d50a56d50ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x8989898989898989ULL, 0x8989898989898989ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x6767676767676767ULL, 0x6767676767676767ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x50a56b50a56b50a5ULL, 0x6b50a56b50a56b50ULL, },
+        { 0x4fa46c4fa46c4fa4ULL, 0x6c4fa46c4fa46c4fULL, },
+        { 0x1e73391e73391e73ULL, 0x391e73391e73391eULL, },    /*  48  */
+        { 0x1d72381d72381d72ULL, 0x381d72381d72381dULL, },
+        { 0x73c88e73c88e73c8ULL, 0x8e73c88e73c88e73ULL, },
+        { 0x72c78d72c78d72c7ULL, 0x8d72c78d72c78d72ULL, },
+        { 0x51a66c51a66c51a6ULL, 0x6c51a66c51a66c51ULL, },
+        { 0x50a56b50a56b50a5ULL, 0x6b50a56b50a56b50ULL, },
+        { 0x3ae4703ae4703ae4ULL, 0x703ae4703ae4703aULL, },
+        { 0x39e37139e37139e3ULL, 0x7139e37139e37139ULL, },
+        { 0x1d723a1d723a1d72ULL, 0x3a1d723a1d723a1dULL, },    /*  56  */
+        { 0x1c71391c71391c71ULL, 0x391c71391c71391cULL, },
+        { 0x72c78f72c78f72c7ULL, 0x8f72c78f72c78f72ULL, },
+        { 0x71c68e71c68e71c6ULL, 0x8e71c68e71c68e71ULL, },
+        { 0x50a56d50a56d50a5ULL, 0x6d50a56d50a56d50ULL, },
+        { 0x4fa46c4fa46c4fa4ULL, 0x6c4fa46c4fa46c4fULL, },
+        { 0x39e37139e37139e3ULL, 0x7139e37139e37139ULL, },
+        { 0x38e27238e27238e2ULL, 0x7238e27238e27238ULL, },
+        { 0xf0d4346850c4aa80ULL, 0x96ce16bc04f6a018ULL, },    /*  64  */
+        { 0x7dac1a9775cf8e48ULL, 0x5d70507817baa210ULL, },
+        { 0xccc46c8a6f93cac0ULL, 0x728f455f57a67520ULL, },
+        { 0xe8b930818693738eULL, 0xbe76838659bd6e6cULL, },
+        { 0x7dac1a9775cf8e48ULL, 0x5d70507817baa210ULL, },
+        { 0x0a8400c69ada7210ULL, 0x24128a342a7ea408ULL, },
+        { 0x599c52b9949eae88ULL, 0x39317f1b6a6a7718ULL, },
+        { 0x759116b0ab9e5756ULL, 0x8518bd426c817064ULL, },
+        { 0xccc46c8a6f93cac0ULL, 0x728f455f57a67520ULL, },    /*  72  */
+        { 0x599c52b9949eae88ULL, 0x39317f1b6a6a7718ULL, },
+        { 0xa8b4a4ac8e62ea00ULL, 0x4e507402aa564a28ULL, },
+        { 0xc4a968a3a56293ceULL, 0x9a37b229ac6d4374ULL, },
+        { 0xe8b930818693738eULL, 0xbe76838659bd6e6cULL, },
+        { 0x759116b0ab9e5756ULL, 0x8518bd426c817064ULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_B(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_B(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_add_a_d.c

+/*
+ *  Test program for MSA instruction ADD_A.D
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADD_A.D";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0000000000000002ULL, 0x0000000000000002ULL, },    /*   0  */
+        { 0x0000000000000001ULL, 0x0000000000000001ULL, },
+        { 0x5555555555555557ULL, 0x5555555555555557ULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0x3333333333333335ULL, 0x3333333333333335ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x1c71c71c71c71c73ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e5ULL, },
+        { 0x0000000000000001ULL, 0x0000000000000001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x5555555555555557ULL, 0x5555555555555557ULL, },    /*  16  */
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0xaaaaaaaaaaaaaaacULL, 0xaaaaaaaaaaaaaaacULL, },
+        { 0xaaaaaaaaaaaaaaabULL, 0xaaaaaaaaaaaaaaabULL, },
+        { 0x888888888888888aULL, 0x888888888888888aULL, },
+        { 0x8888888888888889ULL, 0x8888888888888889ULL, },
+        { 0x71c71c71c71c71c8ULL, 0x8e38e38e38e38e39ULL, },
+        { 0x71c71c71c71c71c7ULL, 0x8e38e38e38e38e3aULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xaaaaaaaaaaaaaaabULL, 0xaaaaaaaaaaaaaaabULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8888888888888889ULL, 0x8888888888888889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x71c71c71c71c71c7ULL, 0x8e38e38e38e38e38ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x8e38e38e38e38e39ULL, },
+        { 0x3333333333333335ULL, 0x3333333333333335ULL, },    /*  32  */
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x888888888888888aULL, 0x888888888888888aULL, },
+        { 0x8888888888888889ULL, 0x8888888888888889ULL, },
+        { 0x6666666666666668ULL, 0x6666666666666668ULL, },
+        { 0x6666666666666667ULL, 0x6666666666666667ULL, },
+        { 0x4fa4fa4fa4fa4fa6ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c18ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x8888888888888889ULL, 0x8888888888888889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x6666666666666667ULL, 0x6666666666666667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x1c71c71c71c71c73ULL, 0x38e38e38e38e38e4ULL, },    /*  48  */
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e3ULL, },
+        { 0x71c71c71c71c71c8ULL, 0x8e38e38e38e38e39ULL, },
+        { 0x71c71c71c71c71c7ULL, 0x8e38e38e38e38e38ULL, },
+        { 0x4fa4fa4fa4fa4fa6ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x38e38e38e38e38e4ULL, 0x71c71c71c71c71c6ULL, },
+        { 0x38e38e38e38e38e3ULL, 0x71c71c71c71c71c7ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e5ULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x71c71c71c71c71c7ULL, 0x8e38e38e38e38e3aULL, },
+        { 0x71c71c71c71c71c6ULL, 0x8e38e38e38e38e39ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c18ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x38e38e38e38e38e3ULL, 0x71c71c71c71c71c7ULL, },
+        { 0x38e38e38e38e38e2ULL, 0x71c71c71c71c71c8ULL, },
+        { 0xef2a3267af3b5580ULL, 0x96ce16bdfcf76018ULL, },    /*  64  */
+        { 0x7bd718d08a09e3b8ULL, 0x5e5ec67913bb0308ULL, },
+        { 0xcb3a6a891dce1f40ULL, 0x733fd25ea9a6d520ULL, },
+        { 0xe7e42f8135cf8d0eULL, 0xbd7582865538cd6cULL, },
+        { 0x7bd718d08a09e3b8ULL, 0x5e5ec67913bb0308ULL, },
+        { 0x0883ff3964d871f0ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0x57e750f1f89cad78ULL, 0x3ad08219c06a7810ULL, },
+        { 0x749115ea109e1b46ULL, 0x850632416bfc705cULL, },
+        { 0xcb3a6a891dce1f40ULL, 0x733fd25ea9a6d520ULL, },    /*  72  */
+        { 0x57e750f1f89cad78ULL, 0x3ad08219c06a7810ULL, },
+        { 0xa74aa2aa8c60e900ULL, 0x4fb18dff56564a28ULL, },
+        { 0xc3f467a2a46256ceULL, 0x99e73e2701e84274ULL, },
+        { 0xe7e42f8135cf8d0eULL, 0xbd7582865538cd6cULL, },
+        { 0x749115ea109e1b46ULL, 0x850632416bfc705cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_D(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_D(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_add_a_h.c

+/*
+ *  Test program for MSA instruction ADD_A.H
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADD_A.H";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0002000200020002ULL, 0x0002000200020002ULL, },    /*   0  */
+        { 0x0001000100010001ULL, 0x0001000100010001ULL, },
+        { 0x5557555755575557ULL, 0x5557555755575557ULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0x3335333533353335ULL, 0x3335333533353335ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x1c7338e471c91c73ULL, 0x38e471c91c7338e4ULL, },
+        { 0x1c7238e571c81c72ULL, 0x38e571c81c7238e5ULL, },
+        { 0x0001000100010001ULL, 0x0001000100010001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c7238e371c81c72ULL, 0x38e371c81c7238e3ULL, },
+        { 0x1c7138e471c71c71ULL, 0x38e471c71c7138e4ULL, },
+        { 0x5557555755575557ULL, 0x5557555755575557ULL, },    /*  16  */
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0xaaacaaacaaacaaacULL, 0xaaacaaacaaacaaacULL, },
+        { 0xaaabaaabaaabaaabULL, 0xaaabaaabaaabaaabULL, },
+        { 0x888a888a888a888aULL, 0x888a888a888a888aULL, },
+        { 0x8889888988898889ULL, 0x8889888988898889ULL, },
+        { 0x71c88e39c71e71c8ULL, 0x8e39c71e71c88e39ULL, },
+        { 0x71c78e3ac71d71c7ULL, 0x8e3ac71d71c78e3aULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xaaabaaabaaabaaabULL, 0xaaabaaabaaabaaabULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8889888988898889ULL, 0x8889888988898889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x71c78e38c71d71c7ULL, 0x8e38c71d71c78e38ULL, },
+        { 0x71c68e39c71c71c6ULL, 0x8e39c71c71c68e39ULL, },
+        { 0x3335333533353335ULL, 0x3335333533353335ULL, },    /*  32  */
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x888a888a888a888aULL, 0x888a888a888a888aULL, },
+        { 0x8889888988898889ULL, 0x8889888988898889ULL, },
+        { 0x6668666866686668ULL, 0x6668666866686668ULL, },
+        { 0x6667666766676667ULL, 0x6667666766676667ULL, },
+        { 0x4fa66c17a4fc4fa6ULL, 0x6c17a4fc4fa66c17ULL, },
+        { 0x4fa56c18a4fb4fa5ULL, 0x6c18a4fb4fa56c18ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x8889888988898889ULL, 0x8889888988898889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x6667666766676667ULL, 0x6667666766676667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa56c16a4fb4fa5ULL, 0x6c16a4fb4fa56c16ULL, },
+        { 0x4fa46c17a4fa4fa4ULL, 0x6c17a4fa4fa46c17ULL, },
+        { 0x1c7338e471c91c73ULL, 0x38e471c91c7338e4ULL, },    /*  48  */
+        { 0x1c7238e371c81c72ULL, 0x38e371c81c7238e3ULL, },
+        { 0x71c88e39c71e71c8ULL, 0x8e39c71e71c88e39ULL, },
+        { 0x71c78e38c71d71c7ULL, 0x8e38c71d71c78e38ULL, },
+        { 0x4fa66c17a4fc4fa6ULL, 0x6c17a4fc4fa66c17ULL, },
+        { 0x4fa56c16a4fb4fa5ULL, 0x6c16a4fb4fa56c16ULL, },
+        { 0x38e471c6e39038e4ULL, 0x71c6e39038e471c6ULL, },
+        { 0x38e371c7e38f38e3ULL, 0x71c7e38f38e371c7ULL, },
+        { 0x1c7238e571c81c72ULL, 0x38e571c81c7238e5ULL, },    /*  56  */
+        { 0x1c7138e471c71c71ULL, 0x38e471c71c7138e4ULL, },
+        { 0x71c78e3ac71d71c7ULL, 0x8e3ac71d71c78e3aULL, },
+        { 0x71c68e39c71c71c6ULL, 0x8e39c71c71c68e39ULL, },
+        { 0x4fa56c18a4fb4fa5ULL, 0x6c18a4fb4fa56c18ULL, },
+        { 0x4fa46c17a4fa4fa4ULL, 0x6c17a4fa4fa46c17ULL, },
+        { 0x38e371c7e38f38e3ULL, 0x71c7e38f38e371c7ULL, },
+        { 0x38e271c8e38e38e2ULL, 0x71c8e38e38e271c8ULL, },
+        { 0xef2c326850c4aa80ULL, 0x96ce16bc030a9fe8ULL, },    /*  64  */
+        { 0x7bd8199775f58e38ULL, 0x5e5e504416c4a2f0ULL, },
+        { 0xcb3c6a8a6e93c9c0ULL, 0x733f445f565a7508ULL, },
+        { 0xe7e52f81869372f2ULL, 0xbd76828658436d54ULL, },
+        { 0x7bd8199775f58e38ULL, 0x5e5e504416c4a2f0ULL, },
+        { 0x088400c69b2671f0ULL, 0x25ee89cc2a7ea5f8ULL, },
+        { 0x57e851b993c4ad78ULL, 0x3acf7de76a147810ULL, },
+        { 0x749116b0abc456aaULL, 0x8506bc0e6bfd705cULL, },
+        { 0xcb3c6a8a6e93c9c0ULL, 0x733f445f565a7508ULL, },    /*  72  */
+        { 0x57e851b993c4ad78ULL, 0x3acf7de76a147810ULL, },
+        { 0xa74ca2ac8c62e900ULL, 0x4fb07202a9aa4a28ULL, },
+        { 0xc3f567a3a4629232ULL, 0x99e7b029ab934274ULL, },
+        { 0xe7e52f81869372f2ULL, 0xbd76828658436d54ULL, },
+        { 0x749116b0abc456aaULL, 0x8506bc0e6bfd705cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_H(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_H(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_add_a_w.c

+/*
+ *  Test program for MSA instruction ADD_A.W
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADD_A.W";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0000000200000002ULL, 0x0000000200000002ULL, },    /*   0  */
+        { 0x0000000100000001ULL, 0x0000000100000001ULL, },
+        { 0x5555555755555557ULL, 0x5555555755555557ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0x3333333533333335ULL, 0x3333333533333335ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x1c71c71e71c71c73ULL, 0x38e38e391c71c71eULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e3a1c71c71dULL, },
+        { 0x0000000100000001ULL, 0x0000000100000001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e381c71c71dULL, },
+        { 0x1c71c71c71c71c71ULL, 0x38e38e391c71c71cULL, },
+        { 0x5555555755555557ULL, 0x5555555755555557ULL, },    /*  16  */
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0xaaaaaaacaaaaaaacULL, 0xaaaaaaacaaaaaaacULL, },
+        { 0xaaaaaaabaaaaaaabULL, 0xaaaaaaabaaaaaaabULL, },
+        { 0x8888888a8888888aULL, 0x8888888a8888888aULL, },
+        { 0x8888888988888889ULL, 0x8888888988888889ULL, },
+        { 0x71c71c73c71c71c8ULL, 0x8e38e38e71c71c73ULL, },
+        { 0x71c71c72c71c71c7ULL, 0x8e38e38f71c71c72ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xaaaaaaabaaaaaaabULL, 0xaaaaaaabaaaaaaabULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8888888988888889ULL, 0x8888888988888889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x71c71c72c71c71c7ULL, 0x8e38e38d71c71c72ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x8e38e38e71c71c71ULL, },
+        { 0x3333333533333335ULL, 0x3333333533333335ULL, },    /*  32  */
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x8888888a8888888aULL, 0x8888888a8888888aULL, },
+        { 0x8888888988888889ULL, 0x8888888988888889ULL, },
+        { 0x6666666866666668ULL, 0x6666666866666668ULL, },
+        { 0x6666666766666667ULL, 0x6666666766666667ULL, },
+        { 0x4fa4fa51a4fa4fa6ULL, 0x6c16c16c4fa4fa51ULL, },
+        { 0x4fa4fa50a4fa4fa5ULL, 0x6c16c16d4fa4fa50ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x8888888988888889ULL, 0x8888888988888889ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x6666666766666667ULL, 0x6666666766666667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa4fa50a4fa4fa5ULL, 0x6c16c16b4fa4fa50ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c4fa4fa4fULL, },
+        { 0x1c71c71e71c71c73ULL, 0x38e38e391c71c71eULL, },    /*  48  */
+        { 0x1c71c71d71c71c72ULL, 0x38e38e381c71c71dULL, },
+        { 0x71c71c73c71c71c8ULL, 0x8e38e38e71c71c73ULL, },
+        { 0x71c71c72c71c71c7ULL, 0x8e38e38d71c71c72ULL, },
+        { 0x4fa4fa51a4fa4fa6ULL, 0x6c16c16c4fa4fa51ULL, },
+        { 0x4fa4fa50a4fa4fa5ULL, 0x6c16c16b4fa4fa50ULL, },
+        { 0x38e38e3ae38e38e4ULL, 0x71c71c7038e38e3aULL, },
+        { 0x38e38e39e38e38e3ULL, 0x71c71c7138e38e39ULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e3a1c71c71dULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0x38e38e391c71c71cULL, },
+        { 0x71c71c72c71c71c7ULL, 0x8e38e38f71c71c72ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x8e38e38e71c71c71ULL, },
+        { 0x4fa4fa50a4fa4fa5ULL, 0x6c16c16d4fa4fa50ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c4fa4fa4fULL, },
+        { 0x38e38e39e38e38e3ULL, 0x71c71c7138e38e39ULL, },
+        { 0x38e38e38e38e38e2ULL, 0x71c71c7238e38e38ULL, },
+        { 0xef2a326850c4aa80ULL, 0x96ce16bc03089fe8ULL, },    /*  64  */
+        { 0x7bd718d175f61c48ULL, 0x5e5ec67816c3a2f0ULL, },
+        { 0xcb3a6a8a6e92c9c0ULL, 0x733fd25d56592ae0ULL, },
+        { 0xe7e42f818694378eULL, 0xbd75828658416d54ULL, },
+        { 0x7bd718d175f61c48ULL, 0x5e5ec67816c3a2f0ULL, },
+        { 0x0883ff3a9b278e10ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0x57e750f393c43b88ULL, 0x3ad082196a142de8ULL, },
+        { 0x749115eaabc5a956ULL, 0x850632426bfc705cULL, },
+        { 0xcb3a6a8a6e92c9c0ULL, 0x733fd25d56592ae0ULL, },    /*  72  */
+        { 0x57e750f393c43b88ULL, 0x3ad082196a142de8ULL, },
+        { 0xa74aa2ac8c60e900ULL, 0x4fb18dfea9a9b5d8ULL, },
+        { 0xc3f467a3a46256ceULL, 0x99e73e27ab91f84cULL, },
+        { 0xe7e42f818694378eULL, 0xbd75828658416d54ULL, },
+        { 0x749115eaabc5a956ULL, 0x850632426bfc705cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_W(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADD_A_W(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_a_b.c

+/*
+ *  Test program for MSA instruction ADDS_A.B
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_A.B";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0202020202020202ULL, 0x0202020202020202ULL, },    /*   0  */
+        { 0x0101010101010101ULL, 0x0101010101010101ULL, },
+        { 0x5757575757575757ULL, 0x5757575757575757ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0x3535353535353535ULL, 0x3535353535353535ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x1e73391e73391e73ULL, 0x391e73391e73391eULL, },
+        { 0x1d723a1d723a1d72ULL, 0x3a1d723a1d723a1dULL, },
+        { 0x0101010101010101ULL, 0x0101010101010101ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1d72381d72381d72ULL, 0x381d72381d72381dULL, },
+        { 0x1c71391c71391c71ULL, 0x391c71391c71391cULL, },
+        { 0x5757575757575757ULL, 0x5757575757575757ULL, },    /*  16  */
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x737f7f737f7f737fULL, 0x7f737f7f737f7f73ULL, },
+        { 0x727f7f727f7f727fULL, 0x7f727f7f727f7f72ULL, },
+        { 0x5656565656565656ULL, 0x5656565656565656ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x727f7f727f7f727fULL, 0x7f727f7f727f7f72ULL, },
+        { 0x717f7f717f7f717fULL, 0x7f717f7f717f7f71ULL, },
+        { 0x3535353535353535ULL, 0x3535353535353535ULL, },    /*  32  */
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x6868686868686868ULL, 0x6868686868686868ULL, },
+        { 0x6767676767676767ULL, 0x6767676767676767ULL, },
+        { 0x517f6c517f6c517fULL, 0x6c517f6c517f6c51ULL, },
+        { 0x507f6d507f6d507fULL, 0x6d507f6d507f6d50ULL, },
+        { 0x3434343434343434ULL, 0x3434343434343434ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x6767676767676767ULL, 0x6767676767676767ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x507f6b507f6b507fULL, 0x6b507f6b507f6b50ULL, },
+        { 0x4f7f6c4f7f6c4f7fULL, 0x6c4f7f6c4f7f6c4fULL, },
+        { 0x1e73391e73391e73ULL, 0x391e73391e73391eULL, },    /*  48  */
+        { 0x1d72381d72381d72ULL, 0x381d72381d72381dULL, },
+        { 0x737f7f737f7f737fULL, 0x7f737f7f737f7f73ULL, },
+        { 0x727f7f727f7f727fULL, 0x7f727f7f727f7f72ULL, },
+        { 0x517f6c517f6c517fULL, 0x6c517f6c517f6c51ULL, },
+        { 0x507f6b507f6b507fULL, 0x6b507f6b507f6b50ULL, },
+        { 0x3a7f703a7f703a7fULL, 0x703a7f703a7f703aULL, },
+        { 0x397f71397f71397fULL, 0x71397f71397f7139ULL, },
+        { 0x1d723a1d723a1d72ULL, 0x3a1d723a1d723a1dULL, },    /*  56  */
+        { 0x1c71391c71391c71ULL, 0x391c71391c71391cULL, },
+        { 0x727f7f727f7f727fULL, 0x7f727f7f727f7f72ULL, },
+        { 0x717f7f717f7f717fULL, 0x7f717f7f717f7f71ULL, },
+        { 0x507f6d507f6d507fULL, 0x6d507f6d507f6d50ULL, },
+        { 0x4f7f6c4f7f6c4f7fULL, 0x6c4f7f6c4f7f6c4fULL, },
+        { 0x397f71397f71397fULL, 0x71397f71397f7139ULL, },
+        { 0x387f72387f72387fULL, 0x72387f72387f7238ULL, },
+        { 0x7f7f3468507f7f7fULL, 0x7f7f167f047f7f18ULL, },    /*  64  */
+        { 0x7d7f1a7f757f7f48ULL, 0x5d705078177f7f10ULL, },
+        { 0x7f7f6c7f6f7f7f7fULL, 0x727f455f577f7520ULL, },
+        { 0x7f7f307f7f7f737fULL, 0x7f767f7f597f6e6cULL, },
+        { 0x7d7f1a7f757f7f48ULL, 0x5d705078177f7f10ULL, },
+        { 0x0a7f007f7f7f7210ULL, 0x24127f342a7e7f08ULL, },
+        { 0x597f527f7f7f7f7fULL, 0x39317f1b6a6a7718ULL, },
+        { 0x757f167f7f7f5756ULL, 0x7f187f426c7f7064ULL, },
+        { 0x7f7f6c7f6f7f7f7fULL, 0x727f455f577f7520ULL, },    /*  72  */
+        { 0x597f527f7f7f7f7fULL, 0x39317f1b6a6a7718ULL, },
+        { 0x7f7f7f7f7f627f7fULL, 0x4e5074027f564a28ULL, },
+        { 0x7f7f687f7f627f7fULL, 0x7f377f297f6d4374ULL, },
+        { 0x7f7f307f7f7f737fULL, 0x7f767f7f597f6e6cULL, },
+        { 0x757f167f7f7f5756ULL, 0x7f187f426c7f7064ULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_B(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_B(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_a_d.c

+/*
+ *  Test program for MSA instruction ADDS_A.D
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_A.D";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0000000000000002ULL, 0x0000000000000002ULL, },    /*   0  */
+        { 0x0000000000000001ULL, 0x0000000000000001ULL, },
+        { 0x5555555555555557ULL, 0x5555555555555557ULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0x3333333333333335ULL, 0x3333333333333335ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x1c71c71c71c71c73ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e5ULL, },
+        { 0x0000000000000001ULL, 0x0000000000000001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x5555555555555557ULL, 0x5555555555555557ULL, },    /*  16  */
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c8ULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c7ULL, 0x7fffffffffffffffULL, },
+        { 0x5555555555555556ULL, 0x5555555555555556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c7ULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c6ULL, 0x7fffffffffffffffULL, },
+        { 0x3333333333333335ULL, 0x3333333333333335ULL, },    /*  32  */
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x6666666666666668ULL, 0x6666666666666668ULL, },
+        { 0x6666666666666667ULL, 0x6666666666666667ULL, },
+        { 0x4fa4fa4fa4fa4fa6ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c18ULL, },
+        { 0x3333333333333334ULL, 0x3333333333333334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x6666666666666667ULL, 0x6666666666666667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x1c71c71c71c71c73ULL, 0x38e38e38e38e38e4ULL, },    /*  48  */
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e3ULL, },
+        { 0x71c71c71c71c71c8ULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c7ULL, 0x7fffffffffffffffULL, },
+        { 0x4fa4fa4fa4fa4fa6ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x38e38e38e38e38e4ULL, 0x71c71c71c71c71c6ULL, },
+        { 0x38e38e38e38e38e3ULL, 0x71c71c71c71c71c7ULL, },
+        { 0x1c71c71c71c71c72ULL, 0x38e38e38e38e38e5ULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0x38e38e38e38e38e4ULL, },
+        { 0x71c71c71c71c71c7ULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c6ULL, 0x7fffffffffffffffULL, },
+        { 0x4fa4fa4fa4fa4fa5ULL, 0x6c16c16c16c16c18ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0x6c16c16c16c16c17ULL, },
+        { 0x38e38e38e38e38e3ULL, 0x71c71c71c71c71c7ULL, },
+        { 0x38e38e38e38e38e2ULL, 0x71c71c71c71c71c8ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },    /*  64  */
+        { 0x7bd718d08a09e3b8ULL, 0x5e5ec67913bb0308ULL, },
+        { 0x7fffffffffffffffULL, 0x733fd25ea9a6d520ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7bd718d08a09e3b8ULL, 0x5e5ec67913bb0308ULL, },
+        { 0x0883ff3964d871f0ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0x57e750f1f89cad78ULL, 0x3ad08219c06a7810ULL, },
+        { 0x749115ea109e1b46ULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x733fd25ea9a6d520ULL, },    /*  72  */
+        { 0x57e750f1f89cad78ULL, 0x3ad08219c06a7810ULL, },
+        { 0x7fffffffffffffffULL, 0x4fb18dff56564a28ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x749115ea109e1b46ULL, 0x7fffffffffffffffULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_D(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_D(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_a_h.c

+/*
+ *  Test program for MSA instruction ADDS_A.H
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_A.H";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0002000200020002ULL, 0x0002000200020002ULL, },    /*   0  */
+        { 0x0001000100010001ULL, 0x0001000100010001ULL, },
+        { 0x5557555755575557ULL, 0x5557555755575557ULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0x3335333533353335ULL, 0x3335333533353335ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x1c7338e471c91c73ULL, 0x38e471c91c7338e4ULL, },
+        { 0x1c7238e571c81c72ULL, 0x38e571c81c7238e5ULL, },
+        { 0x0001000100010001ULL, 0x0001000100010001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c7238e371c81c72ULL, 0x38e371c81c7238e3ULL, },
+        { 0x1c7138e471c71c71ULL, 0x38e471c71c7138e4ULL, },
+        { 0x5557555755575557ULL, 0x5557555755575557ULL, },    /*  16  */
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x71c87fff7fff71c8ULL, 0x7fff7fff71c87fffULL, },
+        { 0x71c77fff7fff71c7ULL, 0x7fff7fff71c77fffULL, },
+        { 0x5556555655565556ULL, 0x5556555655565556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x71c77fff7fff71c7ULL, 0x7fff7fff71c77fffULL, },
+        { 0x71c67fff7fff71c6ULL, 0x7fff7fff71c67fffULL, },
+        { 0x3335333533353335ULL, 0x3335333533353335ULL, },    /*  32  */
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x6668666866686668ULL, 0x6668666866686668ULL, },
+        { 0x6667666766676667ULL, 0x6667666766676667ULL, },
+        { 0x4fa66c177fff4fa6ULL, 0x6c177fff4fa66c17ULL, },
+        { 0x4fa56c187fff4fa5ULL, 0x6c187fff4fa56c18ULL, },
+        { 0x3334333433343334ULL, 0x3334333433343334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x6667666766676667ULL, 0x6667666766676667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa56c167fff4fa5ULL, 0x6c167fff4fa56c16ULL, },
+        { 0x4fa46c177fff4fa4ULL, 0x6c177fff4fa46c17ULL, },
+        { 0x1c7338e471c91c73ULL, 0x38e471c91c7338e4ULL, },    /*  48  */
+        { 0x1c7238e371c81c72ULL, 0x38e371c81c7238e3ULL, },
+        { 0x71c87fff7fff71c8ULL, 0x7fff7fff71c87fffULL, },
+        { 0x71c77fff7fff71c7ULL, 0x7fff7fff71c77fffULL, },
+        { 0x4fa66c177fff4fa6ULL, 0x6c177fff4fa66c17ULL, },
+        { 0x4fa56c167fff4fa5ULL, 0x6c167fff4fa56c16ULL, },
+        { 0x38e471c67fff38e4ULL, 0x71c67fff38e471c6ULL, },
+        { 0x38e371c77fff38e3ULL, 0x71c77fff38e371c7ULL, },
+        { 0x1c7238e571c81c72ULL, 0x38e571c81c7238e5ULL, },    /*  56  */
+        { 0x1c7138e471c71c71ULL, 0x38e471c71c7138e4ULL, },
+        { 0x71c77fff7fff71c7ULL, 0x7fff7fff71c77fffULL, },
+        { 0x71c67fff7fff71c6ULL, 0x7fff7fff71c67fffULL, },
+        { 0x4fa56c187fff4fa5ULL, 0x6c187fff4fa56c18ULL, },
+        { 0x4fa46c177fff4fa4ULL, 0x6c177fff4fa46c17ULL, },
+        { 0x38e371c77fff38e3ULL, 0x71c77fff38e371c7ULL, },
+        { 0x38e271c87fff38e2ULL, 0x71c87fff38e271c8ULL, },
+        { 0x7fff326850c47fffULL, 0x7fff16bc030a7fffULL, },    /*  64  */
+        { 0x7bd8199775f57fffULL, 0x5e5e504416c47fffULL, },
+        { 0x7fff6a8a6e937fffULL, 0x733f445f565a7508ULL, },
+        { 0x7fff2f817fff72f2ULL, 0x7fff7fff58436d54ULL, },
+        { 0x7bd8199775f57fffULL, 0x5e5e504416c47fffULL, },
+        { 0x088400c67fff71f0ULL, 0x25ee7fff2a7e7fffULL, },
+        { 0x57e851b97fff7fffULL, 0x3acf7de76a147810ULL, },
+        { 0x749116b07fff56aaULL, 0x7fff7fff6bfd705cULL, },
+        { 0x7fff6a8a6e937fffULL, 0x733f445f565a7508ULL, },    /*  72  */
+        { 0x57e851b97fff7fffULL, 0x3acf7de76a147810ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x4fb072027fff4a28ULL, },
+        { 0x7fff67a37fff7fffULL, 0x7fff7fff7fff4274ULL, },
+        { 0x7fff2f817fff72f2ULL, 0x7fff7fff58436d54ULL, },
+        { 0x749116b07fff56aaULL, 0x7fff7fff6bfd705cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_H(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_H(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_a_w.c

+/*
+ *  Test program for MSA instruction ADDS_A.W
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_A.W";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0x0000000200000002ULL, 0x0000000200000002ULL, },    /*   0  */
+        { 0x0000000100000001ULL, 0x0000000100000001ULL, },
+        { 0x5555555755555557ULL, 0x5555555755555557ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0x3333333533333335ULL, 0x3333333533333335ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x1c71c71e71c71c73ULL, 0x38e38e391c71c71eULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e3a1c71c71dULL, },
+        { 0x0000000100000001ULL, 0x0000000100000001ULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e381c71c71dULL, },
+        { 0x1c71c71c71c71c71ULL, 0x38e38e391c71c71cULL, },
+        { 0x5555555755555557ULL, 0x5555555755555557ULL, },    /*  16  */
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x71c71c737fffffffULL, 0x7fffffff71c71c73ULL, },
+        { 0x71c71c727fffffffULL, 0x7fffffff71c71c72ULL, },
+        { 0x5555555655555556ULL, 0x5555555655555556ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x71c71c727fffffffULL, 0x7fffffff71c71c72ULL, },
+        { 0x71c71c717fffffffULL, 0x7fffffff71c71c71ULL, },
+        { 0x3333333533333335ULL, 0x3333333533333335ULL, },    /*  32  */
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x6666666866666668ULL, 0x6666666866666668ULL, },
+        { 0x6666666766666667ULL, 0x6666666766666667ULL, },
+        { 0x4fa4fa517fffffffULL, 0x6c16c16c4fa4fa51ULL, },
+        { 0x4fa4fa507fffffffULL, 0x6c16c16d4fa4fa50ULL, },
+        { 0x3333333433333334ULL, 0x3333333433333334ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x6666666766666667ULL, 0x6666666766666667ULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x4fa4fa507fffffffULL, 0x6c16c16b4fa4fa50ULL, },
+        { 0x4fa4fa4f7fffffffULL, 0x6c16c16c4fa4fa4fULL, },
+        { 0x1c71c71e71c71c73ULL, 0x38e38e391c71c71eULL, },    /*  48  */
+        { 0x1c71c71d71c71c72ULL, 0x38e38e381c71c71dULL, },
+        { 0x71c71c737fffffffULL, 0x7fffffff71c71c73ULL, },
+        { 0x71c71c727fffffffULL, 0x7fffffff71c71c72ULL, },
+        { 0x4fa4fa517fffffffULL, 0x6c16c16c4fa4fa51ULL, },
+        { 0x4fa4fa507fffffffULL, 0x6c16c16b4fa4fa50ULL, },
+        { 0x38e38e3a7fffffffULL, 0x71c71c7038e38e3aULL, },
+        { 0x38e38e397fffffffULL, 0x71c71c7138e38e39ULL, },
+        { 0x1c71c71d71c71c72ULL, 0x38e38e3a1c71c71dULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0x38e38e391c71c71cULL, },
+        { 0x71c71c727fffffffULL, 0x7fffffff71c71c72ULL, },
+        { 0x71c71c717fffffffULL, 0x7fffffff71c71c71ULL, },
+        { 0x4fa4fa507fffffffULL, 0x6c16c16d4fa4fa50ULL, },
+        { 0x4fa4fa4f7fffffffULL, 0x6c16c16c4fa4fa4fULL, },
+        { 0x38e38e397fffffffULL, 0x71c71c7138e38e39ULL, },
+        { 0x38e38e387fffffffULL, 0x71c71c7238e38e38ULL, },
+        { 0x7fffffff50c4aa80ULL, 0x7fffffff03089fe8ULL, },    /*  64  */
+        { 0x7bd718d175f61c48ULL, 0x5e5ec67816c3a2f0ULL, },
+        { 0x7fffffff6e92c9c0ULL, 0x733fd25d56592ae0ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff58416d54ULL, },
+        { 0x7bd718d175f61c48ULL, 0x5e5ec67816c3a2f0ULL, },
+        { 0x0883ff3a7fffffffULL, 0x25ef76342a7ea5f8ULL, },
+        { 0x57e750f37fffffffULL, 0x3ad082196a142de8ULL, },
+        { 0x749115ea7fffffffULL, 0x7fffffff6bfc705cULL, },
+        { 0x7fffffff6e92c9c0ULL, 0x733fd25d56592ae0ULL, },    /*  72  */
+        { 0x57e750f37fffffffULL, 0x3ad082196a142de8ULL, },
+        { 0x7fffffff7fffffffULL, 0x4fb18dfe7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff58416d54ULL, },
+        { 0x749115ea7fffffffULL, 0x7fffffff6bfc705cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_W(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_A_W(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_s_b.c

+/*
+ *  Test program for MSA instruction ADDS_S.B
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_S.B";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfefefefefefefefeULL, 0xfefefefefefefefeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xa9a9a9a9a9a9a9a9ULL, 0xa9a9a9a9a9a9a9a9ULL, },
+        { 0x5454545454545454ULL, 0x5454545454545454ULL, },
+        { 0xcbcbcbcbcbcbcbcbULL, 0xcbcbcbcbcbcbcbcbULL, },
+        { 0x3232323232323232ULL, 0x3232323232323232ULL, },
+        { 0xe28d37e28d37e28dULL, 0x37e28d37e28d37e2ULL, },
+        { 0x1b70c61b70c61b70ULL, 0xc61b70c61b70c61bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xa9a9a9a9a9a9a9a9ULL, 0xa9a9a9a9a9a9a9a9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8080808080808080ULL, 0x8080808080808080ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8080808080808080ULL, 0x8080808080808080ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8d80e28d80e28d80ULL, 0xe28d80e28d80e28dULL, },
+        { 0xc61b80c61b80c61bULL, 0x80c61b80c61b80c6ULL, },
+        { 0x5454545454545454ULL, 0x5454545454545454ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x2121212121212121ULL, 0x2121212121212121ULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0x38e37f38e37f38e3ULL, 0x7f38e37f38e37f38ULL, },
+        { 0x717f1c717f1c717fULL, 0x1c717f1c717f1c71ULL, },
+        { 0xcbcbcbcbcbcbcbcbULL, 0xcbcbcbcbcbcbcbcbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x8080808080808080ULL, 0x8080808080808080ULL, },
+        { 0x2121212121212121ULL, 0x2121212121212121ULL, },
+        { 0x9898989898989898ULL, 0x9898989898989898ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaf8004af8004af80ULL, 0x04af8004af8004afULL, },
+        { 0xe83d93e83d93e83dULL, 0x93e83d93e83d93e8ULL, },
+        { 0x3232323232323232ULL, 0x3232323232323232ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x7f7f7f7f7f7f7f7fULL, 0x7f7f7f7f7f7f7f7fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16b16c16b16c1ULL, 0x6b16c16b16c16b16ULL, },
+        { 0x4f7ffa4f7ffa4f7fULL, 0xfa4f7ffa4f7ffa4fULL, },
+        { 0xe28d37e28d37e28dULL, 0x37e28d37e28d37e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8d80e28d80e28d80ULL, 0xe28d80e28d80e28dULL, },
+        { 0x38e37f38e37f38e3ULL, 0x7f38e37f38e37f38ULL, },
+        { 0xaf8004af8004af80ULL, 0x04af8004af8004afULL, },
+        { 0x16c16b16c16b16c1ULL, 0x6b16c16b16c16b16ULL, },
+        { 0xc68070c68070c680ULL, 0x70c68070c68070c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1b70c61b70c61b70ULL, 0xc61b70c61b70c61bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc61b80c61b80c61bULL, 0x80c61b80c61b80c6ULL, },
+        { 0x717f1c717f1c717fULL, 0x1c717f1c717f1c71ULL, },
+        { 0xe83d93e83d93e83dULL, 0x93e83d93e83d93e8ULL, },
+        { 0x4f7ffa4f7ffa4f7fULL, 0xfa4f7ffa4f7ffa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x387f8e387f8e387fULL, 0x8e387f8e387f8e38ULL, },
+        { 0x807fcc98507f7f7fULL, 0x7f7f167ffc7f8018ULL, },    /*  64  */
+        { 0x8328e62f75f51c48ULL, 0x5d5ec678137f0208ULL, },
+        { 0x807f9480e131e0c0ULL, 0x723fd15da97fd520ULL, },
+        { 0xf87ffc197f7f377fULL, 0xd8589336a77f92acULL, },
+        { 0x8328e62f75f51c48ULL, 0x5d5ec678137f0208ULL, },
+        { 0xf680007f7f808e10ULL, 0x24ee80342a7e7ff8ULL, },
+        { 0xa718ae0d06808088ULL, 0x39cf8119c06a7710ULL, },
+        { 0x6b0d167f7fc4a956ULL, 0x9fe880f2be7f349cULL, },
+        { 0x807f9480e131e0c0ULL, 0x723fd15da97fd520ULL, },    /*  72  */
+        { 0xa718ae0d06808088ULL, 0x39cf8119c06a7710ULL, },
+        { 0x807f8080809e8080ULL, 0x4eb08cfe80564a28ULL, },
+        { 0x1c7fc4f7170080ceULL, 0xb4c980d7806d07b4ULL, },
+        { 0xf87ffc197f7f377fULL, 0xd8589336a77f92acULL, },
+        { 0x6b0d167f7fc4a956ULL, 0x9fe880f2be7f349cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_B(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_B(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_s_d.c

+/*
+ *  Test program for MSA instruction ADDS_S.D
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_S.D";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfffffffffffffffeULL, 0xfffffffffffffffeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaa9ULL, 0xaaaaaaaaaaaaaaa9ULL, },
+        { 0x5555555555555554ULL, 0x5555555555555554ULL, },
+        { 0xcccccccccccccccbULL, 0xcccccccccccccccbULL, },
+        { 0x3333333333333332ULL, 0x3333333333333332ULL, },
+        { 0xe38e38e38e38e38dULL, 0x38e38e38e38e38e2ULL, },
+        { 0x1c71c71c71c71c70ULL, 0xc71c71c71c71c71bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xaaaaaaaaaaaaaaa9ULL, 0xaaaaaaaaaaaaaaa9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8000000000000000ULL, 0x8000000000000000ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8000000000000000ULL, 0x8000000000000000ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8e38e38e38e38e38ULL, 0xe38e38e38e38e38dULL, },
+        { 0xc71c71c71c71c71bULL, 0x8000000000000000ULL, },
+        { 0x5555555555555554ULL, 0x5555555555555554ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x2222222222222221ULL, 0x2222222222222221ULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0x38e38e38e38e38e3ULL, 0x7fffffffffffffffULL, },
+        { 0x71c71c71c71c71c6ULL, 0x1c71c71c71c71c71ULL, },
+        { 0xcccccccccccccccbULL, 0xcccccccccccccccbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x8000000000000000ULL, 0x8000000000000000ULL, },
+        { 0x2222222222222221ULL, 0x2222222222222221ULL, },
+        { 0x9999999999999998ULL, 0x9999999999999998ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xb05b05b05b05b05aULL, 0x05b05b05b05b05afULL, },
+        { 0xe93e93e93e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x3333333333333332ULL, 0x3333333333333332ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x7fffffffffffffffULL, 0x7fffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xe38e38e38e38e38dULL, 0x38e38e38e38e38e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8e38e38e38e38e38ULL, 0xe38e38e38e38e38dULL, },
+        { 0x38e38e38e38e38e3ULL, 0x7fffffffffffffffULL, },
+        { 0xb05b05b05b05b05aULL, 0x05b05b05b05b05afULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16c16c16c16ULL, },
+        { 0xc71c71c71c71c71cULL, 0x71c71c71c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1c71c71c71c71c70ULL, 0xc71c71c71c71c71bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71c71c71c71c71bULL, 0x8000000000000000ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x1c71c71c71c71c71ULL, },
+        { 0xe93e93e93e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e38e38e38e38e2ULL, 0x8e38e38e38e38e38ULL, },
+        { 0x8000000000000000ULL, 0x7fffffffffffffffULL, },    /*  64  */
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67913bb0308ULL, },
+        { 0x8000000000000000ULL, 0x733fd25ea9a6d520ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67913bb0308ULL, },
+        { 0xf77c00c69b278e10ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0xa818af0e07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x6c0d16b0abc5a956ULL, 0xa0e943f2be82359cULL, },
+        { 0x8000000000000000ULL, 0x733fd25ea9a6d520ULL, },    /*  72  */
+        { 0xa818af0e07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x8000000000000000ULL, 0x4fb18dff56564a28ULL, },
+        { 0x1ca9c4f818016dceULL, 0xb5ca4fd8546e07b4ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0x6c0d16b0abc5a956ULL, 0xa0e943f2be82359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_D(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_D(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_s_h.c

+/*
+ *  Test program for MSA instruction ADDS_S.H
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_S.H";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfffefffefffefffeULL, 0xfffefffefffefffeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaa9aaa9aaa9aaa9ULL, 0xaaa9aaa9aaa9aaa9ULL, },
+        { 0x5554555455545554ULL, 0x5554555455545554ULL, },
+        { 0xcccbcccbcccbcccbULL, 0xcccbcccbcccbcccbULL, },
+        { 0x3332333233323332ULL, 0x3332333233323332ULL, },
+        { 0xe38d38e28e37e38dULL, 0x38e28e37e38d38e2ULL, },
+        { 0x1c70c71b71c61c70ULL, 0xc71b71c61c70c71bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xaaa9aaa9aaa9aaa9ULL, 0xaaa9aaa9aaa9aaa9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8000800080008000ULL, 0x8000800080008000ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8000800080008000ULL, 0x8000800080008000ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8e38e38d80008e38ULL, 0xe38d80008e38e38dULL, },
+        { 0xc71b80001c71c71bULL, 0x80001c71c71b8000ULL, },
+        { 0x5554555455545554ULL, 0x5554555455545554ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x2221222122212221ULL, 0x2221222122212221ULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0x38e37fffe38d38e3ULL, 0x7fffe38d38e37fffULL, },
+        { 0x71c61c717fff71c6ULL, 0x1c717fff71c61c71ULL, },
+        { 0xcccbcccbcccbcccbULL, 0xcccbcccbcccbcccbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x8000800080008000ULL, 0x8000800080008000ULL, },
+        { 0x2221222122212221ULL, 0x2221222122212221ULL, },
+        { 0x9998999899989998ULL, 0x9998999899989998ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xb05a05af8000b05aULL, 0x05af8000b05a05afULL, },
+        { 0xe93d93e83e93e93dULL, 0x93e83e93e93d93e8ULL, },
+        { 0x3332333233323332ULL, 0x3332333233323332ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x7fff7fff7fff7fffULL, 0x7fff7fff7fff7fffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16c16c16b16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0x4fa4fa4f7fff4fa4ULL, 0xfa4f7fff4fa4fa4fULL, },
+        { 0xe38d38e28e37e38dULL, 0x38e28e37e38d38e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8e38e38d80008e38ULL, 0xe38d80008e38e38dULL, },
+        { 0x38e37fffe38d38e3ULL, 0x7fffe38d38e37fffULL, },
+        { 0xb05a05af8000b05aULL, 0x05af8000b05a05afULL, },
+        { 0x16c16c16c16b16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0xc71c71c68000c71cULL, 0x71c68000c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1c70c71b71c61c70ULL, 0xc71b71c61c70c71bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71b80001c71c71bULL, 0x80001c71c71b8000ULL, },
+        { 0x71c61c717fff71c6ULL, 0x1c717fff71c61c71ULL, },
+        { 0xe93d93e83e93e93dULL, 0x93e83e93e93d93e8ULL, },
+        { 0x4fa4fa4f7fff4fa4ULL, 0xfa4f7fff4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e28e387fff38e2ULL, 0x8e387fff38e28e38ULL, },
+        { 0x8000cd9850c47fffULL, 0x7fff16bcfcf68000ULL, },    /*  64  */
+        { 0x8428e72f75f51c48ULL, 0x5e5ec67813ba0308ULL, },
+        { 0x80009576e231e0c0ULL, 0x733fd25da9a6d520ULL, },
+        { 0xf8b9fd197fff378eULL, 0xd9589436a7bd92acULL, },
+        { 0x8428e72f75f51c48ULL, 0x5e5ec67813ba0308ULL, },
+        { 0xf77c00c67fff8e10ULL, 0x25ee80002a7e7fffULL, },
+        { 0xa818af0d07628000ULL, 0x3acf8219c06a7810ULL, },
+        { 0x6c0d16b07fffa956ULL, 0xa0e88000be81359cULL, },
+        { 0x80009576e231e0c0ULL, 0x733fd25da9a6d520ULL, },    /*  72  */
+        { 0xa818af0d07628000ULL, 0x3acf8219c06a7810ULL, },
+        { 0x8000800080008000ULL, 0x4fb08dfe80004a28ULL, },
+        { 0x1ca9c4f718008000ULL, 0xb5c98000800007b4ULL, },
+        { 0xf8b9fd197fff378eULL, 0xd9589436a7bd92acULL, },
+        { 0x6c0d16b07fffa956ULL, 0xa0e88000be81359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_H(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_H(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_s_w.c

+/*
+ *  Test program for MSA instruction ADDS_S.W
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_S.W";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfffffffefffffffeULL, 0xfffffffefffffffeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaa9aaaaaaa9ULL, 0xaaaaaaa9aaaaaaa9ULL, },
+        { 0x5555555455555554ULL, 0x5555555455555554ULL, },
+        { 0xcccccccbcccccccbULL, 0xcccccccbcccccccbULL, },
+        { 0x3333333233333332ULL, 0x3333333233333332ULL, },
+        { 0xe38e38e28e38e38dULL, 0x38e38e37e38e38e2ULL, },
+        { 0x1c71c71b71c71c70ULL, 0xc71c71c61c71c71bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xaaaaaaa9aaaaaaa9ULL, 0xaaaaaaa9aaaaaaa9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x8000000080000000ULL, 0x8000000080000000ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8000000080000000ULL, 0x8000000080000000ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8e38e38d80000000ULL, 0xe38e38e28e38e38dULL, },
+        { 0xc71c71c61c71c71bULL, 0x80000000c71c71c6ULL, },
+        { 0x5555555455555554ULL, 0x5555555455555554ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x2222222122222221ULL, 0x2222222122222221ULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0x38e38e38e38e38e3ULL, 0x7fffffff38e38e38ULL, },
+        { 0x71c71c717fffffffULL, 0x1c71c71c71c71c71ULL, },
+        { 0xcccccccbcccccccbULL, 0xcccccccbcccccccbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x8000000080000000ULL, 0x8000000080000000ULL, },
+        { 0x2222222122222221ULL, 0x2222222122222221ULL, },
+        { 0x9999999899999998ULL, 0x9999999899999998ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xb05b05af80000000ULL, 0x05b05b04b05b05afULL, },
+        { 0xe93e93e83e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x3333333233333332ULL, 0x3333333233333332ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x7fffffff7fffffffULL, 0x7fffffff7fffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0x4fa4fa4f7fffffffULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xe38e38e28e38e38dULL, 0x38e38e37e38e38e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8e38e38d80000000ULL, 0xe38e38e28e38e38dULL, },
+        { 0x38e38e38e38e38e3ULL, 0x7fffffff38e38e38ULL, },
+        { 0xb05b05af80000000ULL, 0x05b05b04b05b05afULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0xc71c71c680000000ULL, 0x71c71c70c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1c71c71b71c71c70ULL, 0xc71c71c61c71c71bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71c71c61c71c71bULL, 0x80000000c71c71c6ULL, },
+        { 0x71c71c717fffffffULL, 0x1c71c71c71c71c71ULL, },
+        { 0xe93e93e83e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x4fa4fa4f7fffffffULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e38e387fffffffULL, 0x8e38e38e38e38e38ULL, },
+        { 0x8000000050c4aa80ULL, 0x7ffffffffcf76018ULL, },    /*  64  */
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67813bb0308ULL, },
+        { 0x80000000e231e0c0ULL, 0x733fd25da9a6d520ULL, },
+        { 0xf8b9fd197fffffffULL, 0xd9589436a7be92acULL, },
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67813bb0308ULL, },
+        { 0xf77c00c67fffffffULL, 0x25ef76342a7ea5f8ULL, },
+        { 0xa818af0d07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x6c0d16b07fffffffULL, 0xa0e943f2be82359cULL, },
+        { 0x80000000e231e0c0ULL, 0x733fd25da9a6d520ULL, },    /*  72  */
+        { 0xa818af0d07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x8000000080000000ULL, 0x4fb18dfe80000000ULL, },
+        { 0x1ca9c4f718016dceULL, 0xb5ca4fd780000000ULL, },
+        { 0xf8b9fd197fffffffULL, 0xd9589436a7be92acULL, },
+        { 0x6c0d16b07fffffffULL, 0xa0e943f2be82359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_W(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_S_W(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_u_b.c

+/*
+ *  Test program for MSA instruction ADDS_U.B
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_U.B";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0xffffe2ffffe2ffffULL, 0xe2ffffe2ffffe2ffULL, },
+        { 0xc6ffffc6ffffc6ffULL, 0xffc6ffffc6ffffc6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffe38dffe38dffe3ULL, 0x8dffe38dffe38dffULL, },
+        { 0x71c6ff71c6ff71c6ULL, 0xff71c6ff71c6ff71ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xe8ffffe8ffffe8ffULL, 0xffe8ffffe8ffffe8ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0xffc16bffc16bffc1ULL, 0x6bffc16bffc16bffULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0xffffe2ffffe2ffffULL, 0xe2ffffe2ffffe2ffULL, },
+        { 0xffe38dffe38dffe3ULL, 0x8dffe38dffe38dffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffc16bffc16bffc1ULL, 0x6bffc16bffc16bffULL, },
+        { 0xffff70ffff70ffffULL, 0x70ffff70ffff70ffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc6ffffc6ffffc6ffULL, 0xffc6ffffc6ffffc6ULL, },
+        { 0x71c6ff71c6ff71c6ULL, 0xff71c6ff71c6ff71ULL, },
+        { 0xe8ffffe8ffffe8ffULL, 0xffe8ffffe8ffffe8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e2ff38e2ff38e2ULL, 0xff38e2ff38e2ff38ULL, },
+        { 0xffd4ffff50c4aa80ULL, 0x96ce16bcfff6ff18ULL, },    /*  64  */
+        { 0xffffe6ff75f5ff48ULL, 0x5dffc678ffbaffffULL, },
+        { 0xffc4ffffe1ffe0c0ULL, 0x72ffd1ffffa6d520ULL, },
+        { 0xf8b9fcff8693ff8eULL, 0xd8ff93ffffbdffacULL, },
+        { 0xffffe6ff75f5ff48ULL, 0x5dffc678ffbaffffULL, },
+        { 0xffff00c69affff10ULL, 0x24ffff342a7ea4ffULL, },
+        { 0xffffaeffffffff88ULL, 0x39ffffffc06a77ffULL, },
+        { 0xffff16b0abc4ff56ULL, 0x9ffffff2be81ffffULL, },
+        { 0xffc4ffffe1ffe0c0ULL, 0x72ffd1ffffa6d520ULL, },    /*  72  */
+        { 0xffffaeffffffff88ULL, 0x39ffffffc06a77ffULL, },
+        { 0xffb4ffffffffffffULL, 0x4effffffff564a28ULL, },
+        { 0xffa9c4f7ffffffceULL, 0xb4ffffffff6dffb4ULL, },
+        { 0xf8b9fcff8693ff8eULL, 0xd8ff93ffffbdffacULL, },
+        { 0xffff16b0abc4ff56ULL, 0x9ffffff2be81ffffULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_B(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_B(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_u_d.c

+/*
+ *  Test program for MSA instruction ADDS_U.D
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_U.D";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0xffffffffffffffffULL, 0xe38e38e38e38e38dULL, },
+        { 0xc71c71c71c71c71bULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0x8e38e38e38e38e38ULL, },
+        { 0x71c71c71c71c71c6ULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xe93e93e93e93e93dULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0xffffffffffffffffULL, 0x6c16c16c16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0xffffffffffffffffULL, 0xe38e38e38e38e38dULL, },
+        { 0xffffffffffffffffULL, 0x8e38e38e38e38e38ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0x6c16c16c16c16c16ULL, },
+        { 0xffffffffffffffffULL, 0x71c71c71c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71c71c71c71c71bULL, 0xffffffffffffffffULL, },
+        { 0x71c71c71c71c71c6ULL, 0xffffffffffffffffULL, },
+        { 0xe93e93e93e93e93dULL, 0xffffffffffffffffULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e38e38e38e38e2ULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0x96ce16bdfcf76018ULL, },    /*  64  */
+        { 0xffffffffffffffffULL, 0x5e5ec67913bb0308ULL, },
+        { 0xffffffffffffffffULL, 0x733fd25ea9a6d520ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0xffffffffffffffffULL, 0x5e5ec67913bb0308ULL, },
+        { 0xffffffffffffffffULL, 0x25ef76342a7ea5f8ULL, },
+        { 0xffffffffffffffffULL, 0x3ad08219c06a7810ULL, },
+        { 0xffffffffffffffffULL, 0xa0e943f2be82359cULL, },
+        { 0xffffffffffffffffULL, 0x733fd25ea9a6d520ULL, },    /*  72  */
+        { 0xffffffffffffffffULL, 0x3ad08219c06a7810ULL, },
+        { 0xffffffffffffffffULL, 0x4fb18dff56564a28ULL, },
+        { 0xffffffffffffffffULL, 0xb5ca4fd8546e07b4ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0xffffffffffffffffULL, 0xa0e943f2be82359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_D(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_D(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_u_h.c

+/*
+ *  Test program for MSA instruction ADDS_U.H
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_U.H";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0xffffe38dffffffffULL, 0xe38dffffffffe38dULL, },
+        { 0xc71bffffffffc71bULL, 0xffffffffc71bffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffff8e38e38dffffULL, 0x8e38e38dffff8e38ULL, },
+        { 0x71c6ffffc71c71c6ULL, 0xffffc71c71c6ffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xe93dffffffffe93dULL, 0xffffffffe93dffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0xffff6c16c16bffffULL, 0x6c16c16bffff6c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0xffffe38dffffffffULL, 0xe38dffffffffe38dULL, },
+        { 0xffff8e38e38dffffULL, 0x8e38e38dffff8e38ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffff6c16c16bffffULL, 0x6c16c16bffff6c16ULL, },
+        { 0xffff71c6ffffffffULL, 0x71c6ffffffff71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71bffffffffc71bULL, 0xffffffffc71bffffULL, },
+        { 0x71c6ffffc71c71c6ULL, 0xffffc71c71c6ffffULL, },
+        { 0xe93dffffffffe93dULL, 0xffffffffe93dffffULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e2ffffe38e38e2ULL, 0xffffe38e38e2ffffULL, },
+        { 0xffffffff50c4aa80ULL, 0x96ce16bcffffffffULL, },    /*  64  */
+        { 0xffffe72f75f5ffffULL, 0x5e5ec678ffffffffULL, },
+        { 0xffffffffe231e0c0ULL, 0x733fd25dffffd520ULL, },
+        { 0xf8b9fd198693ffffULL, 0xd9589436ffffffffULL, },
+        { 0xffffe72f75f5ffffULL, 0x5e5ec678ffffffffULL, },
+        { 0xffff00c69b26ffffULL, 0x25eeffff2a7ea5f8ULL, },
+        { 0xffffaf0dffffffffULL, 0x3acfffffc06a7810ULL, },
+        { 0xffff16b0abc4ffffULL, 0xa0e8ffffbe81ffffULL, },
+        { 0xffffffffe231e0c0ULL, 0x733fd25dffffd520ULL, },    /*  72  */
+        { 0xffffaf0dffffffffULL, 0x3acfffffc06a7810ULL, },
+        { 0xffffffffffffffffULL, 0x4fb0ffffffff4a28ULL, },
+        { 0xffffc4f7ffffffffULL, 0xb5c9ffffffffffffULL, },
+        { 0xf8b9fd198693ffffULL, 0xd9589436ffffffffULL, },
+        { 0xffff16b0abc4ffffULL, 0xa0e8ffffbe81ffffULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_H(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_H(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_adds_u_w.c

+/*
+ *  Test program for MSA instruction ADDS_U.W
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDS_U.W";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0xffffffffffffffffULL, 0xe38e38e2ffffffffULL, },
+        { 0xc71c71c6ffffffffULL, 0xffffffffc71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffe38e38e3ULL, 0x8e38e38dffffffffULL, },
+        { 0x71c71c71c71c71c6ULL, 0xffffffff71c71c71ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xe93e93e8ffffffffULL, 0xffffffffe93e93e8ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0xffffffffc16c16c1ULL, 0x6c16c16bffffffffULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0xffffffffffffffffULL, 0xe38e38e2ffffffffULL, },
+        { 0xffffffffe38e38e3ULL, 0x8e38e38dffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffc16c16c1ULL, 0x6c16c16bffffffffULL, },
+        { 0xffffffffffffffffULL, 0x71c71c70ffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71c71c6ffffffffULL, 0xffffffffc71c71c6ULL, },
+        { 0x71c71c71c71c71c6ULL, 0xffffffff71c71c71ULL, },
+        { 0xe93e93e8ffffffffULL, 0xffffffffe93e93e8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e38e38e38e38e2ULL, 0xffffffff38e38e38ULL, },
+        { 0xffffffff50c4aa80ULL, 0x96ce16bcffffffffULL, },    /*  64  */
+        { 0xffffffff75f61c48ULL, 0x5e5ec678ffffffffULL, },
+        { 0xffffffffe231e0c0ULL, 0x733fd25dffffffffULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589436ffffffffULL, },
+        { 0xffffffff75f61c48ULL, 0x5e5ec678ffffffffULL, },
+        { 0xffffffff9b278e10ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0xffffffffffffffffULL, 0x3ad08219c06a7810ULL, },
+        { 0xffffffffabc5a956ULL, 0xa0e943f2be82359cULL, },
+        { 0xffffffffe231e0c0ULL, 0x733fd25dffffffffULL, },    /*  72  */
+        { 0xffffffffffffffffULL, 0x3ad08219c06a7810ULL, },
+        { 0xffffffffffffffffULL, 0x4fb18dfeffffffffULL, },
+        { 0xffffffffffffffffULL, 0xb5ca4fd7ffffffffULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589436ffffffffULL, },
+        { 0xffffffffabc5a956ULL, 0xa0e943f2be82359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_W(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDS_U_W(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_addv_b.c

+/*
+ *  Test program for MSA instruction ADDV.B
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDV.B";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfefefefefefefefeULL, 0xfefefefefefefefeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xa9a9a9a9a9a9a9a9ULL, 0xa9a9a9a9a9a9a9a9ULL, },
+        { 0x5454545454545454ULL, 0x5454545454545454ULL, },
+        { 0xcbcbcbcbcbcbcbcbULL, 0xcbcbcbcbcbcbcbcbULL, },
+        { 0x3232323232323232ULL, 0x3232323232323232ULL, },
+        { 0xe28d37e28d37e28dULL, 0x37e28d37e28d37e2ULL, },
+        { 0x1b70c61b70c61b70ULL, 0xc61b70c61b70c61bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xa9a9a9a9a9a9a9a9ULL, 0xa9a9a9a9a9a9a9a9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5454545454545454ULL, 0x5454545454545454ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7676767676767676ULL, 0x7676767676767676ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8d38e28d38e28d38ULL, 0xe28d38e28d38e28dULL, },
+        { 0xc61b71c61b71c61bULL, 0x71c61b71c61b71c6ULL, },
+        { 0x5454545454545454ULL, 0x5454545454545454ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x2121212121212121ULL, 0x2121212121212121ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x38e38d38e38d38e3ULL, 0x8d38e38d38e38d38ULL, },
+        { 0x71c61c71c61c71c6ULL, 0x1c71c61c71c61c71ULL, },
+        { 0xcbcbcbcbcbcbcbcbULL, 0xcbcbcbcbcbcbcbcbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x7676767676767676ULL, 0x7676767676767676ULL, },
+        { 0x2121212121212121ULL, 0x2121212121212121ULL, },
+        { 0x9898989898989898ULL, 0x9898989898989898ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaf5a04af5a04af5aULL, 0x04af5a04af5a04afULL, },
+        { 0xe83d93e83d93e83dULL, 0x93e83d93e83d93e8ULL, },
+        { 0x3232323232323232ULL, 0x3232323232323232ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16b16c16b16c1ULL, 0x6b16c16b16c16b16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xe28d37e28d37e28dULL, 0x37e28d37e28d37e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8d38e28d38e28d38ULL, 0xe28d38e28d38e28dULL, },
+        { 0x38e38d38e38d38e3ULL, 0x8d38e38d38e38d38ULL, },
+        { 0xaf5a04af5a04af5aULL, 0x04af5a04af5a04afULL, },
+        { 0x16c16b16c16b16c1ULL, 0x6b16c16b16c16b16ULL, },
+        { 0xc61c70c61c70c61cULL, 0x70c61c70c61c70c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1b70c61b70c61b70ULL, 0xc61b70c61b70c61bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc61b71c61b71c61bULL, 0x71c61b71c61b71c6ULL, },
+        { 0x71c61c71c61c71c6ULL, 0x1c71c61c71c61c71ULL, },
+        { 0xe83d93e83d93e83dULL, 0x93e83d93e83d93e8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e28e38e28e38e2ULL, 0x8e38e28e38e28e38ULL, },
+        { 0x10d4cc9850c4aa80ULL, 0x96ce16bcfcf66018ULL, },    /*  64  */
+        { 0x8328e62f75f51c48ULL, 0x5d5ec67813ba0208ULL, },
+        { 0x34c49476e131e0c0ULL, 0x723fd15da9a6d520ULL, },
+        { 0xf8b9fc198693378eULL, 0xd8589336a7bd92acULL, },
+        { 0x8328e62f75f51c48ULL, 0x5d5ec67813ba0208ULL, },
+        { 0xf67c00c69a268e10ULL, 0x24ee76342a7ea4f8ULL, },
+        { 0xa718ae0d06625288ULL, 0x39cf8119c06a7710ULL, },
+        { 0x6b0d16b0abc4a956ULL, 0x9fe843f2be81349cULL, },
+        { 0x34c49476e131e0c0ULL, 0x723fd15da9a6d520ULL, },    /*  72  */
+        { 0xa718ae0d06625288ULL, 0x39cf8119c06a7710ULL, },
+        { 0x58b45c54729e1600ULL, 0x4eb08cfe56564a28ULL, },
+        { 0x1ca9c4f717006dceULL, 0xb4c94ed7546d07b4ULL, },
+        { 0xf8b9fc198693378eULL, 0xd8589336a7bd92acULL, },
+        { 0x6b0d16b0abc4a956ULL, 0x9fe843f2be81349cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_B(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_B(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_addv_d.c

+/*
+ *  Test program for MSA instruction ADDV.D
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDV.D";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfffffffffffffffeULL, 0xfffffffffffffffeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaa9ULL, 0xaaaaaaaaaaaaaaa9ULL, },
+        { 0x5555555555555554ULL, 0x5555555555555554ULL, },
+        { 0xcccccccccccccccbULL, 0xcccccccccccccccbULL, },
+        { 0x3333333333333332ULL, 0x3333333333333332ULL, },
+        { 0xe38e38e38e38e38dULL, 0x38e38e38e38e38e2ULL, },
+        { 0x1c71c71c71c71c70ULL, 0xc71c71c71c71c71bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xaaaaaaaaaaaaaaa9ULL, 0xaaaaaaaaaaaaaaa9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555554ULL, 0x5555555555555554ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7777777777777776ULL, 0x7777777777777776ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8e38e38e38e38e38ULL, 0xe38e38e38e38e38dULL, },
+        { 0xc71c71c71c71c71bULL, 0x71c71c71c71c71c6ULL, },
+        { 0x5555555555555554ULL, 0x5555555555555554ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x2222222222222221ULL, 0x2222222222222221ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x38e38e38e38e38e3ULL, 0x8e38e38e38e38e38ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x1c71c71c71c71c71ULL, },
+        { 0xcccccccccccccccbULL, 0xcccccccccccccccbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x7777777777777776ULL, 0x7777777777777776ULL, },
+        { 0x2222222222222221ULL, 0x2222222222222221ULL, },
+        { 0x9999999999999998ULL, 0x9999999999999998ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xb05b05b05b05b05aULL, 0x05b05b05b05b05afULL, },
+        { 0xe93e93e93e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x3333333333333332ULL, 0x3333333333333332ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16c16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xe38e38e38e38e38dULL, 0x38e38e38e38e38e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8e38e38e38e38e38ULL, 0xe38e38e38e38e38dULL, },
+        { 0x38e38e38e38e38e3ULL, 0x8e38e38e38e38e38ULL, },
+        { 0xb05b05b05b05b05aULL, 0x05b05b05b05b05afULL, },
+        { 0x16c16c16c16c16c1ULL, 0x6c16c16c16c16c16ULL, },
+        { 0xc71c71c71c71c71cULL, 0x71c71c71c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1c71c71c71c71c70ULL, 0xc71c71c71c71c71bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71c71c71c71c71bULL, 0x71c71c71c71c71c6ULL, },
+        { 0x71c71c71c71c71c6ULL, 0x1c71c71c71c71c71ULL, },
+        { 0xe93e93e93e93e93dULL, 0x93e93e93e93e93e8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e38e38e38e38e2ULL, 0x8e38e38e38e38e38ULL, },
+        { 0x10d5cd9850c4aa80ULL, 0x96ce16bdfcf76018ULL, },    /*  64  */
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67913bb0308ULL, },
+        { 0x34c59576e231e0c0ULL, 0x733fd25ea9a6d520ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0x8428e72f75f61c48ULL, 0x5e5ec67913bb0308ULL, },
+        { 0xf77c00c69b278e10ULL, 0x25ef76342a7ea5f8ULL, },
+        { 0xa818af0e07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x6c0d16b0abc5a956ULL, 0xa0e943f2be82359cULL, },
+        { 0x34c59576e231e0c0ULL, 0x733fd25ea9a6d520ULL, },    /*  72  */
+        { 0xa818af0e07635288ULL, 0x3ad08219c06a7810ULL, },
+        { 0x58b55d55739f1700ULL, 0x4fb18dff56564a28ULL, },
+        { 0x1ca9c4f818016dceULL, 0xb5ca4fd8546e07b4ULL, },
+        { 0xf8b9fd198694378eULL, 0xd9589437a7be92acULL, },
+        { 0x6c0d16b0abc5a956ULL, 0xa0e943f2be82359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_D(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_D(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}

tests/tcg/mips/user/ase/msa/int-add/test_msa_addv_h.c

+/*
+ *  Test program for MSA instruction ADDV.H
+ *
+ *  Copyright (C) 2019  Wave Computing, Inc.
+ *  Copyright (C) 2019  Mateja Marjanovic <mateja.marjanovic@rt-rk.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <sys/time.h>
+#include <stdint.h>
+
+#include "../../../../include/wrappers_msa.h"
+#include "../../../../include/test_inputs.h"
+#include "../../../../include/test_utils.h"
+
+#define TEST_COUNT_TOTAL (                                                \
+            (PATTERN_INPUTS_SHORT_COUNT) * (PATTERN_INPUTS_SHORT_COUNT) + \
+            (RANDOM_INPUTS_SHORT_COUNT) * (RANDOM_INPUTS_SHORT_COUNT))
+
+
+int32_t main(void)
+{
+    char *instruction_name = "ADDV.H";
+    int32_t ret;
+    uint32_t i, j;
+    struct timeval start, end;
+    double elapsed_time;
+
+    uint64_t b128_result[TEST_COUNT_TOTAL][2];
+    uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
+        { 0xfffefffefffefffeULL, 0xfffefffefffefffeULL, },    /*   0  */
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaa9aaa9aaa9aaa9ULL, 0xaaa9aaa9aaa9aaa9ULL, },
+        { 0x5554555455545554ULL, 0x5554555455545554ULL, },
+        { 0xcccbcccbcccbcccbULL, 0xcccbcccbcccbcccbULL, },
+        { 0x3332333233323332ULL, 0x3332333233323332ULL, },
+        { 0xe38d38e28e37e38dULL, 0x38e28e37e38d38e2ULL, },
+        { 0x1c70c71b71c61c70ULL, 0xc71b71c61c70c71bULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },    /*   8  */
+        { 0x0000000000000000ULL, 0x0000000000000000ULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xaaa9aaa9aaa9aaa9ULL, 0xaaa9aaa9aaa9aaa9ULL, },    /*  16  */
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x5554555455545554ULL, 0x5554555455545554ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x7776777677767776ULL, 0x7776777677767776ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8e38e38d38e28e38ULL, 0xe38d38e28e38e38dULL, },
+        { 0xc71b71c61c71c71bULL, 0x71c61c71c71b71c6ULL, },
+        { 0x5554555455545554ULL, 0x5554555455545554ULL, },    /*  24  */
+        { 0x5555555555555555ULL, 0x5555555555555555ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL, },
+        { 0x2221222122212221ULL, 0x2221222122212221ULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0x38e38e38e38d38e3ULL, 0x8e38e38d38e38e38ULL, },
+        { 0x71c61c71c71c71c6ULL, 0x1c71c71c71c61c71ULL, },
+        { 0xcccbcccbcccbcccbULL, 0xcccbcccbcccbcccbULL, },    /*  32  */
+        { 0xccccccccccccccccULL, 0xccccccccccccccccULL, },
+        { 0x7776777677767776ULL, 0x7776777677767776ULL, },
+        { 0x2221222122212221ULL, 0x2221222122212221ULL, },
+        { 0x9998999899989998ULL, 0x9998999899989998ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0xb05a05af5b04b05aULL, 0x05af5b04b05a05afULL, },
+        { 0xe93d93e83e93e93dULL, 0x93e83e93e93d93e8ULL, },
+        { 0x3332333233323332ULL, 0x3332333233323332ULL, },    /*  40  */
+        { 0x3333333333333333ULL, 0x3333333333333333ULL, },
+        { 0xddddddddddddddddULL, 0xddddddddddddddddULL, },
+        { 0x8888888888888888ULL, 0x8888888888888888ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x6666666666666666ULL, 0x6666666666666666ULL, },
+        { 0x16c16c16c16b16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xe38d38e28e37e38dULL, 0x38e28e37e38d38e2ULL, },    /*  48  */
+        { 0xe38e38e38e38e38eULL, 0x38e38e38e38e38e3ULL, },
+        { 0x8e38e38d38e28e38ULL, 0xe38d38e28e38e38dULL, },
+        { 0x38e38e38e38d38e3ULL, 0x8e38e38d38e38e38ULL, },
+        { 0xb05a05af5b04b05aULL, 0x05af5b04b05a05afULL, },
+        { 0x16c16c16c16b16c1ULL, 0x6c16c16b16c16c16ULL, },
+        { 0xc71c71c61c70c71cULL, 0x71c61c70c71c71c6ULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x1c70c71b71c61c70ULL, 0xc71b71c61c70c71bULL, },    /*  56  */
+        { 0x1c71c71c71c71c71ULL, 0xc71c71c71c71c71cULL, },
+        { 0xc71b71c61c71c71bULL, 0x71c61c71c71b71c6ULL, },
+        { 0x71c61c71c71c71c6ULL, 0x1c71c71c71c61c71ULL, },
+        { 0xe93d93e83e93e93dULL, 0x93e83e93e93d93e8ULL, },
+        { 0x4fa4fa4fa4fa4fa4ULL, 0xfa4fa4fa4fa4fa4fULL, },
+        { 0xffffffffffffffffULL, 0xffffffffffffffffULL, },
+        { 0x38e28e38e38e38e2ULL, 0x8e38e38e38e28e38ULL, },
+        { 0x10d4cd9850c4aa80ULL, 0x96ce16bcfcf66018ULL, },    /*  64  */
+        { 0x8428e72f75f51c48ULL, 0x5e5ec67813ba0308ULL, },
+        { 0x34c49576e231e0c0ULL, 0x733fd25da9a6d520ULL, },
+        { 0xf8b9fd198693378eULL, 0xd9589436a7bd92acULL, },
+        { 0x8428e72f75f51c48ULL, 0x5e5ec67813ba0308ULL, },
+        { 0xf77c00c69b268e10ULL, 0x25ee76342a7ea5f8ULL, },
+        { 0xa818af0d07625288ULL, 0x3acf8219c06a7810ULL, },
+        { 0x6c0d16b0abc4a956ULL, 0xa0e843f2be81359cULL, },
+        { 0x34c49576e231e0c0ULL, 0x733fd25da9a6d520ULL, },    /*  72  */
+        { 0xa818af0d07625288ULL, 0x3acf8219c06a7810ULL, },
+        { 0x58b45d54739e1700ULL, 0x4fb08dfe56564a28ULL, },
+        { 0x1ca9c4f718006dceULL, 0xb5c94fd7546d07b4ULL, },
+        { 0xf8b9fd198693378eULL, 0xd9589436a7bd92acULL, },
+        { 0x6c0d16b0abc4a956ULL, 0xa0e843f2be81359cULL, },
+};
+
+    gettimeofday(&start, NULL);
+
+    for (i = 0; i < PATTERN_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < PATTERN_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_H(b128_pattern[i], b128_pattern[j],
+                           b128_result[PATTERN_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    for (i = 0; i < RANDOM_INPUTS_SHORT_COUNT; i++) {
+        for (j = 0; j < RANDOM_INPUTS_SHORT_COUNT; j++) {
+            do_msa_ADDV_H(b128_random[i], b128_random[j],
+                           b128_result[((PATTERN_INPUTS_SHORT_COUNT) *
+                                        (PATTERN_INPUTS_SHORT_COUNT)) +
+                                       RANDOM_INPUTS_SHORT_COUNT * i + j]);
+        }
+    }
+
+    gettimeofday(&end, NULL);
+
+    elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
+    elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
+
+    ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
+                        &b128_result[0][0], &b128_expect[0][0]);
+
+    return ret;
+}