--- /dev/null
+/*
+ * Copyright 2009 Freescale Semiconductor, Inc.
+ *
+ * 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.
+ *
+ * provides masks and opcode images for use by code generation, emulation
+ * and for instructions that older assemblers might not know about
+ */
+#ifndef _ASM_POWERPC_PPC_OPCODE_H
+#define _ASM_POWERPC_PPC_OPCODE_H
+
+
+#  define stringify_in_c(...)  __VA_ARGS__
+#  define ASM_CONST(x)         x
+
+
+#define PPC_INST_VCMPEQUD_RC           0x100000c7
+#define PPC_INST_VCMPEQUB_RC           0x10000006
+
+#define __PPC_RC21     (0x1 << 10)
+
+/* macros to insert fields into opcodes */
+#define ___PPC_RA(a)   (((a) & 0x1f) << 16)
+#define ___PPC_RB(b)   (((b) & 0x1f) << 11)
+#define ___PPC_RS(s)   (((s) & 0x1f) << 21)
+#define ___PPC_RT(t)   ___PPC_RS(t)
+
+#define VCMPEQUD_RC(vrt, vra, vrb)     stringify_in_c(.long PPC_INST_VCMPEQUD_RC | \
+                             ___PPC_RT(vrt) | ___PPC_RA(vra) | \
+                             ___PPC_RB(vrb) | __PPC_RC21)
+
+#define VCMPEQUB_RC(vrt, vra, vrb)     stringify_in_c(.long PPC_INST_VCMPEQUB_RC | \
+                             ___PPC_RT(vrt) | ___PPC_RA(vra) | \
+                             ___PPC_RB(vrb) | __PPC_RC21)
+
+#endif /* _ASM_POWERPC_PPC_OPCODE_H */
 
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include "utils.h"
 
 #define SIZE 256
 #define ITERATIONS 10000
 
+#define LARGE_SIZE (5 * 1024)
+#define LARGE_ITERATIONS 1000
+#define LARGE_MAX_OFFSET 32
+#define LARGE_SIZE_START 4096
+
+#define MAX_OFFSET_DIFF_S1_S2 48
+
+int vmx_count;
+int enter_vmx_ops(void)
+{
+       vmx_count++;
+       return 1;
+}
+
+void exit_vmx_ops(void)
+{
+       vmx_count--;
+}
 int test_memcmp(const void *s1, const void *s2, size_t n);
 
 /* test all offsets and lengths */
-static void test_one(char *s1, char *s2)
+static void test_one(char *s1, char *s2, unsigned long max_offset,
+               unsigned long size_start, unsigned long max_size)
 {
        unsigned long offset, size;
 
-       for (offset = 0; offset < SIZE; offset++) {
-               for (size = 0; size < (SIZE-offset); size++) {
+       for (offset = 0; offset < max_offset; offset++) {
+               for (size = size_start; size < (max_size - offset); size++) {
                        int x, y;
                        unsigned long i;
 
                                printf("\n");
                                abort();
                        }
+
+                       if (vmx_count != 0) {
+                               printf("vmx enter/exit not paired.(offset:%ld size:%ld s1:%p s2:%p vc:%d\n",
+                                       offset, size, s1, s2, vmx_count);
+                               printf("\n");
+                               abort();
+                       }
                }
        }
 }
 
-static int testcase(void)
+static int testcase(bool islarge)
 {
        char *s1;
        char *s2;
        unsigned long i;
 
-       s1 = memalign(128, SIZE);
+       unsigned long comp_size = (islarge ? LARGE_SIZE : SIZE);
+       unsigned long alloc_size = comp_size + MAX_OFFSET_DIFF_S1_S2;
+       int iterations = islarge ? LARGE_ITERATIONS : ITERATIONS;
+
+       s1 = memalign(128, alloc_size);
        if (!s1) {
                perror("memalign");
                exit(1);
        }
 
-       s2 = memalign(128, SIZE);
+       s2 = memalign(128, alloc_size);
        if (!s2) {
                perror("memalign");
                exit(1);
        }
 
-       srandom(1);
+       srandom(time(0));
 
-       for (i = 0; i < ITERATIONS; i++) {
+       for (i = 0; i < iterations; i++) {
                unsigned long j;
                unsigned long change;
+               char *rand_s1 = s1;
+               char *rand_s2 = s2;
 
-               for (j = 0; j < SIZE; j++)
+               for (j = 0; j < alloc_size; j++)
                        s1[j] = random();
 
-               memcpy(s2, s1, SIZE);
+               rand_s1 += random() % MAX_OFFSET_DIFF_S1_S2;
+               rand_s2 += random() % MAX_OFFSET_DIFF_S1_S2;
+               memcpy(rand_s2, rand_s1, comp_size);
 
                /* change one byte */
-               change = random() % SIZE;
-               s2[change] = random() & 0xff;
-
-               test_one(s1, s2);
+               change = random() % comp_size;
+               rand_s2[change] = random() & 0xff;
+
+               if (islarge)
+                       test_one(rand_s1, rand_s2, LARGE_MAX_OFFSET,
+                                       LARGE_SIZE_START, comp_size);
+               else
+                       test_one(rand_s1, rand_s2, SIZE, 0, comp_size);
        }
 
-       srandom(1);
+       srandom(time(0));
 
-       for (i = 0; i < ITERATIONS; i++) {
+       for (i = 0; i < iterations; i++) {
                unsigned long j;
                unsigned long change;
+               char *rand_s1 = s1;
+               char *rand_s2 = s2;
 
-               for (j = 0; j < SIZE; j++)
+               for (j = 0; j < alloc_size; j++)
                        s1[j] = random();
 
-               memcpy(s2, s1, SIZE);
+               rand_s1 += random() % MAX_OFFSET_DIFF_S1_S2;
+               rand_s2 += random() % MAX_OFFSET_DIFF_S1_S2;
+               memcpy(rand_s2, rand_s1, comp_size);
 
                /* change multiple bytes, 1/8 of total */
-               for (j = 0; j < SIZE / 8; j++) {
-                       change = random() % SIZE;
+               for (j = 0; j < comp_size / 8; j++) {
+                       change = random() % comp_size;
                        s2[change] = random() & 0xff;
                }
 
-               test_one(s1, s2);
+               if (islarge)
+                       test_one(rand_s1, rand_s2, LARGE_MAX_OFFSET,
+                                       LARGE_SIZE_START, comp_size);
+               else
+                       test_one(rand_s1, rand_s2, SIZE, 0, comp_size);
        }
 
        return 0;
 }
 
+static int testcases(void)
+{
+       testcase(0);
+       testcase(1);
+       return 0;
+}
+
 int main(void)
 {
-       return test_harness(testcase, "memcmp");
+       return test_harness(testcases, "memcmp");
 }