Convert compile-time code to not require SIMD

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 988049238f8c3829dc8a1e1c01c6f66416185a29..0559932d15f5cb1bc1003382e0feb617f25a1511 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -210,10 +210,12 @@ else()
 
     if (NOT CMAKE_C_FLAGS MATCHES .*march.*)
         message(STATUS "Building for current host CPU")
-        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -march=native -mtune=native")
+        set(ARCH_C_FLAGS "${ARCH_C_FLAGS} -march=native -mtune=native")
     endif()
+
+    # we don't use these for the lib, but other tools/unit tests
     if (NOT CMAKE_CXX_FLAGS MATCHES .*march.*)
-        set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -march=native -mtune=native")
+        set(ARCH_CXX_FLAGS "${ARCH_CXX_FLAGS} -march=native -mtune=native")
     endif()
 
     if(CMAKE_COMPILER_IS_GNUCC)
@@ -389,7 +391,7 @@ if (NOT WIN32)
 endif()
 
 # only set these after all tests are done
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH_C_FLAGS} ${EXTRA_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
 
 

diff --git a/src/hwlm/hwlm_build.cpp b/src/hwlm/hwlm_build.cpp
index 3ab10f23dce6d2ab031a5ed5c64cbe42a8de3f51..fa6335c9443ede6b67122330a451e7729259350d 100644 (file)
--- a/src/hwlm/hwlm_build.cpp
+++ b/src/hwlm/hwlm_build.cpp
@@ -461,7 +461,8 @@ void findForwardAccelScheme(const vector<hwlmLiteral> &lits,
     }
 
     const CharReach &cr = reach[min_offset];
-    if (shuftiBuildMasks(cr, &aux->shufti.lo, &aux->shufti.hi) != -1) {
+    if (-1 !=
+        shuftiBuildMasks(cr, (u8 *)&aux->shufti.lo, (u8 *)&aux->shufti.hi)) {
         DEBUG_PRINTF("built shufti for %s (%zu chars, offset %u)\n",
                      describeClass(cr).c_str(), cr.count(), min_offset);
         aux->shufti.accel_type = ACCEL_SHUFTI;
@@ -469,7 +470,7 @@ void findForwardAccelScheme(const vector<hwlmLiteral> &lits,
         return;
     }
 
-    truffleBuildMasks(cr, &aux->truffle.mask1, &aux->truffle.mask2);
+    truffleBuildMasks(cr, (u8 *)&aux->truffle.mask1, (u8 *)&aux->truffle.mask2);
     DEBUG_PRINTF("built truffle for %s (%zu chars, offset %u)\n",
                  describeClass(cr).c_str(), cr.count(), min_offset);
     aux->truffle.accel_type = ACCEL_TRUFFLE;

diff --git a/src/nfa/accel_dfa_build_strat.cpp b/src/nfa/accel_dfa_build_strat.cpp
index 70d2d103199e327a6b4436fde400e0b0b7a63f3e..d257b530b8d3eb14821879f0e0804dad87dd087c 100644 (file)
--- a/src/nfa/accel_dfa_build_strat.cpp
+++ b/src/nfa/accel_dfa_build_strat.cpp
@@ -473,9 +473,10 @@ accel_dfa_build_strat::buildAccel(UNUSED dstate_id_t this_idx,
     }
 
     if (double_byte_ok(info) &&
-        shuftiBuildDoubleMasks(info.double_cr, info.double_byte,
-                               &accel->dshufti.lo1, &accel->dshufti.hi1,
-                               &accel->dshufti.lo2, &accel->dshufti.hi2)) {
+        shuftiBuildDoubleMasks(
+            info.double_cr, info.double_byte, (u8 *)&accel->dshufti.lo1,
+            (u8 *)&accel->dshufti.hi1, (u8 *)&accel->dshufti.lo2,
+            (u8 *)&accel->dshufti.hi2)) {
         accel->accel_type = ACCEL_DSHUFTI;
         accel->dshufti.offset = verify_u8(info.double_offset);
         DEBUG_PRINTF("state %hu is double shufti\n", this_idx);
@@ -511,14 +512,16 @@ accel_dfa_build_strat::buildAccel(UNUSED dstate_id_t this_idx,
     }
 
     accel->accel_type = ACCEL_SHUFTI;
-    if (-1 != shuftiBuildMasks(info.cr, &accel->shufti.lo, &accel->shufti.hi)) {
+    if (-1 != shuftiBuildMasks(info.cr, (u8 *)&accel->shufti.lo,
+                               (u8 *)&accel->shufti.hi)) {
         DEBUG_PRINTF("state %hu is shufti\n", this_idx);
         return;
     }
 
     assert(!info.cr.none());
     accel->accel_type = ACCEL_TRUFFLE;
-    truffleBuildMasks(info.cr, &accel->truffle.mask1, &accel->truffle.mask2);
+    truffleBuildMasks(info.cr, (u8 *)&accel->truffle.mask1,
+                      (u8 *)&accel->truffle.mask2);
     DEBUG_PRINTF("state %hu is truffle\n", this_idx);
 }
 

diff --git a/src/nfa/accel_dump.cpp b/src/nfa/accel_dump.cpp
index 6e2b8f4191103a0d46990eef3c95971a55fb5256..e99e71a59cda5d52dc8c16456314518df12b2019 100644 (file)
--- a/src/nfa/accel_dump.cpp
+++ b/src/nfa/accel_dump.cpp
@@ -41,7 +41,7 @@
 #include "util/charreach.h"
 #include "util/dump_charclass.h"
 #include "util/dump_mask.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 #include <cstdio>
 #include <vector>
@@ -147,16 +147,20 @@ const char *accelName(u8 accel_type) {
 }
 
 static
-void dumpShuftiCharReach(FILE *f, const m128 &lo, const m128 &hi) {
+void dumpShuftiCharReach(FILE *f, const u8 *lo, const u8 *hi) {
     CharReach cr = shufti2cr(lo, hi);
     fprintf(f, "count %zu class %s\n", cr.count(),
             describeClass(cr).c_str());
 }
 
 static
-vector<CharReach> shufti2cr_array(const m128 lo_in, const m128 hi_in) {
-    const u8 *lo = (const u8 *)&lo_in;
-    const u8 *hi = (const u8 *)&hi_in;
+vector<CharReach> dshufti2cr_array(const u8 *lo_in, const u8 *hi_in) {
+    u8 lo[16];
+    u8 hi[16];
+    for (u32 i = 0; i < 16; i++) {
+        lo[i] = ~lo_in[i];
+        hi[i] = ~hi_in[i];
+    }
     vector<CharReach> crs(8);
     for (u32 i = 0; i < 256; i++) {
         u32 combined = lo[(u8)i & 0xf] & hi[(u8)i >> 4];
@@ -169,10 +173,10 @@ vector<CharReach> shufti2cr_array(const m128 lo_in, const m128 hi_in) {
 }
 
 static
-void dumpDShuftiCharReach(FILE *f, const m128 &lo1, const m128 &hi1,
-                                   const m128 &lo2, const m128 &hi2) {
-    vector<CharReach> cr1 = shufti2cr_array(not128(lo1), not128(hi1));
-    vector<CharReach> cr2 = shufti2cr_array(not128(lo2), not128(hi2));
+void dumpDShuftiCharReach(FILE *f, const u8 *lo1, const u8 *hi1,
+                                   const u8 *lo2, const u8 *hi2) {
+    vector<CharReach> cr1 = dshufti2cr_array(lo1, hi1);
+    vector<CharReach> cr2 = dshufti2cr_array(lo2, hi2);
     map<CharReach, set<u32> > cr1_group;
     assert(cr1.size() == 8 && cr2.size() == 8);
     for (u32 i = 0; i < 8; i++) {
@@ -208,26 +212,22 @@ void dumpDShuftiCharReach(FILE *f, const m128 &lo1, const m128 &hi1,
 }
 
 static
-void dumpShuftiMasks(FILE *f, const m128 &lo, const m128 &hi) {
-    fprintf(f, "lo %s\n",
-            dumpMask((const u8 *)&lo, 128).c_str());
-    fprintf(f, "hi %s\n",
-            dumpMask((const u8 *)&hi, 128).c_str());
+void dumpShuftiMasks(FILE *f, const u8 *lo, const u8 *hi) {
+    fprintf(f, "lo %s\n", dumpMask(lo, 128).c_str());
+    fprintf(f, "hi %s\n", dumpMask(hi, 128).c_str());
 }
 
 static
-void dumpTruffleCharReach(FILE *f, const m128 &hiset, const m128 &hiclear) {
+void dumpTruffleCharReach(FILE *f, const u8 *hiset, const u8 *hiclear) {
     CharReach cr = truffle2cr(hiset, hiclear);
     fprintf(f, "count %zu class %s\n", cr.count(),
             describeClass(cr).c_str());
 }
 
 static
-void dumpTruffleMasks(FILE *f, const m128 &hiset, const m128 &hiclear) {
-    fprintf(f, "lo %s\n",
-            dumpMask((const u8 *)&hiset, 128).c_str());
-    fprintf(f, "hi %s\n",
-            dumpMask((const u8 *)&hiclear, 128).c_str());
+void dumpTruffleMasks(FILE *f, const u8 *hiset, const u8 *hiclear) {
+    fprintf(f, "lo %s\n", dumpMask(hiset, 128).c_str());
+    fprintf(f, "hi %s\n", dumpMask(hiclear, 128).c_str());
 }
 
 
@@ -256,23 +256,31 @@ void dumpAccelInfo(FILE *f, const AccelAux &accel) {
         break;
     case ACCEL_SHUFTI: {
         fprintf(f, "\n");
-        dumpShuftiMasks(f, accel.shufti.lo, accel.shufti.hi);
-        dumpShuftiCharReach(f, accel.shufti.lo, accel.shufti.hi);
+        dumpShuftiMasks(f, (const u8 *)&accel.shufti.lo,
+                        (const u8 *)&accel.shufti.hi);
+        dumpShuftiCharReach(f, (const u8 *)&accel.shufti.lo,
+                            (const u8 *)&accel.shufti.hi);
         break;
     }
     case ACCEL_DSHUFTI:
         fprintf(f, "\n");
         fprintf(f, "mask 1\n");
-        dumpShuftiMasks(f, accel.dshufti.lo1, accel.dshufti.hi1);
+        dumpShuftiMasks(f, (const u8 *)&accel.dshufti.lo1,
+                        (const u8 *)&accel.dshufti.hi1);
         fprintf(f, "mask 2\n");
-        dumpShuftiMasks(f, accel.dshufti.lo2, accel.dshufti.hi2);
-        dumpDShuftiCharReach(f, accel.dshufti.lo1, accel.dshufti.hi1,
-                             accel.dshufti.lo2, accel.dshufti.hi2);
+        dumpShuftiMasks(f, (const u8 *)&accel.dshufti.lo2,
+                        (const u8 *)&accel.dshufti.hi2);
+        dumpDShuftiCharReach(f, (const u8 *)&accel.dshufti.lo1,
+                             (const u8 *)&accel.dshufti.hi1,
+                             (const u8 *)&accel.dshufti.lo2,
+                             (const u8 *)&accel.dshufti.hi2);
         break;
     case ACCEL_TRUFFLE: {
         fprintf(f, "\n");
-        dumpTruffleMasks(f, accel.truffle.mask1, accel.truffle.mask2);
-        dumpTruffleCharReach(f, accel.truffle.mask1, accel.truffle.mask2);
+        dumpTruffleMasks(f, (const u8 *)&accel.truffle.mask1,
+                         (const u8 *)&accel.truffle.mask2);
+        dumpTruffleCharReach(f, (const u8 *)&accel.truffle.mask1,
+                             (const u8 *)&accel.truffle.mask2);
         break;
     }
     case ACCEL_MLVERM:
@@ -297,28 +305,36 @@ void dumpAccelInfo(FILE *f, const AccelAux &accel) {
     case ACCEL_MSSHUFTI:
     case ACCEL_MSGSHUFTI:
         fprintf(f, " len:%u\n", accel.mshufti.len);
-        dumpShuftiMasks(f, accel.mshufti.lo, accel.mshufti.hi);
-        dumpShuftiCharReach(f, accel.mshufti.lo, accel.mshufti.hi);
+        dumpShuftiMasks(f, (const u8 *)&accel.mshufti.lo,
+                        (const u8 *)&accel.mshufti.hi);
+        dumpShuftiCharReach(f, (const u8 *)&accel.mshufti.lo,
+                            (const u8 *)&accel.mshufti.hi);
         break;
     case ACCEL_MDSSHUFTI:
     case ACCEL_MDSGSHUFTI:
         fprintf(f, " len1:%u len2:%u\n", accel.mdshufti.len1, accel.mdshufti.len2);
-        dumpShuftiMasks(f, accel.mdshufti.lo, accel.mdshufti.hi);
-        dumpShuftiCharReach(f, accel.mdshufti.lo, accel.mdshufti.hi);
+        dumpShuftiMasks(f, (const u8 *)&accel.mdshufti.lo,
+                        (const u8 *)&accel.mdshufti.hi);
+        dumpShuftiCharReach(f, (const u8 *)&accel.mdshufti.lo,
+                            (const u8 *)&accel.mdshufti.hi);
         break;
     case ACCEL_MLTRUFFLE:
     case ACCEL_MLGTRUFFLE:
     case ACCEL_MSTRUFFLE:
     case ACCEL_MSGTRUFFLE:
         fprintf(f, " len:%u\n", accel.mtruffle.len);
-        dumpTruffleMasks(f, accel.mtruffle.mask1, accel.mtruffle.mask2);
-        dumpTruffleCharReach(f, accel.mtruffle.mask1, accel.mtruffle.mask2);
+        dumpTruffleMasks(f, (const u8 *)&accel.mtruffle.mask1,
+                         (const u8 *)&accel.mtruffle.mask2);
+        dumpTruffleCharReach(f, (const u8 *)&accel.mtruffle.mask1,
+                             (const u8 *)&accel.mtruffle.mask2);
         break;
     case ACCEL_MDSTRUFFLE:
     case ACCEL_MDSGTRUFFLE:
         fprintf(f, " len1:%u len2:%u\n", accel.mdtruffle.len1, accel.mdtruffle.len2);
-        dumpTruffleMasks(f, accel.mdtruffle.mask1, accel.mdtruffle.mask2);
-        dumpTruffleCharReach(f, accel.mdtruffle.mask1, accel.mdtruffle.mask2);
+        dumpTruffleMasks(f, (const u8 *)&accel.mdtruffle.mask1,
+                         (const u8 *)&accel.mdtruffle.mask2);
+        dumpTruffleCharReach(f, (const u8 *)&accel.mdtruffle.mask1,
+                             (const u8 *)&accel.mdtruffle.mask2);
         break;
     default:
         fprintf(f, "\n");

diff --git a/src/nfa/accelcompile.cpp b/src/nfa/accelcompile.cpp
index 75960dda0edbacc1c5c16ec0158ff60fdfdc1a28..32e569ba91d0fc9fbedd42ef5261c2fdbca84f1c 100644 (file)
--- a/src/nfa/accelcompile.cpp
+++ b/src/nfa/accelcompile.cpp
@@ -72,8 +72,8 @@ void buildAccelSingle(const AccelInfo &info, AccelAux *aux) {
     }
 
     DEBUG_PRINTF("attempting shufti for %zu chars\n", outs);
-    if (-1 != shuftiBuildMasks(info.single_stops, &aux->shufti.lo,
-                               &aux->shufti.hi)) {
+    if (-1 != shuftiBuildMasks(info.single_stops, (u8 *)&aux->shufti.lo,
+                               (u8 *)&aux->shufti.hi)) {
         aux->accel_type = ACCEL_SHUFTI;
         aux->shufti.offset = offset;
         DEBUG_PRINTF("shufti built OK\n");
@@ -86,8 +86,8 @@ void buildAccelSingle(const AccelInfo &info, AccelAux *aux) {
         DEBUG_PRINTF("building Truffle for %zu chars\n", outs);
         aux->accel_type = ACCEL_TRUFFLE;
         aux->truffle.offset = offset;
-        truffleBuildMasks(info.single_stops, &aux->truffle.mask1,
-                          &aux->truffle.mask2);
+        truffleBuildMasks(info.single_stops, (u8 *)&aux->truffle.mask1,
+                          (u8 *)&aux->truffle.mask2);
         return;
     }
 
@@ -212,9 +212,10 @@ void buildAccelDouble(const AccelInfo &info, AccelAux *aux) {
                      " two-byte literals\n", outs1, outs2);
         aux->accel_type = ACCEL_DSHUFTI;
         aux->dshufti.offset = offset;
-        if (shuftiBuildDoubleMasks(info.double_stop1, info.double_stop2,
-                                   &aux->dshufti.lo1, &aux->dshufti.hi1,
-                                   &aux->dshufti.lo2, &aux->dshufti.hi2)) {
+        if (shuftiBuildDoubleMasks(
+                info.double_stop1, info.double_stop2, (u8 *)&aux->dshufti.lo1,
+                (u8 *)&aux->dshufti.hi1, (u8 *)&aux->dshufti.lo2,
+                (u8 *)&aux->dshufti.hi2)) {
             return;
         }
     }
@@ -372,8 +373,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
 
     switch (info.ma_type) {
     case MultibyteAccelInfo::MAT_LONG:
-        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
-                &aux->mshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo,
+                (u8 *)&aux->mshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MLSHUFTI;
@@ -381,8 +382,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
         aux->mshufti.len = info.ma_len1;
         return;
     case MultibyteAccelInfo::MAT_LONGGRAB:
-        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
-                &aux->mshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo,
+                (u8 *)&aux->mshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MLGSHUFTI;
@@ -390,8 +391,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
         aux->mshufti.len = info.ma_len1;
         return;
     case MultibyteAccelInfo::MAT_SHIFT:
-        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
-                &aux->mshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo,
+                (u8 *)&aux->mshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MSSHUFTI;
@@ -399,8 +400,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
         aux->mshufti.len = info.ma_len1;
         return;
     case MultibyteAccelInfo::MAT_SHIFTGRAB:
-        if (shuftiBuildMasks(stops, &aux->mshufti.lo,
-                &aux->mshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo,
+                (u8 *)&aux->mshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MSGSHUFTI;
@@ -408,8 +409,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
         aux->mshufti.len = info.ma_len1;
         return;
     case MultibyteAccelInfo::MAT_DSHIFT:
-        if (shuftiBuildMasks(stops, &aux->mdshufti.lo,
-                &aux->mdshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mdshufti.lo,
+                (u8 *)&aux->mdshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MDSSHUFTI;
@@ -418,8 +419,8 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
         aux->mdshufti.len2 = info.ma_len2;
         return;
     case MultibyteAccelInfo::MAT_DSHIFTGRAB:
-        if (shuftiBuildMasks(stops, &aux->mdshufti.lo,
-                &aux->mdshufti.hi) == -1) {
+        if (shuftiBuildMasks(stops, (u8 *)&aux->mdshufti.lo,
+                (u8 *)&aux->mdshufti.hi) == -1) {
             break;
         }
         aux->accel_type = ACCEL_MDSGSHUFTI;
@@ -441,45 +442,45 @@ void buildAccelMulti(const AccelInfo &info, AccelAux *aux) {
             aux->accel_type = ACCEL_MLTRUFFLE;
             aux->mtruffle.offset = offset;
             aux->mtruffle.len = info.ma_len1;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mtruffle.mask2);
             break;
         case MultibyteAccelInfo::MAT_LONGGRAB:
             aux->accel_type = ACCEL_MLGTRUFFLE;
             aux->mtruffle.offset = offset;
             aux->mtruffle.len = info.ma_len1;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mtruffle.mask2);
             break;
         case MultibyteAccelInfo::MAT_SHIFT:
             aux->accel_type = ACCEL_MSTRUFFLE;
             aux->mtruffle.offset = offset;
             aux->mtruffle.len = info.ma_len1;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mtruffle.mask2);
             break;
         case MultibyteAccelInfo::MAT_SHIFTGRAB:
             aux->accel_type = ACCEL_MSGTRUFFLE;
             aux->mtruffle.offset = offset;
             aux->mtruffle.len = info.ma_len1;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mtruffle.mask2);
             break;
         case MultibyteAccelInfo::MAT_DSHIFT:
             aux->accel_type = ACCEL_MDSTRUFFLE;
             aux->mdtruffle.offset = offset;
             aux->mdtruffle.len1 = info.ma_len1;
             aux->mdtruffle.len2 = info.ma_len2;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mdtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mdtruffle.mask2);
             break;
         case MultibyteAccelInfo::MAT_DSHIFTGRAB:
             aux->accel_type = ACCEL_MDSGTRUFFLE;
             aux->mdtruffle.offset = offset;
             aux->mdtruffle.len1 = info.ma_len1;
             aux->mdtruffle.len2 = info.ma_len2;
-            truffleBuildMasks(stops, &aux->mtruffle.mask1,
-                              &aux->mdtruffle.mask2);
+            truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1,
+                              (u8 *)&aux->mdtruffle.mask2);
             break;
         default:
             // shouldn't happen

diff --git a/src/nfa/castle_dump.cpp b/src/nfa/castle_dump.cpp
index 9426b6db1fe13f30e756778015b8a599920f3e3d..1514ca8c1aa8a046c6ec54ddd04d9bf9cc973e2b 100644 (file)
--- a/src/nfa/castle_dump.cpp
+++ b/src/nfa/castle_dump.cpp
@@ -88,13 +88,15 @@ void nfaExecCastle_dump(const struct NFA *nfa, const string &base) {
         fprintf(f, "negated verm, scanning for 0x%02x\n", c->u.verm.c);
         break;
     case CASTLE_SHUFTI: {
-        const CharReach cr = shufti2cr(c->u.shuf.mask_lo, c->u.shuf.mask_hi);
+        const CharReach cr = shufti2cr((const u8 *)&c->u.shuf.mask_lo,
+                                       (const u8 *)&c->u.shuf.mask_hi);
         fprintf(f, "shufti, scanning for %s (%zu chars)\n",
                 describeClass(cr).c_str(), cr.count());
         break;
     }
     case CASTLE_TRUFFLE: {
-        const CharReach cr = truffle2cr(c->u.truffle.mask1, c->u.truffle.mask2);
+        const CharReach cr = truffle2cr((const u8 *)&c->u.truffle.mask1,
+                                        (const u8 *)&c->u.truffle.mask2);
         fprintf(f, "truffle, scanning for %s (%zu chars)\n",
                 describeClass(cr).c_str(), cr.count());
         break;

diff --git a/src/nfa/castlecompile.cpp b/src/nfa/castlecompile.cpp
index 4f3bcf2e17eadfb3f3bbad27055d34ac25cf261c..3b40ab9a81eaaf91ea8c78ce6342f9f57f1191e2 100644 (file)
--- a/src/nfa/castlecompile.cpp
+++ b/src/nfa/castlecompile.cpp
@@ -100,13 +100,15 @@ void writeCastleScanEngine(const CharReach &cr, Castle *c) {
         return;
     }
 
-    if (shuftiBuildMasks(negated, &c->u.shuf.mask_lo, &c->u.shuf.mask_hi) != -1) {
+    if (shuftiBuildMasks(negated, (u8 *)&c->u.shuf.mask_lo,
+                         (u8 *)&c->u.shuf.mask_hi) != -1) {
         c->type = CASTLE_SHUFTI;
         return;
     }
 
     c->type = CASTLE_TRUFFLE;
-    truffleBuildMasks(negated, &c->u.truffle.mask1, &c->u.truffle.mask2);
+    truffleBuildMasks(negated, (u8 *)(u8 *)&c->u.truffle.mask1,
+                      (u8 *)&c->u.truffle.mask2);
 }
 
 static

diff --git a/src/nfa/lbr_dump.cpp b/src/nfa/lbr_dump.cpp
index 92cf7e0316010e6f1aea5b5c17f5fbbab05ea912..0948e122186cf7396fbeed70e546d53a7ba38f3d 100644 (file)
--- a/src/nfa/lbr_dump.cpp
+++ b/src/nfa/lbr_dump.cpp
@@ -116,7 +116,8 @@ void nfaExecLbrShuf_dump(const NFA *nfa, const string &base) {
     const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa);
     lbrDumpCommon(&ls->common, f);
 
-    CharReach cr = shufti2cr(ls->mask_lo, ls->mask_hi);
+    CharReach cr = shufti2cr((const u8 *)&ls->mask_lo,
+                             (const u8 *)&ls->mask_hi);
     fprintf(f, "SHUF model, scanning for: %s (%zu chars)\n",
             describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count());
     fprintf(f, "\n");
@@ -133,7 +134,8 @@ void nfaExecLbrTruf_dump(const NFA *nfa, const string &base) {
     const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa);
     lbrDumpCommon(&lt->common, f);
 
-    CharReach cr = truffle2cr(lt->mask1, lt->mask2);
+    CharReach cr = truffle2cr((const u8 *)&lt->mask1,
+                              (const u8 *)&lt->mask2);
     fprintf(f, "TRUFFLE model, scanning for: %s (%zu chars)\n",
             describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count());
     fprintf(f, "\n");

diff --git a/src/nfa/mcsheng_compile.cpp b/src/nfa/mcsheng_compile.cpp
index bc12cc5c2141b89b6f5ce8524422665499b2d88d..b7570af42fd8a282e839a1d0a8d7e1c689c76bb3 100644 (file)
--- a/src/nfa/mcsheng_compile.cpp
+++ b/src/nfa/mcsheng_compile.cpp
@@ -193,7 +193,7 @@ void createShuffleMasks(mcsheng *m, const dfa_info &info,
     }
     for (u32 i = 0; i < N_CHARS; i++) {
         assert(info.alpha_remap[i] != info.alpha_remap[TOP]);
-        m->sheng_masks[i] = loadu128(masks[info.alpha_remap[i]].data());
+        memcpy((u8*)&m->sheng_masks[i], (u8*)masks[info.alpha_remap[i]].data(), sizeof(m128));
     }
     m->sheng_end = sheng_end;
     m->sheng_accel_limit = sheng_end - 1;

diff --git a/src/nfa/mcsheng_internal.h b/src/nfa/mcsheng_internal.h
index 5ced6f76bbe3658b67ddd1a70fd9a73008010131..81a658e0e72aa23cf344f2fe5ec3f134dddf31f3 100644 (file)
--- a/src/nfa/mcsheng_internal.h
+++ b/src/nfa/mcsheng_internal.h
@@ -31,7 +31,7 @@
 
 #include "nfa_internal.h"
 #include "ue2common.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 #define ACCEPT_FLAG 0x8000
 #define ACCEL_FLAG  0x4000

diff --git a/src/nfa/mpvcompile.cpp b/src/nfa/mpvcompile.cpp
index 908267be65773d9fedda2c3e050f4063d17e90de..87fb462e5369cf2b6975dbb836908d247c5f2ac6 100644 (file)
--- a/src/nfa/mpvcompile.cpp
+++ b/src/nfa/mpvcompile.cpp
@@ -175,12 +175,13 @@ void writeKiloPuff(const map<ClusterKey, vector<raw_puff>>::const_iterator &it,
         size_t set = reach.find_first();
         assert(set != CharReach::npos);
         kp->u.verm.c = (char)set;
-    } else if (shuftiBuildMasks(~reach, &kp->u.shuf.mask_lo,
-                                &kp->u.shuf.mask_hi) != -1) {
+    } else if (shuftiBuildMasks(~reach, (u8 *)&kp->u.shuf.mask_lo,
+                                (u8 *)&kp->u.shuf.mask_hi) != -1) {
         kp->type = MPV_SHUFTI;
     } else {
         kp->type = MPV_TRUFFLE;
-        truffleBuildMasks(~reach, &kp->u.truffle.mask1, &kp->u.truffle.mask2);
+        truffleBuildMasks(~reach, (u8 *)&kp->u.truffle.mask1,
+                          (u8 *)&kp->u.truffle.mask2);
     }
 
     kp->count = verify_u32(puffs.size());

diff --git a/src/nfa/multishufti.h b/src/nfa/multishufti.h
index bcccf607c949f477c37b4e381a167a497d444d17..af5784831a6a10249d39bd4e89324032e910f394 100644 (file)
--- a/src/nfa/multishufti.h
+++ b/src/nfa/multishufti.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,7 +36,7 @@
 #define MULTISHUFTI_H
 
 #include "ue2common.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 #ifdef __cplusplus
 extern "C"

diff --git a/src/nfa/sheng_internal.h b/src/nfa/sheng_internal.h
index 046eb759a5c6c254d1ce0cac624543c10c9e081b..ff843ebee3f37da854ccde1d72eb956b2a8e24a5 100644 (file)
--- a/src/nfa/sheng_internal.h
+++ b/src/nfa/sheng_internal.h
@@ -30,7 +30,7 @@
 #define SHENG_INTERNAL_H_
 
 #include "ue2common.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 #define SHENG_STATE_ACCEPT 0x10
 #define SHENG_STATE_DEAD 0x20

diff --git a/src/nfa/shengcompile.cpp b/src/nfa/shengcompile.cpp
index a02a9b96b32f5abb6bf4bb570f00cdb3ce9fc20a..53f2c1318e53715f8a5b7cbb49b32542b83b753b 100644 (file)
--- a/src/nfa/shengcompile.cpp
+++ b/src/nfa/shengcompile.cpp
@@ -48,7 +48,7 @@
 #include "util/compile_context.h"
 #include "util/make_unique.h"
 #include "util/verify_types.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 #include <map>
 #include <vector>
@@ -442,8 +442,7 @@ void createShuffleMasks(sheng *s, dfa_info &info,
 #ifdef DEBUG
         dumpShuffleMask(chr, buf, sizeof(buf));
 #endif
-        m128 mask = loadu128(buf);
-        s->shuffle_masks[chr] = mask;
+        memcpy(&s->shuffle_masks[chr], buf, sizeof(m128));
     }
 }
 

diff --git a/src/nfa/shengdump.cpp b/src/nfa/shengdump.cpp
index c23716015953360811bb499ff8049f5433ab53c3..ce87beaf64cc0486f3b4309d12f1cd784aa28996 100644 (file)
--- a/src/nfa/shengdump.cpp
+++ b/src/nfa/shengdump.cpp
@@ -39,7 +39,7 @@
 #include "util/charreach.h"
 #include "util/dump_charclass.h"
 #include "util/dump_util.h"
-#include "util/simd_utils.h"
+#include "util/simd_types.h"
 
 
 #ifndef DUMP_SUPPORT
@@ -101,7 +101,7 @@ void dumpMasks(FILE *f, const sheng *s) {
     for (u32 chr = 0; chr < 256; chr++) {
         u8 buf[16];
         m128 shuffle_mask = s->shuffle_masks[chr];
-        store128(buf, shuffle_mask);
+        memcpy(buf, &shuffle_mask, sizeof(m128));
 
         fprintf(f, "%3u: ", chr);
         for (u32 pos = 0; pos < 16; pos++) {
@@ -237,7 +237,7 @@ void shengGetTransitions(const NFA *n, u16 state, u16 *t) {
         u8 buf[16];
         m128 shuffle_mask = s->shuffle_masks[i];
 
-        store128(buf, shuffle_mask);
+        memcpy(buf, &shuffle_mask, sizeof(m128));
 
         t[i] = buf[state] & SHENG_STATE_MASK;
     }

diff --git a/src/nfa/shufticompile.cpp b/src/nfa/shufticompile.cpp
index 217fcee03f24dce34cb892e74142f77d3c86cb7f..12a94b7b0b7c3d0b6d9f5e35b133369e669a2711 100644 (file)
--- a/src/nfa/shufticompile.cpp
+++ b/src/nfa/shufticompile.cpp
@@ -51,7 +51,7 @@ namespace ue2 {
  *
  * Note: always able to construct masks for 8 or fewer characters.
  */
-int shuftiBuildMasks(const CharReach &c, m128 *lo, m128 *hi) {
+int shuftiBuildMasks(const CharReach &c, u8 *lo, u8 *hi) {
     /* Things could be packed much more optimally, but this should be able to
      * handle any set of characters entirely in the lower half.  */
 
@@ -134,7 +134,7 @@ void set_buckets_from_mask(u16 nibble_mask, u32 bucket,
 
 bool shuftiBuildDoubleMasks(const CharReach &onechar,
                             const flat_set<pair<u8, u8>> &twochar,
-                            m128 *lo1, m128 *hi1, m128 *lo2, m128 *hi2) {
+                            u8 *lo1, u8 *hi1, u8 *lo2, u8 *hi2) {
     DEBUG_PRINTF("unibytes %zu dibytes %zu\n", onechar.size(),
                  twochar.size());
     array<u8, 16> lo1_a;
@@ -210,9 +210,7 @@ bool shuftiBuildDoubleMasks(const CharReach &onechar,
 
 #ifdef DUMP_SUPPORT
 
-CharReach shufti2cr(const m128 lo_in, const m128 hi_in) {
-    const u8 *lo = (const u8 *)&lo_in;
-    const u8 *hi = (const u8 *)&hi_in;
+CharReach shufti2cr(const u8 *lo, const u8 *hi) {
     CharReach cr;
     for (u32 i = 0; i < 256; i++) {
         if (lo[(u8)i & 0xf] & hi[(u8)i >> 4]) {

diff --git a/src/nfa/shufticompile.h b/src/nfa/shufticompile.h
index 59126b0b5d5cf1dc98dbd317a17ff3083c6b2037..a72904e055599564c7b2c80a3fcc19752e6ae074 100644 (file)
--- a/src/nfa/shufticompile.h
+++ b/src/nfa/shufticompile.h
@@ -48,7 +48,7 @@ namespace ue2 {
  *
  * Note: always able to construct masks for 8 or fewer characters.
  */
-int shuftiBuildMasks(const CharReach &chars, m128 *lo, m128 *hi);
+int shuftiBuildMasks(const CharReach &chars, u8 *lo, u8 *hi);
 
 /** \brief Double-byte variant
  *
@@ -56,7 +56,7 @@ int shuftiBuildMasks(const CharReach &chars, m128 *lo, m128 *hi);
  */
 bool shuftiBuildDoubleMasks(const CharReach &onechar,
                             const flat_set<std::pair<u8, u8>> &twochar,
-                            m128 *lo1, m128 *hi1, m128 *lo2, m128 *hi2);
+                            u8 *lo1, u8 *hi1, u8 *lo2, u8 *hi2);
 
 #ifdef DUMP_SUPPORT
 
@@ -64,7 +64,7 @@ bool shuftiBuildDoubleMasks(const CharReach &onechar,
  * \brief Dump code: returns a CharReach with the reach that would match this
  * shufti.
  */
-CharReach shufti2cr(const m128 lo, const m128 hi);
+CharReach shufti2cr(const u8 *lo, const u8 *hi);
 
 #endif // DUMP_SUPPORT
 

diff --git a/src/nfa/trufflecompile.cpp b/src/nfa/trufflecompile.cpp
index 6bde7abb93493406d4168856a33dc61a181df033..9442d046d245eae2538550103e4f14336fa18973 100644 (file)
--- a/src/nfa/trufflecompile.cpp
+++ b/src/nfa/trufflecompile.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -36,7 +36,7 @@
 #include "ue2common.h"
 #include "util/charreach.h"
 #include "util/simd_types.h"
-#include "util/simd_utils.h"
+
 #include "util/dump_mask.h"
 
 using namespace std;
@@ -53,17 +53,15 @@ namespace ue2 {
  * bits 456 is the bit that is set at that offset.
  */
 
-void truffleBuildMasks(const CharReach &cr, m128 *shuf_mask_lo_highclear,
-                       m128 *shuf_mask_lo_highset) {
-    *shuf_mask_lo_highset = zeroes128();
-    *shuf_mask_lo_highclear = zeroes128();
-    u8 *lo_highset = (u8 *)shuf_mask_lo_highset;
-    u8 *lo_highclear = (u8 *)shuf_mask_lo_highclear;
+void truffleBuildMasks(const CharReach &cr, u8 *shuf_mask_lo_highclear,
+                       u8 *shuf_mask_lo_highset) {
+    memset(shuf_mask_lo_highset, 0, sizeof(m128));
+    memset(shuf_mask_lo_highclear, 0, sizeof(m128));
 
     for (size_t v = cr.find_first(); v != CharReach::npos;
          v = cr.find_next(v)) {
         DEBUG_PRINTF("adding 0x%02x to %s\n", (u8)v, (v & 0x80) ? "highset" : "highclear");
-        u8 *change_mask = (v & 0x80) ? lo_highset : lo_highclear;
+        u8 *change_mask = (v & 0x80) ? shuf_mask_lo_highset : shuf_mask_lo_highclear;
         u8 low_nibble = v & 0xf;
         u8 bits_456 = (v & 0x70) >> 4;
         change_mask[low_nibble] |= 1 << bits_456;
@@ -73,18 +71,16 @@ void truffleBuildMasks(const CharReach &cr, m128 *shuf_mask_lo_highclear,
 /*
  * Reconstruct the charclass that the truffle masks represent
  */
-CharReach truffle2cr(const m128 highclear, const m128 highset) {
-    const u8 *lo = (const u8 *)&highclear;
-    const u8 *hi = (const u8 *)&highset;
+CharReach truffle2cr(const u8 *highclear, const u8 *highset) {
     CharReach cr;
     for (u8 i = 0; i < 16; i++) {
-        u32 bits_456 = lo[i];
+        u32 bits_456 = highclear[i];
         while (bits_456) {
             u32 pos = findAndClearLSB_32(&bits_456);
             assert(pos < 8);
             cr.set(pos << 4 | i);
         }
-        bits_456 = hi[i];
+        bits_456 = highset[i];
         while (bits_456) {
             u32 pos = findAndClearLSB_32(&bits_456);
             assert(pos < 8);

diff --git a/src/nfa/trufflecompile.h b/src/nfa/trufflecompile.h
index 19d3eb54eab335b88031f1f52935c2b1031c81fc..14b314f391401d683b926d64ba4779c31a744ddb 100644 (file)
--- a/src/nfa/trufflecompile.h
+++ b/src/nfa/trufflecompile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -34,8 +34,8 @@
 
 namespace ue2 {
 
-void truffleBuildMasks(const CharReach &cr, m128 *mask1, m128 *mask2);
-CharReach truffle2cr(const m128 lo_in, const m128 hi_in);
+void truffleBuildMasks(const CharReach &cr, u8 *mask1, u8 *mask2);
+CharReach truffle2cr(const u8 *lo_in, const u8 *hi_in);
 
 }
 

diff --git a/src/nfagraph/ng_lbr.cpp b/src/nfagraph/ng_lbr.cpp
index d68c768155eb6829f5d3746bf9ce5750ba7e4ca0..d832bdaaca9087bb92e2b81ccea2ce7941e5143a 100644 (file)
--- a/src/nfagraph/ng_lbr.cpp
+++ b/src/nfagraph/ng_lbr.cpp
@@ -224,7 +224,7 @@ aligned_unique_ptr<NFA> buildLbrShuf(const CharReach &cr,
     fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax,
                       minPeriod, rtype);
 
-    if (shuftiBuildMasks(~cr, &ls->mask_lo, &ls->mask_hi) == -1) {
+    if (shuftiBuildMasks(~cr, (u8 *)&ls->mask_lo, (u8 *)&ls->mask_hi) == -1) {
         return nullptr;
     }
 
@@ -245,7 +245,7 @@ aligned_unique_ptr<NFA> buildLbrTruf(const CharReach &cr,
     fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax,
                       minPeriod, rtype);
 
-    truffleBuildMasks(~cr, &lc->mask1, &lc->mask2);
+    truffleBuildMasks(~cr, (u8 *)&lc->mask1, (u8 *)&lc->mask2);
 
     DEBUG_PRINTF("built truffle lbr\n");
     return nfa;

diff --git a/src/rose/rose_build_bytecode.cpp b/src/rose/rose_build_bytecode.cpp
index 3d89f87ac616c7d743b85ca2b1dca5a36fc1737c..9f4abcadfb1f9cc16f7bc39cf71af85ecbd84eef 100644 (file)
--- a/src/rose/rose_build_bytecode.cpp
+++ b/src/rose/rose_build_bytecode.cpp
@@ -2010,7 +2010,7 @@ void buildCountingMiracles(build_context &bc) {
             rcm.c = cr.find_first();
         } else {
             rcm.shufti = 1;
-            int rv = shuftiBuildMasks(cr, &rcm.lo, &rcm.hi);
+            int rv = shuftiBuildMasks(cr, (u8 *)&rcm.lo, (u8 *)&rcm.hi);
             if (rv == -1) {
                 DEBUG_PRINTF("failed to build shufti\n");
                 lbi.countingMiracleCount = 0; /* remove counting miracle */

diff --git a/src/util/simd_types.h b/src/util/simd_types.h
index e454141116fbffb53d036298e5316999a6e3533f..35f27e66fcbd641af552e39b2e9f569336bdd21a 100644 (file)
--- a/src/util/simd_types.h
+++ b/src/util/simd_types.h
@@ -62,6 +62,10 @@
 #endif
 
 typedef __m128i m128;
+#else
+typedef struct ALIGN_DIRECTIVE {u64a hi; u64a lo;} m128;
+#endif
+
 #if defined(__AVX2__)
 typedef __m256i m256;
 #else

diff --git a/unit/CMakeLists.txt b/unit/CMakeLists.txt
index 17818cacbbc0bb839a671bf38636492e2ed03393..77f3ac3b5f4eeb0786e5226e6dff75ae58d52e2d 100644 (file)
--- a/unit/CMakeLists.txt
+++ b/unit/CMakeLists.txt
@@ -1,5 +1,5 @@
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARCH_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")
 
 set(gtest_SOURCES gtest/gtest-all.cc gtest/gtest.h)
 if(NOT XCODE)

diff --git a/unit/internal/shufti.cpp b/unit/internal/shufti.cpp
index 67ceadc528966638c396222d274c76baa6d4f589..06407c4173b21069c0c84a3ae9030f82f1447d5a 100644 (file)
--- a/unit/internal/shufti.cpp
+++ b/unit/internal/shufti.cpp
@@ -47,7 +47,7 @@ TEST(Shufti, BuildMask1) {
 
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lomask, &himask);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask);
     ASSERT_NE(-1, ret);
 
     u8 *lo = (u8 *)&lomask;
@@ -75,7 +75,7 @@ TEST(Shufti, BuildMask2) {
     chars.set('a');
     chars.set('B');
 
-    int ret = shuftiBuildMasks(chars, &lomask, &himask);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask);
     ASSERT_NE(-1, ret);
 
     u8 *lo = (u8 *)&lomask;
@@ -96,7 +96,7 @@ TEST(Shufti, BuildMask4) {
     chars.set('A');
     chars.set('b');
 
-    int ret = shuftiBuildMasks(chars, &lomask, &himask);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask);
     ASSERT_NE(-1, ret);
 
     u8 *lo = (u8 *)&lomask;
@@ -113,7 +113,7 @@ TEST(Shufti, ExecNoMatch1) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -132,7 +132,7 @@ TEST(Shufti, ExecNoMatch2) {
     chars.set('a');
     chars.set('B');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -150,7 +150,7 @@ TEST(Shufti, ExecNoMatch3) {
     CharReach chars;
     chars.set('V'); /* V = 0x56, e = 0x65 */
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -168,7 +168,7 @@ TEST(Shufti, ExecMatch1) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -187,7 +187,7 @@ TEST(Shufti, ExecMatch2) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -207,7 +207,7 @@ TEST(Shufti, ExecMatch3) {
     chars.set('a');
     chars.set('B');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -229,7 +229,7 @@ TEST(Shufti, ExecMatch4) {
     chars.set('A');
     chars.set('c');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -263,7 +263,7 @@ TEST(Shufti, ExecMatch5) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -283,8 +283,8 @@ TEST(DoubleShufti, BuildMask1) {
 
     lits.insert(make_pair('a', 'B'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_TRUE(ret);
 
     u8 *lo1 = (u8 *)&lo1m;
@@ -326,8 +326,8 @@ TEST(DoubleShufti, BuildMask2) {
     lits.insert(make_pair('a','z'));
     lits.insert(make_pair('B','z'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_TRUE(ret);
 
     u8 *lo1 = (u8 *)&lo1m;
@@ -354,8 +354,8 @@ TEST(DoubleShufti, BuildMask4) {
     lits.insert(make_pair('A','z'));
     lits.insert(make_pair('b','z'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_TRUE(ret);
 
     u8 *lo1 = (u8 *)&lo1m;
@@ -383,8 +383,8 @@ TEST(DoubleShufti, BuildMask5) {
     CharReach bytes;
     bytes.set('X');
 
-    bool ret = shuftiBuildDoubleMasks(bytes, lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool ret = shuftiBuildDoubleMasks(bytes, lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_TRUE(ret);
 
     u8 *lo1 = (u8 *)&lo1m;
@@ -421,8 +421,8 @@ TEST(DoubleShufti, BuildMask6) {
     lits.insert(make_pair('A','x'));
     lits.insert(make_pair('b','x'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_TRUE(ret);
 
     u8 *lo1 = (u8 *)&lo1m;
@@ -473,8 +473,8 @@ TEST(DoubleShufti, BuildMask7) {
     lits.insert(make_pair('u','v'));
     lits.insert(make_pair('w','x'));
 
-    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, &lo1m, &hi1m,
-                                     &lo2m, &hi2m);
+    bool rv = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m,
+                                     (u8 *)&lo2m, (u8 *)&hi2m);
     ASSERT_FALSE(rv);
 }
 
@@ -485,8 +485,8 @@ TEST(DoubleShufti, ExecNoMatch1) {
 
     lits.insert(make_pair('a','b'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1,
-                                     &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                     (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -506,7 +506,8 @@ TEST(DoubleShufti, ExecNoMatch1b) {
 
     lits.insert(make_pair('b','a'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -527,7 +528,8 @@ TEST(DoubleShufti, ExecNoMatch2) {
     lits.insert(make_pair('a','b'));
     lits.insert(make_pair('B','b'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -548,14 +550,15 @@ TEST(DoubleShufti, ExecNoMatch2b) {
     lits.insert(make_pair('b','a'));
     lits.insert(make_pair('b','B'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
     for (size_t i = 0; i < 16; i++) {
-        const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2,
-                                        (u8 *)t1 + i, (u8 *)t1 + strlen(t1));
+        const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i,
+                                        (u8 *)t1 + strlen(t1));
 
         ASSERT_EQ((size_t)t1 + i + 15, (size_t)rv);
     }
@@ -568,7 +571,8 @@ TEST(DoubleShufti, ExecNoMatch3) {
 
     lits.insert(make_pair('V','e'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -588,7 +592,8 @@ TEST(DoubleShufti, ExecNoMatch3b) {
 
     lits.insert(make_pair('e','V'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -608,7 +613,8 @@ TEST(DoubleShufti, ExecMatchShort1) {
 
     lits.insert(make_pair('a','b'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -629,7 +635,8 @@ TEST(DoubleShufti, ExecMatch1) {
 
     lits.insert(make_pair('a','b'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -650,7 +657,8 @@ TEST(DoubleShufti, ExecMatch2) {
 
     lits.insert(make_pair('a','a'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -672,7 +680,8 @@ TEST(DoubleShufti, ExecMatch3) {
     lits.insert(make_pair('B','a'));
     lits.insert(make_pair('a','a'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -696,7 +705,8 @@ TEST(DoubleShufti, ExecMatch4) {
     lits.insert(make_pair('C','a'));
     lits.insert(make_pair('c','a'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -738,7 +748,8 @@ TEST(DoubleShufti, ExecMatch4b) {
     lits.insert(make_pair('a','C'));
     lits.insert(make_pair('a','c'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     /*          0123456789012345678901234567890 */
@@ -777,7 +788,8 @@ TEST(DoubleShufti, ExecMatch5) {
 
     lits.insert(make_pair('a','A'));
 
-    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -801,7 +813,8 @@ TEST(DoubleShufti, ExecMatchMixed1) {
     // just one one-byte literal
     onebyte.set('a');
 
-    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -825,7 +838,8 @@ TEST(DoubleShufti, ExecMatchMixed2) {
     onebyte.set('a');
     twobyte.insert(make_pair('x', 'y'));
 
-    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -859,7 +873,8 @@ TEST(DoubleShufti, ExecMatchMixed3) {
     onebyte.set('a');
     twobyte.insert(make_pair('x', 'y'));
 
-    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, &lo1, &hi1, &lo2, &hi2);
+    bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1,
+                                      (u8 *)&lo2, (u8 *)&hi2);
     ASSERT_TRUE(ret);
 
     const int len = 420;
@@ -892,7 +907,7 @@ TEST(ReverseShufti, ExecNoMatch1) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -911,7 +926,7 @@ TEST(ReverseShufti, ExecNoMatch2) {
     chars.set('a');
     chars.set('B');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -929,7 +944,7 @@ TEST(ReverseShufti, ExecNoMatch3) {
     CharReach chars;
     chars.set('V'); /* V = 0x56, e = 0x65 */
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
@@ -947,7 +962,7 @@ TEST(ReverseShufti, ExecMatch1) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -968,7 +983,7 @@ TEST(ReverseShufti, ExecMatch2) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -990,7 +1005,7 @@ TEST(ReverseShufti, ExecMatch3) {
     chars.set('a');
     chars.set('B');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -1024,7 +1039,7 @@ TEST(ReverseShufti, ExecMatch4) {
     chars.set('A');
     chars.set('c');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     /*          0123456789012345678901234567890 */
@@ -1059,7 +1074,7 @@ TEST(ReverseShufti, ExecMatch5) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -1079,7 +1094,7 @@ TEST(ReverseShufti, ExecMatch6) {
     CharReach chars;
     chars.set('a');
 
-    int ret = shuftiBuildMasks(chars, &lo, &hi);
+    int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
     ASSERT_NE(-1, ret);
 
     const size_t len = 256;

diff --git a/unit/internal/truffle.cpp b/unit/internal/truffle.cpp
index 859c8a0874eafb32f4088624b6f26d33b4a8d361..e9e4f19cd4506f27f1ec1dd8885ea54f6ee464a4 100644 (file)
--- a/unit/internal/truffle.cpp
+++ b/unit/internal/truffle.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -45,9 +45,9 @@ TEST(Truffle, CompileDot) {
 
     chars.setall();
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
-    CharReach out = truffle2cr(mask1, mask2);
+    CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2);
 
     ASSERT_EQ(out, chars);
 
@@ -64,8 +64,8 @@ TEST(Truffle, CompileChars) {
         mask2 = zeroes128();
         chars.clear();
         chars.set((u8)c);
-        truffleBuildMasks(chars, &mask1, &mask2);
-        CharReach out = truffle2cr(mask1, mask2);
+        truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
+        CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2);
         ASSERT_EQ(out, chars);
     }
 
@@ -74,8 +74,8 @@ TEST(Truffle, CompileChars) {
         mask1 = zeroes128();
         mask2 = zeroes128();
         chars.set((u8)c);
-        truffleBuildMasks(chars, &mask1, &mask2);
-        CharReach out = truffle2cr(mask1, mask2);
+        truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
+        CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2);
         ASSERT_EQ(out, chars);
     }
 
@@ -84,8 +84,8 @@ TEST(Truffle, CompileChars) {
         mask1 = zeroes128();
         mask2 = zeroes128();
         chars.clear((u8)c);
-        truffleBuildMasks(chars, &mask1, &mask2);
-        CharReach out = truffle2cr(mask1, mask2);
+        truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
+        CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2);
         ASSERT_EQ(out, chars);
     }
 
@@ -100,7 +100,7 @@ TEST(Truffle, ExecNoMatch1) {
 
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\xff";
 
@@ -119,7 +119,7 @@ TEST(Truffle, ExecNoMatch2) {
     chars.set('a');
     chars.set('B');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -137,7 +137,7 @@ TEST(Truffle, ExecNoMatch3) {
 
     chars.set('V'); /* V = 0x56, e = 0x65 */
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 
@@ -154,7 +154,7 @@ TEST(Truffle, ExecMiniMatch0) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     char t1[] = "a";
 
@@ -169,7 +169,7 @@ TEST(Truffle, ExecMiniMatch1) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     char t1[] = "bbbbbbbabbb";
 
@@ -184,7 +184,7 @@ TEST(Truffle, ExecMiniMatch2) {
     CharReach chars;
     chars.set(0);
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     char t1[] = "bbbbbbb\0bbb";
 
@@ -199,7 +199,7 @@ TEST(Truffle, ExecMiniMatch3) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     char t1[] = "\0\0\0\0\0\0\0a\0\0\0";
 
@@ -214,7 +214,7 @@ TEST(Truffle, ExecMatchBig) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     std::array<u8, 400> t1;
     t1.fill('b');
@@ -234,7 +234,7 @@ TEST(Truffle, ExecMatch1) {
 
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -253,7 +253,7 @@ TEST(Truffle, ExecMatch2) {
 
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -273,7 +273,7 @@ TEST(Truffle, ExecMatch3) {
     chars.set('a');
     chars.set('B');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -295,7 +295,7 @@ TEST(Truffle, ExecMatch4) {
     chars.set('A');
     chars.set('c');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb";
@@ -329,7 +329,7 @@ TEST(Truffle, ExecMatch5) {
 
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
@@ -349,7 +349,7 @@ TEST(Truffle, ExecMatch6) {
     // [0-Z] - includes some graph chars
     chars.setRange('0', 'Z');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     std::array<u8, 128> t1;
     t1.fill('*'); // it's full of stars!
@@ -370,7 +370,7 @@ TEST(Truffle, ExecMatch7) {
     // hi bits
     chars.setRange(127, 255);
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     std::array<u8, 128> t1;
     t1.fill('*'); // it's full of stars!
@@ -389,7 +389,7 @@ TEST(ReverseTruffle, ExecNoMatch1) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
     size_t len = strlen(t1);
@@ -408,7 +408,7 @@ TEST(ReverseTruffle, ExecNoMatch2) {
     chars.set('a');
     chars.set('B');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
     size_t len = strlen(t1);
@@ -425,7 +425,7 @@ TEST(ReverseTruffle, ExecNoMatch3) {
     CharReach chars;
     chars.set('V'); /* V = 0x56, e = 0x65 */
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
     size_t len = strlen(t1);
@@ -442,7 +442,7 @@ TEST(ReverseTruffle, ExecMiniMatch0) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &lo, &hi);
+    truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi);
 
     char t1[] = "a";
 
@@ -457,7 +457,7 @@ TEST(ReverseTruffle, ExecMiniMatch1) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbabbbb";
@@ -475,7 +475,7 @@ TEST(ReverseTruffle, ExecMiniMatch2) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "babbbbbabbbb";
@@ -494,7 +494,7 @@ TEST(ReverseTruffle, ExecMatch1) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -514,7 +514,7 @@ TEST(ReverseTruffle, ExecMatch2) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbabbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -535,7 +535,7 @@ TEST(ReverseTruffle, ExecMatch3) {
     chars.set('a');
     chars.set('B');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaBbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -568,7 +568,7 @@ TEST(ReverseTruffle, ExecMatch4) {
     chars.set('A');
     chars.set('c');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     /*          0123456789012345678901234567890 */
     char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -602,7 +602,7 @@ TEST(ReverseTruffle, ExecMatch5) {
     CharReach chars;
     chars.set('a');
 
-    truffleBuildMasks(chars, &mask1, &mask2);
+    truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2);
 
     char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
     size_t len = strlen(t1);