diff --git a/CMakeLists.txt b/CMakeLists.txt index 54e5c9f7..714168d8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -437,6 +437,13 @@ set (hs_exec_SRCS src/nfa/mpv.h src/nfa/mpv.c src/nfa/mpv_internal.h + src/nfa/multiaccel_common.h + src/nfa/multiaccel_doubleshift.h + src/nfa/multiaccel_doubleshiftgrab.h + src/nfa/multiaccel_long.h + src/nfa/multiaccel_longgrab.h + src/nfa/multiaccel_shift.h + src/nfa/multiaccel_shiftgrab.h src/nfa/nfa_api.h src/nfa/nfa_api_dispatch.c src/nfa/nfa_internal.h diff --git a/src/nfa/multiaccel_common.h b/src/nfa/multiaccel_common.h new file mode 100644 index 00000000..1a13c3b6 --- /dev/null +++ b/src/nfa/multiaccel_common.h @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_COMMON_H_ +#define MULTIACCEL_COMMON_H_ + +#include "config.h" +#include "ue2common.h" +#include "util/join.h" +#include "util/bitutils.h" + +/* + * When doing shifting, remember that the total number of shifts should be n-1 + */ +#define VARISHIFT(src, dst, len) \ + do { \ + (dst) &= (src) >> (len); \ + } while (0) +#define STATIC_SHIFT1(x) \ + do { \ + (x) &= (x) >> 1; \ + } while (0) +#define STATIC_SHIFT2(x) \ + do { \ + (x) &= (x) >> 2;\ + } while (0) +#define STATIC_SHIFT4(x) \ + do { \ + (x) &= (x) >> 4; \ + } while (0) +#define STATIC_SHIFT8(x) \ + do { \ + (x) &= (x) >> 8; \ + } while (0) +#define SHIFT1(x) \ + do {} while (0) +#define SHIFT2(x) \ + do { \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT3(x) \ + do { \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT4(x) \ + do { \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT5(x) \ + do { \ + SHIFT4(x); \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT6(x) \ + do { \ + SHIFT4(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT7(x) \ + do { \ + SHIFT4(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT8(x) \ + do { \ + SHIFT4(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT9(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT10(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT11(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT12(x); \ + do { \ + SHIFT8(x);\ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT13(x); \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT14(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT15(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT16(x) \ + do { \ + SHIFT8(x); \ + STATIC_SHIFT8(x); \ + } while (0) +#define SHIFT17(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT18(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT19(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT20(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT21(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT22(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT23(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT24(x) \ + do { \ + SHIFT16(x); \ + STATIC_SHIFT8(x); \ + } while (0) +#define SHIFT25(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT1(x); \ + } while (0) +#define SHIFT26(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT27(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + } while (0) +#define SHIFT28(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT29(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT30(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT31(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT1(x); \ + STATIC_SHIFT2(x); \ + STATIC_SHIFT4(x); \ + } while (0) +#define SHIFT32(x) \ + do { \ + SHIFT24(x); \ + STATIC_SHIFT8(x); \ + } while (0) + +/* + * this function is used by 32-bit multiaccel matchers. 32-bit matchers accept + * a 32-bit integer as a buffer, where low 16 bits is movemask result and + * high 16 bits are "don't care" values. this function is not expected to return + * a result higher than 16. + */ +static really_inline +const u8 *match32(const u8 *buf, const u32 z) { + if (unlikely(z != 0)) { + u32 pos = ctz32(z); + assert(pos < 16); + return buf + pos; + } + return NULL; +} + +/* + * this function is used by 64-bit multiaccel matchers. 64-bit matchers accept + * a 64-bit integer as a buffer, where low 32 bits is movemask result and + * high 32 bits are "don't care" values. this function is not expected to return + * a result higher than 32. + */ +static really_inline +const u8 *match64(const u8 *buf, const u64a z) { + if (unlikely(z != 0)) { + u32 pos = ctz64(z); + assert(pos < 32); + return buf + pos; + } + return NULL; +} + +#endif /* MULTIACCEL_COMMON_H_ */ diff --git a/src/nfa/multiaccel_doubleshift.h b/src/nfa/multiaccel_doubleshift.h new file mode 100644 index 00000000..7ed7534c --- /dev/null +++ b/src/nfa/multiaccel_doubleshift.h @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_DOUBLESHIFT_H_ +#define MULTIACCEL_DOUBLESHIFT_H_ + +#include "multiaccel_common.h" + +#define DOUBLESHIFT_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(doubleshiftMatch_, match_sz, _, len)(const u8 *buf, match_t z, u32 len2) {\ + if (unlikely(z)) { \ + match_t tmp = z; \ + z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \ + tmp |= ((match_t) (1 << (len + len2)) - 1) << (match_sz / 2); \ + VARISHIFT(z, z, len); \ + VARISHIFT(tmp, tmp, len2); \ + VARISHIFT(tmp, z, len); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define DOUBLESHIFT_MATCH_32_DEF(n) \ + DOUBLESHIFT_MATCH(n, u32, 32) +#define DOUBLESHIFT_MATCH_64_DEF(n) \ + DOUBLESHIFT_MATCH(n, u64a, 64) +#define DOUBLESHIFT_MATCH_DEF(n) \ + DOUBLESHIFT_MATCH_32_DEF(n) \ + DOUBLESHIFT_MATCH_64_DEF(n) + +DOUBLESHIFT_MATCH_DEF(1) +DOUBLESHIFT_MATCH_DEF(2) +DOUBLESHIFT_MATCH_DEF(3) +DOUBLESHIFT_MATCH_DEF(4) +DOUBLESHIFT_MATCH_DEF(5) +DOUBLESHIFT_MATCH_DEF(6) +DOUBLESHIFT_MATCH_DEF(7) +DOUBLESHIFT_MATCH_DEF(8) +DOUBLESHIFT_MATCH_DEF(9) +DOUBLESHIFT_MATCH_DEF(10) +DOUBLESHIFT_MATCH_DEF(11) +DOUBLESHIFT_MATCH_DEF(12) +DOUBLESHIFT_MATCH_DEF(13) +DOUBLESHIFT_MATCH_DEF(14) +DOUBLESHIFT_MATCH_DEF(15) +DOUBLESHIFT_MATCH_64_DEF(16) +DOUBLESHIFT_MATCH_64_DEF(17) +DOUBLESHIFT_MATCH_64_DEF(18) +DOUBLESHIFT_MATCH_64_DEF(19) +DOUBLESHIFT_MATCH_64_DEF(20) +DOUBLESHIFT_MATCH_64_DEF(21) +DOUBLESHIFT_MATCH_64_DEF(22) +DOUBLESHIFT_MATCH_64_DEF(23) +DOUBLESHIFT_MATCH_64_DEF(24) +DOUBLESHIFT_MATCH_64_DEF(25) +DOUBLESHIFT_MATCH_64_DEF(26) +DOUBLESHIFT_MATCH_64_DEF(27) +DOUBLESHIFT_MATCH_64_DEF(28) +DOUBLESHIFT_MATCH_64_DEF(29) +DOUBLESHIFT_MATCH_64_DEF(30) +DOUBLESHIFT_MATCH_64_DEF(31) + +static +const UNUSED u8 * (*doubleshift_match_funcs_32[])(const u8 *buf, u32 z, u32 len2) = +{ +// skip the first + 0, + &doubleshiftMatch_32_1, + &doubleshiftMatch_32_2, + &doubleshiftMatch_32_3, + &doubleshiftMatch_32_4, + &doubleshiftMatch_32_5, + &doubleshiftMatch_32_6, + &doubleshiftMatch_32_7, + &doubleshiftMatch_32_8, + &doubleshiftMatch_32_9, + &doubleshiftMatch_32_10, + &doubleshiftMatch_32_11, + &doubleshiftMatch_32_12, + &doubleshiftMatch_32_13, + &doubleshiftMatch_32_14, + &doubleshiftMatch_32_15, +}; + +static +const UNUSED u8 * (*doubleshift_match_funcs_64[])(const u8 *buf, u64a z, u32 len2) = +{ +// skip the first + 0, + &doubleshiftMatch_64_1, + &doubleshiftMatch_64_2, + &doubleshiftMatch_64_3, + &doubleshiftMatch_64_4, + &doubleshiftMatch_64_5, + &doubleshiftMatch_64_6, + &doubleshiftMatch_64_7, + &doubleshiftMatch_64_8, + &doubleshiftMatch_64_9, + &doubleshiftMatch_64_10, + &doubleshiftMatch_64_11, + &doubleshiftMatch_64_12, + &doubleshiftMatch_64_13, + &doubleshiftMatch_64_14, + &doubleshiftMatch_64_15, + &doubleshiftMatch_64_16, + &doubleshiftMatch_64_17, + &doubleshiftMatch_64_18, + &doubleshiftMatch_64_19, + &doubleshiftMatch_64_20, + &doubleshiftMatch_64_21, + &doubleshiftMatch_64_22, + &doubleshiftMatch_64_23, + &doubleshiftMatch_64_24, + &doubleshiftMatch_64_25, + &doubleshiftMatch_64_26, + &doubleshiftMatch_64_27, + &doubleshiftMatch_64_28, + &doubleshiftMatch_64_29, + &doubleshiftMatch_64_30, + &doubleshiftMatch_64_31, +}; + +#endif /* MULTIACCEL_DOUBLESHIFT_H_ */ diff --git a/src/nfa/multiaccel_doubleshiftgrab.h b/src/nfa/multiaccel_doubleshiftgrab.h new file mode 100644 index 00000000..51955b4a --- /dev/null +++ b/src/nfa/multiaccel_doubleshiftgrab.h @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_DOUBLESHIFTGRAB_H_ +#define MULTIACCEL_DOUBLESHIFTGRAB_H_ + +#include "multiaccel_common.h" + +#define DOUBLESHIFTGRAB_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(doubleshiftgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z, u32 len2) {\ + if (unlikely(z)) { \ + match_t neg = ~z; \ + match_t tmp = z; \ + z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \ + tmp |= ((match_t) (1 << (len + len2)) - 1) << (match_sz / 2); \ + neg |= ((match_t) (1 << len) - 1) << (match_sz / 2); \ + VARISHIFT(z, z, len); \ + VARISHIFT(tmp, tmp, len2); \ + VARISHIFT(neg, z, 1); \ + VARISHIFT(tmp, z, len); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define DOUBLESHIFTGRAB_MATCH_32_DEF(n) \ + DOUBLESHIFTGRAB_MATCH(n, u32, 32) +#define DOUBLESHIFTGRAB_MATCH_64_DEF(n) \ + DOUBLESHIFTGRAB_MATCH(n, u64a, 64) +#define DOUBLESHIFTGRAB_MATCH_DEF(n) \ + DOUBLESHIFTGRAB_MATCH_32_DEF(n) \ + DOUBLESHIFTGRAB_MATCH_64_DEF(n) + +DOUBLESHIFTGRAB_MATCH_DEF(1) +DOUBLESHIFTGRAB_MATCH_DEF(2) +DOUBLESHIFTGRAB_MATCH_DEF(3) +DOUBLESHIFTGRAB_MATCH_DEF(4) +DOUBLESHIFTGRAB_MATCH_DEF(5) +DOUBLESHIFTGRAB_MATCH_DEF(6) +DOUBLESHIFTGRAB_MATCH_DEF(7) +DOUBLESHIFTGRAB_MATCH_DEF(8) +DOUBLESHIFTGRAB_MATCH_DEF(9) +DOUBLESHIFTGRAB_MATCH_DEF(10) +DOUBLESHIFTGRAB_MATCH_DEF(11) +DOUBLESHIFTGRAB_MATCH_DEF(12) +DOUBLESHIFTGRAB_MATCH_DEF(13) +DOUBLESHIFTGRAB_MATCH_DEF(14) +DOUBLESHIFTGRAB_MATCH_DEF(15) +DOUBLESHIFTGRAB_MATCH_64_DEF(16) +DOUBLESHIFTGRAB_MATCH_64_DEF(17) +DOUBLESHIFTGRAB_MATCH_64_DEF(18) +DOUBLESHIFTGRAB_MATCH_64_DEF(19) +DOUBLESHIFTGRAB_MATCH_64_DEF(20) +DOUBLESHIFTGRAB_MATCH_64_DEF(21) +DOUBLESHIFTGRAB_MATCH_64_DEF(22) +DOUBLESHIFTGRAB_MATCH_64_DEF(23) +DOUBLESHIFTGRAB_MATCH_64_DEF(24) +DOUBLESHIFTGRAB_MATCH_64_DEF(25) +DOUBLESHIFTGRAB_MATCH_64_DEF(26) +DOUBLESHIFTGRAB_MATCH_64_DEF(27) +DOUBLESHIFTGRAB_MATCH_64_DEF(28) +DOUBLESHIFTGRAB_MATCH_64_DEF(29) +DOUBLESHIFTGRAB_MATCH_64_DEF(30) +DOUBLESHIFTGRAB_MATCH_64_DEF(31) + +static +const UNUSED u8 * (*doubleshiftgrab_match_funcs_32[])(const u8 *buf, u32 z, u32 len2) = +{ +// skip the first + 0, + &doubleshiftgrabMatch_32_1, + &doubleshiftgrabMatch_32_2, + &doubleshiftgrabMatch_32_3, + &doubleshiftgrabMatch_32_4, + &doubleshiftgrabMatch_32_5, + &doubleshiftgrabMatch_32_6, + &doubleshiftgrabMatch_32_7, + &doubleshiftgrabMatch_32_8, + &doubleshiftgrabMatch_32_9, + &doubleshiftgrabMatch_32_10, + &doubleshiftgrabMatch_32_11, + &doubleshiftgrabMatch_32_12, + &doubleshiftgrabMatch_32_13, + &doubleshiftgrabMatch_32_14, + &doubleshiftgrabMatch_32_15, +}; + +static +const UNUSED u8 * (*doubleshiftgrab_match_funcs_64[])(const u8 *buf, u64a z, u32 len2) = +{ +// skip the first + 0, + &doubleshiftgrabMatch_64_1, + &doubleshiftgrabMatch_64_2, + &doubleshiftgrabMatch_64_3, + &doubleshiftgrabMatch_64_4, + &doubleshiftgrabMatch_64_5, + &doubleshiftgrabMatch_64_6, + &doubleshiftgrabMatch_64_7, + &doubleshiftgrabMatch_64_8, + &doubleshiftgrabMatch_64_9, + &doubleshiftgrabMatch_64_10, + &doubleshiftgrabMatch_64_11, + &doubleshiftgrabMatch_64_12, + &doubleshiftgrabMatch_64_13, + &doubleshiftgrabMatch_64_14, + &doubleshiftgrabMatch_64_15, + &doubleshiftgrabMatch_64_16, + &doubleshiftgrabMatch_64_17, + &doubleshiftgrabMatch_64_18, + &doubleshiftgrabMatch_64_19, + &doubleshiftgrabMatch_64_20, + &doubleshiftgrabMatch_64_21, + &doubleshiftgrabMatch_64_22, + &doubleshiftgrabMatch_64_23, + &doubleshiftgrabMatch_64_24, + &doubleshiftgrabMatch_64_25, + &doubleshiftgrabMatch_64_26, + &doubleshiftgrabMatch_64_27, + &doubleshiftgrabMatch_64_28, + &doubleshiftgrabMatch_64_29, + &doubleshiftgrabMatch_64_30, + &doubleshiftgrabMatch_64_31, +}; + +#endif /* MULTIACCEL_DOUBLESHIFTGRAB_H_ */ diff --git a/src/nfa/multiaccel_long.h b/src/nfa/multiaccel_long.h new file mode 100644 index 00000000..515f0bc2 --- /dev/null +++ b/src/nfa/multiaccel_long.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_LONG_H_ +#define MULTIACCEL_LONG_H_ + +#include "multiaccel_common.h" + +#define LONG_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(longMatch_, match_sz, _, len)(const u8 *buf, match_t z) { \ + if (unlikely(z)) { \ + z |= ((match_t) (1 << (len - 1)) - 1) << (match_sz / 2); \ + JOIN(SHIFT, len)(z); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define LONG_MATCH_32_DEF(n) \ + LONG_MATCH(n, u32, 32) +#define LONG_MATCH_64_DEF(n) \ + LONG_MATCH(n, u64a, 64) +#define LONG_MATCH_DEF(n) \ + LONG_MATCH_32_DEF(n) \ + LONG_MATCH_64_DEF(n) + +LONG_MATCH_DEF(1) +LONG_MATCH_DEF(2) +LONG_MATCH_DEF(3) +LONG_MATCH_DEF(4) +LONG_MATCH_DEF(5) +LONG_MATCH_DEF(6) +LONG_MATCH_DEF(7) +LONG_MATCH_DEF(8) +LONG_MATCH_DEF(9) +LONG_MATCH_DEF(10) +LONG_MATCH_DEF(11) +LONG_MATCH_DEF(12) +LONG_MATCH_DEF(13) +LONG_MATCH_DEF(14) +LONG_MATCH_DEF(15) +LONG_MATCH_64_DEF(16) +LONG_MATCH_64_DEF(17) +LONG_MATCH_64_DEF(18) +LONG_MATCH_64_DEF(19) +LONG_MATCH_64_DEF(20) +LONG_MATCH_64_DEF(21) +LONG_MATCH_64_DEF(22) +LONG_MATCH_64_DEF(23) +LONG_MATCH_64_DEF(24) +LONG_MATCH_64_DEF(25) +LONG_MATCH_64_DEF(26) +LONG_MATCH_64_DEF(27) +LONG_MATCH_64_DEF(28) +LONG_MATCH_64_DEF(29) +LONG_MATCH_64_DEF(30) +LONG_MATCH_64_DEF(31) + +static +const UNUSED u8 *(*long_match_funcs_32[])(const u8 *buf, u32 z) = +{ + // skip the first three + 0, + &longMatch_32_1, + &longMatch_32_2, + &longMatch_32_3, + &longMatch_32_4, + &longMatch_32_5, + &longMatch_32_6, + &longMatch_32_7, + &longMatch_32_8, + &longMatch_32_9, + &longMatch_32_10, + &longMatch_32_11, + &longMatch_32_12, + &longMatch_32_13, + &longMatch_32_14, + &longMatch_32_15, + }; + +static +const UNUSED u8 *(*long_match_funcs_64[])(const u8 *buf, u64a z) = +{ +// skip the first three + 0, + &longMatch_64_1, + &longMatch_64_2, + &longMatch_64_3, + &longMatch_64_4, + &longMatch_64_5, + &longMatch_64_6, + &longMatch_64_7, + &longMatch_64_8, + &longMatch_64_9, + &longMatch_64_10, + &longMatch_64_11, + &longMatch_64_12, + &longMatch_64_13, + &longMatch_64_14, + &longMatch_64_15, + &longMatch_64_16, + &longMatch_64_17, + &longMatch_64_18, + &longMatch_64_19, + &longMatch_64_20, + &longMatch_64_21, + &longMatch_64_22, + &longMatch_64_23, + &longMatch_64_24, + &longMatch_64_25, + &longMatch_64_26, + &longMatch_64_27, + &longMatch_64_28, + &longMatch_64_29, + &longMatch_64_30, + &longMatch_64_31, +}; + +#endif /* MULTIACCEL_LONG_H_ */ diff --git a/src/nfa/multiaccel_longgrab.h b/src/nfa/multiaccel_longgrab.h new file mode 100644 index 00000000..09daaf82 --- /dev/null +++ b/src/nfa/multiaccel_longgrab.h @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_LONGGRAB_H_ +#define MULTIACCEL_LONGGRAB_H_ + +#include "multiaccel_common.h" + +#define LONGGRAB_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(longgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z) { \ + if (unlikely(z)) { \ + match_t tmp = ~z; \ + tmp |= ((match_t) (1 << len) - 1) << (match_sz / 2); \ + z |= ((match_t) (1 << (len - 1)) - 1) << (match_sz / 2); \ + JOIN(SHIFT, len)(z); \ + VARISHIFT(tmp, z, len); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define LONGGRAB_MATCH_32_DEF(n) \ + LONGGRAB_MATCH(n, u32, 32) +#define LONGGRAB_MATCH_64_DEF(n) \ + LONGGRAB_MATCH(n, u64a, 64) +#define LONGGRAB_MATCH_DEF(n) \ + LONGGRAB_MATCH_32_DEF(n) \ + LONGGRAB_MATCH_64_DEF(n) + +LONGGRAB_MATCH_DEF(1) +LONGGRAB_MATCH_DEF(2) +LONGGRAB_MATCH_DEF(3) +LONGGRAB_MATCH_DEF(4) +LONGGRAB_MATCH_DEF(5) +LONGGRAB_MATCH_DEF(6) +LONGGRAB_MATCH_DEF(7) +LONGGRAB_MATCH_DEF(8) +LONGGRAB_MATCH_DEF(9) +LONGGRAB_MATCH_DEF(10) +LONGGRAB_MATCH_DEF(11) +LONGGRAB_MATCH_DEF(12) +LONGGRAB_MATCH_DEF(13) +LONGGRAB_MATCH_DEF(14) +LONGGRAB_MATCH_DEF(15) +LONGGRAB_MATCH_64_DEF(16) +LONGGRAB_MATCH_64_DEF(17) +LONGGRAB_MATCH_64_DEF(18) +LONGGRAB_MATCH_64_DEF(19) +LONGGRAB_MATCH_64_DEF(20) +LONGGRAB_MATCH_64_DEF(21) +LONGGRAB_MATCH_64_DEF(22) +LONGGRAB_MATCH_64_DEF(23) +LONGGRAB_MATCH_64_DEF(24) +LONGGRAB_MATCH_64_DEF(25) +LONGGRAB_MATCH_64_DEF(26) +LONGGRAB_MATCH_64_DEF(27) +LONGGRAB_MATCH_64_DEF(28) +LONGGRAB_MATCH_64_DEF(29) +LONGGRAB_MATCH_64_DEF(30) +LONGGRAB_MATCH_64_DEF(31) + +static +const UNUSED u8 *(*longgrab_match_funcs_32[])(const u8 *buf, u32 z) = +{ +// skip the first three + 0, + &longgrabMatch_32_1, + &longgrabMatch_32_2, + &longgrabMatch_32_3, + &longgrabMatch_32_4, + &longgrabMatch_32_5, + &longgrabMatch_32_6, + &longgrabMatch_32_7, + &longgrabMatch_32_8, + &longgrabMatch_32_9, + &longgrabMatch_32_10, + &longgrabMatch_32_11, + &longgrabMatch_32_12, + &longgrabMatch_32_13, + &longgrabMatch_32_14, + &longgrabMatch_32_15, + }; + +static +const UNUSED u8 *(*longgrab_match_funcs_64[])(const u8 *buf, u64a z) = +{ +// skip the first three + 0, + &longgrabMatch_64_1, + &longgrabMatch_64_2, + &longgrabMatch_64_3, + &longgrabMatch_64_4, + &longgrabMatch_64_5, + &longgrabMatch_64_6, + &longgrabMatch_64_7, + &longgrabMatch_64_8, + &longgrabMatch_64_9, + &longgrabMatch_64_10, + &longgrabMatch_64_11, + &longgrabMatch_64_12, + &longgrabMatch_64_13, + &longgrabMatch_64_14, + &longgrabMatch_64_15, + &longgrabMatch_64_16, + &longgrabMatch_64_17, + &longgrabMatch_64_18, + &longgrabMatch_64_19, + &longgrabMatch_64_20, + &longgrabMatch_64_21, + &longgrabMatch_64_22, + &longgrabMatch_64_23, + &longgrabMatch_64_24, + &longgrabMatch_64_25, + &longgrabMatch_64_26, + &longgrabMatch_64_27, + &longgrabMatch_64_28, + &longgrabMatch_64_29, + &longgrabMatch_64_30, + &longgrabMatch_64_31, +}; + +#endif /* MULTIACCEL_LONGGRAB_H_ */ diff --git a/src/nfa/multiaccel_shift.h b/src/nfa/multiaccel_shift.h new file mode 100644 index 00000000..fd362a8b --- /dev/null +++ b/src/nfa/multiaccel_shift.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_SHIFT_H_ +#define MULTIACCEL_SHIFT_H_ + +#include "multiaccel_common.h" + +#define SHIFT_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(shiftMatch_, match_sz, _, len)(const u8 *buf, match_t z) {\ + if (unlikely(z)) { \ + z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \ + VARISHIFT(z, z, len); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define SHIFT_MATCH_32_DEF(n) \ + SHIFT_MATCH(n, u32, 32) +#define SHIFT_MATCH_64_DEF(n) \ + SHIFT_MATCH(n, u64a, 64) +#define SHIFT_MATCH_DEF(n) \ + SHIFT_MATCH_32_DEF(n) \ + SHIFT_MATCH_64_DEF(n) + +SHIFT_MATCH_DEF(1) +SHIFT_MATCH_DEF(2) +SHIFT_MATCH_DEF(3) +SHIFT_MATCH_DEF(4) +SHIFT_MATCH_DEF(5) +SHIFT_MATCH_DEF(6) +SHIFT_MATCH_DEF(7) +SHIFT_MATCH_DEF(8) +SHIFT_MATCH_DEF(9) +SHIFT_MATCH_DEF(10) +SHIFT_MATCH_DEF(11) +SHIFT_MATCH_DEF(12) +SHIFT_MATCH_DEF(13) +SHIFT_MATCH_DEF(14) +SHIFT_MATCH_DEF(15) +SHIFT_MATCH_64_DEF(16) +SHIFT_MATCH_64_DEF(17) +SHIFT_MATCH_64_DEF(18) +SHIFT_MATCH_64_DEF(19) +SHIFT_MATCH_64_DEF(20) +SHIFT_MATCH_64_DEF(21) +SHIFT_MATCH_64_DEF(22) +SHIFT_MATCH_64_DEF(23) +SHIFT_MATCH_64_DEF(24) +SHIFT_MATCH_64_DEF(25) +SHIFT_MATCH_64_DEF(26) +SHIFT_MATCH_64_DEF(27) +SHIFT_MATCH_64_DEF(28) +SHIFT_MATCH_64_DEF(29) +SHIFT_MATCH_64_DEF(30) +SHIFT_MATCH_64_DEF(31) + +static +const UNUSED u8 * (*shift_match_funcs_32[])(const u8 *buf, u32 z) = +{ +// skip the first + 0, + &shiftMatch_32_1, + &shiftMatch_32_2, + &shiftMatch_32_3, + &shiftMatch_32_4, + &shiftMatch_32_5, + &shiftMatch_32_6, + &shiftMatch_32_7, + &shiftMatch_32_8, + &shiftMatch_32_9, + &shiftMatch_32_10, + &shiftMatch_32_11, + &shiftMatch_32_12, + &shiftMatch_32_13, + &shiftMatch_32_14, + &shiftMatch_32_15, +}; + +static +const UNUSED u8 * (*shift_match_funcs_64[])(const u8 *buf, u64a z) = +{ +// skip the first + 0, + &shiftMatch_64_1, + &shiftMatch_64_2, + &shiftMatch_64_3, + &shiftMatch_64_4, + &shiftMatch_64_5, + &shiftMatch_64_6, + &shiftMatch_64_7, + &shiftMatch_64_8, + &shiftMatch_64_9, + &shiftMatch_64_10, + &shiftMatch_64_11, + &shiftMatch_64_12, + &shiftMatch_64_13, + &shiftMatch_64_14, + &shiftMatch_64_15, + &shiftMatch_64_16, + &shiftMatch_64_17, + &shiftMatch_64_18, + &shiftMatch_64_19, + &shiftMatch_64_20, + &shiftMatch_64_21, + &shiftMatch_64_22, + &shiftMatch_64_23, + &shiftMatch_64_24, + &shiftMatch_64_25, + &shiftMatch_64_26, + &shiftMatch_64_27, + &shiftMatch_64_28, + &shiftMatch_64_29, + &shiftMatch_64_30, + &shiftMatch_64_31, +}; + +#endif /* MULTIACCEL_SHIFT_H_ */ diff --git a/src/nfa/multiaccel_shiftgrab.h b/src/nfa/multiaccel_shiftgrab.h new file mode 100644 index 00000000..032ed086 --- /dev/null +++ b/src/nfa/multiaccel_shiftgrab.h @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2015, Intel Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Intel Corporation nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef MULTIACCEL_SHIFTGRAB_H_ +#define MULTIACCEL_SHIFTGRAB_H_ + +#include "multiaccel_common.h" + +#define SHIFTGRAB_MATCH(len, match_t, match_sz) \ + static really_inline \ + const u8 * JOIN4(shiftgrabMatch_, match_sz, _, len)(const u8 *buf, match_t z) {\ + if (unlikely(z)) { \ + match_t tmp = ~z; \ + z |= ((match_t) (1 << (len)) - 1) << (match_sz / 2); \ + tmp |= ((match_t) (1 << len) - 1) << (match_sz / 2); \ + VARISHIFT(z, z, len); \ + VARISHIFT(tmp, z, 1); \ + return JOIN(match, match_sz)(buf, z); \ + } \ + return NULL; \ + } + +#define SHIFTGRAB_MATCH_32_DEF(n) \ + SHIFTGRAB_MATCH(n, u32, 32) +#define SHIFTGRAB_MATCH_64_DEF(n) \ + SHIFTGRAB_MATCH(n, u64a, 64) +#define SHIFTGRAB_MATCH_DEF(n) \ + SHIFTGRAB_MATCH_32_DEF(n) \ + SHIFTGRAB_MATCH_64_DEF(n) + +SHIFTGRAB_MATCH_DEF(1) +SHIFTGRAB_MATCH_DEF(2) +SHIFTGRAB_MATCH_DEF(3) +SHIFTGRAB_MATCH_DEF(4) +SHIFTGRAB_MATCH_DEF(5) +SHIFTGRAB_MATCH_DEF(6) +SHIFTGRAB_MATCH_DEF(7) +SHIFTGRAB_MATCH_DEF(8) +SHIFTGRAB_MATCH_DEF(9) +SHIFTGRAB_MATCH_DEF(10) +SHIFTGRAB_MATCH_DEF(11) +SHIFTGRAB_MATCH_DEF(12) +SHIFTGRAB_MATCH_DEF(13) +SHIFTGRAB_MATCH_DEF(14) +SHIFTGRAB_MATCH_DEF(15) +SHIFTGRAB_MATCH_64_DEF(16) +SHIFTGRAB_MATCH_64_DEF(17) +SHIFTGRAB_MATCH_64_DEF(18) +SHIFTGRAB_MATCH_64_DEF(19) +SHIFTGRAB_MATCH_64_DEF(20) +SHIFTGRAB_MATCH_64_DEF(21) +SHIFTGRAB_MATCH_64_DEF(22) +SHIFTGRAB_MATCH_64_DEF(23) +SHIFTGRAB_MATCH_64_DEF(24) +SHIFTGRAB_MATCH_64_DEF(25) +SHIFTGRAB_MATCH_64_DEF(26) +SHIFTGRAB_MATCH_64_DEF(27) +SHIFTGRAB_MATCH_64_DEF(28) +SHIFTGRAB_MATCH_64_DEF(29) +SHIFTGRAB_MATCH_64_DEF(30) +SHIFTGRAB_MATCH_64_DEF(31) + +static +const UNUSED u8 * (*shiftgrab_match_funcs_32[])(const u8 *buf, u32 z) = +{ +// skip the first + 0, + &shiftgrabMatch_32_1, + &shiftgrabMatch_32_2, + &shiftgrabMatch_32_3, + &shiftgrabMatch_32_4, + &shiftgrabMatch_32_5, + &shiftgrabMatch_32_6, + &shiftgrabMatch_32_7, + &shiftgrabMatch_32_8, + &shiftgrabMatch_32_9, + &shiftgrabMatch_32_10, + &shiftgrabMatch_32_11, + &shiftgrabMatch_32_12, + &shiftgrabMatch_32_13, + &shiftgrabMatch_32_14, + &shiftgrabMatch_32_15, +}; + +static +const UNUSED u8 * (*shiftgrab_match_funcs_64[])(const u8 *buf, u64a z) = + { +// skip the first + 0, + &shiftgrabMatch_64_1, + &shiftgrabMatch_64_2, + &shiftgrabMatch_64_3, + &shiftgrabMatch_64_4, + &shiftgrabMatch_64_5, + &shiftgrabMatch_64_6, + &shiftgrabMatch_64_7, + &shiftgrabMatch_64_8, + &shiftgrabMatch_64_9, + &shiftgrabMatch_64_10, + &shiftgrabMatch_64_11, + &shiftgrabMatch_64_12, + &shiftgrabMatch_64_13, + &shiftgrabMatch_64_14, + &shiftgrabMatch_64_15, + &shiftgrabMatch_64_16, + &shiftgrabMatch_64_17, + &shiftgrabMatch_64_18, + &shiftgrabMatch_64_19, + &shiftgrabMatch_64_20, + &shiftgrabMatch_64_21, + &shiftgrabMatch_64_22, + &shiftgrabMatch_64_23, + &shiftgrabMatch_64_24, + &shiftgrabMatch_64_25, + &shiftgrabMatch_64_26, + &shiftgrabMatch_64_27, + &shiftgrabMatch_64_28, + &shiftgrabMatch_64_29, + &shiftgrabMatch_64_30, + &shiftgrabMatch_64_31, +}; + +#endif /* MULTIACCEL_SHIFTGRAB_H_ */ diff --git a/src/util/join.h b/src/util/join.h index 0bc79d9b..7d5a30c3 100644 --- a/src/util/join.h +++ b/src/util/join.h @@ -31,4 +31,10 @@ #define JOIN(x, y) JOIN_AGAIN(x, y) #define JOIN_AGAIN(x, y) x ## y +#define JOIN3(x, y, z) JOIN_AGAIN3(x, y, z) +#define JOIN_AGAIN3(x, y, z) x ## y ## z + +#define JOIN4(w, x, y, z) JOIN_AGAIN4(w, x, y, z) +#define JOIN_AGAIN4(w, x, y, z) w ## x ## y ## z + #endif