From 2214296b7f4302bf1f81d1e25c2b1f3fa250222f Mon Sep 17 00:00:00 2001 From: Matthew Barr Date: Thu, 6 Oct 2016 15:33:24 +1100 Subject: [PATCH] Convert compile-time code to not require SIMD --- CMakeLists.txt | 8 +- src/hwlm/hwlm_build.cpp | 5 +- src/nfa/accel_dfa_build_strat.cpp | 13 ++-- src/nfa/accel_dump.cpp | 88 +++++++++++++--------- src/nfa/accelcompile.cpp | 63 ++++++++-------- src/nfa/castle_dump.cpp | 6 +- src/nfa/castlecompile.cpp | 6 +- src/nfa/lbr_dump.cpp | 6 +- src/nfa/mcsheng_compile.cpp | 2 +- src/nfa/mcsheng_internal.h | 2 +- src/nfa/mpvcompile.cpp | 7 +- src/nfa/multishufti.h | 4 +- src/nfa/sheng_internal.h | 2 +- src/nfa/shengcompile.cpp | 5 +- src/nfa/shengdump.cpp | 6 +- src/nfa/shufticompile.cpp | 8 +- src/nfa/shufticompile.h | 6 +- src/nfa/trufflecompile.cpp | 24 +++--- src/nfa/trufflecompile.h | 6 +- src/nfagraph/ng_lbr.cpp | 4 +- src/rose/rose_build_bytecode.cpp | 2 +- src/util/simd_types.h | 4 + unit/CMakeLists.txt | 2 +- unit/internal/shufti.cpp | 117 +++++++++++++++++------------- unit/internal/truffle.cpp | 70 +++++++++--------- 25 files changed, 254 insertions(+), 212 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 98804923..0559932d 100644 --- 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 3ab10f23..fa6335c9 100644 --- a/src/hwlm/hwlm_build.cpp +++ b/src/hwlm/hwlm_build.cpp @@ -461,7 +461,8 @@ void findForwardAccelScheme(const vector &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 &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 70d2d103..d257b530 100644 --- 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 6e2b8f41..e99e71a5 100644 --- 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 #include @@ -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 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 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 crs(8); for (u32 i = 0; i < 256; i++) { u32 combined = lo[(u8)i & 0xf] & hi[(u8)i >> 4]; @@ -169,10 +173,10 @@ vector 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 cr1 = shufti2cr_array(not128(lo1), not128(hi1)); - vector cr2 = shufti2cr_array(not128(lo2), not128(hi2)); +void dumpDShuftiCharReach(FILE *f, const u8 *lo1, const u8 *hi1, + const u8 *lo2, const u8 *hi2) { + vector cr1 = dshufti2cr_array(lo1, hi1); + vector cr2 = dshufti2cr_array(lo2, hi2); map > 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 75960dda..32e569ba 100644 --- 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 9426b6db..1514ca8c 100644 --- 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 4f3bcf2e..3b40ab9a 100644 --- 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 92cf7e03..0948e122 100644 --- 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(<->common, f); - CharReach cr = truffle2cr(lt->mask1, lt->mask2); + CharReach cr = truffle2cr((const u8 *)<->mask1, + (const u8 *)<->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 bc12cc5c..b7570af4 100644 --- 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 5ced6f76..81a658e0 100644 --- 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 908267be..87fb462e 100644 --- a/src/nfa/mpvcompile.cpp +++ b/src/nfa/mpvcompile.cpp @@ -175,12 +175,13 @@ void writeKiloPuff(const map>::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 bcccf607..af578483 100644 --- 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 046eb759..ff843ebe 100644 --- 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 a02a9b96..53f2c131 100644 --- 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 #include @@ -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 c2371601..ce87beaf 100644 --- 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 217fcee0..12a94b7b 100644 --- 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> &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 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 59126b0b..a72904e0 100644 --- 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> &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 6bde7abb..9442d046 100644 --- 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 19d3eb54..14b314f3 100644 --- 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 d68c7681..d832bdaa 100644 --- a/src/nfagraph/ng_lbr.cpp +++ b/src/nfagraph/ng_lbr.cpp @@ -224,7 +224,7 @@ aligned_unique_ptr buildLbrShuf(const CharReach &cr, fillNfa(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 buildLbrTruf(const CharReach &cr, fillNfa(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 3d89f87a..9f4abcad 100644 --- 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 e4541411..35f27e66 100644 --- 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 17818cac..77f3ac3b 100644 --- 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 67ceadc5..06407c41 100644 --- 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 859c8a08..e9e4f19c 100644 --- 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 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 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 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);