aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/hyperscan/runtime_corei7
diff options
context:
space:
mode:
authorDevtools Arcadia <arcadia-devtools@yandex-team.ru>2022-02-07 18:08:42 +0300
committerDevtools Arcadia <arcadia-devtools@mous.vla.yp-c.yandex.net>2022-02-07 18:08:42 +0300
commit1110808a9d39d4b808aef724c861a2e1a38d2a69 (patch)
treee26c9fed0de5d9873cce7e00bc214573dc2195b7 /contrib/libs/hyperscan/runtime_corei7
downloadydb-1110808a9d39d4b808aef724c861a2e1a38d2a69.tar.gz
intermediate changes
ref:cde9a383711a11544ce7e107a78147fb96cc4029
Diffstat (limited to 'contrib/libs/hyperscan/runtime_corei7')
-rw-r--r--contrib/libs/hyperscan/runtime_corei7/.yandex_meta/licenses.list.txt32
-rw-r--r--contrib/libs/hyperscan/runtime_corei7/hs_common.h596
-rw-r--r--contrib/libs/hyperscan/runtime_corei7/hs_runtime.h621
-rw-r--r--contrib/libs/hyperscan/runtime_corei7/ya.make494
4 files changed, 1743 insertions, 0 deletions
diff --git a/contrib/libs/hyperscan/runtime_corei7/.yandex_meta/licenses.list.txt b/contrib/libs/hyperscan/runtime_corei7/.yandex_meta/licenses.list.txt
new file mode 100644
index 0000000000..b2ced66bbd
--- /dev/null
+++ b/contrib/libs/hyperscan/runtime_corei7/.yandex_meta/licenses.list.txt
@@ -0,0 +1,32 @@
+====================BSD-3-Clause====================
+ * 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.
+
+
+====================COPYRIGHT====================
+ * Copyright (c) 2015-2018, Intel Corporation
+
+
+====================COPYRIGHT====================
+ * Copyright (c) 2015-2019, Intel Corporation
diff --git a/contrib/libs/hyperscan/runtime_corei7/hs_common.h b/contrib/libs/hyperscan/runtime_corei7/hs_common.h
new file mode 100644
index 0000000000..174bb2a250
--- /dev/null
+++ b/contrib/libs/hyperscan/runtime_corei7/hs_common.h
@@ -0,0 +1,596 @@
+/*
+ * Copyright (c) 2015-2019, 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 HS_COREI7_COMMON_H
+#define HS_COREI7_COMMON_H
+
+#if defined(_WIN32)
+#define HS_CDECL __cdecl
+#else
+#define HS_CDECL
+#endif
+#include <stdlib.h>
+
+/**
+ * @file
+ * @brief The Hyperscan common API definition.
+ *
+ * Hyperscan is a high speed regular expression engine.
+ *
+ * This header contains functions available to both the Hyperscan compiler and
+ * runtime.
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct hs_database;
+
+/**
+ * A Hyperscan pattern database.
+ *
+ * Generated by one of the Hyperscan compiler functions:
+ * - @ref hs_compile()
+ * - @ref hs_compile_multi()
+ * - @ref hs_compile_ext_multi()
+ */
+typedef struct hs_database hs_database_t;
+
+/**
+ * A type for errors returned by Hyperscan functions.
+ */
+typedef int hs_error_t;
+
+/**
+ * Free a compiled pattern database.
+ *
+ * The free callback set by @ref hs_set_database_allocator() (or @ref
+ * hs_set_allocator()) will be used by this function.
+ *
+ * @param db
+ * A compiled pattern database. NULL may also be safely provided, in which
+ * case the function does nothing.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_free_database(hs_database_t *db);
+
+/**
+ * Serialize a pattern database to a stream of bytes.
+ *
+ * The allocator callback set by @ref hs_set_misc_allocator() (or @ref
+ * hs_set_allocator()) will be used by this function.
+ *
+ * @param db
+ * A compiled pattern database.
+ *
+ * @param bytes
+ * On success, a pointer to an array of bytes will be returned here.
+ * These bytes can be subsequently relocated or written to disk. The
+ * caller is responsible for freeing this block.
+ *
+ * @param length
+ * On success, the number of bytes in the generated byte array will be
+ * returned here.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, @ref HS_NOMEM if the byte array cannot be
+ * allocated, other values may be returned if errors are detected.
+ */
+hs_error_t corei7_hs_serialize_database(const hs_database_t *db, char **bytes,
+ size_t *length);
+
+/**
+ * Reconstruct a pattern database from a stream of bytes previously generated
+ * by @ref hs_serialize_database().
+ *
+ * This function will allocate sufficient space for the database using the
+ * allocator set with @ref hs_set_database_allocator() (or @ref
+ * hs_set_allocator()); to use a pre-allocated region of memory, use the @ref
+ * hs_deserialize_database_at() function.
+ *
+ * @param bytes
+ * A byte array generated by @ref hs_serialize_database() representing a
+ * compiled pattern database.
+ *
+ * @param length
+ * The length of the byte array generated by @ref hs_serialize_database().
+ * This should be the same value as that returned by @ref
+ * hs_serialize_database().
+ *
+ * @param db
+ * On success, a pointer to a newly allocated @ref hs_database_t will be
+ * returned here. This database can then be used for scanning, and
+ * eventually freed by the caller using @ref hs_free_database().
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_deserialize_database(const char *bytes,
+ const size_t length,
+ hs_database_t **db);
+
+/**
+ * Reconstruct a pattern database from a stream of bytes previously generated
+ * by @ref hs_serialize_database() at a given memory location.
+ *
+ * This function (unlike @ref hs_deserialize_database()) will write the
+ * reconstructed database to the memory location given in the @p db parameter.
+ * The amount of space required at this location can be determined with the
+ * @ref hs_serialized_database_size() function.
+ *
+ * @param bytes
+ * A byte array generated by @ref hs_serialize_database() representing a
+ * compiled pattern database.
+ *
+ * @param length
+ * The length of the byte array generated by @ref hs_serialize_database().
+ * This should be the same value as that returned by @ref
+ * hs_serialize_database().
+ *
+ * @param db
+ * Pointer to an 8-byte aligned block of memory of sufficient size to hold
+ * the deserialized database. On success, the reconstructed database will
+ * be written to this location. This database can then be used for pattern
+ * matching. The user is responsible for freeing this memory; the @ref
+ * hs_free_database() call should not be used.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_deserialize_database_at(const char *bytes,
+ const size_t length,
+ hs_database_t *db);
+
+/**
+ * Provides the size of the stream state allocated by a single stream opened
+ * against the given database.
+ *
+ * @param database
+ * Pointer to a compiled (streaming mode) pattern database.
+ *
+ * @param stream_size
+ * On success, the size in bytes of an individual stream opened against the
+ * given database is placed in this parameter.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_stream_size(const hs_database_t *database,
+ size_t *stream_size);
+
+/**
+ * Provides the size of the given database in bytes.
+ *
+ * @param database
+ * Pointer to compiled pattern database.
+ *
+ * @param database_size
+ * On success, the size of the compiled database in bytes is placed in this
+ * parameter.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_database_size(const hs_database_t *database,
+ size_t *database_size);
+
+/**
+ * Utility function for reporting the size that would be required by a
+ * database if it were deserialized.
+ *
+ * This can be used to allocate a shared memory region or other "special"
+ * allocation prior to deserializing with the @ref hs_deserialize_database_at()
+ * function.
+ *
+ * @param bytes
+ * Pointer to a byte array generated by @ref hs_serialize_database()
+ * representing a compiled pattern database.
+ *
+ * @param length
+ * The length of the byte array generated by @ref hs_serialize_database().
+ * This should be the same value as that returned by @ref
+ * hs_serialize_database().
+ *
+ * @param deserialized_size
+ * On success, the size of the compiled database that would be generated
+ * by @ref hs_deserialize_database_at() is returned here.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_serialized_database_size(const char *bytes,
+ const size_t length,
+ size_t *deserialized_size);
+
+/**
+ * Utility function providing information about a database.
+ *
+ * @param database
+ * Pointer to a compiled database.
+ *
+ * @param info
+ * On success, a string containing the version and platform information for
+ * the supplied database is placed in the parameter. The string is
+ * allocated using the allocator supplied in @ref hs_set_misc_allocator()
+ * (or malloc() if no allocator was set) and should be freed by the caller.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_database_info(const hs_database_t *database,
+ char **info);
+
+/**
+ * Utility function providing information about a serialized database.
+ *
+ * @param bytes
+ * Pointer to a serialized database.
+ *
+ * @param length
+ * Length in bytes of the serialized database.
+ *
+ * @param info
+ * On success, a string containing the version and platform information
+ * for the supplied serialized database is placed in the parameter. The
+ * string is allocated using the allocator supplied in @ref
+ * hs_set_misc_allocator() (or malloc() if no allocator was set) and
+ * should be freed by the caller.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_serialized_database_info(const char *bytes,
+ size_t length, char **info);
+
+/**
+ * The type of the callback function that will be used by Hyperscan to allocate
+ * more memory at runtime as required, for example in @ref hs_open_stream() to
+ * allocate stream state.
+ *
+ * If Hyperscan is to be used in a multi-threaded, or similarly concurrent
+ * environment, the allocation function will need to be re-entrant, or
+ * similarly safe for concurrent use.
+ *
+ * @param size
+ * The number of bytes to allocate.
+ * @return
+ * A pointer to the region of memory allocated, or NULL on error.
+ */
+typedef void *(HS_CDECL *hs_alloc_t)(size_t size);
+
+/**
+ * The type of the callback function that will be used by Hyperscan to free
+ * memory regions previously allocated using the @ref hs_alloc_t function.
+ *
+ * @param ptr
+ * The region of memory to be freed.
+ */
+typedef void (HS_CDECL *hs_free_t)(void *ptr);
+
+/**
+ * Set the allocate and free functions used by Hyperscan for allocating
+ * memory at runtime for stream state, scratch space, database bytecode,
+ * and various other data structure returned by the Hyperscan API.
+ *
+ * The function is equivalent to calling @ref hs_set_stream_allocator(),
+ * @ref hs_set_scratch_allocator(), @ref hs_set_database_allocator() and
+ * @ref hs_set_misc_allocator() with the provided parameters.
+ *
+ * This call will override any previous allocators that have been set.
+ *
+ * Note: there is no way to change the allocator used for temporary objects
+ * created during the various compile calls (@ref hs_compile(), @ref
+ * hs_compile_multi(), @ref hs_compile_ext_multi()).
+ *
+ * @param alloc_func
+ * A callback function pointer that allocates memory. This function must
+ * return memory suitably aligned for the largest representable data type
+ * on this platform.
+ *
+ * @param free_func
+ * A callback function pointer that frees allocated memory.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_set_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
+
+/**
+ * Set the allocate and free functions used by Hyperscan for allocating memory
+ * for database bytecode produced by the compile calls (@ref hs_compile(), @ref
+ * hs_compile_multi(), @ref hs_compile_ext_multi()) and by database
+ * deserialization (@ref hs_deserialize_database()).
+ *
+ * If no database allocation functions are set, or if NULL is used in place of
+ * both parameters, then memory allocation will default to standard methods
+ * (such as the system malloc() and free() calls).
+ *
+ * This call will override any previous database allocators that have been set.
+ *
+ * Note: the database allocator may also be set by calling @ref
+ * hs_set_allocator().
+ *
+ * Note: there is no way to change how temporary objects created during the
+ * various compile calls (@ref hs_compile(), @ref hs_compile_multi(), @ref
+ * hs_compile_ext_multi()) are allocated.
+ *
+ * @param alloc_func
+ * A callback function pointer that allocates memory. This function must
+ * return memory suitably aligned for the largest representable data type
+ * on this platform.
+ *
+ * @param free_func
+ * A callback function pointer that frees allocated memory.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_set_database_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
+
+/**
+ * Set the allocate and free functions used by Hyperscan for allocating memory
+ * for items returned by the Hyperscan API such as @ref hs_compile_error_t, @ref
+ * hs_expr_info_t and serialized databases.
+ *
+ * If no misc allocation functions are set, or if NULL is used in place of both
+ * parameters, then memory allocation will default to standard methods (such as
+ * the system malloc() and free() calls).
+ *
+ * This call will override any previous misc allocators that have been set.
+ *
+ * Note: the misc allocator may also be set by calling @ref hs_set_allocator().
+ *
+ * @param alloc_func
+ * A callback function pointer that allocates memory. This function must
+ * return memory suitably aligned for the largest representable data type
+ * on this platform.
+ *
+ * @param free_func
+ * A callback function pointer that frees allocated memory.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_set_misc_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
+
+/**
+ * Set the allocate and free functions used by Hyperscan for allocating memory
+ * for scratch space by @ref hs_alloc_scratch() and @ref hs_clone_scratch().
+ *
+ * If no scratch allocation functions are set, or if NULL is used in place of
+ * both parameters, then memory allocation will default to standard methods
+ * (such as the system malloc() and free() calls).
+ *
+ * This call will override any previous scratch allocators that have been set.
+ *
+ * Note: the scratch allocator may also be set by calling @ref
+ * hs_set_allocator().
+ *
+ * @param alloc_func
+ * A callback function pointer that allocates memory. This function must
+ * return memory suitably aligned for the largest representable data type
+ * on this platform.
+ *
+ * @param free_func
+ * A callback function pointer that frees allocated memory.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_set_scratch_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
+
+/**
+ * Set the allocate and free functions used by Hyperscan for allocating memory
+ * for stream state by @ref hs_open_stream().
+ *
+ * If no stream allocation functions are set, or if NULL is used in place of
+ * both parameters, then memory allocation will default to standard methods
+ * (such as the system malloc() and free() calls).
+ *
+ * This call will override any previous stream allocators that have been set.
+ *
+ * Note: the stream allocator may also be set by calling @ref
+ * hs_set_allocator().
+ *
+ * @param alloc_func
+ * A callback function pointer that allocates memory. This function must
+ * return memory suitably aligned for the largest representable data type
+ * on this platform.
+ *
+ * @param free_func
+ * A callback function pointer that frees allocated memory.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_set_stream_allocator(hs_alloc_t alloc_func,
+ hs_free_t free_func);
+
+/**
+ * Utility function for identifying this release version.
+ *
+ * @return
+ * A string containing the version number of this release build and the
+ * date of the build. It is allocated statically, so it does not need to
+ * be freed by the caller.
+ */
+const char * corei7_hs_version(void);
+
+/**
+ * Utility function to test the current system architecture.
+ *
+ * Hyperscan requires the Supplemental Streaming SIMD Extensions 3 instruction
+ * set. This function can be called on any x86 platform to determine if the
+ * system provides the required instruction set.
+ *
+ * This function does not test for more advanced features if Hyperscan has
+ * been built for a more specific architecture, for example the AVX2
+ * instruction set.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, @ref HS_ARCH_ERROR if system does not
+ * support Hyperscan.
+ */
+hs_error_t corei7_hs_valid_platform(void);
+
+/**
+ * @defgroup HS_ERROR hs_error_t values
+ *
+ * @{
+ */
+
+/**
+ * The engine completed normally.
+ */
+#define HS_SUCCESS 0
+
+/**
+ * A parameter passed to this function was invalid.
+ *
+ * This error is only returned in cases where the function can detect an
+ * invalid parameter -- it cannot be relied upon to detect (for example)
+ * pointers to freed memory or other invalid data.
+ */
+#define HS_INVALID (-1)
+
+/**
+ * A memory allocation failed.
+ */
+#define HS_NOMEM (-2)
+
+/**
+ * The engine was terminated by callback.
+ *
+ * This return value indicates that the target buffer was partially scanned,
+ * but that the callback function requested that scanning cease after a match
+ * was located.
+ */
+#define HS_SCAN_TERMINATED (-3)
+
+/**
+ * The pattern compiler failed, and the @ref hs_compile_error_t should be
+ * inspected for more detail.
+ */
+#define HS_COMPILER_ERROR (-4)
+
+/**
+ * The given database was built for a different version of Hyperscan.
+ */
+#define HS_DB_VERSION_ERROR (-5)
+
+/**
+ * The given database was built for a different platform (i.e., CPU type).
+ */
+#define HS_DB_PLATFORM_ERROR (-6)
+
+/**
+ * The given database was built for a different mode of operation. This error
+ * is returned when streaming calls are used with a block or vectored database
+ * and vice versa.
+ */
+#define HS_DB_MODE_ERROR (-7)
+
+/**
+ * A parameter passed to this function was not correctly aligned.
+ */
+#define HS_BAD_ALIGN (-8)
+
+/**
+ * The memory allocator (either malloc() or the allocator set with @ref
+ * hs_set_allocator()) did not correctly return memory suitably aligned for the
+ * largest representable data type on this platform.
+ */
+#define HS_BAD_ALLOC (-9)
+
+/**
+ * The scratch region was already in use.
+ *
+ * This error is returned when Hyperscan is able to detect that the scratch
+ * region given is already in use by another Hyperscan API call.
+ *
+ * A separate scratch region, allocated with @ref hs_alloc_scratch() or @ref
+ * hs_clone_scratch(), is required for every concurrent caller of the Hyperscan
+ * API.
+ *
+ * For example, this error might be returned when @ref hs_scan() has been
+ * called inside a callback delivered by a currently-executing @ref hs_scan()
+ * call using the same scratch region.
+ *
+ * Note: Not all concurrent uses of scratch regions may be detected. This error
+ * is intended as a best-effort debugging tool, not a guarantee.
+ */
+#define HS_SCRATCH_IN_USE (-10)
+
+/**
+ * Unsupported CPU architecture.
+ *
+ * This error is returned when Hyperscan is able to detect that the current
+ * system does not support the required instruction set.
+ *
+ * At a minimum, Hyperscan requires Supplemental Streaming SIMD Extensions 3
+ * (SSSE3).
+ */
+#define HS_ARCH_ERROR (-11)
+
+/**
+ * Provided buffer was too small.
+ *
+ * This error indicates that there was insufficient space in the buffer. The
+ * call should be repeated with a larger provided buffer.
+ *
+ * Note: in this situation, it is normal for the amount of space required to be
+ * returned in the same manner as the used space would have been returned if the
+ * call was successful.
+ */
+#define HS_INSUFFICIENT_SPACE (-12)
+
+/**
+ * Unexpected internal error.
+ *
+ * This error indicates that there was unexpected matching behaviors. This
+ * could be related to invalid usage of stream and scratch space or invalid memory
+ * operations by users.
+ *
+ */
+#define HS_UNKNOWN_ERROR (-13)
+
+/** @} */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* HS_COREI7_COMMON_H */
diff --git a/contrib/libs/hyperscan/runtime_corei7/hs_runtime.h b/contrib/libs/hyperscan/runtime_corei7/hs_runtime.h
new file mode 100644
index 0000000000..a55b183ce3
--- /dev/null
+++ b/contrib/libs/hyperscan/runtime_corei7/hs_runtime.h
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) 2015-2018, 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 HS_COREI7_RUNTIME_H
+#define HS_COREI7_RUNTIME_H
+
+#include <stdlib.h>
+
+/**
+ * @file
+ * @brief The Hyperscan runtime API definition.
+ *
+ * Hyperscan is a high speed regular expression engine.
+ *
+ * This header contains functions for using compiled Hyperscan databases for
+ * scanning data at runtime.
+ */
+
+#include "hs_common.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * Definition of the stream identifier type.
+ */
+struct hs_stream;
+
+/**
+ * The stream identifier returned by @ref hs_open_stream().
+ */
+typedef struct hs_stream hs_stream_t;
+
+struct hs_scratch;
+
+/**
+ * A Hyperscan scratch space.
+ */
+typedef struct hs_scratch hs_scratch_t;
+
+/**
+ * Definition of the match event callback function type.
+ *
+ * A callback function matching the defined type must be provided by the
+ * application calling the @ref hs_scan(), @ref hs_scan_vector() or @ref
+ * hs_scan_stream() functions (or other streaming calls which can produce
+ * matches).
+ *
+ * This callback function will be invoked whenever a match is located in the
+ * target data during the execution of a scan. The details of the match are
+ * passed in as parameters to the callback function, and the callback function
+ * should return a value indicating whether or not matching should continue on
+ * the target data. If no callbacks are desired from a scan call, NULL may be
+ * provided in order to suppress match production.
+ *
+ * This callback function should not attempt to call Hyperscan API functions on
+ * the same stream nor should it attempt to reuse the scratch space allocated
+ * for the API calls that caused it to be triggered. Making another call to the
+ * Hyperscan library with completely independent parameters should work (for
+ * example, scanning a different database in a new stream and with new scratch
+ * space), but reusing data structures like stream state and/or scratch space
+ * will produce undefined behavior.
+ *
+ * @param id
+ * The ID number of the expression that matched. If the expression was a
+ * single expression compiled with @ref hs_compile(), this value will be
+ * zero.
+ *
+ * @param from
+ * - If a start of match flag is enabled for the current pattern, this
+ * argument will be set to the start of match for the pattern assuming
+ * that that start of match value lies within the current 'start of match
+ * horizon' chosen by one of the SOM_HORIZON mode flags.
+
+ * - If the start of match value lies outside this horizon (possible only
+ * when the SOM_HORIZON value is not @ref HS_MODE_SOM_HORIZON_LARGE),
+ * the @p from value will be set to @ref HS_OFFSET_PAST_HORIZON.
+
+ * - This argument will be set to zero if the Start of Match flag is not
+ * enabled for the given pattern.
+ *
+ * @param to
+ * The offset after the last byte that matches the expression.
+ *
+ * @param flags
+ * This is provided for future use and is unused at present.
+ *
+ * @param context
+ * The pointer supplied by the user to the @ref hs_scan(), @ref
+ * hs_scan_vector() or @ref hs_scan_stream() function.
+ *
+ * @return
+ * Non-zero if the matching should cease, else zero. If scanning is
+ * performed in streaming mode and a non-zero value is returned, any
+ * subsequent calls to @ref hs_scan_stream() for that stream will
+ * immediately return with @ref HS_SCAN_TERMINATED.
+ */
+typedef int (HS_CDECL *match_event_handler)(unsigned int id,
+ unsigned long long from,
+ unsigned long long to,
+ unsigned int flags,
+ void *context);
+
+/**
+ * Open and initialise a stream.
+ *
+ * @param db
+ * A compiled pattern database.
+ *
+ * @param flags
+ * Flags modifying the behaviour of the stream. This parameter is provided
+ * for future use and is unused at present.
+ *
+ * @param stream
+ * On success, a pointer to the generated @ref hs_stream_t will be
+ * returned; NULL on failure.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_open_stream(const hs_database_t *db, unsigned int flags,
+ hs_stream_t **stream);
+
+/**
+ * Write data to be scanned to the opened stream.
+ *
+ * This is the function call in which the actual pattern matching takes place
+ * as data is written to the stream. Matches will be returned via the @ref
+ * match_event_handler callback supplied.
+ *
+ * @param id
+ * The stream ID (returned by @ref hs_open_stream()) to which the data
+ * will be written.
+ *
+ * @param data
+ * Pointer to the data to be scanned.
+ *
+ * @param length
+ * The number of bytes to scan.
+ *
+ * @param flags
+ * Flags modifying the behaviour of the stream. This parameter is provided
+ * for future use and is unused at present.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch().
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param ctxt
+ * The user defined pointer which will be passed to the callback function
+ * when a match occurs.
+ *
+ * @return
+ * Returns @ref HS_SUCCESS on success; @ref HS_SCAN_TERMINATED if the
+ * match callback indicated that scanning should stop; other values on
+ * error.
+ */
+hs_error_t corei7_hs_scan_stream(hs_stream_t *id, const char *data,
+ unsigned int length, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *ctxt);
+
+/**
+ * Close a stream.
+ *
+ * This function completes matching on the given stream and frees the memory
+ * associated with the stream state. After this call, the stream pointed to by
+ * @p id is invalid and can no longer be used. To reuse the stream state after
+ * completion, rather than closing it, the @ref hs_reset_stream function can be
+ * used.
+ *
+ * This function must be called for any stream created with @ref
+ * hs_open_stream(), even if scanning has been terminated by a non-zero return
+ * from the match callback function.
+ *
+ * Note: This operation may result in matches being returned (via calls to the
+ * match event callback) for expressions anchored to the end of the data stream
+ * (for example, via the use of the `$` meta-character). If these matches are
+ * not desired, NULL may be provided as the @ref match_event_handler callback.
+ *
+ * If NULL is provided as the @ref match_event_handler callback, it is
+ * permissible to provide a NULL scratch.
+ *
+ * @param id
+ * The stream ID returned by @ref hs_open_stream().
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch(). This is
+ * allowed to be NULL only if the @p onEvent callback is also NULL.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param ctxt
+ * The user defined pointer which will be passed to the callback function
+ * when a match occurs.
+ *
+ * @return
+ * Returns @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch,
+ match_event_handler onEvent, void *ctxt);
+
+/**
+ * Reset a stream to an initial state.
+ *
+ * Conceptually, this is equivalent to performing @ref hs_close_stream() on the
+ * given stream, followed by a @ref hs_open_stream(). This new stream replaces
+ * the original stream in memory, avoiding the overhead of freeing the old
+ * stream and allocating the new one.
+ *
+ * Note: This operation may result in matches being returned (via calls to the
+ * match event callback) for expressions anchored to the end of the original
+ * data stream (for example, via the use of the `$` meta-character). If these
+ * matches are not desired, NULL may be provided as the @ref match_event_handler
+ * callback.
+ *
+ * Note: the stream will also be tied to the same database.
+ *
+ * @param id
+ * The stream (as created by @ref hs_open_stream()) to be replaced.
+ *
+ * @param flags
+ * Flags modifying the behaviour of the stream. This parameter is provided
+ * for future use and is unused at present.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch(). This is
+ * allowed to be NULL only if the @p onEvent callback is also NULL.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param context
+ * The user defined pointer which will be passed to the callback function
+ * when a match occurs.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_reset_stream(hs_stream_t *id, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context);
+
+/**
+ * Duplicate the given stream. The new stream will have the same state as the
+ * original including the current stream offset.
+ *
+ * @param to_id
+ * On success, a pointer to the new, copied @ref hs_stream_t will be
+ * returned; NULL on failure.
+ *
+ * @param from_id
+ * The stream (as created by @ref hs_open_stream()) to be copied.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_copy_stream(hs_stream_t **to_id,
+ const hs_stream_t *from_id);
+
+/**
+ * Duplicate the given 'from' stream state onto the 'to' stream. The 'to' stream
+ * will first be reset (reporting any EOD matches if a non-NULL @p onEvent
+ * callback handler is provided).
+ *
+ * Note: the 'to' stream and the 'from' stream must be open against the same
+ * database.
+ *
+ * @param to_id
+ * On success, a pointer to the new, copied @ref hs_stream_t will be
+ * returned; NULL on failure.
+ *
+ * @param from_id
+ * The stream (as created by @ref hs_open_stream()) to be copied.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch(). This is
+ * allowed to be NULL only if the @p onEvent callback is also NULL.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param context
+ * The user defined pointer which will be passed to the callback function
+ * when a match occurs.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_reset_and_copy_stream(hs_stream_t *to_id,
+ const hs_stream_t *from_id,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context);
+
+/**
+ * Creates a compressed representation of the provided stream in the buffer
+ * provided. This compressed representation can be converted back into a stream
+ * state by using @ref hs_expand_stream() or @ref hs_reset_and_expand_stream().
+ * The size of the compressed representation will be placed into @p used_space.
+ *
+ * If there is not sufficient space in the buffer to hold the compressed
+ * representation, @ref HS_INSUFFICIENT_SPACE will be returned and @p used_space
+ * will be populated with the amount of space required.
+ *
+ * Note: this function does not close the provided stream, you may continue to
+ * use the stream or to free it with @ref hs_close_stream().
+ *
+ * @param stream
+ * The stream (as created by @ref hs_open_stream()) to be compressed.
+ *
+ * @param buf
+ * Buffer to write the compressed representation into. Note: if the call is
+ * just being used to determine the amount of space required, it is allowed
+ * to pass NULL here and @p buf_space as 0.
+ *
+ * @param buf_space
+ * The number of bytes in @p buf. If buf_space is too small, the call will
+ * fail with @ref HS_INSUFFICIENT_SPACE.
+ *
+ * @param used_space
+ * Pointer to where the amount of used space will be written to. The used
+ * buffer space is always less than or equal to @p buf_space. If the call
+ * fails with @ref HS_INSUFFICIENT_SPACE, this pointer will be used to
+ * write out the amount of buffer space required.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, @ref HS_INSUFFICIENT_SPACE if the provided
+ * buffer is too small.
+ */
+hs_error_t corei7_hs_compress_stream(const hs_stream_t *stream, char *buf,
+ size_t buf_space, size_t *used_space);
+
+/**
+ * Decompresses a compressed representation created by @ref hs_compress_stream()
+ * into a new stream.
+ *
+ * Note: @p buf must correspond to a complete compressed representation created
+ * by @ref hs_compress_stream() of a stream that was opened against @p db. It is
+ * not always possible to detect misuse of this API and behaviour is undefined
+ * if these properties are not satisfied.
+ *
+ * @param db
+ * The compiled pattern database that the compressed stream was opened
+ * against.
+ *
+ * @param stream
+ * On success, a pointer to the expanded @ref hs_stream_t will be
+ * returned; NULL on failure.
+ *
+ * @param buf
+ * A compressed representation of a stream. These compressed forms are
+ * created by @ref hs_compress_stream().
+ *
+ * @param buf_size
+ * The size in bytes of the compressed representation.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_expand_stream(const hs_database_t *db,
+ hs_stream_t **stream, const char *buf,
+ size_t buf_size);
+
+/**
+ * Decompresses a compressed representation created by @ref hs_compress_stream()
+ * on top of the 'to' stream. The 'to' stream will first be reset (reporting
+ * any EOD matches if a non-NULL @p onEvent callback handler is provided).
+ *
+ * Note: the 'to' stream must be opened against the same database as the
+ * compressed stream.
+ *
+ * Note: @p buf must correspond to a complete compressed representation created
+ * by @ref hs_compress_stream() of a stream that was opened against @p db. It is
+ * not always possible to detect misuse of this API and behaviour is undefined
+ * if these properties are not satisfied.
+ *
+ * @param to_stream
+ * A pointer to a valid stream state. A pointer to the expanded @ref
+ * hs_stream_t will be returned; NULL on failure.
+ *
+ * @param buf
+ * A compressed representation of a stream. These compressed forms are
+ * created by @ref hs_compress_stream().
+ *
+ * @param buf_size
+ * The size in bytes of the compressed representation.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch(). This is
+ * allowed to be NULL only if the @p onEvent callback is also NULL.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param context
+ * The user defined pointer which will be passed to the callback function
+ * when a match occurs.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_reset_and_expand_stream(hs_stream_t *to_stream,
+ const char *buf, size_t buf_size,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent,
+ void *context);
+
+/**
+ * The block (non-streaming) regular expression scanner.
+ *
+ * This is the function call in which the actual pattern matching takes place
+ * for block-mode pattern databases.
+ *
+ * @param db
+ * A compiled pattern database.
+ *
+ * @param data
+ * Pointer to the data to be scanned.
+ *
+ * @param length
+ * The number of bytes to scan.
+ *
+ * @param flags
+ * Flags modifying the behaviour of this function. This parameter is
+ * provided for future use and is unused at present.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch() for this
+ * database.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param context
+ * The user defined pointer which will be passed to the callback function.
+ *
+ * @return
+ * Returns @ref HS_SUCCESS on success; @ref HS_SCAN_TERMINATED if the
+ * match callback indicated that scanning should stop; other values on
+ * error.
+ */
+hs_error_t corei7_hs_scan(const hs_database_t *db, const char *data,
+ unsigned int length, unsigned int flags,
+ hs_scratch_t *scratch, match_event_handler onEvent,
+ void *context);
+
+/**
+ * The vectored regular expression scanner.
+ *
+ * This is the function call in which the actual pattern matching takes place
+ * for vectoring-mode pattern databases.
+ *
+ * @param db
+ * A compiled pattern database.
+ *
+ * @param data
+ * An array of pointers to the data blocks to be scanned.
+ *
+ * @param length
+ * An array of lengths (in bytes) of each data block to scan.
+ *
+ * @param count
+ * Number of data blocks to scan. This should correspond to the size of
+ * of the @p data and @p length arrays.
+ *
+ * @param flags
+ * Flags modifying the behaviour of this function. This parameter is
+ * provided for future use and is unused at present.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch() for
+ * this database.
+ *
+ * @param onEvent
+ * Pointer to a match event callback function. If a NULL pointer is given,
+ * no matches will be returned.
+ *
+ * @param context
+ * The user defined pointer which will be passed to the callback function.
+ *
+ * @return
+ * Returns @ref HS_SUCCESS on success; @ref HS_SCAN_TERMINATED if the match
+ * callback indicated that scanning should stop; other values on error.
+ */
+hs_error_t corei7_hs_scan_vector(const hs_database_t *db,
+ const char *const *data,
+ const unsigned int *length,
+ unsigned int count, unsigned int flags,
+ hs_scratch_t *scratch,
+ match_event_handler onEvent, void *context);
+
+/**
+ * Allocate a "scratch" space for use by Hyperscan.
+ *
+ * This is required for runtime use, and one scratch space per thread, or
+ * concurrent caller, is required. Any allocator callback set by @ref
+ * hs_set_scratch_allocator() or @ref hs_set_allocator() will be used by this
+ * function.
+ *
+ * @param db
+ * The database, as produced by @ref hs_compile().
+ *
+ * @param scratch
+ * On first allocation, a pointer to NULL should be provided so a new
+ * scratch can be allocated. If a scratch block has been previously
+ * allocated, then a pointer to it should be passed back in to see if it
+ * is valid for this database block. If a new scratch block is required,
+ * the original will be freed and the new one returned, otherwise the
+ * previous scratch block will be returned. On success, the scratch block
+ * will be suitable for use with the provided database in addition to any
+ * databases that original scratch space was suitable for.
+ *
+ * @return
+ * @ref HS_SUCCESS on successful allocation; @ref HS_NOMEM if the
+ * allocation fails. Other errors may be returned if invalid parameters
+ * are specified.
+ */
+hs_error_t corei7_hs_alloc_scratch(const hs_database_t *db,
+ hs_scratch_t **scratch);
+
+/**
+ * Allocate a scratch space that is a clone of an existing scratch space.
+ *
+ * This is useful when multiple concurrent threads will be using the same set
+ * of compiled databases, and another scratch space is required. Any allocator
+ * callback set by @ref hs_set_scratch_allocator() or @ref hs_set_allocator()
+ * will be used by this function.
+ *
+ * @param src
+ * The existing @ref hs_scratch_t to be cloned.
+ *
+ * @param dest
+ * A pointer to the new scratch space will be returned here.
+ *
+ * @return
+ * @ref HS_SUCCESS on success; @ref HS_NOMEM if the allocation fails.
+ * Other errors may be returned if invalid parameters are specified.
+ */
+hs_error_t corei7_hs_clone_scratch(const hs_scratch_t *src,
+ hs_scratch_t **dest);
+
+/**
+ * Provides the size of the given scratch space.
+ *
+ * @param scratch
+ * A per-thread scratch space allocated by @ref hs_alloc_scratch() or @ref
+ * hs_clone_scratch().
+ *
+ * @param scratch_size
+ * On success, the size of the scratch space in bytes is placed in this
+ * parameter.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_scratch_size(const hs_scratch_t *scratch,
+ size_t *scratch_size);
+
+/**
+ * Free a scratch block previously allocated by @ref hs_alloc_scratch() or @ref
+ * hs_clone_scratch().
+ *
+ * The free callback set by @ref hs_set_scratch_allocator() or @ref
+ * hs_set_allocator() will be used by this function.
+ *
+ * @param scratch
+ * The scratch block to be freed. NULL may also be safely provided.
+ *
+ * @return
+ * @ref HS_SUCCESS on success, other values on failure.
+ */
+hs_error_t corei7_hs_free_scratch(hs_scratch_t *scratch);
+
+/**
+ * Callback 'from' return value, indicating that the start of this match was
+ * too early to be tracked with the requested SOM_HORIZON precision.
+ */
+#define HS_OFFSET_PAST_HORIZON (~0ULL)
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* HS_COREI7_RUNTIME_H */
diff --git a/contrib/libs/hyperscan/runtime_corei7/ya.make b/contrib/libs/hyperscan/runtime_corei7/ya.make
new file mode 100644
index 0000000000..efdd466c09
--- /dev/null
+++ b/contrib/libs/hyperscan/runtime_corei7/ya.make
@@ -0,0 +1,494 @@
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
+OWNER(
+ galtsev
+ g:antiinfra
+ g:cpp-contrib
+ g:yql
+)
+
+LICENSE(BSD-3-Clause)
+
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
+
+ADDINCL(
+ contrib/libs/hyperscan
+ contrib/libs/hyperscan/src
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_RUNTIME()
+
+CFLAGS(
+ ${SSE41_CFLAGS}
+ -DHAVE_SSE41
+ ${SSE42_CFLAGS}
+ -DHAVE_SSE42
+ ${POPCNT_CFLAGS}
+ -DHAVE_POPCOUNT_INSTR
+ -DCrc32c_ComputeBuf=corei7_Crc32c_ComputeBuf
+ -DblockInitSufPQ=corei7_blockInitSufPQ
+ -Dcompress_stream=corei7_compress_stream
+ -Dcpuid_flags=corei7_cpuid_flags
+ -Dcpuid_tune=corei7_cpuid_tune
+ -DdbIsValid=corei7_dbIsValid
+ -DdoAccel128=corei7_doAccel128
+ -DdoAccel256=corei7_doAccel256
+ -DdoAccel32=corei7_doAccel32
+ -DdoAccel384=corei7_doAccel384
+ -DdoAccel512=corei7_doAccel512
+ -DdoAccel64=corei7_doAccel64
+ -Dexpand_stream=corei7_expand_stream
+ -DfdrExec=corei7_fdrExec
+ -DfdrExecStreaming=corei7_fdrExecStreaming
+ -Dfdr_exec_fat_teddy_msks1=corei7_fdr_exec_fat_teddy_msks1
+ -Dfdr_exec_fat_teddy_msks1_pck=corei7_fdr_exec_fat_teddy_msks1_pck
+ -Dfdr_exec_fat_teddy_msks2=corei7_fdr_exec_fat_teddy_msks2
+ -Dfdr_exec_fat_teddy_msks2_pck=corei7_fdr_exec_fat_teddy_msks2_pck
+ -Dfdr_exec_fat_teddy_msks3=corei7_fdr_exec_fat_teddy_msks3
+ -Dfdr_exec_fat_teddy_msks3_pck=corei7_fdr_exec_fat_teddy_msks3_pck
+ -Dfdr_exec_fat_teddy_msks4=corei7_fdr_exec_fat_teddy_msks4
+ -Dfdr_exec_fat_teddy_msks4_pck=corei7_fdr_exec_fat_teddy_msks4_pck
+ -Dfdr_exec_teddy_msks1=corei7_fdr_exec_teddy_msks1
+ -Dfdr_exec_teddy_msks1_pck=corei7_fdr_exec_teddy_msks1_pck
+ -Dfdr_exec_teddy_msks2=corei7_fdr_exec_teddy_msks2
+ -Dfdr_exec_teddy_msks2_pck=corei7_fdr_exec_teddy_msks2_pck
+ -Dfdr_exec_teddy_msks3=corei7_fdr_exec_teddy_msks3
+ -Dfdr_exec_teddy_msks3_pck=corei7_fdr_exec_teddy_msks3_pck
+ -Dfdr_exec_teddy_msks4=corei7_fdr_exec_teddy_msks4
+ -Dfdr_exec_teddy_msks4_pck=corei7_fdr_exec_teddy_msks4_pck
+ -DflushQueuedLiterals_i=corei7_flushQueuedLiterals_i
+ -DflushStoredSomMatches_i=corei7_flushStoredSomMatches_i
+ -DhandleSomExternal=corei7_handleSomExternal
+ -DhandleSomInternal=corei7_handleSomInternal
+ -Dhs_alloc_scratch=corei7_hs_alloc_scratch
+ -Dhs_clone_scratch=corei7_hs_clone_scratch
+ -Dhs_close_stream=corei7_hs_close_stream
+ -Dhs_compress_stream=corei7_hs_compress_stream
+ -Dhs_copy_stream=corei7_hs_copy_stream
+ -Dhs_database_alloc=corei7_hs_database_alloc
+ -Dhs_database_free=corei7_hs_database_free
+ -Dhs_database_info=corei7_hs_database_info
+ -Dhs_database_size=corei7_hs_database_size
+ -Dhs_deserialize_database=corei7_hs_deserialize_database
+ -Dhs_deserialize_database_at=corei7_hs_deserialize_database_at
+ -Dhs_expand_stream=corei7_hs_expand_stream
+ -Dhs_free_database=corei7_hs_free_database
+ -Dhs_free_scratch=corei7_hs_free_scratch
+ -Dhs_misc_alloc=corei7_hs_misc_alloc
+ -Dhs_misc_free=corei7_hs_misc_free
+ -Dhs_open_stream=corei7_hs_open_stream
+ -Dhs_reset_and_copy_stream=corei7_hs_reset_and_copy_stream
+ -Dhs_reset_and_expand_stream=corei7_hs_reset_and_expand_stream
+ -Dhs_reset_stream=corei7_hs_reset_stream
+ -Dhs_scan=corei7_hs_scan
+ -Dhs_scan_stream=corei7_hs_scan_stream
+ -Dhs_scan_vector=corei7_hs_scan_vector
+ -Dhs_scratch_alloc=corei7_hs_scratch_alloc
+ -Dhs_scratch_free=corei7_hs_scratch_free
+ -Dhs_scratch_size=corei7_hs_scratch_size
+ -Dhs_serialize_database=corei7_hs_serialize_database
+ -Dhs_serialized_database_info=corei7_hs_serialized_database_info
+ -Dhs_serialized_database_size=corei7_hs_serialized_database_size
+ -Dhs_set_allocator=corei7_hs_set_allocator
+ -Dhs_set_database_allocator=corei7_hs_set_database_allocator
+ -Dhs_set_misc_allocator=corei7_hs_set_misc_allocator
+ -Dhs_set_scratch_allocator=corei7_hs_set_scratch_allocator
+ -Dhs_set_stream_allocator=corei7_hs_set_stream_allocator
+ -Dhs_stream_alloc=corei7_hs_stream_alloc
+ -Dhs_stream_free=corei7_hs_stream_free
+ -Dhs_stream_size=corei7_hs_stream_size
+ -Dhs_valid_platform=corei7_hs_valid_platform
+ -Dhs_version=corei7_hs_version
+ -DhwlmExec=corei7_hwlmExec
+ -DhwlmExecStreaming=corei7_hwlmExecStreaming
+ -DloadSomFromStream=corei7_loadSomFromStream
+ -Dloadcompressed128=corei7_loadcompressed128
+ -Dloadcompressed256=corei7_loadcompressed256
+ -Dloadcompressed32=corei7_loadcompressed32
+ -Dloadcompressed384=corei7_loadcompressed384
+ -Dloadcompressed512=corei7_loadcompressed512
+ -Dloadcompressed64=corei7_loadcompressed64
+ -Dmcsheng_pext_mask=corei7_mcsheng_pext_mask
+ -Dmm_mask_mask=corei7_mm_mask_mask
+ -Dmm_shuffle_end=corei7_mm_shuffle_end
+ -Dmmbit_keyshift_lut=corei7_mmbit_keyshift_lut
+ -Dmmbit_maxlevel_direct_lut=corei7_mmbit_maxlevel_direct_lut
+ -Dmmbit_maxlevel_from_keyshift_lut=corei7_mmbit_maxlevel_from_keyshift_lut
+ -Dmmbit_root_offset_from_level=corei7_mmbit_root_offset_from_level
+ -Dmmbit_zero_to_lut=corei7_mmbit_zero_to_lut
+ -DnfaBlockExecReverse=corei7_nfaBlockExecReverse
+ -DnfaCheckFinalState=corei7_nfaCheckFinalState
+ -DnfaExecCastle_Q=corei7_nfaExecCastle_Q
+ -DnfaExecCastle_Q2=corei7_nfaExecCastle_Q2
+ -DnfaExecCastle_QR=corei7_nfaExecCastle_QR
+ -DnfaExecCastle_expandState=corei7_nfaExecCastle_expandState
+ -DnfaExecCastle_inAccept=corei7_nfaExecCastle_inAccept
+ -DnfaExecCastle_inAnyAccept=corei7_nfaExecCastle_inAnyAccept
+ -DnfaExecCastle_initCompressedState=corei7_nfaExecCastle_initCompressedState
+ -DnfaExecCastle_queueCompressState=corei7_nfaExecCastle_queueCompressState
+ -DnfaExecCastle_queueInitState=corei7_nfaExecCastle_queueInitState
+ -DnfaExecCastle_reportCurrent=corei7_nfaExecCastle_reportCurrent
+ -DnfaExecGough16_Q=corei7_nfaExecGough16_Q
+ -DnfaExecGough16_Q2=corei7_nfaExecGough16_Q2
+ -DnfaExecGough16_QR=corei7_nfaExecGough16_QR
+ -DnfaExecGough16_expandState=corei7_nfaExecGough16_expandState
+ -DnfaExecGough16_inAccept=corei7_nfaExecGough16_inAccept
+ -DnfaExecGough16_inAnyAccept=corei7_nfaExecGough16_inAnyAccept
+ -DnfaExecGough16_initCompressedState=corei7_nfaExecGough16_initCompressedState
+ -DnfaExecGough16_queueCompressState=corei7_nfaExecGough16_queueCompressState
+ -DnfaExecGough16_queueInitState=corei7_nfaExecGough16_queueInitState
+ -DnfaExecGough16_reportCurrent=corei7_nfaExecGough16_reportCurrent
+ -DnfaExecGough16_testEOD=corei7_nfaExecGough16_testEOD
+ -DnfaExecGough8_Q=corei7_nfaExecGough8_Q
+ -DnfaExecGough8_Q2=corei7_nfaExecGough8_Q2
+ -DnfaExecGough8_QR=corei7_nfaExecGough8_QR
+ -DnfaExecGough8_expandState=corei7_nfaExecGough8_expandState
+ -DnfaExecGough8_inAccept=corei7_nfaExecGough8_inAccept
+ -DnfaExecGough8_inAnyAccept=corei7_nfaExecGough8_inAnyAccept
+ -DnfaExecGough8_initCompressedState=corei7_nfaExecGough8_initCompressedState
+ -DnfaExecGough8_queueCompressState=corei7_nfaExecGough8_queueCompressState
+ -DnfaExecGough8_queueInitState=corei7_nfaExecGough8_queueInitState
+ -DnfaExecGough8_reportCurrent=corei7_nfaExecGough8_reportCurrent
+ -DnfaExecGough8_testEOD=corei7_nfaExecGough8_testEOD
+ -DnfaExecLbrDot_Q=corei7_nfaExecLbrDot_Q
+ -DnfaExecLbrDot_Q2=corei7_nfaExecLbrDot_Q2
+ -DnfaExecLbrDot_QR=corei7_nfaExecLbrDot_QR
+ -DnfaExecLbrDot_expandState=corei7_nfaExecLbrDot_expandState
+ -DnfaExecLbrDot_inAccept=corei7_nfaExecLbrDot_inAccept
+ -DnfaExecLbrDot_inAnyAccept=corei7_nfaExecLbrDot_inAnyAccept
+ -DnfaExecLbrDot_initCompressedState=corei7_nfaExecLbrDot_initCompressedState
+ -DnfaExecLbrDot_queueCompressState=corei7_nfaExecLbrDot_queueCompressState
+ -DnfaExecLbrDot_queueInitState=corei7_nfaExecLbrDot_queueInitState
+ -DnfaExecLbrDot_reportCurrent=corei7_nfaExecLbrDot_reportCurrent
+ -DnfaExecLbrNVerm_Q=corei7_nfaExecLbrNVerm_Q
+ -DnfaExecLbrNVerm_Q2=corei7_nfaExecLbrNVerm_Q2
+ -DnfaExecLbrNVerm_QR=corei7_nfaExecLbrNVerm_QR
+ -DnfaExecLbrNVerm_expandState=corei7_nfaExecLbrNVerm_expandState
+ -DnfaExecLbrNVerm_inAccept=corei7_nfaExecLbrNVerm_inAccept
+ -DnfaExecLbrNVerm_inAnyAccept=corei7_nfaExecLbrNVerm_inAnyAccept
+ -DnfaExecLbrNVerm_initCompressedState=corei7_nfaExecLbrNVerm_initCompressedState
+ -DnfaExecLbrNVerm_queueCompressState=corei7_nfaExecLbrNVerm_queueCompressState
+ -DnfaExecLbrNVerm_queueInitState=corei7_nfaExecLbrNVerm_queueInitState
+ -DnfaExecLbrNVerm_reportCurrent=corei7_nfaExecLbrNVerm_reportCurrent
+ -DnfaExecLbrShuf_Q=corei7_nfaExecLbrShuf_Q
+ -DnfaExecLbrShuf_Q2=corei7_nfaExecLbrShuf_Q2
+ -DnfaExecLbrShuf_QR=corei7_nfaExecLbrShuf_QR
+ -DnfaExecLbrShuf_expandState=corei7_nfaExecLbrShuf_expandState
+ -DnfaExecLbrShuf_inAccept=corei7_nfaExecLbrShuf_inAccept
+ -DnfaExecLbrShuf_inAnyAccept=corei7_nfaExecLbrShuf_inAnyAccept
+ -DnfaExecLbrShuf_initCompressedState=corei7_nfaExecLbrShuf_initCompressedState
+ -DnfaExecLbrShuf_queueCompressState=corei7_nfaExecLbrShuf_queueCompressState
+ -DnfaExecLbrShuf_queueInitState=corei7_nfaExecLbrShuf_queueInitState
+ -DnfaExecLbrShuf_reportCurrent=corei7_nfaExecLbrShuf_reportCurrent
+ -DnfaExecLbrTruf_Q=corei7_nfaExecLbrTruf_Q
+ -DnfaExecLbrTruf_Q2=corei7_nfaExecLbrTruf_Q2
+ -DnfaExecLbrTruf_QR=corei7_nfaExecLbrTruf_QR
+ -DnfaExecLbrTruf_expandState=corei7_nfaExecLbrTruf_expandState
+ -DnfaExecLbrTruf_inAccept=corei7_nfaExecLbrTruf_inAccept
+ -DnfaExecLbrTruf_inAnyAccept=corei7_nfaExecLbrTruf_inAnyAccept
+ -DnfaExecLbrTruf_initCompressedState=corei7_nfaExecLbrTruf_initCompressedState
+ -DnfaExecLbrTruf_queueCompressState=corei7_nfaExecLbrTruf_queueCompressState
+ -DnfaExecLbrTruf_queueInitState=corei7_nfaExecLbrTruf_queueInitState
+ -DnfaExecLbrTruf_reportCurrent=corei7_nfaExecLbrTruf_reportCurrent
+ -DnfaExecLbrVerm_Q=corei7_nfaExecLbrVerm_Q
+ -DnfaExecLbrVerm_Q2=corei7_nfaExecLbrVerm_Q2
+ -DnfaExecLbrVerm_QR=corei7_nfaExecLbrVerm_QR
+ -DnfaExecLbrVerm_expandState=corei7_nfaExecLbrVerm_expandState
+ -DnfaExecLbrVerm_inAccept=corei7_nfaExecLbrVerm_inAccept
+ -DnfaExecLbrVerm_inAnyAccept=corei7_nfaExecLbrVerm_inAnyAccept
+ -DnfaExecLbrVerm_initCompressedState=corei7_nfaExecLbrVerm_initCompressedState
+ -DnfaExecLbrVerm_queueCompressState=corei7_nfaExecLbrVerm_queueCompressState
+ -DnfaExecLbrVerm_queueInitState=corei7_nfaExecLbrVerm_queueInitState
+ -DnfaExecLbrVerm_reportCurrent=corei7_nfaExecLbrVerm_reportCurrent
+ -DnfaExecLimEx128_B_Reverse=corei7_nfaExecLimEx128_B_Reverse
+ -DnfaExecLimEx128_Q=corei7_nfaExecLimEx128_Q
+ -DnfaExecLimEx128_Q2=corei7_nfaExecLimEx128_Q2
+ -DnfaExecLimEx128_QR=corei7_nfaExecLimEx128_QR
+ -DnfaExecLimEx128_expandState=corei7_nfaExecLimEx128_expandState
+ -DnfaExecLimEx128_inAccept=corei7_nfaExecLimEx128_inAccept
+ -DnfaExecLimEx128_inAnyAccept=corei7_nfaExecLimEx128_inAnyAccept
+ -DnfaExecLimEx128_initCompressedState=corei7_nfaExecLimEx128_initCompressedState
+ -DnfaExecLimEx128_queueCompressState=corei7_nfaExecLimEx128_queueCompressState
+ -DnfaExecLimEx128_queueInitState=corei7_nfaExecLimEx128_queueInitState
+ -DnfaExecLimEx128_reportCurrent=corei7_nfaExecLimEx128_reportCurrent
+ -DnfaExecLimEx128_testEOD=corei7_nfaExecLimEx128_testEOD
+ -DnfaExecLimEx128_zombie_status=corei7_nfaExecLimEx128_zombie_status
+ -DnfaExecLimEx256_B_Reverse=corei7_nfaExecLimEx256_B_Reverse
+ -DnfaExecLimEx256_Q=corei7_nfaExecLimEx256_Q
+ -DnfaExecLimEx256_Q2=corei7_nfaExecLimEx256_Q2
+ -DnfaExecLimEx256_QR=corei7_nfaExecLimEx256_QR
+ -DnfaExecLimEx256_expandState=corei7_nfaExecLimEx256_expandState
+ -DnfaExecLimEx256_inAccept=corei7_nfaExecLimEx256_inAccept
+ -DnfaExecLimEx256_inAnyAccept=corei7_nfaExecLimEx256_inAnyAccept
+ -DnfaExecLimEx256_initCompressedState=corei7_nfaExecLimEx256_initCompressedState
+ -DnfaExecLimEx256_queueCompressState=corei7_nfaExecLimEx256_queueCompressState
+ -DnfaExecLimEx256_queueInitState=corei7_nfaExecLimEx256_queueInitState
+ -DnfaExecLimEx256_reportCurrent=corei7_nfaExecLimEx256_reportCurrent
+ -DnfaExecLimEx256_testEOD=corei7_nfaExecLimEx256_testEOD
+ -DnfaExecLimEx256_zombie_status=corei7_nfaExecLimEx256_zombie_status
+ -DnfaExecLimEx32_B_Reverse=corei7_nfaExecLimEx32_B_Reverse
+ -DnfaExecLimEx32_Q=corei7_nfaExecLimEx32_Q
+ -DnfaExecLimEx32_Q2=corei7_nfaExecLimEx32_Q2
+ -DnfaExecLimEx32_QR=corei7_nfaExecLimEx32_QR
+ -DnfaExecLimEx32_expandState=corei7_nfaExecLimEx32_expandState
+ -DnfaExecLimEx32_inAccept=corei7_nfaExecLimEx32_inAccept
+ -DnfaExecLimEx32_inAnyAccept=corei7_nfaExecLimEx32_inAnyAccept
+ -DnfaExecLimEx32_initCompressedState=corei7_nfaExecLimEx32_initCompressedState
+ -DnfaExecLimEx32_queueCompressState=corei7_nfaExecLimEx32_queueCompressState
+ -DnfaExecLimEx32_queueInitState=corei7_nfaExecLimEx32_queueInitState
+ -DnfaExecLimEx32_reportCurrent=corei7_nfaExecLimEx32_reportCurrent
+ -DnfaExecLimEx32_testEOD=corei7_nfaExecLimEx32_testEOD
+ -DnfaExecLimEx32_zombie_status=corei7_nfaExecLimEx32_zombie_status
+ -DnfaExecLimEx384_B_Reverse=corei7_nfaExecLimEx384_B_Reverse
+ -DnfaExecLimEx384_Q=corei7_nfaExecLimEx384_Q
+ -DnfaExecLimEx384_Q2=corei7_nfaExecLimEx384_Q2
+ -DnfaExecLimEx384_QR=corei7_nfaExecLimEx384_QR
+ -DnfaExecLimEx384_expandState=corei7_nfaExecLimEx384_expandState
+ -DnfaExecLimEx384_inAccept=corei7_nfaExecLimEx384_inAccept
+ -DnfaExecLimEx384_inAnyAccept=corei7_nfaExecLimEx384_inAnyAccept
+ -DnfaExecLimEx384_initCompressedState=corei7_nfaExecLimEx384_initCompressedState
+ -DnfaExecLimEx384_queueCompressState=corei7_nfaExecLimEx384_queueCompressState
+ -DnfaExecLimEx384_queueInitState=corei7_nfaExecLimEx384_queueInitState
+ -DnfaExecLimEx384_reportCurrent=corei7_nfaExecLimEx384_reportCurrent
+ -DnfaExecLimEx384_testEOD=corei7_nfaExecLimEx384_testEOD
+ -DnfaExecLimEx384_zombie_status=corei7_nfaExecLimEx384_zombie_status
+ -DnfaExecLimEx512_B_Reverse=corei7_nfaExecLimEx512_B_Reverse
+ -DnfaExecLimEx512_Q=corei7_nfaExecLimEx512_Q
+ -DnfaExecLimEx512_Q2=corei7_nfaExecLimEx512_Q2
+ -DnfaExecLimEx512_QR=corei7_nfaExecLimEx512_QR
+ -DnfaExecLimEx512_expandState=corei7_nfaExecLimEx512_expandState
+ -DnfaExecLimEx512_inAccept=corei7_nfaExecLimEx512_inAccept
+ -DnfaExecLimEx512_inAnyAccept=corei7_nfaExecLimEx512_inAnyAccept
+ -DnfaExecLimEx512_initCompressedState=corei7_nfaExecLimEx512_initCompressedState
+ -DnfaExecLimEx512_queueCompressState=corei7_nfaExecLimEx512_queueCompressState
+ -DnfaExecLimEx512_queueInitState=corei7_nfaExecLimEx512_queueInitState
+ -DnfaExecLimEx512_reportCurrent=corei7_nfaExecLimEx512_reportCurrent
+ -DnfaExecLimEx512_testEOD=corei7_nfaExecLimEx512_testEOD
+ -DnfaExecLimEx512_zombie_status=corei7_nfaExecLimEx512_zombie_status
+ -DnfaExecLimEx64_B_Reverse=corei7_nfaExecLimEx64_B_Reverse
+ -DnfaExecLimEx64_Q=corei7_nfaExecLimEx64_Q
+ -DnfaExecLimEx64_Q2=corei7_nfaExecLimEx64_Q2
+ -DnfaExecLimEx64_QR=corei7_nfaExecLimEx64_QR
+ -DnfaExecLimEx64_expandState=corei7_nfaExecLimEx64_expandState
+ -DnfaExecLimEx64_inAccept=corei7_nfaExecLimEx64_inAccept
+ -DnfaExecLimEx64_inAnyAccept=corei7_nfaExecLimEx64_inAnyAccept
+ -DnfaExecLimEx64_initCompressedState=corei7_nfaExecLimEx64_initCompressedState
+ -DnfaExecLimEx64_queueCompressState=corei7_nfaExecLimEx64_queueCompressState
+ -DnfaExecLimEx64_queueInitState=corei7_nfaExecLimEx64_queueInitState
+ -DnfaExecLimEx64_reportCurrent=corei7_nfaExecLimEx64_reportCurrent
+ -DnfaExecLimEx64_testEOD=corei7_nfaExecLimEx64_testEOD
+ -DnfaExecLimEx64_zombie_status=corei7_nfaExecLimEx64_zombie_status
+ -DnfaExecMcClellan16_B=corei7_nfaExecMcClellan16_B
+ -DnfaExecMcClellan16_Q=corei7_nfaExecMcClellan16_Q
+ -DnfaExecMcClellan16_Q2=corei7_nfaExecMcClellan16_Q2
+ -DnfaExecMcClellan16_QR=corei7_nfaExecMcClellan16_QR
+ -DnfaExecMcClellan16_SimpStream=corei7_nfaExecMcClellan16_SimpStream
+ -DnfaExecMcClellan16_expandState=corei7_nfaExecMcClellan16_expandState
+ -DnfaExecMcClellan16_inAccept=corei7_nfaExecMcClellan16_inAccept
+ -DnfaExecMcClellan16_inAnyAccept=corei7_nfaExecMcClellan16_inAnyAccept
+ -DnfaExecMcClellan16_initCompressedState=corei7_nfaExecMcClellan16_initCompressedState
+ -DnfaExecMcClellan16_queueCompressState=corei7_nfaExecMcClellan16_queueCompressState
+ -DnfaExecMcClellan16_queueInitState=corei7_nfaExecMcClellan16_queueInitState
+ -DnfaExecMcClellan16_reportCurrent=corei7_nfaExecMcClellan16_reportCurrent
+ -DnfaExecMcClellan16_testEOD=corei7_nfaExecMcClellan16_testEOD
+ -DnfaExecMcClellan8_B=corei7_nfaExecMcClellan8_B
+ -DnfaExecMcClellan8_Q=corei7_nfaExecMcClellan8_Q
+ -DnfaExecMcClellan8_Q2=corei7_nfaExecMcClellan8_Q2
+ -DnfaExecMcClellan8_QR=corei7_nfaExecMcClellan8_QR
+ -DnfaExecMcClellan8_SimpStream=corei7_nfaExecMcClellan8_SimpStream
+ -DnfaExecMcClellan8_expandState=corei7_nfaExecMcClellan8_expandState
+ -DnfaExecMcClellan8_inAccept=corei7_nfaExecMcClellan8_inAccept
+ -DnfaExecMcClellan8_inAnyAccept=corei7_nfaExecMcClellan8_inAnyAccept
+ -DnfaExecMcClellan8_initCompressedState=corei7_nfaExecMcClellan8_initCompressedState
+ -DnfaExecMcClellan8_queueCompressState=corei7_nfaExecMcClellan8_queueCompressState
+ -DnfaExecMcClellan8_queueInitState=corei7_nfaExecMcClellan8_queueInitState
+ -DnfaExecMcClellan8_reportCurrent=corei7_nfaExecMcClellan8_reportCurrent
+ -DnfaExecMcClellan8_testEOD=corei7_nfaExecMcClellan8_testEOD
+ -DnfaExecMcSheng16_Q=corei7_nfaExecMcSheng16_Q
+ -DnfaExecMcSheng16_Q2=corei7_nfaExecMcSheng16_Q2
+ -DnfaExecMcSheng16_QR=corei7_nfaExecMcSheng16_QR
+ -DnfaExecMcSheng16_expandState=corei7_nfaExecMcSheng16_expandState
+ -DnfaExecMcSheng16_inAccept=corei7_nfaExecMcSheng16_inAccept
+ -DnfaExecMcSheng16_inAnyAccept=corei7_nfaExecMcSheng16_inAnyAccept
+ -DnfaExecMcSheng16_initCompressedState=corei7_nfaExecMcSheng16_initCompressedState
+ -DnfaExecMcSheng16_queueCompressState=corei7_nfaExecMcSheng16_queueCompressState
+ -DnfaExecMcSheng16_queueInitState=corei7_nfaExecMcSheng16_queueInitState
+ -DnfaExecMcSheng16_reportCurrent=corei7_nfaExecMcSheng16_reportCurrent
+ -DnfaExecMcSheng16_testEOD=corei7_nfaExecMcSheng16_testEOD
+ -DnfaExecMcSheng8_Q=corei7_nfaExecMcSheng8_Q
+ -DnfaExecMcSheng8_Q2=corei7_nfaExecMcSheng8_Q2
+ -DnfaExecMcSheng8_QR=corei7_nfaExecMcSheng8_QR
+ -DnfaExecMcSheng8_expandState=corei7_nfaExecMcSheng8_expandState
+ -DnfaExecMcSheng8_inAccept=corei7_nfaExecMcSheng8_inAccept
+ -DnfaExecMcSheng8_inAnyAccept=corei7_nfaExecMcSheng8_inAnyAccept
+ -DnfaExecMcSheng8_initCompressedState=corei7_nfaExecMcSheng8_initCompressedState
+ -DnfaExecMcSheng8_queueCompressState=corei7_nfaExecMcSheng8_queueCompressState
+ -DnfaExecMcSheng8_queueInitState=corei7_nfaExecMcSheng8_queueInitState
+ -DnfaExecMcSheng8_reportCurrent=corei7_nfaExecMcSheng8_reportCurrent
+ -DnfaExecMcSheng8_testEOD=corei7_nfaExecMcSheng8_testEOD
+ -DnfaExecMpv_Q=corei7_nfaExecMpv_Q
+ -DnfaExecMpv_QueueExecRaw=corei7_nfaExecMpv_QueueExecRaw
+ -DnfaExecMpv_expandState=corei7_nfaExecMpv_expandState
+ -DnfaExecMpv_initCompressedState=corei7_nfaExecMpv_initCompressedState
+ -DnfaExecMpv_queueCompressState=corei7_nfaExecMpv_queueCompressState
+ -DnfaExecMpv_queueInitState=corei7_nfaExecMpv_queueInitState
+ -DnfaExecMpv_reportCurrent=corei7_nfaExecMpv_reportCurrent
+ -DnfaExecSheng_B=corei7_nfaExecSheng_B
+ -DnfaExecSheng_Q=corei7_nfaExecSheng_Q
+ -DnfaExecSheng_Q2=corei7_nfaExecSheng_Q2
+ -DnfaExecSheng_QR=corei7_nfaExecSheng_QR
+ -DnfaExecSheng_expandState=corei7_nfaExecSheng_expandState
+ -DnfaExecSheng_inAccept=corei7_nfaExecSheng_inAccept
+ -DnfaExecSheng_inAnyAccept=corei7_nfaExecSheng_inAnyAccept
+ -DnfaExecSheng_initCompressedState=corei7_nfaExecSheng_initCompressedState
+ -DnfaExecSheng_queueCompressState=corei7_nfaExecSheng_queueCompressState
+ -DnfaExecSheng_queueInitState=corei7_nfaExecSheng_queueInitState
+ -DnfaExecSheng_reportCurrent=corei7_nfaExecSheng_reportCurrent
+ -DnfaExecSheng_testEOD=corei7_nfaExecSheng_testEOD
+ -DnfaExecTamarama_Q=corei7_nfaExecTamarama_Q
+ -DnfaExecTamarama_Q2=corei7_nfaExecTamarama_Q2
+ -DnfaExecTamarama_QR=corei7_nfaExecTamarama_QR
+ -DnfaExecTamarama_expandState=corei7_nfaExecTamarama_expandState
+ -DnfaExecTamarama_inAccept=corei7_nfaExecTamarama_inAccept
+ -DnfaExecTamarama_inAnyAccept=corei7_nfaExecTamarama_inAnyAccept
+ -DnfaExecTamarama_queueCompressState=corei7_nfaExecTamarama_queueCompressState
+ -DnfaExecTamarama_queueInitState=corei7_nfaExecTamarama_queueInitState
+ -DnfaExecTamarama_reportCurrent=corei7_nfaExecTamarama_reportCurrent
+ -DnfaExecTamarama_testEOD=corei7_nfaExecTamarama_testEOD
+ -DnfaExecTamarama_zombie_status=corei7_nfaExecTamarama_zombie_status
+ -DnfaExpandState=corei7_nfaExpandState
+ -DnfaGetZombieStatus=corei7_nfaGetZombieStatus
+ -DnfaInAcceptState=corei7_nfaInAcceptState
+ -DnfaInAnyAcceptState=corei7_nfaInAnyAcceptState
+ -DnfaInitCompressedState=corei7_nfaInitCompressedState
+ -DnfaQueueCompressState=corei7_nfaQueueCompressState
+ -DnfaQueueExec=corei7_nfaQueueExec
+ -DnfaQueueExec2_raw=corei7_nfaQueueExec2_raw
+ -DnfaQueueExecRose=corei7_nfaQueueExecRose
+ -DnfaQueueExecToMatch=corei7_nfaQueueExecToMatch
+ -DnfaQueueExec_raw=corei7_nfaQueueExec_raw
+ -DnfaQueueInitState=corei7_nfaQueueInitState
+ -DnfaReportCurrentMatches=corei7_nfaReportCurrentMatches
+ -DnoodExec=corei7_noodExec
+ -DnoodExecStreaming=corei7_noodExecStreaming
+ -Dp_mask_arr=corei7_p_mask_arr
+ -Dp_mask_arr256=corei7_p_mask_arr256
+ -DrepeatHasMatchBitmap=corei7_repeatHasMatchBitmap
+ -DrepeatHasMatchRange=corei7_repeatHasMatchRange
+ -DrepeatHasMatchRing=corei7_repeatHasMatchRing
+ -DrepeatHasMatchSparseOptimalP=corei7_repeatHasMatchSparseOptimalP
+ -DrepeatHasMatchTrailer=corei7_repeatHasMatchTrailer
+ -DrepeatLastTopBitmap=corei7_repeatLastTopBitmap
+ -DrepeatLastTopRange=corei7_repeatLastTopRange
+ -DrepeatLastTopRing=corei7_repeatLastTopRing
+ -DrepeatLastTopSparseOptimalP=corei7_repeatLastTopSparseOptimalP
+ -DrepeatLastTopTrailer=corei7_repeatLastTopTrailer
+ -DrepeatNextMatchBitmap=corei7_repeatNextMatchBitmap
+ -DrepeatNextMatchRange=corei7_repeatNextMatchRange
+ -DrepeatNextMatchRing=corei7_repeatNextMatchRing
+ -DrepeatNextMatchSparseOptimalP=corei7_repeatNextMatchSparseOptimalP
+ -DrepeatNextMatchTrailer=corei7_repeatNextMatchTrailer
+ -DrepeatPack=corei7_repeatPack
+ -DrepeatStoreBitmap=corei7_repeatStoreBitmap
+ -DrepeatStoreRange=corei7_repeatStoreRange
+ -DrepeatStoreRing=corei7_repeatStoreRing
+ -DrepeatStoreSparseOptimalP=corei7_repeatStoreSparseOptimalP
+ -DrepeatStoreTrailer=corei7_repeatStoreTrailer
+ -DrepeatUnpack=corei7_repeatUnpack
+ -DroseAnchoredCallback=corei7_roseAnchoredCallback
+ -DroseBlockExec=corei7_roseBlockExec
+ -DroseCallback=corei7_roseCallback
+ -DroseCatchUpAll=corei7_roseCatchUpAll
+ -DroseCatchUpMPV_i=corei7_roseCatchUpMPV_i
+ -DroseCatchUpSuf=corei7_roseCatchUpSuf
+ -DroseDelayRebuildCallback=corei7_roseDelayRebuildCallback
+ -DroseFloatingCallback=corei7_roseFloatingCallback
+ -DroseHandleChainMatch=corei7_roseHandleChainMatch
+ -DroseInitState=corei7_roseInitState
+ -DroseNfaAdaptor=corei7_roseNfaAdaptor
+ -DroseNfaEarliestSom=corei7_roseNfaEarliestSom
+ -DroseReportAdaptor=corei7_roseReportAdaptor
+ -DroseRunBoundaryProgram=corei7_roseRunBoundaryProgram
+ -DroseRunFlushCombProgram=corei7_roseRunFlushCombProgram
+ -DroseRunLastFlushCombProgram=corei7_roseRunLastFlushCombProgram
+ -DroseRunProgram=corei7_roseRunProgram
+ -DroseRunProgram_l=corei7_roseRunProgram_l
+ -DroseStreamEodExec=corei7_roseStreamEodExec
+ -DroseStreamExec=corei7_roseStreamExec
+ -DrshuftiExec=corei7_rshuftiExec
+ -DrtruffleExec=corei7_rtruffleExec
+ -Drun_accel=corei7_run_accel
+ -DsetSomFromSomAware=corei7_setSomFromSomAware
+ -DshuftiDoubleExec=corei7_shuftiDoubleExec
+ -DshuftiExec=corei7_shuftiExec
+ -Dsimd_onebit_masks=corei7_simd_onebit_masks
+ -Dsize_compress_stream=corei7_size_compress_stream
+ -DstoreSomToStream=corei7_storeSomToStream
+ -Dstorecompressed128=corei7_storecompressed128
+ -Dstorecompressed256=corei7_storecompressed256
+ -Dstorecompressed32=corei7_storecompressed32
+ -Dstorecompressed384=corei7_storecompressed384
+ -Dstorecompressed512=corei7_storecompressed512
+ -Dstorecompressed64=corei7_storecompressed64
+ -DstreamInitSufPQ=corei7_streamInitSufPQ
+ -DtruffleExec=corei7_truffleExec
+ -Dvbs_mask_data=corei7_vbs_mask_data
+)
+
+SRCDIR(contrib/libs/hyperscan)
+
+SRCS(
+ src/alloc.c
+ src/crc32.c
+ src/database.c
+ src/fdr/fdr.c
+ src/fdr/teddy.c
+ src/fdr/teddy_avx2.c
+ src/hs_valid_platform.c
+ src/hs_version.c
+ src/hwlm/hwlm.c
+ src/hwlm/noodle_engine.c
+ src/nfa/accel.c
+ src/nfa/castle.c
+ src/nfa/gough.c
+ src/nfa/lbr.c
+ src/nfa/limex_64.c
+ src/nfa/limex_accel.c
+ src/nfa/limex_native.c
+ src/nfa/limex_simd128.c
+ src/nfa/limex_simd256.c
+ src/nfa/limex_simd384.c
+ src/nfa/limex_simd512.c
+ src/nfa/mcclellan.c
+ src/nfa/mcsheng.c
+ src/nfa/mcsheng_data.c
+ src/nfa/mpv.c
+ src/nfa/nfa_api_dispatch.c
+ src/nfa/repeat.c
+ src/nfa/sheng.c
+ src/nfa/shufti.c
+ src/nfa/tamarama.c
+ src/nfa/truffle.c
+ src/rose/block.c
+ src/rose/catchup.c
+ src/rose/init.c
+ src/rose/match.c
+ src/rose/program_runtime.c
+ src/rose/stream.c
+ src/runtime.c
+ src/scratch.c
+ src/som/som_runtime.c
+ src/som/som_stream.c
+ src/stream_compress.c
+ src/util/cpuid_flags.c
+ src/util/masked_move.c
+ src/util/multibit.c
+ src/util/simd_utils.c
+ src/util/state_compress.c
+)
+
+END()