github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Convert compile-time code to not require SIMD

Browse Source
This commit is contained in:
Matthew Barr 2016-10-06 15:33:24 +11:00
parent e993fe1eb0
commit 2214296b7f
25 changed files with 254 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -210,10 +210,12 @@ else()
if (NOT CMAKE_C_FLAGS MATCHES .*march.*) if (NOT CMAKE_C_FLAGS MATCHES .*march.*)
message(STATUS "Building for current host CPU") 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() endif()
# we don't use these for the lib, but other tools/unit tests
if (NOT CMAKE_CXX_FLAGS MATCHES .*march.*) 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() endif()
if(CMAKE_COMPILER_IS_GNUCC) if(CMAKE_COMPILER_IS_GNUCC)
@ -389,7 +391,7 @@ if (NOT WIN32)
endif() endif()
# only set these after all tests are done # 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}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}")

5
src/hwlm/hwlm_build.cpp
View File

@ -461,7 +461,8 @@ void findForwardAccelScheme(const vector<hwlmLiteral> &lits,
} }
const CharReach &cr = reach[min_offset]; 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", DEBUG_PRINTF("built shufti for %s (%zu chars, offset %u)\n",
describeClass(cr).c_str(), cr.count(), min_offset); describeClass(cr).c_str(), cr.count(), min_offset);
aux->shufti.accel_type = ACCEL_SHUFTI; aux->shufti.accel_type = ACCEL_SHUFTI;
@ -469,7 +470,7 @@ void findForwardAccelScheme(const vector<hwlmLiteral> &lits,
return; 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", DEBUG_PRINTF("built truffle for %s (%zu chars, offset %u)\n",
describeClass(cr).c_str(), cr.count(), min_offset); describeClass(cr).c_str(), cr.count(), min_offset);
aux->truffle.accel_type = ACCEL_TRUFFLE; aux->truffle.accel_type = ACCEL_TRUFFLE;

13
src/nfa/accel_dfa_build_strat.cpp
View File

@ -473,9 +473,10 @@ accel_dfa_build_strat::buildAccel(UNUSED dstate_id_t this_idx,
} }
if (double_byte_ok(info) && if (double_byte_ok(info) &&
shuftiBuildDoubleMasks(info.double_cr, info.double_byte, shuftiBuildDoubleMasks(
&accel->dshufti.lo1, &accel->dshufti.hi1, info.double_cr, info.double_byte, (u8 *)&accel->dshufti.lo1,
&accel->dshufti.lo2, &accel->dshufti.hi2)) { (u8 *)&accel->dshufti.hi1, (u8 *)&accel->dshufti.lo2,
(u8 *)&accel->dshufti.hi2)) {
accel->accel_type = ACCEL_DSHUFTI; accel->accel_type = ACCEL_DSHUFTI;
accel->dshufti.offset = verify_u8(info.double_offset); accel->dshufti.offset = verify_u8(info.double_offset);
DEBUG_PRINTF("state %hu is double shufti\n", this_idx); 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; 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); DEBUG_PRINTF("state %hu is shufti\n", this_idx);
return; return;
} }
assert(!info.cr.none()); assert(!info.cr.none());
accel->accel_type = ACCEL_TRUFFLE; 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); DEBUG_PRINTF("state %hu is truffle\n", this_idx);
} }

88
src/nfa/accel_dump.cpp
View File

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

63
src/nfa/accelcompile.cpp
View File

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

6
src/nfa/castle_dump.cpp
View File

@ -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); fprintf(f, "negated verm, scanning for 0x%02x\n", c->u.verm.c);
break; break;
case CASTLE_SHUFTI: { 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", fprintf(f, "shufti, scanning for %s (%zu chars)\n",
describeClass(cr).c_str(), cr.count()); describeClass(cr).c_str(), cr.count());
break; break;
} }
case CASTLE_TRUFFLE: { 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", fprintf(f, "truffle, scanning for %s (%zu chars)\n",
describeClass(cr).c_str(), cr.count()); describeClass(cr).c_str(), cr.count());
break; break;

6
src/nfa/castlecompile.cpp
View File

@ -100,13 +100,15 @@ void writeCastleScanEngine(const CharReach &cr, Castle *c) {
return; 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; c->type = CASTLE_SHUFTI;
return; return;
} }
c->type = CASTLE_TRUFFLE; 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 static

6
src/nfa/lbr_dump.cpp
View File

@ -116,7 +116,8 @@ void nfaExecLbrShuf_dump(const NFA *nfa, const string &base) {
const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa); const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa);
lbrDumpCommon(&ls->common, f); 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", fprintf(f, "SHUF model, scanning for: %s (%zu chars)\n",
describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count()); describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count());
fprintf(f, "\n"); 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); const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa);
lbrDumpCommon(&lt->common, f); 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", fprintf(f, "TRUFFLE model, scanning for: %s (%zu chars)\n",
describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count()); describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count());
fprintf(f, "\n"); fprintf(f, "\n");

2
src/nfa/mcsheng_compile.cpp
View File

@ -193,7 +193,7 @@ void createShuffleMasks(mcsheng *m, const dfa_info &info,
} }
for (u32 i = 0; i < N_CHARS; i++) { for (u32 i = 0; i < N_CHARS; i++) {
assert(info.alpha_remap[i] != info.alpha_remap[TOP]); 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_end = sheng_end;
m->sheng_accel_limit = sheng_end - 1; m->sheng_accel_limit = sheng_end - 1;

2
src/nfa/mcsheng_internal.h
View File

@ -31,7 +31,7 @@
#include "nfa_internal.h" #include "nfa_internal.h"
#include "ue2common.h" #include "ue2common.h"
#include "util/simd_utils.h" #include "util/simd_types.h"
#define ACCEPT_FLAG 0x8000 #define ACCEPT_FLAG 0x8000
#define ACCEL_FLAG 0x4000 #define ACCEL_FLAG 0x4000

7
src/nfa/mpvcompile.cpp
View File

@ -175,12 +175,13 @@ void writeKiloPuff(const map<ClusterKey, vector<raw_puff>>::const_iterator &it,
size_t set = reach.find_first(); size_t set = reach.find_first();
assert(set != CharReach::npos); assert(set != CharReach::npos);
kp->u.verm.c = (char)set; kp->u.verm.c = (char)set;
} else if (shuftiBuildMasks(~reach, &kp->u.shuf.mask_lo, } else if (shuftiBuildMasks(~reach, (u8 *)&kp->u.shuf.mask_lo,
&kp->u.shuf.mask_hi) != -1) { (u8 *)&kp->u.shuf.mask_hi) != -1) {
kp->type = MPV_SHUFTI; kp->type = MPV_SHUFTI;
} else { } else {
kp->type = MPV_TRUFFLE; 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()); kp->count = verify_u32(puffs.size());

4
src/nfa/multishufti.h
View File

@ -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 * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
@ -36,7 +36,7 @@
#define MULTISHUFTI_H #define MULTISHUFTI_H
#include "ue2common.h" #include "ue2common.h"
#include "util/simd_utils.h" #include "util/simd_types.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"

2
src/nfa/sheng_internal.h
View File

@ -30,7 +30,7 @@
#define SHENG_INTERNAL_H_ #define SHENG_INTERNAL_H_
#include "ue2common.h" #include "ue2common.h"
#include "util/simd_utils.h" #include "util/simd_types.h"
#define SHENG_STATE_ACCEPT 0x10 #define SHENG_STATE_ACCEPT 0x10
#define SHENG_STATE_DEAD 0x20 #define SHENG_STATE_DEAD 0x20

5
src/nfa/shengcompile.cpp
View File

@ -48,7 +48,7 @@
#include "util/compile_context.h" #include "util/compile_context.h"
#include "util/make_unique.h" #include "util/make_unique.h"
#include "util/verify_types.h" #include "util/verify_types.h"
#include "util/simd_utils.h" #include "util/simd_types.h"
#include <map> #include <map>
#include <vector> #include <vector>
@ -442,8 +442,7 @@ void createShuffleMasks(sheng *s, dfa_info &info,
#ifdef DEBUG #ifdef DEBUG
dumpShuffleMask(chr, buf, sizeof(buf)); dumpShuffleMask(chr, buf, sizeof(buf));
#endif #endif
m128 mask = loadu128(buf); memcpy(&s->shuffle_masks[chr], buf, sizeof(m128));
s->shuffle_masks[chr] = mask;
} }
} }

6
src/nfa/shengdump.cpp
View File

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

8
src/nfa/shufticompile.cpp
View File

@ -51,7 +51,7 @@ namespace ue2 {
* *
* Note: always able to construct masks for 8 or fewer characters. * 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 /* Things could be packed much more optimally, but this should be able to
* handle any set of characters entirely in the lower half. */ * 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, bool shuftiBuildDoubleMasks(const CharReach &onechar,
const flat_set<pair<u8, u8>> &twochar, 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(), DEBUG_PRINTF("unibytes %zu dibytes %zu\n", onechar.size(),
twochar.size()); twochar.size());
array<u8, 16> lo1_a; array<u8, 16> lo1_a;
@ -210,9 +210,7 @@ bool shuftiBuildDoubleMasks(const CharReach &onechar,
#ifdef DUMP_SUPPORT #ifdef DUMP_SUPPORT
CharReach shufti2cr(const m128 lo_in, const m128 hi_in) { CharReach shufti2cr(const u8 *lo, const u8 *hi) {
const u8 *lo = (const u8 *)&lo_in;
const u8 *hi = (const u8 *)&hi_in;
CharReach cr; CharReach cr;
for (u32 i = 0; i < 256; i++) { for (u32 i = 0; i < 256; i++) {
if (lo[(u8)i & 0xf] & hi[(u8)i >> 4]) { if (lo[(u8)i & 0xf] & hi[(u8)i >> 4]) {

6
src/nfa/shufticompile.h
View File

@ -48,7 +48,7 @@ namespace ue2 {
* *
* Note: always able to construct masks for 8 or fewer characters. * 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 /** \brief Double-byte variant
* *
@ -56,7 +56,7 @@ int shuftiBuildMasks(const CharReach &chars, m128 *lo, m128 *hi);
*/ */
bool shuftiBuildDoubleMasks(const CharReach &onechar, bool shuftiBuildDoubleMasks(const CharReach &onechar,
const flat_set<std::pair<u8, u8>> &twochar, 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 #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 * \brief Dump code: returns a CharReach with the reach that would match this
* shufti. * shufti.
*/ */
CharReach shufti2cr(const m128 lo, const m128 hi); CharReach shufti2cr(const u8 *lo, const u8 *hi);
#endif // DUMP_SUPPORT #endif // DUMP_SUPPORT

24
src/nfa/trufflecompile.cpp
View File

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

6
src/nfa/trufflecompile.h
View File

@ -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 * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
@ -34,8 +34,8 @@
namespace ue2 { namespace ue2 {
void truffleBuildMasks(const CharReach &cr, m128 *mask1, m128 *mask2); void truffleBuildMasks(const CharReach &cr, u8 *mask1, u8 *mask2);
CharReach truffle2cr(const m128 lo_in, const m128 hi_in); CharReach truffle2cr(const u8 *lo_in, const u8 *hi_in);
} }

4
src/nfagraph/ng_lbr.cpp
View File

@ -224,7 +224,7 @@ aligned_unique_ptr<NFA> buildLbrShuf(const CharReach &cr,
fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax, fillNfa<lbr_shuf>(nfa.get(), &ls->common, report, repeatMin, repeatMax,
minPeriod, rtype); 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; return nullptr;
} }
@ -245,7 +245,7 @@ aligned_unique_ptr<NFA> buildLbrTruf(const CharReach &cr,
fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax, fillNfa<lbr_truf>(nfa.get(), &lc->common, report, repeatMin, repeatMax,
minPeriod, rtype); minPeriod, rtype);
truffleBuildMasks(~cr, &lc->mask1, &lc->mask2); truffleBuildMasks(~cr, (u8 *)&lc->mask1, (u8 *)&lc->mask2);
DEBUG_PRINTF("built truffle lbr\n"); DEBUG_PRINTF("built truffle lbr\n");
return nfa; return nfa;

2
src/rose/rose_build_bytecode.cpp
View File

@ -2010,7 +2010,7 @@ void buildCountingMiracles(build_context &bc) {
rcm.c = cr.find_first(); rcm.c = cr.find_first();
} else { } else {
rcm.shufti = 1; rcm.shufti = 1;
int rv = shuftiBuildMasks(cr, &rcm.lo, &rcm.hi); int rv = shuftiBuildMasks(cr, (u8 *)&rcm.lo, (u8 *)&rcm.hi);
if (rv == -1) { if (rv == -1) {
DEBUG_PRINTF("failed to build shufti\n"); DEBUG_PRINTF("failed to build shufti\n");
lbi.countingMiracleCount = 0; /* remove counting miracle */ lbi.countingMiracleCount = 0; /* remove counting miracle */

4
src/util/simd_types.h
View File

@ -62,6 +62,10 @@
#endif #endif
typedef __m128i m128; typedef __m128i m128;
#else
typedef struct ALIGN_DIRECTIVE {u64a hi; u64a lo;} m128;
#endif
#if defined(__AVX2__) #if defined(__AVX2__)
typedef __m256i m256; typedef __m256i m256;
#else #else

2
unit/CMakeLists.txt
View File

@ -1,5 +1,5 @@
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}") 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) set(gtest_SOURCES gtest/gtest-all.cc gtest/gtest.h)
if(NOT XCODE) if(NOT XCODE)

117
unit/internal/shufti.cpp
View File

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

70
unit/internal/truffle.cpp
View File

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